关于node.js:NodejsCOMMONJS-规范

ECMAScript 规范的缺点
没有模块零碎
规范库较少
没有标准接口
不足管理系统
模块化
如果程序设计的规模达到了肯定水平，则必须对其进行模块化。
模块化 能够有多种形式，但至多 应该 提供可能将代码宰割为多个源文件的机制。
CommonJS 的模块 性能能够帮咱们解决该问题。
CommonJS 标准
CommonJS 标准的提出，次要是为了补救当
前 JavaScript 没有 模块化 规范 的 缺点。
CommonJS 标准为 JS 指定了一个美妙的愿景，
心愿 JS 可能在任何中央运行。
CommonJS 对模块的定义非常简略：
– 模块援用
– 模块定义
– 模块标识
模块 援用
在标准中，定义了 require() 办法，这个方
法接手模块标识，以此将一个模块引入到
以后运行环境中。
模块援用的示例代码：
– var math = require(‘math’);
模块定义
在运行环境中，提供了 exports 对象用于导
出以后模块的办法或者变量，并且它是唯
一的导出的进口。
在模块中还存在一个 module 对象，它代表
模块本身，而 exports 是 module 的属性。
在 Node 中一个文件就是一个模块。
模块定义
exports . xxx = function () {};
module . exports = {} ;
模块标识
模块 标识 其实就是模块的名字，也就是传
递给 require() 办法的参数，它必须是合乎
驼峰命名法的字符串，或者是以 .、.. 结尾的
相对路径、或者绝对路径。
模块的定义非常简略，接口也非常简洁。
每个模块具备独立的空间，它们互不烦扰，
在援用时也显得干净利落。
Node 的模块实现
Node 中尽管应用的是 CommonJS 标准，然而
其本身也对标准做了一些取舍。
在 Node 中引入模块，须要经验如下 3 个步骤：
– 路径分析
– 文件定位
– 编译执行
在 Node 中，模块分为 三 类：一类是底层由
C++ 编写的 内建模块，一类是 Node 提供的 核
心模块；还有一类是用户编写的模块，称为 文
件模块。
包 package
CommonJS 的包标准容许咱们将一组相干
的模块组合到一起，造成一组残缺的工具。
CommonJS 的包标准由 包构造 和 包形容文
件 两个局部组成。
包构造
– 用于组织包中的各种文件
包形容文件
– 形容包的相干信息，以供内部读取剖析
包构造
包实际上就是一个压缩文件，解压当前还
原为目录。符合规范的目录，应该蕴含如
下文件：
– package.json 形容文件
– bin 可执行二进制文件
– lib js 代码
– doc 文档
– test 单元测试
包形容文件
包形容文件用于表白非代码相干的信息，
它是一个 JSON 格局的文件 – package.json，
位于包的根目录下，是包的重要组成部分。
package.json 中的字段
– name、description、version、keywords、
maintainers、contributors、bugs、
licenses、repositories、dependencies、
homepage、os、cpu、engine、builtin、
directories、implements、scripts、author、
bin、main、devDependencies。
NPM(Node Package Manager)
CommonJS 包标准是实践，NPM 是其中一
种实际。
对于 Node 而言，NPM 帮忙其实现了第三
方模块的公布、装置和依赖等。借助 NPM，
Node 与第三方模块之间造成了很好的一个
生态系统。
NPM 命令
npm – v– 查看版本
npm– 帮忙阐明
npm search 包名– 搜寻模块包
npm install 包名– 在当前目录装置 包
npm install 包名 – g– 全局模式装置 包
npm remove 包名– 删除一个 模块
npm install 文件门路– 从本地装置
npm install 包名 – registry= 地址– 从镜像源装置
npm config set registry 地址– 设置镜像源
Buffer(缓冲区)
从构造上看 Buffer 十分像一个数组，它的元
素为 16 进制的两位数。
实际上一个元素就示意内存中的一个字节。
实际上 Buffer 中的内存不是通过 JavaScript
调配的，而是在底层通过 C++ 申请的。
也就是咱们能够间接通过 Buffer 来创立内存
中的空间。
Buffer 的操作
应用 Buffer 保留字符串
创立指定大小的 Buffer 对象
let str = ” 你好 atguigu”;
let buf = Buffer.from(str , “utf -8”) ;
let buf3 = Buffer.alloc(1024*8)
Buffer 的转换
Buffer 与字符串间的转换
– 反对的编码 :
ASCII、UTF – 8、UTF – 16LE/UCS – 2、Base64、
Binary、Hex
– 字符串转 Buffer
Buffer.from(str , [encoding]);
– Buffer 转字符串
buf.toString([encoding] , [start] , [end]);
写入操作
向缓冲区中写入字符串
– buf.write(string [, offset[, length]][, encoding])
替换指定索引地位的数据
– buf[index]
将指定值填入到缓冲区的指定地位
– buf.fill(value [, offset[, end]][, encoding])
读取 操作
将缓冲区中的内容，转换为一个字符串返回
– buf.toString ([encoding[, start[, end]]])
读取缓冲区指定索引的内容
– buf[index]
其余操作
复制缓冲区
– buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])
对缓冲区切片
– buf.slice([start[, end]])
拼接缓冲区
– Buffer.concat(list[, totalLength])
fs（文件系统）
在 Node 中，与文件系统的交互是十分重要
的，服务器的实质就将本地的文件发送给
近程的客户端
Node 通过 fs 模块来和文件系统进行交互
该模块提供了一些标准文件拜访 API 来关上、
读取、写入文件，以及与其交互。
要应用 fs 模块，首先须要对其进行加载
– const fs = require(“fs”);
同步和异步调用
fs 模块中所有的操作都有两种模式可供选择
同步 和 异步。
同步文件系统会 阻塞 程序的执行，也就是
除非操作结束，否则不会向下执行代码。
异步文件系统 不会阻塞 程序的执行，而是
在操作实现时，通过回调函数将后果返回。
关上和敞开文件
关上文件
– fs.open(path, flags[, mode], callback )
– fs.openSync(path, flags[, mode])
敞开文件
– fs.close(fd, callback)
– fs.closeSync(fd)
关上状态

写入文件
fs 中提供了四种不同的形式将数据写入文件
– 简略文件写入
– 同步文件写入
– 异步文件写入
– 流式文件写入
简略文件 写入
fs.writeFile(file , data[, options], callback )
fs.writeFileSync(file, data[, options])
参数：
– file 文件门路
– data 被写入的内容，能够是 String 或 Buffer
– options 对象，蕴含属性（encoding、mode、
flag）
– callback 回调函数
同步文件写入
fs.writeSync(fd, buffer, offset, length[, position])
fs.writeSync(fd, data[, position[, encoding]])
要实现同步写入文件，先须要通过 openSync() 关上文件来获取
一个文件描述符，而后在通过 writeSync() 写入文件。
参数
– fd 文件描述符，通过 openSync() 获取
– data 要写入的数据（String 或 Buffer）
– offset buffer 写入的偏移量
– length 写入的长度
– position 写入的起始地位
– encoding 写入编码
异步文件写入
fs.write(fd, buffer, offset, length[, position], callback )
fs.write(fd, data[, position[, encoding]], callback )
要应用异步写入文件，先须要通过 open() 关上文件，而后在回
调函数中通过 write() 写入。
参数：
– fd 文件描述符
– data 要写入的数据（String 或 Buffer）
– offset buffer 写入的偏移量
– length 写入的长度
– position 写入的起始地位
– encoding 写入编码
流式文件写入
往一个文件中写入大量数据时，最好的办法之一
是应用流。
若要将数据异步传送到文件，首须要应用以下语
法创立一个 Writable 对象：
– fs.createWriteStream(path[, options])
path 文件门路
options {encoding:””,mode:””,flag:””}
一旦你关上了 Writable 文件流，就能够应用
write() 办法来写入它，写入实现后，在调用 end()
办法来敞开流。
读取文件
fs 中提供了四 种读取文件的形式
– 简略文件读取
– 同步文件读取
– 异步文件读取
– 流式文件读取
简略文件 读取
fs.readFile(file[, options], callback )
fs.readFileSync(file[, options])
– 参数：
file 文件门路或文件描述符
options|
– encoding| 默认 = null
– flag 默认 = ‘r ‘
callback 回调函数，有两个参数 err、data
同步文件读取
fs.readSync(fd, buffer, offset, length,
position )
– 参数：
fd 文件描述符
buffer 读取文件的缓冲区
offset buffer 的开始写入的地位
length 要读取的字节数
position 开始读取文件的地位
异步 文件读取
fs.read(fd, buffer, offset, length,
position, callback )
– 参数：
fd 文件描述符
buffer 读取文件的 缓冲区
offset buffer 的开始写入的地位
length 要读取的字节数
position 开始读取文件的 地位
callback 回调函数 参数 err , bytesRead , buffer
流式文件读取
从一个文件中读取大量的数据时，最好的办法之一就是
流式读取，这样将把一个文件作为 Readable 流的模式
关上。
要从异步从文件传输数据，首先须要通过以下语法创立
一个 Readable 流对象：
– fs.createReadStream(path[, options])
path 文件门路
options {encoding:””,mode:””,flag :””}
当你关上 Readable 文件流当前，能够通过 readable 事
件和 read() 申请，或通过 data 事件处理程序轻松地从它
读出。
其余操作
验证门路是否存在
– fs.exists(path，callback)
– fs.existsSync(path)
获取文件信息
– fs.stat(path, callback)
– fs.statSync(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)

关键词：前端培训