初识Node.js

为什么javascript可以在浏览器中被执行

• 不同的浏览器使用不同的javascript解析引擎

 Chrome--V8
 Firefox -- OdinMonkey(奥丁猴)
 Safri -- JSCore
 IE -- Chakra
 其中，Chrome浏览器的V8解析引擎性能最好，推荐使用chrome
1
2
3
4
5

为什么JavaScript可以操作DOM和BOM

• 因为每个浏览器都内置了DOM,BOM这样的API函数，因此，浏览器中的JavaScript才可以调用他们。

浏览器中的JavaScript运行环境

• 运行环境是指代码正常运行所需的必要环境
• 前端运行环境就是指浏览器，浏览器包括V8引擎（负责解析和执行JavaScript代码），内置API（是由运行环境提供的特殊接口，只能在所属的运行环境中被调用）

JavaScript能否做后端开发

• 可以，JavaScript运行在浏览器就是前端开发，运行在node.js就是后端开发

什么是Node.js

• node.js是一个基于chromeV8引擎的JavaScript运行环境(运行时)

Node.js中的JavaScript运行环境

• 浏览器是JavaScript的前端运行环境
• node.js是JavaScript的后端运行环境（V8引擎，内置API，提供一些能力）
• Node.js中无法调用BOM,DOM等浏览器内置API

Node.js可以做什么

• Node.js提供了一些基础的功能，基于Node.js，我们可以使用框架搭建各种事情。

Node.js环境的安装

• 安装的时候一般安装LTS版本，并且不改变安装的路径，使用默认路径

区分LTS版本和Current版本的不同

• LTS为长期稳定版，对于追求稳定性的企业项目来说，推荐安装LTS版本的Node.js
• Current为新特性尝鲜版，对热衷于尝试新特性的用户来说，推荐安装，这个版本可能存在隐藏的Bug或安全性漏洞

验证安装成功–查看已安装的node.js的版本号

• 打开终端(win+r,输入cmd,回车)，输入node -v，出现一个版本号，就是安装成功了
  

什么是终端

• 终端是专门为开发人员设计的，用于实现人机交互的一种方式

在node.js环境中执行JavaScript代码

我们在文件夹里面设置一个记事本，记事本命名为1.js，命名完成后这个记事本会改变，将这个文件用记事本打开，后在里面编辑js代码，完成后保存
1

• 1.打开终端
• 2.输入node空格要执行的js文件的路径
• 我们可以通过cd C:\Users\w5339\Desktop\node.js来切换到这个路径

在node.js环境中执行JavaScript代码–直接定位到文件位置

• 在文件打开位置空白处，按下shift+鼠标右键，点击打开windows powershell,就会直接定位到文件的目录下，此刻直接输入文件名字就可以运行
• cmd是早期的终端，powershell比较新，功能也更加强大，推荐使用
  

终端里面的快捷键

• 使用上箭头输入上面的命令
• 使用tab键快速补全文件的名字
• 使用ESC键清空当前正在输入的命令
• cls清空当前的终端中的所有内容

---

fs文件系统模块

• fs模块是node.js官方提供的，用来操作文件的模块，用来提供一系列的方法和属性，用来满足用户对文件的操作需求
• fs.readFile()方法，用来读取指定文件中的内容
• fs.writeFile()方法，用来向指定的文件中写入内容
• 在JavaScript代码中，使用fs模块来操作文件，则需要先导入

const fs = require('fs')
1

fs.readFile()读取指定文件中的内容

fs.readFile(path[,options],callback)
参数1：必选参数，字符串，表示文件的路径
参数2：可选参数，表示已什么编码格式来读取文件
参数3：必选参数，文件读取完成以后，通过回调函数拿到读取的结果
1
2
3
4

• 加上【】就是可选参数

• 实例

const fs = require('fs');
fs.readFile('./files/11.txt','utf8',function(err,datastr){
    console.log(err);
    console.log('-----');
    console.log(datastr);
})
1
2
3
4
5
6

判断文件是否读取成功

• 可以判断err对象是否为null
• if(err)–读取文章失败

const fs = require('fs');
fs.readFile('./files/11.txt','utf8',function(err,datastr){
    if(err){
        return console.log('读取文章失败'+err)
    }
    console.log('读取文章成功,内容是：' + datastr);
})
1
2
3
4
5
6
7

fs.writeFile()向文件中写入内容

fs.writeFile(file,data[,options],callback)
参数1：必选参数，指定一个文件路径的字符串，表示文件的存放路径
参数2：必选参数，表示要写入的内容
参数3：可选参数，表示要以什么格式写入文件，默认是utf8
参数4：必选参数，文件写入完成后的回调函数
1
2
3
4
5

• 实例

const fs = require('fs');
fs.writeFile('f:./files/1.txt','真乖','utf8',function(err,datastr){
    //写入成功打印的是null,写入失败err的值是一个错误对象
    //datastr无论成功还是是败都是undefined，写一个err就行了
    console.log(err)
    console.log('----------');
    console.log(datastr)
})
1
2
3
4
5
6
7
8

判断文件是否写入成功

• 源文件2.txt可以不用事先存在，可以自动创建，如果源文件里面有内容，新写入的内容会将原来内容覆盖掉

const fs = require('fs');
fs.writeFile('./files/2.txt','哈哈哈','utf8',function(err){
    if(err){
        return console.log('写入文件失败' + err.message);
    }
    console.log('文件写入成功');
})
1
2
3
4
5
6
7

实战

const fs = require('fs');
fs.readFile('./files/成绩.txt','utf8',function(err,datastr){
    if(err){
        return console.log('读取成绩失败' + err.message)
    }
    //split,slice,splice的区别
    //split用来操作字符串，分割字符串，split(' ')根据空格分隔字符串，返回一个数组，不改变原字符串
    //slice用来操作字符串，截取字符串，slice(1,4),不包括结束字符串，返回字符串，不改变原字符串
    //splice用来操作数组，删除替换数组，splice(1，1，e)没有第三个参数就是删除，有就是替换，开始位置，个数，返回被删除或替换的元素，改变原数组
   
    //1、将字符串按照空格分成数组
    var attr = datastr.split(' ');
    const attrnew = [];
    attr.forEach(element => {
        //item index
        attrnew.push(element.replace('=',':'))
    });
//3.将数组转换成字符串返回，join()默认使用逗号连接，join('=')使用=连接
    const newstr = attrnew.join('\r\n')
    fs.writeFile('./files/成绩ok.txt',newstr,'utf8',function(err){
        if(err){
            return console.log('写入文件失败')
        }
        console.log('写入文件成功')
    })
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

路径动态拼接的问题

• cd…/返回上一层上一级…/同级./下一级/

• 在使用./或者…/开头的相对路径时，很容易出现路径动态拼接错误的问题

• 原因：代码在运行时，会以node命令所处的目录，动态拼接操作文件的路径
  

• 解决办法：提供一个绝对路径(完整的路径),移植性差(文件位置发生改变)，不利于维护
  

  • 这里注意将路径里面的\变成\
    

• 完美的解决办法：

• --dirname不会随着node路径的变化而变化，就表示当前文件的路径

  
  为什么/files/1.txt，因为这里是路径拼接，而那个./files是在当前目录，返回上一层目录。

---

path路径模块

• path模块是Node.js官方提供的，用来处理路径的模块
• path.join()方法，将多个路径片段拼接成一个完整的路径字符串
• path.basename()方法，从路径字符串中，将文件名解析出来

在JavaScript代码中，使用path模块来处理路径，先导入
const path = require('path')
1
2

path.join()路径拼接

path.join([...paths])
参数：
...paths路径片段的序列
返回值：
1
2
3
4

• 实例1：拼接时../会抵消前面的一个路径，./不会

const path = require('path')
const str = path.join('/a','/b/c','../','/d')
console.log(str)
1
2
3

• 实例2：今后涉及到路径拼接的问题，都要使用path.join()方法进行处理不要直接使用+进行拼接，如果使用+，__dirname+'./files/1.txt'多了一个点就会报错，而使用path.join就不会报错，会自动屏蔽掉这个点

const fs = require('fs')
fs.readFile(__dirname + './files/1.txt','utf8',function (err,datastr) {
   if(err){
     return console.log(err.message)
   }
   console.log(datastr)
})
1
2
3
4
5
6
7

const fs = require('fs')
fs.readFile(path.join(__dirname , './files/1.txt'),'utf8',function (err,datastr) {
  if(err){
    return console.log(err.message)
  }
  console.log(datastr)
})
1
2
3
4
5
6
7

path.basename()获取路径中的最后一部分，通常是文件名

path.basename(path[,ext])
参数解读：
path必选参数，表示一个路径的字符串
ext可选参数，表示文件扩展名
返回：表示路径中的最后一部分
1
2
3
4
5

-实例1：截取文件最后的文件名，带扩展名

const path = require('path')
const address = '/a/b/c/index.html'
const endadd = path.basename(address)
console.log(endadd);
1
2
3
4

• 截取文件名，不带扩展名

const path = require('path')
const address = '/a/b/c/index.html'
const withoutext = path.basename(address,'.html')
console.log(withoutext)
1
2
3
4

path.extname()获取路径中的文件扩展名

path.extname(path)
参数
path必选参数，表示一个路径的字符串
返回:返回得到的扩展字符串
1
2
3
4

• 实例1

const path = require('path');
const fpath = '/a/b/c/index.html'
const fext = path.extname(fpath)
console.log(fext)
1
2
3
4

---

时钟案例，练习fs和path


代码

//导入相应模块
const fs = require('fs')
const path = require('path')

//定义两个正则表达式，以//开始和结尾,结束的style的/需转义，否则就和开始和结尾重合了
//(\s匹配空白字符)(\S匹配非空白字符)(*匹配任意多次)
//定义两个正则表达式用于匹配style和script
const regstyle = /','')
  //将这个文本写入文件,这个clock不能自己创建，path.join别忘记了
  fs.writeFile(path.join(__dirname,'./clock/index.css'),newscss,'utf8',function (err) {
    if(err){
      return console.log('写入css文件失败' + err.message)
    }
    console.log('写入css文件成功')
  })
}

//分离js
function resolvejs(htmlstr) {
  const r2 = regscript.exec(htmlstr)
  const newjs = r2[0].replace('','')
  fs.writeFile(path.join(__dirname,'./clock/index.js'),newjs,'utf8',function (err) {
    if(err){
      return console.log('写入js文件失败' + err.message)
    }
    console.log('写入js文件成功')
  })
}

//分离html
function resolvehtml(htmlstr) {
  const newhtml = htmlstr.replace(regstyle,'  ')
      .replace(regscript,'  ')
fs.writeFile(path.join(__dirname,'./clock/index.html'),newhtml,'utf8',function (err) {
  if(err){
    return console.log('写入html文件失败' +err.message)
  }
 console.log('写入html文件成功')
})
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

总结：两个注意点

• fs.writeFile()方法只能用来创建文件，但是不能用来创建路径
• 重复调用fs.writeFile()写入同一个文件，新写入的内容会覆盖之前的内容

---

http模块

什么是http模块

什么是客户端，什么是服务器

• 负责消费网络资源的电脑，叫客户端；负责对外提供网络资源的电脑，叫服务器

http模块是node.js官方提供的，用来创建web服务器的模块，通过http.createServer()方法，就能方便把一台普通的电脑，变成一台web服务器，从而对外提供web资源服务

• 如果想要使用http模块创建服务器，则需要先导入他

const http = require('http')
1

服务器和普通电脑的区别

• 服务器比普通电脑多了web服务器软件，例如IIS,Apache
• 但是这些软件不是给前端程序员使用的，因为前端程序员可以使用node.js中HTTP模块，通过几行简单的代码，手写一个web服务器模块

服务器相关的概念

IP地址

• ip地址就是每台计算机的唯一地址，具有唯一性，电话号码，每台web服务器都有自己的ip地址
• ip地址的格式：a.b.c.d(abcd就是0–255之间的10进制数)
• 我们可以在终端输入ping www.baidu.com来查看百度的ip地址,直接通过这个ip地址我们就可以访问百度的首页
• 在开发期间，自己的电脑既是服务器，又是客户端，为了方便测试，我们在浏览器中输入127.0.0.1这个ip地址，把自己的电脑当作一台服务器进行访问，但是别人不能访问

域名

• 域名既IP地址的别名，域名是为了我们方便记忆
• 在开发测试期间，127.0.0.1也有域名为localhost

域名服务器

• 当我们输入域名的时候，他首先会转换成ip地址，这个对应关系存放在叫做
  域名服务器(DNS)中的电脑中
• 没有域名单纯使用ip地址也可以正常工作，但有了域名的加持，更加方便

举例

百度的域名为：www.baidu.com
ip地址为：182.61.200.7
两者都可以访问到百度的首页
1
2
3

端口号

• 端口号，相当于是门牌号，一台电脑中，可以运行成百上千个web服务，每个web服务对应一个唯一的端口号，客户端发送过来的请求，通过端口号，准确的交给对应web服务进行处理。
• 每个端口号只能对应一个web服务
• 在实际开发中，url中的80端口可以被省略

实例

• 创建一个基本的web服务器，终端也可以使用webstorm,code自带的终端

步骤：
//1.先导入HTTP模块
//2.创建一个web服务实例
//3.为web服务实例绑定request事件，监听客户端的需求
//4.启动服务器

const http = require('http')
const server = http.createServer()
server.on('request',function (req,res) {
  console.log('someone visit our web server')
})
server.listen(8080,function () {
 console.log('server running at http://127.0.0.1:8080')
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14

req请求对象-req.url() req.method()

• 只要服务器接收到了客户端的请求，就会通过调用server.on()为服务器绑定的request事件处理函数
• 想在该事件中，访问客户端相关的数据或者属性，可以使用如下方式

req.url请求地址为端口号后面的地址
req.method打印的是发送请求的方法，现在是get方法，如果想要post方法的话，我们可以借助postman工具

const http = require('http')
const server = http.createServer()
server.on('request',(req,res)=>{
  const str = `your request url is ${req.url},and request method is ${req.method}`
  console.log(str)
})
server.listen(8081,(s)=>{
  console.log('server running at http://127.0.0.1:8081')
})
1
2
3
4
5
6
7
8
9

res响应对象–res.end()

• 想访问与服务器相关的数据和属性
• 发送请求以后，将数据返回给客户端，并结束这次请求的过程

const http = require('http')
const server = http.createServer()
server.on('request',(req,res)=>{
  const str = `your request url is ${req.url},and request method is ${req.method}`
  console.log(str)
  *res.end(str)*
})
server.listen(8081,(s)=>{
  console.log('server running at http://127.0.0.1:8081')
})
1
2
3
4
5
6
7
8
9
10

res.end()解码错误–即中文会乱码

const http = require('http')
const server= http.createServer()
server.on('reqest',(req,res)=>{
  const str = '你的地址是${req.url},你的请求方法是${req.method}'
  
  //这个是显示在终端的
  console.log(str)`
  //加上下面这条语句就不会是解码错误
  **res.setHeader('Content-Type','text/html;charset=utf-8')**
  //这个是服务器返回给客户端的
  res.end(str)
})
//启动服务器
server.listen(8082,()=>{
  console.log('server running at http://127.0.0.1:8082')
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

根据不同的url响应不同的html内容

代码

const http = require('http')
const server = http.createServer()
server.on('request',(req,res)=>{
  //1.得到响应地址
  const url = req.url;
  //2.设置相应内容为默认值
  let content = '
404 Not Found
'
  //3.根据地址判断是那个页面，返回相应的内容
  if(url==='/'||url==='/index.html'){
   content = '
index.html
'
  }else if(url === '/about.html'){
      content = '
about.html
'
  }
  //4.设置请求头，防止解码错误
  res.setHeader('Content-Type','text/html; charset=utf-8')
  //5.将相应内容返回给客户端
  res.end(content)
})
server.listen(80,()=>{
    console.log('your server running at 127.0.0.1:80')
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

---

案例-实现clock时钟的web服务器

核心思路

• 将文件的实际存放路径，作为每个资源的请求的url地址
• 将读取到的文件内容（字符串），通过res.end()响应给客户端
• 客户端相应回来的，不是具体的文件，而是文件中所存储的内容
• 存在问题，输入/clock/index.html不会渲染css,但是请求发送了，路径也打印了
  代码

//导入web服务器
const http = require('http')
//导入读写文件模块
const fs = require('fs')
//导入路径拼接模块
const path = require('path')


//创建web服务器、
const server = http.createServer()
//监听web服务器的请求
server.on('request',function(req,res){
//3.1获取到客户端请求的路径,这个路径获取到之后的样子为/clock/index.html
const url = req.url
//3.2将请求过来的路径映射为具体的文件存放路径,就是为了方便我们下面读文件
const fpath = path.join(__dirname,url)
//3.3根据映射过来的路径读取文件的内容
fs.readFile(fpath,'utf8',function(err,datastr){
    //4.1读取失败，向客户端相应固定的错误消息
    if(err)  return res.end('404 not found')
    //4.2 读取成功，将读取成功的内容返回给客户端
    res.end(datastr)

})

})
//启动web服务器
server.listen(8080,function(){
    console.log('your server running at http://127.0.0.1:8080')
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

优化–两个问题

• 当我们不手动输入地址的时候，应该默认访问的是首页的内容，但是现在我们访问不到
  
• 当现在我们输入的时候，如果我们没有输入完整路径，即我们输入的是http://127.0.0.1:8080/index.js，而不是http://127.0.0.1:8080/clock/index.js就会找不见文件，很麻烦

代码

• 在上面的语句上，将 const fpath = path.join(__dirname,url)换成下面的代码就可以了

//3.2将请求过来的路径映射为具体的文件存放路径,就是为了方便我们下面读文件
// const fpath = path.join(__dirname,url)
let fpath = ''
if(url === '/'){
    //这个处理我们直接输入/的问题，默认访问为首页
    fpath = path.join(__dirname,'/clock/index.html')
}else{
    //这个是想让我们可以直接输入index.html,不用输入clock，但是此时我们如果在输入clock的话就会发生错误
    fpath = path.join(__dirname,'/clock',url)
}

1
2
3
4
5
6
7
8
9
10
11

---

模块化

现实生活中的模块化

• 游戏机，卡盘可拆卸

编程领域的模块化

• 遵守固定的规则，将一个大文件拆成独立并相互依赖的小模块

好处

• 复用性
• 可维护性
• 实现按需加载（需要那个模块，引过来加载）

模块化规范

• 就是对代码进行模块化的拆分与组合时，需要遵守的那些规则

例如

• 使用什么样的语法格式****引用模块
• 在模块中使用什么样的语法格式向外暴露成员

好处

• 降低沟通成本
• 极大的方便了各个模块之间的相互调用

node.js中的三大模块

• node.js根据模块来源的不同，将模块分成了三大类

内置模块：内置模块是由node.js提供的，例如fs,path,http等
自定义模块：我们用户写的js文件就是自定义模块
第三方模块：由第三方开发出来的模块，并非官方的内置模块，也不是自定义的模块，使用前需要先下载
1
2
3

加载模块

• 使用强大的require（）方法，可以加载需要的内置模块，自定义模块，第三方模块进行使用，例如
• 内置模块的加载和第三方模块的加载差不多，需要提供一个名字，而自定义模块的加载需要提供一个路径

//内置模块
const fs = require('fs')

//自定义模块
const m1 = require('./13.执行被加载中的模块')
console.log(m1)

//第三方模块
const moment = require('moment')
1
2
3
4
5
6
7
8
9

• 使用require（）方法加载其他模块时，会执行被加载模块中的代码，返回是一个空对象，模块作用域

注意
在使用require加载用户自定义模块时那个路径，可以省略.js，因为require会尝试补全一个路径

模块作用域

• 和函数作用域类似，在自定义模块中的变量，方法，只能在该模块里面被调用，这种模块限制，就叫做模块作用域
• 好处：解决全局变量污染的问题
• 两个文件，在一个文件里面有一个变量和一个方法，方法会打印大家好，但是在另一个文件调用之后，只会打印一个空对象{}（为什么，见下文），而拿不到里面的东西

向外共享模块作用域中的成员

module对象

• 每一个自定义模块都有一个module对象，这个对象存储了和该模块相关的信息

module.exports对象

• 在自定义模块中，我们可以使用module.exports()将模块中的成员，变量共享出去，共外界使用
• 外界使用require导入的时候，得到的就是module.exports()所指向的对象
• 所以我们使用require导入一个自定义模块的时候，默认得到的是一个空的对象，因为exports导出的默认就是一个空对象

使用module.exports向外界共享成员

• 既然有模块作用域，那么想要向外面共享成员怎么办

16

const age = 11;
module.exports.age = age;

module.exports.username = 'as'

module.exports.sayhello = function(){
    console.log('hello')
}
1
2
3
4
5
6
7
8

17

const m =require('./16.使用module.exports向外面共享成员')

console.log(m)
1
2
3

注意点

• 使用require（）方法导入模块时，导入的结果，永远以module.exports指向的对象为准

const age = 11;
module.exports.age = age;

module.exports.username = 'as'

module.exports.sayhello = function(){
    console.log('hello')
}

//让module.exports指向一个全新的对象，打印的是下面这个对象
module.exports = {
    nickname:'小黑',
    sayhi(){
        console.log('丫丫')
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

const m =require('./16.使用module.exports向外面共享成员')

console.log(m)
1
2
3

exports对象

• exports和module.exports指向同一个对象，最终共享的结果，还是以module.exports指向的对象为准

console.log(module.exports === exports)
1

exports和module.exports的使用误区

• 时刻谨记，require（）模块时，得到的永远是module.exports指向的对象

案例一

exports.username = 'xs'
module.exports = {
    gender:'nan',
    age:20
}
1
2
3
4
5

案例二

module.exports.username = 'xs'
exports = {
    gender:'nan',
    age:20
}
1
2
3
4
5

案例三

exports.username = 'zs'
module.exports.gender = '男'
1
2

• 案例四

exports = {
    username:'sx',
    gender:'男'
}
module.exports = exports
module.exports.age = '11'
1
2
3
4
5
6

node.js中的模块化规范

• node.js遵循了Commonjs模块化规范，commonjs规定了模块的特性和各模块之间相互依赖
  CommonJs规定
• 每个模块内部，module变量代表当前模块
• module变量是一个对象，他的exports属性（即moudule.exports）是对外的接口
• 加载某个模块，其实是加载该模块的module.exports属性，require（）方法用于加载模块