Nodejs基础

Buffer 缓冲区

  • Buffer 是专门存储二进数制数据，显示时以 16 进制的形式显示的据结构
  • 每一个元素占用一个字节内存
  • Buffer 是对底层内存的直接操作，因此大小一旦确定就不能修改

常用方法

1
2
3
4
let buf = Buffer.from("hello"); // buf.toString() 转换回来
let buf1 = Buffer.alloc(10); // 创建10字节大小
let buf2 = Buffer.allocUnsafe(10); // 10字节数据，并取出内存未清除敏感的数据

fs 文件系统模块

  • 同步文件系统会阻塞程序的执行

  • 异步文件系统不会阻塞程序的执行，通过回调函数返回结果

操作模式：

模式 说明
r 读取文件，文件不存在抛异常
r+ 读写文件，文件不存在抛异常
rs 同步模式下打开文件用于读取
rs+ 同步模式下打开文件用于读写
w 写文件，不存在则创建，存在则覆盖原有内容
wx 写文件，文件存在打开失败
w+ 读写文件，不存在创建，存在截断
wx+ 读写，存在打开失败
a 追加，不存在创建
ax 追加，存在失败
a+ 追加和读取，不存在创建
ax+ 追加和读取，存在失败

简单文件读取

  • fs.readFile(path, options, callback) 异步
    • encoding：编码格式
    • flag：打开方式
  • fs.readFileSync(path, options, callback) 同步
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
const fs = require("fs")
// 返回二进制数据
fs.readFile("hello.txt", function (err, data) {  
    // data 读取到的是buffer数据
    if (!err) console.log(data.toString())
})

// 复制文件内容
fs.readFile("hello.mp3", function(err, data) {
	if(!err) {
		// 将data写入到文件中
		fs.writeFile("hello.jpg", data, function(err){
			if(!err){
				console.log("文件写入成功");
			}
		} );
	}
});

流式文件读取

  • 简单文件读取的方式会一次性读取文件内容到内存中，若文件较大，会占用过多内存影响系统性能，且读取速度慢
  • 大文件适合用流式文件读取，它会分多次将文件读取到内存中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
const fs = require("fs");

// 创建可读流
let rs = fs.createReadStream("an.jpg");
// 创建可写流
let ws = fs.createWriteStream("copy.jpg");

// 必须通过绑定data事件来读取可读流中的数据
rs.on('data', function (data) {
  console.log(data)
  //将读取到的数据写入到可写流中
  ws.write(data)
})

// 可用pipe() 替换上面方法
// pipe() 可以将可读流中的内容，直接输出到可写流中
rs.pipe(ws);

同步文件写入

1
2
3
4
5
6
7
8
const fs = require("fs");
// 同步打开文件, r只读 , w可写
let fd = fs.openSync("hello.txt", "w"); 
// 同步写内容，起始10字节位置
fs.writeSync(fd, "hello", 10);
// 关闭文件
fs.closeSync(fd);

异步文件写入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
const fs = require("fs");
// 异步打开文件, r只读 , w可写， （err，fd文件描述符）
fs.open("hello.txt", "w", function (err, fd) {
    if (!err) {
        // 异步写内容，起始10字节位置
        fs.write(fd, "hello", 10, function (err) {  
            if (!err) console.log("写入成功");
            // 异步文件
            fs.close(fd, function(err) {
                if (!err) console.log("关闭成功")
            });
        });
    }
});

简单文件异步写入

1
2
3
4
5
6
7
// fs.wirteFile简单文件写入
const fs = require("fs");
// 异步写内容 a 追加
fs.wirteFile("hello.txt", "写入内容", {flag: 'a'}, function (err) {  
    if (!err) console.log("写入成功")
})

流式文件写入

  • 大文件异步操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
const fs = require("fs");
// 创建可写流
let ws = fs.createWriteStream("hello.txt");

// 监听流的open和close事件来监听流的关闭打开 once监听一次
ws.once("open", function () {  
    console.log("打开了")
})
ws.once("close", function () {  
    console.log("关闭了")
})

// 通过ws像文件种输出内容
ws.write("hello name");
// 没关闭流一直可写
ws.write("通过可写流向文件写入内容")
ws.write("通过可写流向文件写入内容")
// 关闭可写流
ws.end();

其它操作

验证路径是否存在：

  • fs.exists(path, callback)
  • fs.existsSync(path)

获取文件信息：

  • fs.stat(path, callback)
  • fs.stat(path)

删除文件：

  • fs.unlink(path, callback)
  • fs.unlinkSync(path)

列出文件：

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

截断文件：

  • fs.truncate(path, len, callback)
  • fs.truncateSync(path, len)

建立目录：

  • fs.mkdir(path[, mode], callback)
  • fs.mkdirSync(path[, mode])

删除目录：

  • fs.rmdir(path, callback)
  • fs.rmdirSync(path)

重命名文件和目录：

  • fs.rename(oldPath, newPath, callback)
  • fs.renameSync(oldPath, newPath)

监视文件更改：

  • fs.watchFile(filename[, options], listener)

path 路径模块

  • path 模块是 Node.js 官方提供的、用来处理路径的模块。

  • 它提供了一系列的方法和属性，用来满足用户对路径的处理需求。

路径拼接 path.join()

  • ../ 回退路径一级

  • ./ 会被忽略

  • __dirname 返回当前路径的绝对路径

1
2
3
4
5
6
7
8
9
10
11
12
const path = require('path')
const fs = require('fs')

const pathStr = path.join('/a', '/b/c', '../../', './d', 'e')
console.log(pathStr) // \a\d\e

fs.readFile(path.join(__dirname, './files/1.txt'), 'utf8', function (err, dataStr) {
  if (err) {
    return console.log(err.message)
  }
  console.log(dataStr)
})

获取路径中的文件名 path.basename(path[, ext])

  • path: 文件路径
  • ext: 文件扩展名
1
2
3
4
5
6
7
8
9
10
const path = require('path')

// 定义文件的存放路径
const fpath = '/a/b/c/index.html'

const fullName = path.basename(fpath)
console.log(fullName) // index.html

const nameWithoutExt = path.basename(fpath, '.html')
console.log(nameWithoutExt) // index

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

1
2
3
4
5
const path = require('path')
const fpath = '/a/b/c/index.html'

const fext = path.extname(fpath)
console.log(fext) // .html

http 模块

  • http 模块是 Node.js 官方提供的、用来创建 web 服务器的模块。

创建基本 Web 服务器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
const http = require('http')
// 创建 Web 服务器实例
const server = http.createServer()

// 为服务器实例绑定 request 事件， 监听客户端的请求
server.on('request', fucntion(req,res){
  const url = req.url
  const method = req.method
  const str = `Your request url is ${url}, and request method is ${method}`
  console.log(str)

  // 设置 Content-Type 响应头，解决中文乱码的问题
  res.setHeader('Content-Type', 'text/html; charset=utf-8')
  // 向客户端响应内容
  res.end(str)
})

// 监听端口
server.listen(8080, function () {
  console.log('server running at http://127.0.0.1:8080')
})

CommonJS 模块化

  • module 变量是一个对象，module.exports 是对外的接口
  • 加载某个模块即加载该模块的 module.exports 属性

导出方式一

1
2
3
4
5
const name = '10wen.github.io'
exports.name = name
exports.getName = function(){
    return name; // 闭包形成
}
1
2
3
const { name, getName } = require('./module.js')
console.log(name)
getName();

导出方式二

1
2
3
4
5
const name = '10wen'
const getName = function(){
    return name
}
module.exports = getName
1
const getName = require('./module.js')