Node.js

fs模块

文件写入

writeFile 异步写入

语法： fs.writeFile(file, data[, options], callback)

参数说明：

file 文件名

data 待写入的数据

options 选项设置 （可选）

callback 写入回调

返回值： undefined

// require 是 Node.js 环境中的 '全局' 变量，用来导入模块
const fs = require('fs')

// 将 [三人行，必有我师焉。] 写入到当前文件夹下的 [座右铭.txt] 文件中
fs.writeFile('./座右铭.txt', '三人行，必有我师焉。', err =>{
    // 如果写入失败，则回调函数调用时，会传入错误对象，如写入成功，会传入 null
    if(err){
        console.log(err)
        return
    }
    console.log('写入成功')  
})

writeFileSync 同步写入

语法: fs.writeFileSync(file, data[, options])

参数与 fs.writeFile 大体一致，只是没有 callback 参数

返回值：undefined

try{
    fs.writeFileSync('./座右铭.txt', '三人行，必有我师焉。')
}catch(e){
    console.log(e)
}

appendFile / appendFileSync 追加写入

appendFile 作用是在文件尾部追加内容，appendFile 语法与 writeFile 语法完全相同

语法:

fs.appendFile(file, data[, options], callback)

fs.appendFileSync(file, data[, options])

返回值：二者都为 undefined

fs.append('./座右铭.txt', '则其善者而从之，其不善者而改之。', err =>{
    if(err) throw err
    console.log('追加成功')
})

fs.appendFileSync('./座右铭.txt','\r\n温故而知新，可以为师矣')

createWriteStream 流式写入

语法：fs.createWriteStream(path[, options])

参数说明：

path 文件路径

options 选项配置（ 可选 ）

**返回值: **Object

let ws = fs.createWriteStream('./观书有感.txt')

//写入数据到流
ws.write('半亩方塘一鉴开\r\n')
ws.write('天光云影共徘徊\r\n')
ws.write('问渠那得清如许\r\n')
ws.write('为有源头活水来\r\n')

//关闭写入流，表明已没有数据要被写入可写流
ws.end()

文件读取

readFile 异步读取

语法: fs.readFile(path[, options], callback)

参数说明：

path 文件路径

options 选项配置

callback 回调函数

返 回 值 ： undefined

fs.readFile('./座右铭.txt', (error,data) =>{
    if(err) throw err
    console.log(data)
})

fs.readFile('./座右铭.txt', 'uft-8', (error,data) =>{
    if(err) throw err
    console.log(data)
})

readFileSync 同步读取

语法：fs.readFileSync(path[, options])

参数说明：

path 文件路径

options 选项配置

返 回 值 ：string | Buffer

let data = fs.readFileSync('./座右铭.txt')
let data = fs.readFileSync('./座右铭.txt', 'utf-8')

createReadStream 流式读取

语法：fs.createReadStream(path[, options])

参数说明：

path 文件路径

options 选项配置（ 可选 ）

返回值：Object

// 创建读取流对象
let rs = fs.createReadStream('./观书有感.txt')

// 每次取出 64k 数据后执行一次 data 回调
// 绑定一个 data 事件  chunk 块儿  大块儿
re.on('data', chunk =>{
    console.log(chunk)
    console.log(chunk.length)
})

// 读取完毕后，执行 end 回调 (可选事件)
re.on('end', () =>{
    console.log('读取完毕')
})

文件移动与重命名

在 Node.js 中，我们可以使用 rename 或 renameSync 来移动或重命名 文件或文件夹

语法：

fs.rename(oldPath, newPath, callback)

fs.renameSync(oldPath, newPath)

参数说明：

oldPath 文件当前的路径

newPath 文件新的路径

callback 操作后的回调

fs.rename('./观书有感.txt', './论语/观书有感.txt', err =>{
	if(err) throw err
    console.log('移动完成')
})

fs.renameSync('./座右铭.txt', './论语/.我的座右铭.txt')

文件删除

在 Node.js 中，我们可以使用 unlink 或 unlinkSync 来删除文件

语法:

fs.unlink(path, callback)

fs.unlinkSync(path)

参数说明：

path 文件路径

callback 操作后的回调

const fs = require('fs')

fs.unlink('./test.txt', err =>{
    if(err) throw err
    console.log('删除成功')
})

fs.unlinkSync('./test2.txt')


// 调用 rm 方法  14.4   同步 rmSync
fs.rm('./论语.txt', err => {
  if (err) {
    console.log('删除失败')
    return

  }
  console.log('删除成功')
})

文件夹操作

mkdir 创建文件夹

在 Node.js 中，我们可以使用 mkdir 或 mkdirSync 来创建文件夹

语法:

fs.mkdir(path[, options], callback)

fs.mkdirSync(path[, options])

参数说明：

path 文件夹路径

options 选项配置（ 可选 ）

callback 操作后的回调

// 异步创建文件夹  mk  make  制作   dir  directory  文件夹
fs.mkdir('./page', err =>{
    if(err) throw err
    console.log('创建成功')
})

// 递归异步创建
fs.mkdir('./1/2/3', {recursive: true}, err =>{
    if(err) throw err
    console.log('递归创建成功')
})

// 递归同步创建文件夹
fs.mkdirSync('./x/y/z', {recursive: true})

readdir 读取文件夹

在 Node.js 中，我们可以使用 readdir 或 readdirSync 来读取文件夹

语法：

fs.readdir(path[, options], callback)

fs.readdirSync(path[, options])

参数说明：

path 文件夹路径

options 选项配置（ 可选 ）

callback 操作后的回调

// 异步读取
fs.readdir('./论语', (err, data) => {
	if(err) throw err
    console.log(data)
})
// 同步读取 
let data = fs.readdirSync('./论语')
console.log(data)

rmdir 删除文件夹

在 Node.js 中，我们可以使用 rmdir 或 rmdirSync 来删除文件夹

语法：

fs.rmdir(path[, options], callback)

fs.redirSync(path[, options])

参数说明：

path 文件夹路径

options 选项配置（ 可选 ）

callback 操作后的回调

// 异步删除文件夹  rm  remove 移除
fs.rmdir('./page', err => {
    if(err) throw err
    console.log('删除成功')
})
//异步递归删除文件夹  不推荐
//=>DeprecationWarning: In future versions of Node.js, fs.rmdir(path, { recursive: true }) will be removed. Use fs.rm(path, { recursive: true }) instead
fs.rmdirSync('./1', {recursive: true}, err => {
    if(err){ 
    	console.log(err)
        return
    }
    console.log('递归删除')
})
//同步递归删除文件夹
fs.rmdirSync('./x', {recursive: true})

// 建议使用
fs.rm('./a', { recursive: true }, err => {
  if (err) {
    console.log(err)
    return
  }
  console.log('删除成功')
})

查看资源状态

在 Node.js 中，我们可以使用 stat 或 statSync 来查看资源的详细信息

语法：

fs.stat(path[, options], callback)

fs.statSync(path[, options])

参数说明：

path 文件夹路径

options 选项配置（ 可选 ）

callback 操作后的回调

// 异步获取状态
// stat  方法  status 缩写 状态
fs.stat('/data.txt', (err, data) =>{
    if(err) throw err
    console.log(data)
})
// 同步获取状态
let data = fs.statSync('./data.txt')

path模块

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

// 写入文件
// fs.writeFileSync(__dirname + '/index.html', 'love')
console.log(__dirname + '/index.html') //=>D:\Desktop\Node\code\04-path/index.html

// resolve 解决问题  拼接绝对路径
console.log(path.resolve(__dirname, './index.html')) //=>D:\Desktop\Node\code\04-path\index.html
console.log(path.resolve(__dirname, 'index.html')) //=>D:\Desktop\Node\code\04-path\index.html
console.log(path.resolve(__dirname, '/index.html', './test')) //=>D:\index.html\test

// sep 获取路径分隔符
console.log(path.sep) //=> window \  linux /

// parse 方法  __filename  '全局变量'
console.log(__filename) //=>文件的绝对路径 //=>D:\Desktop\Node\code\04-path\01-path.js
// 解析路径
let str = 'D:\\Desktop\\Node\\code\\04-path\\01-path.js'
console.log(path.parse(str))

// 获取路径基础名称
console.log(path.basename(pathname))

// 获取路径的目录名
console.log(path.dirname(pathname))

// 获取路径的拓展名
console.log(path.extname(pathname))

http协议

概念

HTTP（hypertext transport protocol）协议；中文叫 超文本传输协议

是一种基于TCP/IP的应用层通信协议

这个协议详细规定了 浏览器 和 万维网 服务器 之间互相通信的规则

协议中主要规定了两个方面的内容:

客户端：用来向服务器发送数据，可以被称之为 请求报文

服务端：向客户端返回数据，可以被称之为 响应报文

报文：可以简单理解为就是一堆字符串

创建 HTTP 服务

操作步骤

//1. 导入 http 模块
const http = require('http');


//2. 创建服务对象 create 创建 server 服务
// request 意为请求. 是对请求报文的封装对象, 通过 request 对象可以获得请求报文的数据
// response 意为响应. 是对响应报文的封装对象, 通过 response 对象可以设置响应报文
const server = http.createServer((request, response) => { 		
    // 设置响应体
    response.end('Hello HTTP server');
});  //=>返回结果是一个对象

//3. 监听端口, 启动服务
server.listen(9000, () => {
	console.log('服务已经启动, 端口 9000 监听中...');
});

注意事项

命令行 ctrl + c 停止服务

当服务启动后，更新代码 必须重启服务才能生效

响应内容中文乱码的解决办法

// 设置响应头

response.setHeader('content-type','text/html;charset=utf-8');

端口号被占用

Error: listen EADDRINUSE: address already in use :::9000

1）关闭当前正在运行监听端口的服务 （ 使用较多 ）

2）修改其他端口号

HTTP 协议默认端口是 80 。HTTPS 协议的默认端口是 443, HTTP 服务开发常用端口有 3000，8080，8090，9000 等

如果端口被其他程序占用，可以使用 资源监视器 找到占用端口的程序，然后使用 任务管理器 关闭对应的程序

获取 HTTP 请求报文

// 1. 导入 http 模块
const http = require('http')

// 2. 创建服务对象
const server = http.createServer((request, response) => {
  // 获取请求的方法
  console.log(request.method)  //=>GET
  // 获取请求的 url
  console.log(request.url)  // 只包含 url 中的 路径 与查询字符串
  // 获取 http 协议的版本号
  console.log(request.httpVersion)  //=> 1.1
  // 获取 http 的请求头
  console.log(request.headers) //=>结果是一个对象
  response.end('http') //=>设置响应体
})

// 3. 监听端口，启动服务
server.listen(9000, () => {
  console.log('服务已经启动...')
})

注意事项：

request.url 只能获取路径以及查询字符串，无法获取 URL 中的域名以及协议的内容
request.headers 将请求信息转化成一个对象，并将属性名都转化成了『小写』
关于路径：如果访问网站的时候，只填写了 IP 地址或者是域名信息，此时请求的路径为『 / 』
关于 favicon.ico：这个请求是属于浏览器自动发送的请求
提取 http 报文的请求体

// 1. 导入 http 模块
const http = require('http')

// 2. 创建服务对象
const server = http.createServer((request, response) => {
  // 1. 声明一个变量
  let body = ''
  // 2. 绑定 data 事件
  request.on('data', chunk => {
    body += chunk
  })
  // 3. 绑定 end 事件
  request.on('end', () => {
    console.log(body)  //=>'username=111&password=111'
    // 响应
    response.end('Hello Http') //=>设置响应体 
  })
})

// 3. 监听端口，启动服务
server.listen(9000, () => {
  console.log('服务已经启动...')
})

提取 http 报文中 url的路径 与 查询字符串

// 导入 http 模块
const http = require('http')
// 1. 导入 url 模块
const url = require('url')

// 创建服务对象
const server = http.createServer((request, response) => {
  // 2. 解析 request.url
  console.log(request.url)   //=>/search?keyword=h5
  // 使用 parse 解析 request.url 的内容
  // true 将 query 属性将会设置为一个 对象
  let res = url.parse(request.url, true)
  console.log(res)  // 如下图所示，为一个对象
  // 路径
  let pathname = res.pathname
  // 查询字符串
  let keyword = res.query.keyword
  console.log(keyword)   //=>h5
  response.end('url')
})

// 监听端口，启动服务
server.listen(9000, () => {
  console.log('服务已经启动...')
})

// 导入 http 模块
const http = require('http')

// 创建服务对象
const server = http.createServer((request, response) => {
  // 实例化 url 对象
  // let url = new URL('/search?a=100&b=200','http://127.0.0.1:9000')
  let url = new URL(request.url, 'http://127.0.0.1')
  console.log(url)  //=>如图所示，为一个对象
  // 输出路径
  console.log(url.pathname)  //=>/search
  // 输出 keyword 查询字符串
  console.log(url.searchParams.get('a'))  //=> 100
  response.end('url new')
})

// 监听端口，启动服务
server.listen(9000, () => {
  console.log('服务已经启动...')
})

设置 HTTP 响应报文

// 1. 设置响应状态码
response.statusCode = 203
// 2. 响应状态的描述
response.statusMessage = 'i love you'
// 3. 响应头
response.setHeader('content-type', 'text/html;charset=utf-8')
// 自定义响应头
response.setHeader('myHeader', 'test test')
// 设置多个同名的响应头
response.setHeader('test', ['a', 'b', 'c'])

// write 和 end 的两种使用情况：
// 1. write 和 end 的结合使用 响应体相对分散
response.write('xx');
response.write('xx');
response.write('xx');
response.end(); //每一个请求，在处理的时候必须要执行 end 方法的

//2. 单独使用 end 方法 响应体相对集中
response.end('xxx');

网页中的 URL

网页中的 URL 主要分为两大类：相对路径 与 绝对路径

绝对路径

绝对路径可靠性强，而且相对容易理解，在项目中运用较多

相对路径

相对路径在发送请求时，需要与当前页面 URL 路径进行 计算 ，得到完整 URL 后，再发送请求，学习阶段用的较多

例如当前网页 url 为 http://www.atguigu.com/course/h5.html

模板化

简介

什么是模板化

将一个复杂的程序文件依据一定规则（规范）拆分成多个文件的过程称之为 模块化

好处

下面是模块化的一些好处：

防止命名冲突

高复用性

高维护性

暴露数据

如何暴露

//声明函数
function tiemo(){
	console.log('贴膜....');
}
//暴露数据
module.exports = tiemo;

//导入模块
const tiemo = require('./me.js');
//调用函数
tiemo(); //=> 贴膜....

两种方式

module.exports = value

exports.name = value

导入模块

在模块中使用 require 传入文件路径即可引入文件

const test = require('./me.js')

require 使用的一些注意事项：

对于自己创建的模块，导入时路径建议写 相对路径，且不能省略 ./ 和 …/

js 和 json 文件导入时可以不用写后缀，c/c++编写的 node 扩展文件也可以不写后缀，但是一般用不到，直接使用 node 的
require() 方法即可将 JSON 文件转换成 JS 对象

如果导入其他类型的文件，会以 js 文件进行处理

如果导入的路径是个文件夹，则会 首先 检测该文件夹下 package.json 文件中 main 属性对应的文件，

如果存在则导入，反之如果文件不存在会报错。

如果 main 属性不存在，或者 package.json 不存在，则会尝试导入文件夹下的 index.js 和 index.json，

如果还是没找到，就会报错

导入 node.js 内置模块时，直接 require 模块的名字即可，无需加 ./ 和 …/

导入模块流程

1.将相对路径转为绝对路径，定位目标文件
2.缓存检测
3.读取目标文件代码
4.包裹为一个函数并执行（自执行函数）。通过 arguments.callee.toString() 查看自执行函数
5.缓存模块的值
6.返回 module.exports 的值

function require(file){
  //1. 将相对路径转为绝对路径，定位目标文件
  let absolutePath = path.resolve(__dirname, file);
  //2. 缓存检测
  if(caches[absolutePath]){
    return caches[absolutePath];
  }
  //3. 读取文件的代码
  let code = fs.readFileSync(absolutePath).toString();
  //4. 包裹为一个函数 然后执行
  let module = {};
  let exports = module.exports = {};
  (function (exports, require, module, __filename, __dirname) {
    const test = {
      name: '尚硅谷'
    }
  
    module.exports = test;
  
    //输出
    console.log(arguments.callee.toString());
  })(exports, require, module, __filename, __dirname)
  //5. 缓存结果
  caches[absolutePath] = module.exports;
  //6. 返回 module.exports 的值
  return module.exports;
}

express

介绍

简单来说，express 是一个封装好的工具包，封装了很多功能，便于我们开发 WEB 应用(HTTP 服务)

使用

下载

npm init
npm i express

使用

//1. 导入 express
const express = require('express');
//2. 创建应用对象
const app = express();
//3. 创建路由规则
app.get('/home', (req, res) => {
	res.end('hello express server');
});
//4. 监听端口 启动服务
app.listen(3000, () =>{
	console.log('服务已经启动, 端口监听为 3000...');
});

路由

介绍

路由确定了应用程序如何响应客户端对特定端点的请求

使用

//导入 express
const express = require('express');

//创建应用对象
const app = express();

//创建 get 路由
app.get('/home', (req, res) => {
	res.send('网站首页');
});

//首页路由
app.get('/', (req,res) => {
	res.send('我才是真正的首页');
});

//创建 post 路由
app.post('/login', (req, res) => {
	res.send('登录成功');
});

//匹配所有的请求方法
app.all('/search', (req, res) => {
	res.send('1 秒钟为您找到相关结果约 100,000,000 个');
});

//自定义 404 路由
app.all("*", (req, res) => {
	res.send('<h1>404 Not Found</h1>')
});

//监听端口 启动服务
app.listen(3000, () =>{
	console.log('服务已经启动, 端口监听为 3000');
})

获取请求参数

//导入 express
const express = require('express');

//创建应用对象
const app = express();

//获取请求的路由规则
app.get('/request', (req, res) => {
	// 1. 获取报文的方式与原生 HTTP 获取方式是兼容的
	console.log(req.method);
	console.log(req.url);
	console.log(req.httpVersion);
	console.log(req.headers);
	
    // 2. express 独有的获取报文的方式
    // 获取路径
	console.log(req.path)
    //获取查询字符串
	console.log(req.query); // 『相对重要』对象形式返回所有的查询字符串
	// 获取指定的请求头
	console.log(req.get('host'));
	res.send('请求报文的获取');
});
//启动服务
app.listen(3000, () => {
	console.log('启动成功....')
})

获取路由参数

app.get('/:id.html', (req, res) => {
	res.send('商品详情, 商品 id 为' + req.params.id);
});

响应设置

//获取请求的路由规则
app.get("/response", (req, res) => {
  	//1. express 中设置响应的方式兼容 HTTP 模块的方式
  	res.statusCode = 404;
  	res.statusMessage = 'xxx';
  	res.setHeader('abc','xyz');
  	res.write('响应体');
  	res.end('xxx');
  
    //2. express 的响应方法
  	res.status(500); //设置响应状态码
  	res.set('xxx','yyy');//设置响应头
  	res.send('中文响应不乱码');//设置响应体
  	//连贯操作
  	res.status(404).set('xxx','yyy').send('你好朋友')
  	
    //3. 其他响应
  	res.redirect('http://atguigu.com')//重定向
  	res.download('./package.json');//下载响应
  	res.json();//响应 JSON
  	res.sendFile(__dirname + '/home.html') //响应文件内容
});

中间件

介绍

中间件（Middleware）本质是一个回调函数

中间件函数 可以像路由回调一样访问 请求对象（request） ， 响应对象（response）

作用

中间件的作用 就是 使用函数封装公共操作，简化代码

类型

定义全局中间件

let recordMiddleware = function(request,response,next){
  //实现功能代码
  //.....
  //执行next函数(当如果希望执行完中间件函数之后，仍然继续执行路由中的回调函数，必须调用next)
  next();
}

app.use(recordMiddleware)

app.use(function (request, response, next) {
  	console.log('定义第一个中间件');
    next();
})

多个全局中间件

app.use(function (request, response, next) {
  	console.log('定义第一个中间件');
    next();
})
app.use(function (request, response, next) {
  	console.log('定义第二个中间件');
    next();
})

路由中间件

app.get('/路径',`中间件函数`,(request,response)=>{

});

app.get('/路径',`中间件函数1`,`中间件函数2`,(request,response)=>{

});

资源中间件

//引入express框架
const express = require('express');
//创建服务对象
const app = express();
//静态资源中间件的设置，将当前文件夹下的public目录作为网站的根目录
app.use(express.static('./public')); //当然这个目录中都是一些静态资源
//如果访问的内容经常变化，还是需要设置路由
//但是，在这里有一个问题，如果public目录下有index.html文件，单独也有index.html的路由
//则谁书写在前，优先执行谁
app.get('/index.html',(request,response)=>{
	respsonse.send('首页');
});
//监听端口
app.listen(3000,()=>{
	console.log('3000 端口启动....');
});

接口

简介

接口是 前后端通信的桥梁

RESTful API

json-server

1.全局安装 json-server

npm i -g json-server

2.创建 JSON 文件（db.json），编写基本结构

{
	"song": [
		{ "id": 1, "name": "干杯", "singer": "五月天" },
		{ "id": 2, "name": "当", "singer": "动力火车" },
		{ "id": 3, "name": "不能说的秘密", "singer": "周杰伦" }
	]
}

以 JSON 文件所在文件夹作为工作目录，执行如下命令

json-server --watch db.json