前后端交互—Node.js初识

Node.js初识

代码下载

回顾与思考

浏览器中的 JavaScript 的组成部分:

JS核心语法
- 变量、数据类型
- 循环、分支判断
- 函数、作用域、this
- etc...
WebAPI
- DOM操作
- BOM 操作
- 基于 XMLHttpRequest 的Aiax 操作
- etc...

为什么 JavaScript 可以在浏览器中被执行，是因为不同的浏览器使用不同的 JavaScript 解析引擎:

Chrome 浏览器 => V8
Firefox 浏览器 => OdinMonkey(奥丁猴)
safri 浏览器 => JSCore
IE 浏览器 => Chakra(查克拉)
etc...

其中，Chrome 浏览器的 V8 解析引擎性能最好!

为什么 JavaScript 可以操作 DOM 和 BOM，是因为每个浏览器都内置了 DOM、BOM 这样的 API 函数，因此，浏览器中的 JavaScript 才可以调用它们。

浏览器中的 JavaScript 运行环境：

JS引擎负责解析和执行 JavaScript 代码。
内置 API 是由运行环境提供的特殊接口，只能在所属的运行环境中被调用。

Node.js 简介

Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境。Node.js 的官网地址: https://nodejs.org/zh-cn/

Node.js 作为一个 JavaScript 的运行环境，仅仅提供了基础的功能和 API。然而，基于 Node.js 提供的这些基础能，很多强大的工具和框架如雨后春笋，层出不穷，所以学会了 Node.js ，可以让前端程序员胜任更多的工作和岗位:

基于 Express 框架(http://www.expressjs.com.cn/)，可以快速构建 Web 应用
基于 Electron 框架(https://electronjs.org/)，可以构建跨平台的桌面应用
基于 restify 框架(http://restify.com/)，可以快速构建 API 接口项目
读写和操作数据库、创建实用的命令行工具辅助前端开发、etc...

浏览器中的 JavaScript 学习路径与Node.js 的学习路径:

JavaScript 基础语法 + 浏览器内置 API(DOM + BOM) + 第三方库(jQuery、art-template 等)
JavaScript 基础语法 + Node.js 内置 API 模块(fs、path、http等) + 第三方 API 模块(express、mysql 等)

Node.js 环境的安装

安装包可以从 Node.js 的官网首页直接下载，进入到 Node.js 的官网首页(https://nodejs.org/en/)，点击绿色的按钮，下载所需的版本后，双击直接安装即可。打开终端，在终端输入命令 node --v 后，按下回车键，即可查看已安装的 Node.js 的版本号。

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

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

在 Node.js 环境中执行 JavaScript 代码：终端输入 node 要执行的js文件的路径。

fs 文件系统模块

fs 模块是 Node.js 官方提供的、用来操作文件的模块。它提供了一系列的方法和属性，用来满足用户对文件的操作需求。例如:

fs.readFile() 方法，用来读取指定文件中的内容
fs.writeFile() 方法，用来向指定的文件中写入内容

如果要在 JavaScript 代码中，使用 fs 模块来操作文件，则需要使用如下的方式先导入它:

const fs = require('fs');

fs.readFile() 的语法格式：fs.readFile(path[, options], callback);

参数1:必选参数，字符串，表示文件的路径。
参数2:可选参数，表示以什么编码格式来读取文件。
参数3:必选参数，文件读取完成后，通过回调函数拿到读取的结果。

fs.writeFile() 的语法格式：fs.writeFile(file, data[, options], callback);

参数1:必选参数，需要指定一个文件路径的字符串，表示文件的存放路径。
参数2:必选参数，表示要写入的内容。
参数3:可选参数，表示以什么格式写入文件内容，默认值是 utf8。
参数4:必选参数，文件写入完成后的回调函数

const fs = require('fs');
fs.writeFile('text.txt', 'hello world', 'utf-8', function(err) {
if (err) {
console.log(err);
} else {
console.log('文件写入成功');
}
});
fs.readFile('text.txt', 'utf-8', function(err, result) {
if (err) {
console.log(err);
} else {
console.log(result);
}
});

成绩整理案例：

    const fs = require('fs');
    // 读取文件
    var score = fs.readFile('./files/score.txt', 'utf-8', function(err, data) {
        if (err) {
            console.log(err);
        } else {
            // 处理成绩
            let v = data.split(' ');
            let sv = v.map(function(e) {
                return e.replace('=', ': ');
            });
            let result = sv.join('\n');
            // 写入新文件
            fs.writeFile('./files/score_ok.txt', result, 'utf-8', function(err) {
                if (err) {
                    console.log(err);
                } else {
                    console.log('成绩处理完成');
                }
            })
        }
    });

路径动态拼接的问题

在使用 fs 模块操作文件时，如果提供的操作路径是以 ./ 或 .../ 开头的相对路径时，很容易出现路径动态拼接错误的问题。

原因: 代码在运行的时候，会以执行 node 命令时所处的目录，动态拼接出被操作文件的完整路径。

解决方案: 在使用 fs 模块操作文件时，直接提供完整的路径，不要提供 ./ 或 .../ 开头的相对路径，从而防止路径动态拼接的问题。使用__dirname表示当前文件所在目录。

    console.log(__dirname);
    let path = __dirname + '/files/score.txt';
    console.log(path);

path 路径模块

如果要在 JavaScript 代码中，使用 path 模块来处理路径，则需要使用如下的方式先导入它 const path = require( 'path')。

path 模块是 Node.js 官方提供的、用来处理路径的模块。它提供了一系列的方法和属性，用来满足用户对路径的处理需求。例如:

path.join([...paths]) 方法，用来将多个路径片段拼接成一个完整的路径字符串
- ...paths 路径片段的序列
- 返回值:
path.basename(path[, ext]) 方法，用来从路径字符串中，将文件名解析出来
- path 必选参数，表示一个路径的字符串
- ext 可选参数，表示文件扩展名
- 返回: 表示路径中的最后一部分

path. extname(path) 方法，可以获取路径中的扩展名部分

path 必选参数，表示一个路径的字符串

返回: 返回得到的扩展名字符串

const path = require('path');
let p = path.join(__dirname, './files/score.txt');
console.log(p);
let name = path.basename(p);
console.log(name); // score.txt
name = path.basename(p, 'txt');
console.log(name); // score.
console.log(path.extname(p)); // .txt

拆分 html、CSS、js案例

导入需要的模块并创建正则表达式

// 1.1 导入 fs 模块
const fs = require('fs')
// 1.2 导入 path 模块
const path = require('path')

// 1.3 定义正则表达式，分别匹配 <style></style> 和 <script></script> 标签
const regStyle = /<style>[\s\S]</style>/
const regScript = /<script>[\s\S]</script>/
使用 fs 模块读取需要被处理的 html 文件

// 2.1 调用 fs.readFile() 方法读取文件
fs.readFile(path.join(__dirname, '../素材/index.html'), 'utf8', function(err, dataStr) {
// 2.2 读取 HTML 文件失败
if (err) return console.log('读取HTML文件失败！' + err.message)
// 2.3 读取文件成功后，调用对应的三个方法，分别拆解出 css, js, html 文件
resolveCSS(dataStr)
resolveJS(dataStr)
resolveHTML(dataStr)
})
自定义函数分别处理 css、js、html

// 3.1 定义处理 css 样式的方法
function resolveCSS(htmlStr) {
// 3.2 使用正则提取需要的内容
const r1 = regStyle.exec(htmlStr)
// 3.3 将提取出来的样式字符串，进行字符串的 replace 替换操作
const newCSS = r1[0].replace('<style>', '').replace('</style>', '')
// 3.4 调用 fs.writeFile() 方法，将提取的样式，写入到 clock 目录中 index.css 的文件里面
fs.writeFile(path.join(__dirname, './clock/index.css'), newCSS, function(err) {
if (err) return console.log('写入 CSS 样式失败！' + err.message)
console.log('写入样式文件成功！')
})
}

// 4.1 定义处理 js 脚本的方法
function resolveJS(htmlStr) {
// 4.2 通过正则，提取对应的 <script></script> 标签内容
const r2 = regScript.exec(htmlStr)
// 4.3 将提取出来的内容，做进一步的处理
const newJS = r2[0].replace('<script>', '').replace('</script>', '')
// 4.4 将处理的结果，写入到 clock 目录中的 index.js 文件里面
fs.writeFile(path.join(__dirname, './clock/index.js'), newJS, function(err) {
if (err) return console.log('写入 JavaScript 脚本失败！' + err.message)
console.log('写入 JS 脚本成功！')
})
}

// 5.1 定义处理 HTML 结构的方法
function resolveHTML(htmlStr) {
// 5.2 将字符串调用 replace 方法，把内嵌的 style 和 script 标签，替换为外联的 link 和 script 标签
const newHTML = htmlStr.replace(regStyle, '<link rel="stylesheet" href="./index.css" />').replace(regScript, '<script src="./index.js"></script>')
// 5.3 写入 index.html 这个文件
fs.writeFile(path.join(__dirname, './clock/index.html'), newHTML, function(err) {
if (err) return console.log('写入 HTML 文件失败！' + err.message)
console.log('写入 HTML 页面成功！')
})
}

http 模块

服务器和普通电脑的区别在于，服务器上安装了 web 服务器软件，例如:IIS、Apache 等。通过安装这些服务器软件，就能把一台普通的电脑变成一台 web 服务器。

在 Node.js 中，不需要使用 IIS、Apache 等这些第三方 web 服务器软件。因为我们可以基于 Node.js 提供的 http 模块，通过几行简单的代码，就能轻松的手写一个服务器软件，从而对外提供 web 服务。

IP 地址

IP 地址就是互联网上每台计算机的唯一地址，因此 IP 地址具有唯一性。如果把"个人电脑"比作"一台电话"，那么"IP地址"就相当于"电话号码"，只有在知道对方 IP 地址的前提下，才能与对应的电脑之间进行数据通信。

IP 地址的格式:通常用"点分十进制"表示成(a.b.c.d)的形式，其中，a,b,c,d 都是 0~255 之间的十进制整数。例如:用点分十进表示的 IP地址(192.168.1.1)注意:

互联网中每台 Web 服务器，都有自己的 IP 地址，例如: 可以在终端中执行 ping www.baidu.com 命令，即可查看到百度服务器的 IP 地址。
在开发期间，自己的电脑既是一台服务器，也是一个客户端，为了方便测试，可以在自己的浏览器中输入 127.0.0.1 这个 IP 地址，就能把自己的电脑当做一台服务器进行访问了。

域名和域名服务器

尽管 IP 地址能够唯一地标记网络上的计算机，但IP地址是一长串数字，不直观，而且不便于记忆，于是人们又发明了另一套

字符型的地址方案，即所谓的域名(Domain Name)地址。

IP地址和域名是一一对应的关系，这份对应关系存放在一种叫做域名服务器(DNS，Domain name server)的电脑中。使用者只需通过好记的域名访问对应的服务器即可，对应的转换工作由域名服务器实现。因此，域名服务器就是提供 IP 地址和域名之间的转换服务的服务器。注意:

单纯使用 IP 地址，互联网中的电脑也能够正常工作。但是有了域名的加持，能让互联网的世界变得更加方便。
在开发测试期间， 127.0.0.1 对应的域名是 localhost，它们都代表自己的这台电脑，在使用效果上没有任何区别。

端口号

计算机中的端口号，就好像是现实生活中的门牌号一样。通过门牌号，外卖小哥可以在整栋大楼众多的房间中，准确把外卖送到你的手中。同样的道理，在一台电脑中，可以运行成百上千个 web 服务。每个 web 服务都对应一个唯一的端口号。客户端发送过来的网络请求，通过端口号，可以被准确地交给对应的 web 服务进行处理。注意:

每个端口号不能同时被多个 web 服务占用。
在实际应用中，URL 中的 80 端口可以被省略。

创建最基本的 web 服务器

导入 http 模块------如果希望在自己的电脑上创建一个 web 服务器，从而对外提供 web 服务，则需要导入 http 模块。
创建 web 服务器实例------调用 http.createServer() 方法，即可快速创建一个 web 服务器实例。
为服务器实例绑定 request 事件------监听客户端发送过来的网络请求。
启动服务器------调用服务器实例的 .listen() 方法，即可启动当前的 web 服务器实例。

// 1. 导入 http 模块
const http = require('http')
// 2. 创建 web 服务器实例
const server = http.createServer()
// 3. 为服务器实例绑定 request 事件，监听客户端的请求
server.on('request', function (req, res) {
console.log('Someone visit our web server.')
})
// 4. 启动服务器
server.listen(8080, function () {
console.log('server running at http://127.0.0.1:8080')
})

请求对象和响应对象

只要服务器接收到了客户端的请求，就会调用通过 server.on() 为服务器绑定的 request 事件处理函数。

如果想在事件处理函数中，访问与客户端相关的数据或属性，可以使用请求对象
在服务器的 request 事件处理函数中，如果想访问与服务器相关的数据或属性，可以使用响应对象

// req 是请求对象，包含了与客户端相关的数据和属性
server.on('request', (req, res) => {
// req.url 是客户端请求的 URL 地址
const url = req.url
// req.method 是客户端请求的 method 类型
const method = req.method
const str = 您请求的 URL 地址是 ${req.url}，请求的 method 类型为 ${req.method}
// 调用 res.setHeader() 方法，设置 Content-Type 响应头，解决中文乱码的问题
res.setHeader('Content-Type', 'text/html; charset=utf-8')
// 调用 res.end() 方法，向客户端响应一些内容
res.end(str)
})

注意：当调用 res.end() 方法，向客户端发送中文内容的时候，会出现乱码问题，此时，需要手动设置内容的编码格式：调用 res.setHeader() 方法，设置 Content-Type 响应头，解决中文乱码的问题。

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

server.on('request', (req, res) => {
  // 1. 获取请求的 url 地址
  const url = req.url
  // 2. 设置默认的响应内容为 404 Not found
  let content = '<h1>404 Not found!</h1>'
  // 3. 判断用户请求的是否为 / 或 /index.html 首页
  // 4. 判断用户请求的是否为 /about.html 关于页面
  if (url === '/' || url === '/index.html') {
    content = '<h1>首页</h1>'
  } else if (url === '/about.html') {
    content = '<h1>关于页面</h1>'
  }
  // 5. 设置 Content-Type 响应头，防止中文乱码
  res.setHeader('Content-Type', 'text/html; charset=utf-8')
  // 6. 使用 res.end() 把内容响应给客户端
  res.end(content)
})

简单文件服务器案例

把文件的实际存放路径，作为每个资源的请求 url 地址。

    const fs = require('fs');
    const path = require('path');
    const http = require('http');
    const server = http.createServer();
    server.on('request', function(req, res) {
        let result = '<h1>404 您请求的内容不在了!</h1>'
        // 把请求的 URL 地址映射为具体文件的存放路径
        let p = '';
        if (req.url === '/') {
            p = path.join(__dirname, '/files/index.html');
        } else {
            p = path.join(__dirname, '/files', req.url);
        }
        console.log(p);
        res.setHeader('Content-Type', 'text/html; charset=utf-8');
        // 根据"映射"过来的文件路径读取文件的内容
        fs.readFile(p, 'utf-8', function(error, value) {
            console.log('error: ', error);
            if (error === null) {
                result = value;
            }
            res.end(result);
        });
    });
    server.listen(80, function() {
        console.log('server running at http://127.0.0.1:80');
    });