• Node.js入门

    Node.js入门

    1.模块化简介

    1.1ECMAScript标准的缺陷

    • 没有模块系统（从ES6开始已经有模块化了）
      • 模块化就是将一个完整的程序文件分成一个个小程序
      • 模块化能够降低程序之间的耦合度，方便代码复用，扩展
    • 标准库较少
      • 官方出的标准库少，很多都是第三方开源社区开发人员开发的，
    • 没有标准接口
    • 缺乏管理系统
      • 下jquery要去jquery官网，下其他的都要去官网，没有统一的管理系统

    模块化

    • 如果程序设计的规模达到了一定程度，则必须对其进行模块化
    • 模块化可以有多种形式，但至少应该提供额能够将代码分割为多个源文件的机制
    • CommonJS的模块功能可以帮我们解决该问题

    CommonJS规范

    • CommonJS规范的提出，主要是为了弥补当前JS没有标准的缺陷
    • CommonJS规范为JS指定了一个美好的愿景，希望JS能够在任何地方运行
    • CommonJS对模块的定义十分简单
      • 模块引用
      • 模块定义
      • 模块标识

    什么是模块？

    - 模块化
	- ES5中没有原生支持模块化，我们只能通过script标签引入js文件来实现模块化
	- 在node中为了对模块管理，引入了CommonJS规范
		
		- 模块的引用
			- 使用 require()函数来引入一个外部的模块，require()可以传递一个文件的路径作为参数，
			node将会自动根据该路径来引入外部模块，这里的路径，若是相对路径则必须要以.或者..开头
			- 例子：
				var 变量 = require("模块的标识");
			
		- 模块的定义
			- 在node中一个js文件就是一个模块,定义一个模块就是创建一个js文件
			- 默认情况下在js文件中编写的内容，都是运行在一个独立的函数中，不是全局作用域
				因此一个模块中的变量和函数外部的模块无法访问
			- 导出变量和函数
				- 使用 exports 
					- 例子：
						exports.属性 = 属性值;
						exports.方法 = 函数;
						
				- 使用module.exports
					- 例子：
						module.exports.属性 = 属性值;
						module.exports.方法 = 函数;
						module.exports = {};
		
		- 模块的标识
			- 模块的标识就是模块的名字或路径
				我们node通过模块的标识来寻找模块的
				对于核心模块（npm中下载的模块），直接使用模块的名字对其进行引入
					var fs = require("fs");
					var express = require("express");
					
				对于自定义的文件模块，需要通过文件的路径来对模块进行引入
					路径可以是绝对路径，如果是相对路径必须以./或 ../开头
					var router = require("./router");

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    模块的引用

    模块A：moduleA.js

    console.log("module A")

    • 1

    模块B：moduleB.js

    在模块A中引入模块B

    // 使用 require()函数来引入一个外部的模块，require()可以传递一个文件的路径作为参数，
// node将会自动根据该路径来引入外部模块，这里的路径，若是相对路径则必须要以.或者..开头
require("./moduleA.js")

    • 1
    • 2
    • 3
    模块的定义

    在node中一个js文件就是一个模块,定义一个模块就是创建一个js文件

    模块A：moduleA.js

    // 默认情况下在js文件中编写的内容，都是运行在一个独立的函数中，不是全局作用域
// 因此一个模块中的变量和函数外部的模块无法访问
console.log("module A")
var x = 1
var y = 2

// Node中模块的代码相当于如下:

(function(){
    console.log("module A")
    var x = 1
    var y = 2
})()

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    模块B：moduleB.js

    // 引入moduleA.js模块
var md = require("./moduleA.js")
console.log(md.x)   // 输出undefined

    • 1
    • 2
    • 3
    模块的导出

    模块A：moduleA.js

    // 我们可以通过exports来向外部暴露变量和方法，只需要将需要暴露给外部的变量或方法设置为exports的属性即可
console.log("module A")
exports.x = "module A 的x"
exports.y = "module A 的y"
exports.fn = function(){}

// Node中模块的代码相当于如下:

(function(){
    console.log("module A")
    exports.x = "module A 的x"
    exports.y = "module A 的y"
})()

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    模块B：moduleB.js

    // 引入moduleA.js模块
var md = require("./moduleA.js")
console.log(md)   
/*
    输出:
    module A
    { x: 'module A 的x', y: 'module A 的y', fn: [Function (anonymous)] }
*/ 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    模块标识

    模块的标识就是模块的名字或路径,使用require()引入模块时，使用得就是模块标识，我们可以通过模块标识来找到指定得模块

    模块可分为两类

    • 1.核心模块：
      • 由node引擎提供得模块，直接使用模块的名字对其进行引入
      • var fs = require(“fs”); var express = require(“express”);
    • 2.文件模块
      • 由用户自己创建得模块
      • 文件模块得标识就是文件得路径，可以是绝对路径或者是相对路径
      • 对于自定义的文件模块，需要通过文件的路径来对模块进行引入路径可以是绝对路径，如果是相对路径必须以./或 …/开头
      • var router = require(“./router”);
    练习

    定义一个模块math

    • 在该模块中提供两个方法
      • add(x, y) 求两个数得和
      • mul(x, y) 求两个数得积
    exports.add = function(a,b){
    return a+b
}
exports.mul = function(a,b){
    return a*b
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    var math = require("./math")
console.log(math.add(1,2))
console.log(math.mul(2,3))

    • 1
    • 2
    • 3

    2.模块化详解

    默认情况下在js文件中编写的内容，都是运行在一个独立的函数中，不是全局作用域
    因此一个模块中的变量和函数外部的模块无法访问

    1.证明模块中得变量是局部变量不是全局变量
    /**
 * 在node中有一个全局对象global，他得作用和网页中得window类似，
 * 在全局中创建得变量都会作为global得属性保存
 * 在全局中创建得函数都会作为global得方法保存
 */
var a = 10
console.log(global.a)  // undefined

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    // 在模块中如果不用var声明得变量，那么变量就是全局变量
a = 10
console.log(global.a)  // 10

    • 1
    • 2
    • 3
    2.证明模块中得代码是在函数中运行

    arguments是伪数组，是封装在函数中获取参数的，全局中没有arguments

    a = 10
// console.log(global.a) 
console.log(arguments.length)   // 输出5

    • 1
    • 2
    • 3

    arguments.callee:保存的是当前执行的函数对象

    a = 10
console.log(arguments.callee)  // [Function (anonymous)]

    • 1
    • 2
    a = 10
console.log(arguments.callee+"") 

// 输出内容如下

function (exports, require, module, __filename, __dirname) {
a = 10
console.log(arguments.callee+"")
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    当node在执行模块中的代码时，会在自己编写代码包裹进函数中，作为函数体，因此模块中的变量都是局部变量

    3.模块参数解释

    exports,

    • 该对象用来将变量或者函数暴露到外部

    require,：

    • 函数，用来引入外部的模块

    module：

    • module代表当前模块本身
    • export就是module的属性
    • 既可以使用exports导出，也可以使用module.exports

    __filename:

    • 当前模块的完整路径

    __dirname：

    • 当前模块所在的文件夹目录
    4.exports和module.exports解释

    exports和module.exports

    • exports

      • 通过exports只能使用点的方式来向外暴露内部变量

      • exports.XXX = yyy

    • module.exports

      • module.exports既可以通过点的方式，也可以之间赋值
      • module.exports.XXX = YYY
      • module.exports = { }
    // module.exports.name = "swk"
// module.exports.age = 18
// module.exports.sayNAme = function(){
//     console.log("我是孙悟空")
// }

// exports = {} 这里如果直接使用exports就不能暴露
module.exports = {
    name:'swk',
    age:18,
    sayNAme(){
        console.log("123")
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    var md = require("./helloModule")
md.sayNAme()

    • 1
    • 2

    3.包 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的命令
		- npm -v 查看npm的版本
		- npm version 查看所有模块的版本
		- npm search 包名 搜索包
		- npm init 创建package.json
		- npm install / i 包名 安装包
		- npm remove / r 包名 删除包
		- npm remove / r 包名 --save 删除包并删除依赖
		- npm install 包名 --save 安装包并添加到依赖中 *****
		- npm install 下载当前项目所依赖的包
		- npm install 包名 -g 全局安装包（全局安装的包一般都是一些工具）

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    Node搜索包得流程

    node在使用模块名字来引入模块时，它会首先在当前目录的node_modules中寻找是否含有该模块
    如果有则直接使用，如果没有则去上一级目录的node_modules中寻找
    如果有则直接使用，如果没有则再去上一级目录寻找，直到找到为止直到找到磁盘的根目录，如果依然没有，则报错

    4.Buffer

    从结构上看Buffer非常像一个数组，它的元素为16进制的两位数。

    实际上一个元素就表示内存中的一个字节。汉字占两个字节。

    实际上Buffer中的内存不是通过JavaScript分配的，而是在底层通过C++申请的。

    也就是我们可以直接通过Buffer来创建内存中的空间。

    /*
    Buffer(缓冲区)
    -Buffer的结构和数组很像，操作的方法也和数组类似
    -数组中不能存储二进制的文件，而buffer就是专门用来存储二进制数据-使用buffer不需要引入模块，直接使用即可
    -在buffer中存储的都是二进制数据，但是在显示时都是以16进制的形式显示
    - buffer中每个元素得范围是从00 - ff  
    - Buffer的大小一旦确定，则不能修改，Buffer实际上是对底层内存的直接操作
*/
var str = "hello atguigu"
// 将一个字符串保存到buffer中
var buf = Buffer.from(str)
console.log(buf.length)  // 13  占用内存大小
console.log(str.length)  // 13  字符串得长度
console.log(buf)  // 

// 创建一个指定大小的buffer
// buffer构造函数都是不推荐使用的
var buf2 = new Buffer(1024)  // 创建一个1024字节的buffer

// 创建一个10字节的buffer
var buff3 = Buffer.alloc(10)
buff3[0] = 88
buff3[3] = 55
buff3[5] = 0xaa
console.log(buff3)  // 

// Buffer.allocUnsafe(size)  创建一个指定大小的buffer，但是buffer中可能有敏感数据
var buf4 = Buffer.allocUnsafe(10)
console.log(buf4)

/**
    Buffer.from(str)   将一个字符串转为buffer
    Buffer.alloc(size)  创建一个指定大小的Buffer
    Buffer.allocUnsafe(size)  创建一个指定大小的buffer，不清除原来内存中的数据，可能读到敏感数据
    buf.toString()   将缓冲区中的数据转换为字符串
 */

var b5 = Buffer.from("我是一段文本数据")
console.log(b5, b5.toString())

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    5.文件系统 fs

    • 在Node中，与文件系统的交互是非常重要的，服务器的本质就将本地的文件发送给远程的客户端

    • 文件系统简单来说就是通过Node来操作系统中的文件

    • Node通过fs模块来和文件系统进行交互该模块提供了一些标准文件访问API来打开、读取、写入文件，以及与其交互。

    • 要使用fs模块，首先需要对其进行加载 const fs = require(“fs”);

    同步和异步调用
    • fs模块中所有的操作都有两种形式可供选择同步和异步。
    • 同步文件系统会阻塞程序的执行，也就是除非操作完毕，否则不会向下执行代码。
    • 异步文件系统不会阻塞程序的执行，而是在操作完成时，通过回调函数将结果返回。
    同步文件写入
    /**
 * 文件系统(File system)
        -文件系统简单来说就是通过Node来操作系统中的文件
        -使用文件系统，需要先引入fs模块，fs是核心模块，直接引入不需要下载

    同步文件的写入
        -手动操作的步骤
            1.打开文件
                fs.opensync(path, flags [, mode])
                    - path要打开文件的路径
                    - flags 打开文件要做操作的类型
                        r只读的
                        w可写的
                    - 返回值
                        该方法会返回一个文件的描述符作为结果，我们可以通过该描述符来对文件进行各种操作

            2.向文件中写入内容
                fs.writeSync(fd, string[, position[, encoding]])
                - fd 文件描述符，需要传递要写入文件的描述符
                - string 要写入的内容
                - position 写入的起始位置
                - encoding 写入的编码，默认为utf-8

            3.保存并关闭文件
                fs.closeSync(fd)
                - fd 要关闭文件的描述符
 */

var fs = require("fs")
// 打开文件
var fd = fs.openSync("hello.txt", "w")
// 向文件中写入内容
fs.writeSync(fd, "今天天气真不错")

// 关闭文件
fs.closeSync(fd)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    异步文件写入
    /**
 * 异步文件写入
 * 1.异步打开文件
 *      fs.open(path,flags[, mode], callback)
 *      - 用来打开一个文件
 *      - 异步调用的方法，结果都是通过回调函数的参数返回的
 *      - 回调函数的两个参数
 *          err 错误对象，如果没有错误则为null
 *          fd 文件描述符
 * 2.异步写入
 *      fs.write(fd, string[, position[, encoding]], callback)
 *          - 用来异步写入文件
 * 
 * 3.异步关闭
 *  fs.close(fd, callback)
 */
var fs = require("fs")

// 打开文件
fs.open("hello2.txt", "w", function(err, fd){
    // 判断是否出错
    if(!err){
        // 如果没有出错，则对文件进行写入操作
        fs.write(fd, "异步写入的内容",function(err){
            if(!err){
                console.log("异步写入成功")
            }

            // 关闭文件
            fs.close(fd, function(err){
                if(!err){
                    console.log("文件已关闭")
                }
            })
        })
    }else{
        console.log(err)
    }
})

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    打开状态

    r 读取文件，文件不存在则出现异常
    r+ 读写文件，文件不存在则出现异常
    rs 在同步模式下打开文件用于读取
    rs+ 在同步模式下打开文件用于读写
    w 打开文件用于写操作，如果不存在则创建，如果存在则截断
    wx 打开文件用于写操作如果存在则打开失败
    w+ 打开文件用于读写,如果不存在则创建,如果存在则载断
    wx+ 打开文件用于读写,如果存在则打开失败
    a 打开文件用于追加,如果不存在则创建
    ax 打开文件用于追加,如果路径存在则失败
    a+ 打开文件进行读取和追加,如果不存在则创建该文件
    ax+ 打开文件进行读取和追加,如果路径存在则失败

    简单文件写入
    /**
 * 简单文件写入
 * fs.writeFile(file, data[, options], callback)
 * fs.writeFileSync(file, data[, options])
 *  - file  要操作的文件的路径
 *  - data  要写入的数据
 *  - options   选项，可以对写入进行一些设置
 *  - callback  当写入完成后要执行的函数
 */

// 引入fs模块
var fs = require("fs")

// fs.writeFile("h3.txt", "通过writeFile写入的内容", {flag:'w'},function(err){
//     if(!err){
//         console.log("写入成功")
//     }
// })


fs.writeFileSync("h4.txt", "通过writeFileSync写入", {flag:'a+'})


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    流式写入
    /**
 * 同步，异步，简单文件的写入都不适合大文件的写入，性能较差，容易导致内存溢出
 */

var fs = require("fs")

/**
 * 流式文件写入
 * 
 * 创建一个可写流
 *  fs.createWriteStream(path[, options])
 *      - 可以用来创建一个可写流
 *      - path：文件路径
 *      - options 配置的参数
 */


/**
 * 可以通过监听流的open和close事件来监听流的打开和关闭
 * on(事件字符串，回调函数)
 *  - 可以为对象绑定一个事件
 * 
 * once(事件字符串，回调函数)
 *  - 可以为对象绑定一个一次性事件，该事件将会触发一次以后自动失效
 */


// 创建一个可写流
var ws = fs.createWriteStream("h5.txt")

ws.once("open", ()=>{
    console.log("流打开了")
})
ws.once("close", ()=>{
    console.log("流关闭了")
})
// 通过ws向文件中输出内容
ws.write("通过可写流写入文件的内容")
ws.write("通过可写流写入文件的内容")
ws.write("通过可写流写入文件的内容")

// 关闭流  不能用ws.close(),这相当于流数据还没写完就断开了
ws.end()

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    文件读取
    /**
 * 1.同步文件读取
 * 2.异步文件读取
 * 3.简单文件读取
 *  fs.readFile(path[, options], callback)
 *      - path   要读取的文件路径
 *      - options  读取的选项
 *      - callback 回调函数，通过回调函数将读取的内容返回（err, data）
 *           err 错误对象
 *          data 读取到的数据
 * 4.流式文件的读取
 * 
 */

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    简单文件读取
    var fs = require("fs")

// 简单文件读取
// fs.readFile("h3.txt",(err, data)=>{
//     if(!err)
//         console.log(data.toString())
// })

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    流式文件读取----方式一
    // 流式文件读取
var fs = require("fs")
// 创建一个可读流
var rs = fs.createReadStream("q_2.jpg")
// 创建一个可写流
var ws = fs.createWriteStream("q_2.jpg")
// 监听流的开启和关闭
rs.once("open", ()=>{
    console.log("可读流打开了")
})
rs.once("close", ()=>{
    console.log("可读流关闭了")

    // 关闭可写流
    ws.end()
})

ws.once("open", ()=>{
    console.log("可写流打开了")
})
ws.once("close", ()=>{
    console.log("可写流关闭了")
})
// 如果要读取一个可读流中的数据，必须要为可读流绑定一个data事件，
// data事件绑定完毕，他会自动开始读取数据,读取之后会自动关闭
rs.on("data", (data)=>{
    console.log(data)
    ws.write(data)
})

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    流式文件读取----方式二
    var fs = require("fs")
// 创建一个可读流
var rs = fs.createReadStream("q_2.jpg")
// 创建一个可写流
var ws = fs.createWriteStream("q_21.jpg")
// 监听流的开启和关闭
rs.once("open", ()=>{
    console.log("可读流打开了")
})
rs.once("close", ()=>{
    console.log("可读流关闭了")
})

ws.once("open", ()=>{
    console.log("可写流打开了")
})
ws.once("close", ()=>{
    console.log("可写流关闭了")
})
// pipe()可以将可读流中的内容，直接输出到可写流中
rs.pipe(ws)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    其他函数

    • 验证路径是否存在

      • 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)
    var fs = require("fs");
/**
 * fs.existsSync (path)
 *  检查一个文件是否存在
 */
var isExists = fs.existsSync("a.mp3")
console.log(isExists)

/*
    fs.stat(path, callback )
    fs.statSync(path)
        -获取文件的状态
        -它会给我们返回一个对象，这个对象中保存了当前对象状态的相关信息
*/
fs.stat("a.mp3", function (err, stat) {
    /**
        stats.size
        stats.isFile()
        stats.isDirectory()
        stats.isBlockDevice()
        stats.isCharacterDevice()
        stats.isSymbolicLink()(仅对fs.lstat()有效)
        stats.isFIFO()
        stats.isSocket()
     */
    console.log(stat);
});

/**
 * fs.unlink (path, callback )
 * fs.unlinkSync(path)
 *  -删除文件
 */

fs.unlinkSync("hello.txt");

/*
    fs.readdir(path[ , options] , callback )
    fs.readdirSync(path[ , options] )
     -读取一个目录的目录结构
     - files是一个字符串数组，每一个元素就是一个文件夹或文件的名字
*/

fs.readdir(".", function (err, files) {
    if (!err) {
        console.log(files);
    }
});

/**
 * fs.truncate (path, len, callback )
 * fs.truncatesync(path, len)
    -截断文件,将文件修改为指定的大小
 */
fs.truncateSync("hello2.txt", 10);


/*
    fs.mkdir(path[, mode] , callback )
    fs.mkdirSync(path [ , mode] )
     - 创建一个目录
    fs.rmdir(path, callback )
    fs.rmdirSync(path)
     - 删除一个目录
*/
// 创建一个文件夹
fs.mkdirSync("hello");
// 删除一个文件夹
fs.rmdirSync("hello");


/*
    fs.rename (oldPath, newPath, callback )
    fs.renameSync(oldPath, newPath)
    -对文件进行重命名
    - 参数:
     oldPath 旧的路径
     newPath 新的路径
     callback回调函数
*/

fs.rename("a.mp3", "笔记.mp3", function (err) {
    if (!err) {
        console.log("修改成功")
    }
})

/*
    fs.watchFile(filename[ , options] , listener)
    -监视文件的修改
    -参数:
        filename要监视的文件的名字
        options配置选项
        listener回调函数，当文件发生变化时，回调函数会执行
            在回调函数中有两个参数：
                curr 当前文件的状态
                prev 修改前文件的状态
                    这两个对象都是stat对象
*/
fs.watchFile("hello2.txt",{interval:1000}, function (curr, prev) {
    console.log("文件发生变化了~~~");
    console.log("修改前文件大小：",prev.size)
    console.log("修改后文件大小：",curr.size)
});

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
  • 相关阅读:
    【技术美术图形部分】坐标空间和MVP变换
    SpringBoot+Redis实现接口幂等性，就看这篇了
    C# 让程序代码在固定的线程里运行
    我的2023年度关键词：ChatGPT、生产力工具
    2022属虎的双胞胎男宝名字 很不错的宝宝取名
    vscode和HBuilderx设置快捷键注释
    Linux 任务进程命令练习
    微信小程序开发之路⑩
    Notepad2 v4.22.11r4478 开源轻量级文本编辑软件
    Redis（12）Bitmap
  • 原文地址：https://blog.csdn.net/cjhxydream/article/details/127661082