Node.js

https://github.com/smallC-L-Y/Demo/blob/notes/nodeJS%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0.md

https://github.com/SunGodAppollo/node.js/tree/learn

如何通过饿了么 Node.js 面试 https://github.com/ElemeFE/node-interview/tree/master/sections/zh-cn

• nodejs，只是一个js运行时环境，解析和执行js代码，让js可以脱离浏览器来运行，
• node.js中的js没有BOM、DOM只是为js提供了一些操作浏览器级别的API，例如文件的读写、网络服务的构建、网络通信、http服务器

一、nodejs的特点

事件驱动

在前端为Ajax请求绑定success时间，在发出请求后，只需要在请求成功时执行相应的业务逻辑即可。

非阻塞IO模型（异步调用）

绝大多数的操作都是以异步的方式进行调用，每个调用之间不用等待之前的I/O调用结束，如网路请求，读取文件。

单线程

保持了js在浏览器中单线程的特点

好处：

不用想多线程那样处处在意状态的同步问题，没有死锁，不用创建多个线程，没有线程切换带来的性能开销。

缺点：

• 无法利用多核CPU（Node提供了child_process模块，来实现进程的复制）
• 错误会引起整个应用的退出。
• 大量计算占用CPU导致无法继续调用异步I/O

Node采用WebWorker思路解决单线程中的大计算量问题：child_process，子进程。

通过将计算分发到各个子进程，然后再通过进程之间的事件消息来传递结果。通过Master-Worker的管理方式，很好的管理各个工作进程。

面试题：

二、Nodejs的简单应用：

1.读写文件

//读文件

var fs = require('fs')
//读文件
fs.readFile('./hello2.txt',*function* (*err*,*data*) {
  //成功
  if(data){
    console.log(data.toString())
  }
  //失败
  if(err) {
    console.log('读取文件失败')
  }
})
*//写文件*
fs.writeFile('./hello1.txt',"大家好，我是nodejs",*function* (*err*) {
  console.log('文件写入成功')
})

2.简单的http请求

需要引入http核心模块，使用 http.createServer() 方法创建一个web服务器 ，返回一个server实例，服务器需要接收请求，处理响应数据。

// 1.加载http核心模块*
*var* http = require('http')
*//2.使用http.createServer() 方法创建一个web服务器 返回一个server实例*
*var* server = http.createServer()
*//3.服务器接收请求 处理请求 响应数据*
*//当客户端请求过来，就会自动触发服务器的request请求事件 ，然后执行回调函数*
server.on('request',*function* () {
  console.log('收到客户端的请求了')
})
*//4，绑定端口号，启动服务器*
server.listen(3000,*function* () {
  console.log('服务器启动成功了，可以通过http://127.0.0.1:3000来访问一下')
})

3.http响应请求

var http = require('http')
var server = http.createServer()
// request 请求事件处理函数，需要接收两个参数*
// Request   请求对象 获取客户端的请求信息*
// Response  响应对象 给客户端发送响应数据 有三个重要函数，用于返回响应头、响应内容，以及结束请求。
server.on('request',*function* (*Request*,*Response*) {
  console.log('收到客户端的请求了,请求路径是：' + Request.url)
   //1. writeHead 设置状态码  设置响应数据类型 
    response.writeHead(200, {'content-type':'text/plain;charset=utf-8'})
  //2.write  Response 对象有一个方法：write，可以用来给客户端发送响应数据 可以使用多次，但是最后一定要用end来结束响应，否则客户端会一直等待
  Response.write('hello')
  Response.write('nodejs')
 //3. 结束响应 必须被调用一次，如果不调用，客户端将永远处于等待状态。
  Response.end()
})
//关闭服务器
server.on('close', ()=>{
    console.log('服务器关闭成功')
})
server.close() // 底层相当于调用了 server.emit('close') 
server.listen(3000,*function* () {
  console.log('服务器启动成功了，可以通过http://127.0.0.1:3000来访问一下')
})

Get方式获取请求参数

get请求请求参数直接嵌套在路径中，而url属性是完整的请求路径，因此可以手动解析url获得请求参数。Nodejs的url模块中parse函数就提供了这个功能。

const http = require('http')
const url = require('url')
const serve = http.createServer((req,res) =>{
    let params = url.parse(req.url, true)
    console.log(params) // 解析后的参数
    console.log(params.query)  // 请求参数
    res.end('Get')
})
serve.listen(8088, ()=>{
    console.log('running...')
})

Post方式获取请求参数

post请求参数不在路径 url上，而是通过请求体传递的。但是 http 并没有一个属性内容是请求体，原因是等待请求体传输可能是一件耗时的工作，比如，上传文件。而很多时候并不需要例会请求体的内容，恶意的POST请求会消耗服务器资源，所以nodejs不会解析请求体的。我们可以借助querystring模块进行参数解析

const http = require('http')
const url = require('url')
const querysrting = require('querystring')
const serve = http.createServer((req,res)=>{
    let params = ''
    req.on('data', (chunk) =>{  //当有data传过来的时候就会触发data事件，对参数进行拼接
        params += chunk
    })
    req.on('end', () =>{
        console.log(querysrting.parse(params))  // 使用querysrting模块将字符串转成js对象
    })
})
serve.listen(8088, ()=>{
    console.log('running...')
})

4.路径分发

根据不同的请求路径，做不同的响应处理。

首先要获取请求路径， req.url获取到的就是端口号之后的那一部分路径，然后根据不同的路径返回不同的内容

*const* http = require('http')
*const* server = http.createServer()
server.on('request', *function* (*req*,*res*) {
  console.log('收到客户端的请求了,请求路径是：' + req.url)
  *// res.write('hello') //这种方式比较麻烦*
  *//发送响应数据并且结束响应*
  *// res.end('hello')*
  *//根据不同的请求路径返回 不同的响应结果*
  *//1.获取请求路径     req.url 获取到的就是端口号之后的那一部分路径*
  *var* url = req.url
  *//2.根据路径处理响应*
  if (url === '/') {
    res.end('index page')
  }else if (url === '/login') {
    res.end('login page')
  }else if (url === '/products') {
    *var* products = [
      {
        name:'苹果X',
        price:8888
      },
      {
        name:'华为p40',
        price:5000
      },
      {
        name:'小米10',
        price:4999
      },
    ]
    res.end(JSON.stringify(products))
  }
  else {
    res.end('404 Not Found')
  }
})
server.listen(3000,*function* () {
  console.log('服务器启动成功，可以访问了')
})

5.nodejs中的核心模块

require是一个方法，它的作用就是用来加载模块的，在node中，模块有三种：

• 1.具名模块，例如：fs、http
• 2.用户自己的编写的文件模块 在引入的时候相对路径必须加 ./
• 3.第三方模块

console.log('a start')
require('./b')  //遇到requre就去加载对应模块
console.log('a end')

在node中没有全局作用域，只有模块作用域

要想模块之间通信，不仅要导入模块，而且还需要另一个模块导出一个接口对象，这样才可以在一个文件模块中使用另一个模块文件的变量

b.js

exports.foo = 'bbbb'
exports.add = function (x, y) {
    return x+y
}

a.js

console.log('a start')
var bExports = require('./b')  //遇到requre就去加载对应模块
console.log(bExports.foo)
console.log(bExports.add(10,30))
console.log('a end')

6.响应内容类型

在服务端默认发送的数据是 utf8编码的内容

但是浏览器不知道是utf8编码内容，它会按照当前操作系统的默认编码去解析，中文操作系统默认是 gbk，所以解析之后会出现乱码情况。

解决方法是正确告诉浏览器我给你发送发的内容是什么编码，在http协议中，Content-Type 就是用来告诉浏览器我给你发送分数据内容是什么类型

const http = require('http')
const server = http.createServer()
server.on('request', function (req, res) {
    if (req.url === '/plain') {
        res.setHeader('Content-Type','text/plain;charset=utf-8')
        res.end('你好，nodejs')
    }else if (req.url === '/html') {
        res.setHeader('Content-Type','text/html;charset=utf-8')
        res.end('<p>hello html <a>点我</a></p>')
    }
})
server.listen(3000, function () {
    console.log('Server  is running...')
})

7. 响应文件内容

将html文件返回给浏览器

const fs = require('fs')
const http = require('http')
const server = http.createServer()
server.on('request', function (req,res) {
    let url = req.url
    if(url === '/') {
        fs.readFile('./resource/index.html', function (err,data) {
            if(err) {
                res.setHeader('Contend-Type','text/plain;charset=utf-8')
                res.end('文件读取失败，请稍后重试')
            }else {
                res.setHeader('Content-Type','text/html;charset=utf-8')
                res.end(data)
            }
        })
    }else if(url === '/img') {
        fs.readFile('./resource/store.png', function (err,data) {
            if(err){
                res.setHeader('Contend-Type','text/plain;charset=utf-8')
                res.end('图片获取失败，请稍后重试')
            }else {
                res.setHeader('Contend-Type','image/jpeg')
                res.end(data)
            }
        })
    }
})
server.listen(3000,function () {
    console.log('Server is running...')
})

1. 结合fs 发送文件中的数据
2. Content-Type 告诉浏览器数据类型是什么
3. 不同的资源对应的Content-Type是不一样的，图片不需要指定编码，一般只为字符数据指定编码
4. Content-Type 对照表 http://tool.oschina.net/commons

8.初步实现Apache的功能

希望资源访问路径不要写死，而是根据url中写入的路径进行查询展示

const http = require('http')
const fs = require('fs')
const Server = http.createServer()
Server.on('request',function(req, res) {
    let url = req.url
    let filePath = '/index.html'
    let wwwDir = 'D:/资料库/学习资料/黑马程序员node/02/code/www'
    if (url !== '/') {
        filePath = url
    }
    console.log(filePath, wwwDir + filePath)
    fs.readFile(wwwDir + filePath, function(err,data){
        if(err) {
            return res.end('404 Not Found')
        }
        res.end(data)
    })
})
Server.listen(5000, function () {
    console.log('runnning...')
})

以读文件的方式读取资源所对的路径。

9.在node中使用模板引擎

使用art-template插件实现模板引擎渲染

const template = require('art-template')
 const fs = require('fs')
 fs.readFile('./tpl.html', function (err,data) {
     if(err){
         return console.log('读取文件失败')
     }
     let ret = template.render(data.toString(),{
         name:'Jack',
         age:18,
         province:'北京市',
         hobbies:[
             '写代码',
             '唱歌',
             '打游戏'
         ]
     })
     console.log(ret)
 })

tpl.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <p>大家好，我叫：{{ name }}</p>
    <p>我今年{{ age }}岁了</p>
    <h1>我来自{{ province }}</h1>
    <p>我喜欢：{{each hobbies }} {{ value }} {{/each}}</p>
</body>
</html>

template.render(模板，渲染数据对象)

10.服务端渲染和客户端渲染的区别

11.后端渲染的留言板

11.1、模板

app.js后端文件

const http = require('http')
const fs = require('fs')
http.createServer(function (req,res) {
    let url = req.url
    if(url === '/') {
        fs.readFile('./view/index.html',function(err,data) {
            if(err){
                return res.end('404 Not Found.')
            }
            res.end(data)
        })
    }
    // res.end('hello')
}).listen(5000, function () {
    console.log('running...')
})

当请求路径是 / 时，就去读取index.html

index.html 首页

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <link rel="stylesheet" href="../public/css/bootstrap.min.css">
</head>
<body>
    <h1>你好</h1>
</body>
<script src="../public/js/index.js"></script>
</html>

post.html 留言板

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <link rel="stylesheet" href="../public/css/bootstrap.min.css">
</head>
<body>
</body>
</html>

对于html中的外链静态资源文件需要统一处理才能访问到，否则会一直是pendding状态

11.2、静态资源开放目录

const http = require('http')
const fs = require('fs')
http.createServer(function (req,res) {
    let url = req.url
    if (url === '/') {
        fs.readFile('./view/index.html', function (err,data) {
            if (err) {
                return res.end('404 Not Found.')
            }
            res.end(data)
        })
    }else if (url.indexOf('/public/') === 0) {
        fs.readFile('.' + url, function (err,data) {
            if(err){
                return end('404 Not Found')
            }
            res.end(data)
        })
    }
    // res.end('hello')
}).listen(5000, function () {
    console.log('running...')
})

将静态资源统一放到public目录下，然后通过indexOf判断请求路径中是否有public，如果有就是去访问这个目录下的静态资源。

11.3、渲染评论首页

app.js

const http = require('http')
const fs = require('fs')
const template = require('art-template')
let comments = [
    {
        name:'小明',
        message:'今天吃什么',
        dateTime:'2020-6-18'
    },
    {
        name:'小丽',
        message:'逛街去',
        dateTime:'2020-6-18'
    },
    {
        name:'小红',
        message:'吃火锅',
        dateTime:'2020-6-18'
    },
    {
        name:'小黑',
        message:'你们都走了我好孤独',
        dateTime:'2020-6-18'
    }
]
http.createServer(function (req,res) {
    let url = req.url
    if (url === '/') { //首页路径处理
        fs.readFile('./view/index.html', function (err,data) {
            if (err) {
                return res.end('404 Not Found.')
            }
            let htmlStr = template.render(data.toString(), {
                comments:comments
            })
            res.end(htmlStr)
        })
    }else if (url.indexOf('/public/') === 0) { //静态资源路径处理
        fs.readFile('.' + url, function (err,data) {
            if(err){
                return res.end('404 Not Found')
            }
            res.end(data)
        })
    }else if (url === '/post') {
        fs.readFile('./view/post.html', function (err, data) {
            if (err) {
                return res.end('404 Not Found')
            }
            res.end(data)
        })
    }else { // 其它路径处理，统一跳转到404页面
        fs.readFile('./view/404.html', function (err,data) {
            if (err) {
                return res.end('404 Not Found.')
            }
            res.end(data)
        })
    }
    // res.end('hello')
}).listen(5000, function () {
    console.log('running...')
})

comments 存放评论数据，当访问首页的时候通过template.render方法渲染这些数据，第一个参数是模板文件，第二个参数是渲染数据。

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <link rel="stylesheet" href="../public/css/bootstrap.min.css">
</head>
<body>
    <div class="header container">
        <div class="page-header">
            <h1>留言板</h1>
            <a class="btn btn-success" href="/post">发表留言</a>
        </div>
    </div>
    <div class="comments container">
        <ul class="list-group">
            {{each comments}}
            <li class="list-group-item">{{$value.name}}说：{{$value.message}}<span class="float-right">{{$value.dateTime}}</span></li>
            {{/each}}
        </ul>
    </div>
</body>
<script src="../public/js/index.js"></script>
</html>

在模板中通过{{each comments}}方法进行渲染页面。

11.4、处理表单get提交留言信息url.parse

需要提交的表单控件元素必须要有name属性

表单提交分为：

• 默认的提交行为
  action： 表单提交地址 method： 请求方法
• 异步提交

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <link rel="stylesheet" href="../public/css/bootstrap.min.css">
</head>
<body>
    <div class="header container">
        <div class="page-header">
            <h1><a href="/">首页</a><small>发表评论</small></h1>
        </div>
    </div>
    <div class="commerts container">
        <form action="/pinglun" method="GET">
            <div class="form-group">
                <label for="input_name">昵称</label>
                <input type="text" name="name" class="form-control" required minlength="2"  placehoder="请输入您的昵称">
            </div>
            <div class="form-group">
                <label for="textarea_message">留言内容</label>
                <textarea name="message" id="textarea_message" required cols="30" rows="10" class="form-control"></textarea>
            </div>
            <button type="submit" class="btn btn-primary">发表留言</button>
        </form>
    </div>
</body>
</html>

这样我们的请求路径会把留言信息拼接到 url 后面，我们可以通过nodejs的 url.parse 方法将 url 进行解析

url.parse,将路径解析成一个方便操作的对象，第二个参数为 true 表示将查询参数转为对象，通过query属性访问获取

const http = require('http')
const fs = require('fs')
const template = require('art-template')
const url = require('url')
const { parse } = require('path')
let comments = [
    {
        name:'小明',
        message:'今天吃什么',
        dateTime:'2020-6-18'
    },
    {
        name:'小丽',
        message:'逛街去',
        dateTime:'2020-6-18'
    },
    {
        name:'小红',
        message:'吃火锅',
        dateTime:'2020-6-18'
    },
    {
        name:'小黑',
        message:'你们都走了我好孤独',
        dateTime:'2020-6-18'
    }
]
http.createServer(function (req,res) {
    // let url = req.url
    //使用url.parse方法将路径解析成一个方便操作的对象，第二个参数为true表示将查询参数转为对象，通过query属性访问获取
    let parseObj = url.parse(req.url,true)
    //单独获取不包含查询字符串的部分 （该路径不包含 ？ 之后的内容）
    let pathname = parseObj.pathname
    if (pathname === '/') { //首页路径处理
        fs.readFile('./view/index.html', function (err,data) {
            if (err) {
                return res.end('404 Not Found.')
            }
            let htmlStr = template.render(data.toString(), {
                comments:comments
            })
            res.end(htmlStr)
        })
    }else if (pathname.indexOf('/public/') === 0) { //静态资源路径处理
        fs.readFile('.' + pathname, function (err,data) {
            if(err){
                return res.end('404 Not Found')
            }
            res.end(data)
        })
    }else if (pathname === '/post') {
        fs.readFile('./view/post.html', function (err, data) {
            if (err) {
                return res.end('404 Not Found')
            }
            res.end(data)
        })
    }else if (pathname === '/pinglun') {
        // res.end(JSON.stringify(parseObj.query))
        //使用parse方法将请求路径中的查询字符串解析成了一个对象，
        //所以接下来要做的就是
        //  1.获取表单提交信息 parseObj.query
        //  2.生成日期,存储到数组中
        //  3.让用户重定向到首页
        let comment = parseObj.query
        comment.dateTime = '2020-6-20'
        comments.unshift(comment)
    } else { // 其它路径处理，统一跳转到404页面
        fs.readFile('./view/404.html', function (err,data) {
            if (err) {
                return res.end('404 Not Found.')
            }
            res.end(data)
        })
    }
    // res.end('hello')
}).listen(5000, function () {
    console.log('running...')
})

当pathname === ‘/pinglun’ 的时候将转换后的查询字符串对象push到comments中，接下来就是要重定向到首页

11.5、提交成功重定向到首页

else if (pathname === '/pinglun') {
        // res.end(JSON.stringify(parseObj.query))
        //使用parse方法将请求路径中的查询字符串解析成了一个对象，
        //所以接下来要做的就是
        //  1.获取表单提交信息 parseObj.query
        //  2.生成日期,存储到数组中
        //  3.让用户重定向到首页
        let comment = parseObj.query
        comment.dateTime = '2020-6-20'
        comments.unshift(comment)
        //服务端这个时候已经把数据存储好了，接下来就是让用户重新请求 / 首页了
        // 如何通过服务器让客户端重定向
        //  1. 在状态码中设置302 临时重定向
        //  2. 在响应头中通过Location 告诉用户往哪儿重定向
        //如果客户端收到服务器的响应状态码是 302 就会自动去响应头中找 Location ，并自动跳转
        res.statusCode = 302
        res.setHeader('Location', '/')
        res.end()
    }

使用statusCode方法设置状态码302 临时重定向

使用setHeader 方法在响应头中设置Location，告诉浏览器要跳转的地址

三、node中的模块系统

1.基本规则

使用Node编写应用程序主要就是在使用：

• EcmaScript语言
  • 和浏览器一样，在Node中没有Bom和Dom
• 核心模块
  • 文件操作的fs
  • http服务操作的http
  • url路径操作模块
  • path路径处理模块
  • os操作系统信息
• 第三方模块
  • art-template
  • 必须通过npm来下载才可以使用
• 自己写的模块
  • 自己创建的文件

2.什么是模块化

https://www.jianshu.com/p/8573cdcde863

• 文件作用域(模块是独立的，在不同的文件使用必须要重新引用)【在node中没有全局作用域，它是文件模块作用域】
• 通信规则
  • 加载require
  • 导出exports

3.CommonJS模块规范

在Node中的JavaScript还有一个重要的概念，模块系统。

CommonJS主要用在Node开发上，每个文件就是一个模块，每个文件都有自己的一个作用域。通过module.exports或者exports暴露给外界。其他模块可以通过require()引入模块依赖，require 函数可以引入Node的内置模块、自定义模块和npm等第三方模块。

package.json是CommonJS规定的用来面熟包的文件，完全符合规范的文件应包含以package.json下字段。

• 模块作用域
• 使用require方法来加载模块
• 使用exports接口对象来导出模板中的成员加载require

语法：

var 自定义变量名 = require('模块')

• 作用：

  • 执行被加载模块中的代码

  • 得到被加载模块中的exports导出接口对象

    导出exports

  • Node中是模块作用域，默认文件中所有的成员只在当前模块有效

  • 对于希望可以被其他模块访问到的成员，我们需要把这些公开的成员都挂载到exports接口对象中就可以了
    导出多个成员（必须在对象中）：

    exports.a = 123;
    exports.b = function(){
    console.log('bbb')
    };
    exports.c = {
    foo:"bar"
    };
    exports.d = 'hello';

  • 导出单个成员（拿到的就是函数，字符串）：

    module.exports = 'hello';

  • 以下情况会覆盖：

    module.exports = 'hello';
    //后者会覆盖前者
    module.exports = function add(x,y) {
    return x+y;
    }

  • 也可以通过以下方法来导出多个成员：

    module.exports = {
    foo = 'hello',
    add:function(){
       return x+y;
    }
    };

4.模块原理

exports和module.exports的一个引用：

console.log(exports === module.exports);    //true
exports.foo = 'bar';
//等价于
module.exports.foo = 'bar';
当给exports重新赋值后，exports！= module.exports.
最终return的是module.exports,无论exports中的成员是什么都没用。
真正去使用的时候：
    导出单个成员：exports.xxx = xxx;
    导出多个成员：module.exports 或者 modeule.exports = {};

总结

// 引用服务
var http = require('http');
var fs = require('fs');
// 引用模板
var template = require('art-template');
// 创建服务
var server = http.createServer();
// 公共路径
var wwwDir = 'D:/app/www';
server.on('request', function (req, res) {
    var url = req.url;
    // 读取文件
    fs.readFile('./template-apche.html', function (err, data) {
        if (err) {
            return res.end('404 Not Found');
        }
        fs.readdir(wwwDir, function (err, files) {
            if (err) {
                return res.end('Can not find www Dir.')
            }
            // 使用模板引擎解析替换data中的模板字符串
            // 去xmpTempleteList.html中编写模板语法
            var htmlStr = template.render(data.toString(), { 
                title: 'D:/app/www/ 的索引',
                files:files 
            });
            // 发送响应数据
            res.end(htmlStr);
        })
    })
});
server.listen(3000, function () {
    console.log('running....');
})

5.加载规则

1. 核心模块 http，fs 等直接返回模块
2. / 开头加载全局的文件，再加载文件夹
3. ./ 和 ../ 开头先加载文件，再加载文件夹
4. 非核心模块，路径里也没有 / ./ ../ 的则去 node_module 里加载文件夹

加载文件 X：X -> X.js -> X.json -> X.node

加载文件夹: X/package.json 里得到 main 字段为 M，加载文件 M。找不到再 加载文件 index

————————————————————————————以上是简单理解——————————————————————

• 1、先计算模块路径
• 2、如果模块在缓存里面，取出缓存
• 3、否则根据计算出来的模块路径加载模块
• 4、输出模块的exports属性即可

在node中引入模块，需要经过三个步骤：

• 路径分析
• 文件定位
• 编译执行

核心模块文件已经被编译到了二进制文件中了，我们只需要按照名字来加载就可以了，不需要文件定位和编译执行，并且在路径分析中优先判断。

文件模块则是运行时动态加载，需要完整的路径分析、文件定位、编译执行。

5.1 优先从缓存加载

node会对引入过的模块进行缓存，以减少二次引入时的开销。node缓存的是编译和执行之后的对象。核心模块的缓存检查先于文件模块的缓存检查。

5.2 路径分析

核心模块：

不需要路径分析。

文件模块：

其实就是加载自己写的JS文件，require会将路径转为真实路径，并以真实路径作为索引。

第三方模块：

没有文件路径，Node将试图去当前目录的node_modules文件夹里搜索。如果当前目录的node_modules里没有找到，Node会从父目录的node_modules里搜索，这样递归下去直到根目录。

5.3 文件定位

文件扩展名分析

如果require标识符中不包含文件扩展名，node就会按照 .js、.json 、.node的次序补足扩展名，依次尝试。

目录分析

从package.json中得到main字段对应的文件，将他和文件扩展名目录对比定位，没有package.json会将index作为默认文件。

5.4 模块编译

编译和执行是引入文件模块的最后一个阶段。定位到具体文件后，Node会新建一个模块对象，然后通过路径载入并编译。对于不同的文件扩展名，其载入的方式也有所不同，具体如下。

• .js文件。通过fs模块同步读取文件后编译执行。
• .node文件。这是用C/C++编写的扩展文件，通过dlopen()方法加载最后的编译生成的文件。
• .json文件。通过fs模块同步读取文件后，用JSON.parse()解析返回结果。
• 其余扩展名文件。它们都被当作.js文件解析。(因为node只能解析js文件，其他文件最后都会被转化成js文件，故当其余扩展名文件出现时，node无法识别，故将其认为是默认扩展名进行解析，即.js)

每一个编译成功的模块都会将文件路径作为索引缓存在Module._cache对象上，以提高二次引入的性能。

js模块编译

node会对获取的js文件内容进行头尾包装，在头部添加(function(require、exports、module、_filename、_dirname) {\n, 在尾部添加 \n} 具体如下：

(function(require、exports、module、_filename、_dirname){
    var math = require('math');
    exports.area = function(radius){
        return Math.PI * radius * radius;
    }
})

这样每个模块文件之间都进行了作用于隔离。不污染全局，最后，将当前模块对象的exports属性，require()方法，module(模块对象本身)，以及在文件定位中得到的完整文件路径和文件目录作为参数传递给一个function()对象执行。

JSON文件编译

Node利用fs模块同步读取JSON文件的内容之后，调用JSON.parse（）方法得到对象，然后将它赋给模块对象的exports，以供外部调用。

JSON文件在用作项目的配置文件时比较有用。如果你定义了JSON文件作为配置，那就不用调用fs模块去异步读取和解析，直接调用require（）引入即可。此外，你还可以享受到模块缓存的便利，并且二次引入时也没有性能影响。

核心模块编译

这里只说一下js核心模块编译。

首先需要将所有的js核心模块编译为C++代码。

其次，再执行编译，和文件模块的编译相同，也要头尾包装，不同的是获取源代码（核心模块是从内存中获取）的方式和缓存执行结果的位置不同。

编译成功的核心模块会缓存到NativeModule.Cache对象上，文件模块则缓存到Module._cache对象上

总结

// 如果非路径形式的标识
// 路径形式的标识：
    // ./  当前目录 不可省略
    // ../  上一级目录  不可省略
    //  /xxx也就是D:/xxx
    // 带有绝对路径几乎不用（D:/a/foo.js）
// 首位表示的是当前文件模块所属磁盘根目录
// require('./a'); 
// 核心模块
// 核心模块本质也是文件，核心模块文件已经被编译到了二进制文件中了，我们只需要按照名字来加载就可以了
require('fs'); 
// 第三方模块
// 凡是第三方模块都必须通过npm下载（npm i node_modules），使用的时候就可以通过require('包名')来加载才可以使用
// 第三方包的名字不可能和核心模块的名字是一样的
// 既不是核心模块，也不是路径形式的模块
//      先找到当前文所述目录的node_modules
//      然后找node_modules/art-template目录
//      node_modules/art-template/package.json
//      node_modules/art-template/package.json中的main属性
//      main属性记录了art-template的入口模块
//      然后加载使用这个第三方包
//      实际上最终加载的还是文件
//      如果package.json不存在或者mian指定的入口模块不存在
//      则node会自动找该目录下的index.js
//      也就是说index.js是一个备选项，如果main没有指定，则加载index.js文件
//      
        // 如果条件都不满足则会进入上一级目录进行查找
// 注意：一个项目只有一个node_modules，放在项目根目录中，子目录可以直接调用根目录的文件
var template = require('art-template');

五、npm

• node package manage(node包管理器)
• 通过npm命令安装jQuery包（npm install —save jquery），在安装时加上—save会主动生成说明书文件信息（将安装文件的信息添加到package.json里面）

1.常用命令

• npm init(生成package.json说明书文件)
  • npm init -y(可以跳过向导，快速生成)
• npm install
  • 一次性把dependencies选项中的依赖项全部安装
  • 简写（npm i）
• npm install 包名
  • 只下载
  • 简写（npm i 包名）
• npm install —save 包名
  • 下载并且保存依赖项（package.json文件中的dependencies选项）
  • 简写（npm i 包名）
• npm uninstall 包名
  • 只删除，如果有依赖项会依然保存
  • 简写（npm un 包名）
• npm uninstall —save 包名
  • 删除的同时也会把依赖信息全部删除
  • 简写（npm un 包名）
• npm help
  • 查看使用帮助
• npm 命令 —help
  • 查看具体命令的使用帮助（npm uninstall —help）

2.解决npm被墙问题

npm存储包文件的服务器在国外，有时候会被墙，速度很慢，所以需要解决这个问题。

https://developer.aliyun.com/mirror/NPM?from=tnpm淘宝的开发团队把npm在国内做了一个镜像（也就是一个备份）。

安装淘宝的cnpm：

npm install -g cnpm --registry=https://registry.npm.taobao.org;
#在任意目录执行都可以
#--global表示安装到全局，而非当前目录
#--global不能省略，否则不管用
npm install --global cnpm

安装包的时候把以前的npm替换成cnpm。

#走国外的npm服务器下载jQuery包，速度比较慢
npm install jQuery;
#使用cnpm就会通过淘宝的服务器来下载jQuery
cnpm install jQuery;

如果不想安装cnpm又想使用淘宝的服务器来下载：

npm install jquery --registry=https://npm.taobao.org;

但是每次手动加参数就很麻烦，所以我们可以把这个选项加入到配置文件中：

npm config set registry https://npm.taobao.org;
#查看npm配置信息
npm config list;

只要经过上面的配置命令，则以后所有的npm install都会通过淘宝的服务器来下载

3.package.json

每一个项目都要有一个package.json文件（包描述文件，就像产品的说明书一样）

这个文件可以通过npm init自动初始化出来

D:\code\node中的模块系统>npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install <pkg>` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
package name: (node中的模块系统)
Sorry, name can only contain URL-friendly characters.
package name: (node中的模块系统) cls
version: (1.0.0)
description: 这是一个测试项目
entry point: (main.js)
test command:
git repository:
keywords:
author: xiaochen
license: (ISC)
About to write to D:\code\node中的模块系统\package.json:
{
  "name": "cls",
  "version": "1.0.0",
  "description": "这是一个测试项目",
  "main": "main.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "xiaochen",
  "license": "ISC"
}
Is this OK? (yes) yes

对于目前来讲，最有用的是dependencies选项，可以用来帮助我们保存第三方包的依赖信息。

如果node_modules删除了也不用担心，只需要在控制面板中npm install就会自动把package.json中的dependencies中所有的依赖项全部都下载回来。

• 建议每个项目的根目录下都有一个package.json文件
• 建议执行npm install 包名的时候都加上--save选项，目的是用来保存依赖信息

4.package.json和package-lock.json

npm 5以前是不会有package-lock.json这个文件

npm5以后才加入这个文件

当你安装包的时候，npm都会生成或者更新package-lock.json这个文件

• npm5以后的版本安装都不要加--save参数，它会自动保存依赖信息

• 当你安装包的时候，会自动创建或者更新package-lock.json文件

  package-lock.json

• 这个文件会包含

  node_modules

• 中所有包的信息（版本，下载地址。。。）

  • 这样的话重新npm install的时候速度就可以提升

• 从文件来看，有一个

  lock

• 称之为锁

  • 这个lock使用来锁版本的
  • 如果项目依赖了1.1.1版本
  • 如果你重新install其实会下载最新版本，而不是1.1.1
  • package-lock.json的另外一个作用就是锁定版本号，防止自动升级

5.path路径操作模块

参考文档：https://nodejs.org/docs/latest-v13.x/api/path.html

• path.basename：获取路径的文件名，默认包含扩展名
• path.dirname：获取路径中的目录部分
• path.extname：获取一个路径中的扩展名部分
• path.parse：把路径转换为对象
  • root：根路径
  • dir：目录
  • base：包含后缀名的文件名
  • ext：后缀名
  • name：不包含后缀名的文件名
• path.join：拼接路径
• path.isAbsolute：判断一个路径是否为绝对路径

6.Node中的其它成员(dirname,filename)

在每个模块中，除了require,exports等模块相关的API之外，还有两个特殊的成员：

• __dirname，是一个成员，可以用来动态获取当前文件模块所属目录的绝对路径
• __filename，可以用来动态获取当前文件的绝对路径（包含文件名）
• __dirname和filename是不受执行node命令所属路径影响的
  

在文件操作中，使用相对路径是不可靠的，因为node中文件操作的路径被设计为相对于执行node命令所处的路径。

所以为了解决这个问题，只需要把相对路径变为绝对路径（绝对路径不受任何影响）就可以了。

就可以使用__dirname或者__filename来帮助我们解决这个问题

在拼接路径的过程中，为了避免手动拼接带来的一些低级错误，推荐使用path.join()来辅助拼接

var fs = require('fs');
var path = require('path');
// console.log(__dirname + 'a.txt');
// path.join方法会将文件操作中的相对路径都统一的转为动态的绝对路径
fs.readFile(path.join(__dirname + '/a.txt'),'utf8',function(err,data){
    if(err){
        throw err
    }
    console.log(data);
});

补充：模块中的路径标识和这里的路径没关系，不受影响（就是相对于文件模块）

注意： 模块中的路径标识和文件操作中的相对路径标识不一致 模块中的路径标识就是相对于当前文件模块，不受node命令所处路径影响

六、Express

作者：Tj

原生的http在某些方面表现不足以应对我们的开发需求，所以就需要使用框架来加快我们的开发效率，框架的目的就是提高效率，让我们的代码高度统一。

安装：

cnpm install express

起步：

const express = require('express')
const app = express()
app.get('/',function (req,res) {
    res.send('hello 你好a')
})
app.get('/login', function (req,res) {
    res.send(`
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Document</title>
    </head>
    <body>
        你好，人生
    </body>
    </html>
    `)
})
app.listen(3000, function () {
    console.log('express app is running...')
})

可以看到我们访问某个路径的时候只需要 app.get 即可获取对应内容，而不需要再像之前一样需要通过 一层一层的 if 条件判断，然后 fs.readfile 来读取文件内容。

1.基本路由

路由：请求方法 + 请求路径 + 请求处理函数

get：

当以get方法请求时，执行对应处理函数

app.get('/',function (req,res) {
    res.send('hello 你好a')
})

post:

当以post方法请求时，执行对应处理函数

app.post('/',function(req,res){
    res.send('hello world');
})

2.Express静态服务API

// app.use不仅仅是用来处理静态资源的，还可以做很多工作(body-parser的配置)
app.use(express.static('public'));
app.use(express.static('files'));
app.use('/stataic',express.static('public'));
// 引入express
var express = require('express');
// 创建app
var app = express();
// 开放静态资源
// 1.当以/public/开头的时候，去./public/目录中找对应资源
// 访问：http://127.0.0.1:3000/public/login.html
app.use('/public/',express.static('./public/')); 
// 2.当省略第一个参数的时候，可以通过省略/public的方式来访问
// 访问：http://127.0.0.1:3000/login.html
// app.use(express.static('./public/'));   
// 3.访问：http://127.0.0.1:3000/a/login.html
// a相当于public的别名
// app.use('/a/',express.static('./public/')); 
//  
app.get('/',function(req,res){
    res.end('hello world');
});
app.listen(3000,function(){
    console.log('express app is runing...');
});

3.在Express中配置使用art-templete模板引擎

• art-template官方文档

• 在node中，有很多第三方模板引擎都可以使用，不是只有

  art-template

  • 还有ejs，jade（pug），handlebars，nunjucks

安装：

npm install --save art-template
npm install --save express-art-template
//两个一起安装
npm i --save art-template express-art-template

配置：

app.engine('html', require('express-art-template'));

使用：

app.get('/',function(req,res){
    // express默认会去views目录找index.html
    res.render('index.html',{
           title:'hello world'     
    });
})

如果希望修改默认的views视图渲染存储目录，可以：

// 第一个参数views千万不要写错
app.set('views',目录路径);

4.使用Express重写留言板

目录：

app.js

const express = require('express')
const app = express()
app.use('/public/', express.static('./public/'))
app.engine('html',require('express-art-template'))
let comments = [
    {
        name:'小明',
        message:'今天吃什么',
        dateTime:'2020-6-18'
    },
    {
        name:'小丽',
        message:'逛街去',
        dateTime:'2020-6-18'
    },
    {
        name:'小红',
        message:'吃火锅',
        dateTime:'2020-6-18'
    },
    {
        name:'小黑',
        message:'你们都走了我好孤独',
        dateTime:'2020-6-18'
    }
]
Date.prototype.Format = function (fmt) { // author: meizz
    var o = {
        "M+": this.getMonth() + 1, // 月份
        "d+": this.getDate(), // 日
        "h+": this.getHours(), // 小时
        "m+": this.getMinutes(), // 分
        "s+": this.getSeconds(), // 秒
        "q+": Math.floor((this.getMonth() + 3) / 3), // 季度
        "S": this.getMilliseconds() // 毫秒
    };
    if (/(y+)/.test(fmt))
        fmt = fmt.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
    for (var k in o)
        if (new RegExp("(" + k + ")").test(fmt)) fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
            return fmt;
}
app.get('/',function (req,res) {
    res.render('index.html', {
        comments:comments
    })
})
app.get('/post',function (req,res) {
    res.render('post.html')
})
app.get('/pinglun', function (req,res) {
    let comment = req.query
    comment.dateTime = new Date().Format("yyyy-MM-dd")
    comments.unshift(comment)
    res.redirect('/') //等价于下面
    // res.status = 302
    // res.setHeader('Location','/')
})
app.listen(3000, function () {
    console.log('express app is running...')
})

相比之前的写法更加简洁

5.在Express中获取post表单请求体数据

对于get方法请求数据可以直接通过req.query来获取数据，但是post方法的数据不能直接获取。

在express中没有内置获取post表单请求体的api，因此使用一个第三方包 body-parser

安装方法：

npm install --save body-parser

使用方法:

通过req.body 这个api拿到请求体数据

var express = require('express')
#记得导包
var bodyParser = require('body-parser')
var app = express()
#关键代码
app.use(bodyParser.urlencoded({ extended: false }))
app.use(bodyParser.json())
//post方法处理表单请求体数据
app.post('/post', function (req,res) {
    //1.获取表单请求体数据
    //2.处理
    //3.发送响应
    let comment = req.body
    comment.dateTime = new Date().Format("yyyy-MM-dd")
    comments.unshift(comment)
    res.redirect('/')
})

七、Express-crud项目

1.路由设计

2.提取路由模块

方法一：

router.js

module.exports = function (app) {
    app.get('/students', function (req, res) {
        //readFile 的第二个参数是可选的，utf8 是告诉浏览器按照utf8编码格式进行转换，除了这样，也可以通过data.toString() 的方式
        fs.readFile('./db.json', function (err, data) {
            if (err) {
                return res.status(500).send('Server error.')
            }
            res.render('index.html',{
                fruits:[
                    '苹果',
                    '香蕉',
                    '橘子',
                    '西瓜'
                ],
                students: JSON.parse(data).students
            })
        })
    })
    app.get('/students/new', function (req, res) {
    })
    app.get('/students/new', function (req, res) {
    })
    app.get('/students/new', function (req, res) {
    })
    app.get('/students/new', function (req, res) {
    })
    app.get('/students/new', function (req, res) {
    })
    app.get('/students/new', function (req, res) {
    })
}

在app.js中引入，并传入参数router(app)

//引入路由模块
const router = require('./router')
const app = express()
const fs = require('fs')
app.engine('html', require('express-art-template'));
app.use('/node_modules/',express.static('./node_modules'))
app.use('/public/',express.static('./public'))
router(app)
app.listen(3000, function () {
    console.log('running...')
})