Node.js 笔记

Node.Js

Node
I/O (Input/Output)
- I/O操作指的是对磁盘的读写操作

• Node是对ES标准一个实现，Node也是一个JS引擎

  • 通过Node可以使js代码在服务器端执行

  • Node仅仅对ES标准进行了实现，所以在Node中不包含DOM 和 BOM

  • Node中可以使用所有的内建对象
    String Number Boolean Math Date RegExp Function Object Array
    而BOM和DOM都不能使用
    但是可以使用 console 也可以使用定时器（setTimeout() setInterval()）

  • Node可以在后台来编写服务器
    Node编写服务器都是单线程的服务器

    • 进程
      • 进程就是一个一个的工作计划（工厂中的车间）
      • 进程负责为程序的运行提供必备的环境
    • 线程
      • 线程是计算机最小的运算单位 执行进程中的程序（工厂中的工人）
      • 线程是干活的

  • 传统的服务器都是多线程的

    • 每进来一个请求，就创建一个线程去处理请求

  • Node的服务器单线程的

    • Node处理请求时是单线程，但是在后台拥有一个I/O线程池
    • JS是单线程

 通过npm下载的包都放到node-module文件夹中
        通过npm下载的包可以直接通过包名引入即可
        通过npm下载的包都放到node_ modules文件夹 中
        我们通过npm下载的包，直接通过包名引入即可
        
        node在使用模块名字来引入模块时，它会首先在当前 目录的node_ modules中寻找是否含有该模块
            如果有则直接使用，如果没有则去上一级目录的node_ modules中寻找
            如果有则直接使用，如果没有则再去上一级目录寻找，直到找到为止
            直到找到磁盘的根目录，如果依然没有，则报错

关键字

• require(); 引入模块
• exports 向外部暴露方法或变量等
• global 在 node 有一个全局对象 global，它的作用和网页中的window类似 || 在全局中创建的变量会作为global的属性保存 || 在全局中创建的函数会作为global的方法保存 …
• arguments.callee - 这个属性保存的是当前执行函数的对象

•     当node执行模块中的代码时，它首先代码的最顶端，添加如下代码：
        function (exports, require, module, __filename, __dirname) {
    在函数的最底部添加如下代码：
        }
    实际上模块的代码都是包装在一个函数中执行的，并且函数执行时，同时传递了5个实参 : 
        exports,
            - 该对象是用来将变量或函数暴露到外部
        require
            - 该函数用来引入外部的模块
        module
            - module 代表的是当前模块本身
            - exports 就是module的属性
            - 即可以使用 exports 导出，也可以使用module.exports 导出
        __filename
            - d:\wed\NodeJS\尚硅谷\one\4-module.js
            - 当前模块的完整路径
        __dirname
            - 当前模块所在的文件夹路径
  
  

// arguments.callee - 这个属性保存的是当前执行函数的对象
	console.log(arguments.callee + "");   // callee + ''字符串打印出函数的名字
	console.log(arguments.length);
	console.log(exports);
	console.log(module.exports === exports);
	console.log(__filename);
	console.log( __dirname);

---

模块化

使用require()引入外部模块时，使用的就是模块标识，我们可以通过模块标识来找到指定的模块

• 模块化的两大类
  • 核心模块
    - 由 node 引擎提供的模块
    - 核心模块的标识就是，模块的名字
  • 文件模块
    - 由用户自己创建的模块
    - 文件模块的标识就是文件的路径（绝对路径，相对路径）
    如果使用相对路径，必须以 ./ 或者 ../

用node通过require()方法把一个js文件引入到另一个js文件中并且调用它的变量，方法等
被引入的JS模块 ：

/* 被引入的JS模块
    模块化
        - 在node中，一个js文件就是一个模块
        - 在node中，每一个js文件中的js代码都是独立运行在一个函数中
            而不是全局作用域，所以一个模块中的变量和函数在其它模块中无法访问
 */
console.log('我是一个模块！ 我是2-module.js');
/* 
    向外部暴露属性或方法 可以通过使用exports方法来进行操作
        将需要暴露给外部的变量或方法设置为exports方法即可
*/
exports.x = '我是2-module模块的';
exports.y = '我是y';
exports.fn = function () {
    console.log(1);
    // console.dir(this);
};
console.log('--------------------');
module.exports.add = function(a,b) {
    return a + b;
};
module.exports.mul = function(a,b) {
    return a * b;
};

引入JS模块

// 引入其它的模块
/*
    在nodejs中，通过require() 函数引入外部的模块
        require() 可以传递文件的路径作为参数，node将会自动根据该路径来引入外部模块
        这里的路径，如果使用相对路径，必须以 ./ 或者 .//
        使用require()引入模块以后，该函数会返回一个对象，这个对象代表的是引入的模块
        我们使用require()引入外部模块时，使用的就是模块标识，
        我们可以通过模块标识来找到指定的模块
*/
require('./1-Nodejs.js');
/* 返回一个模块化的对象  ./2-module.js 模块表识  后缀.js可以省略  */
let result = require('./2-module.js');

console.log(result.add(1,3));
console.log(result.mul(1,3));
//  核心模块 node 的模块
let fs = require('fs');
console.log(fs);

模块化向外部暴露的两种写法

引用模块

	/*
    module.exports = {}  给module里面的exports添加对象属性
    exports = {} 创建一个新对象名为exports并给它赋值    
    exports 和 module.exports 
        - 通过 exports 只能使用 . 的方式暴露内部变量 exports.xx = xx;
        - 通过 module.exports 既可以通过 .  也可以直接赋值
            1. module.exports.xx = xx; 2. module.exports = {};
*/
// 调用模块访可以访问
module.exports = {  
    name:'猪八戒',
    age: 18,
    sayHi: function() {
        console.log('我是猪八戒！~~~');
    }
};

// exports = {    调用模块访问不了
//     name:'猪八戒',
//     age: 18,
//     sayHi: function() {
//         console.log('我是猪八戒！~~~');
//     }
// };

调用模块

let result = require('./helloModule');

console.log(result.name);
console.log(result.age);
result.sayHi();

包

• 包package 增强版的模块
  CommonJS的包规范允许我们将一组相关的模块组合到一起,形成- -组完整的工具
• CommonJS的包规范由包结构和包描述文件两个部分组成。
• 包结构
  - 用于组织包中的各种文件

包结构
●包实际上就是-一个压缩文件,解压以后还
原为目录。符合规范的目录,应该包含如
下文件:
- package.json 	描述文件
- bin			可执行二进制文件
- lib			js代码
- doc			文档
- test			单元测试

• 包描述文件
  -描述包的相关信息,以供外部读取分析

包描述文件
● 包描述文件用于表达非代码相关的信息,它是一个JSON格式的文件- package.json位于包的根目录下,是包的重要组成部分。
●  package.json中的字段
name = 名字  description = 描述	version = 版本	 keywords = 关键字(可以被搜索)		maintainers = 主要贡献者
contributors = 维护提交代码  bugs = 提交bug地址	 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命令

• package记载版本: 13.4.6 --> 13主版本号 4次版本号 6补丁
• npm -v --查看版本
• npm --帮助说明
• npm search 包名 --搜索模块包
• npm install 包名 --在本地当前目录安装包 install 可以简写成 i
• npm install 包名 -g --全局模式安装包(全局安装的包一般都是一些工具)
• npm init – 初始化，创建json文件
• npm remove 包名 – 删除包 remove 可以简写成 r
• npm install 包名 --save – 安装包并添加到依赖中**
• npm install --下载当前项目（json）的依赖
• npm cache clean - -清除缓存 -f 可选参数
• npm install 包名-registry=地址 --从镜像源安装
• npm config set registry地址 —设置镜像源
• npm install -g cnpm --registry=https://registry.npm.taobao.org --添加cnpm国内镜像源下载,并且不覆盖原来的国外源,达到可以下载包速度加快也可以访问最新的包

Buffer(缓冲区)

从结构上看Buffer非常像一个数组,它的元素为16进制的两位数。
实际上一-个元素就表示内存中的一个字节。
实际上Buffer中的内存不是通过JavaScript分配的,而是在底层通过C+ +申请的。
也就是我们可以直接通过Buffer来创建内存中的空间。

方法-属性

• Buffer.from(str) 将一个字符串转换为buffer
• BUffer.alloc(size) 创建一个指定大小的buffer，清除空间再分配
• Buffer.allocUnsafe(size) 创建一个指定大小的buffer，但可能包含敏感数据，不清除空间直接分配可能包含以前的数据
• Buffer.toString() 将缓冲区的数据转换为字符串
• Buffer.allocUnsafeSlow(size) 慢且不安全创建指定大小的buffer
• Buffer.byteLength(string[, encoding]) 获取一个字符串占用内存的大小
• Buffer.compare(buf1, buf2) 比较是否是同一个
• Buffer.concat(list[, totalLength]) 链接两个buffer

/*
    Buffer(缓冲区)
        - Buffer的结构和数组很像，操作的方法也和数组类似
        - 数组中不能存储二进制的文件，而buffer就是专门用来存储二进制数据
        - 使用buffer不需要引入模块，直接使用即可
        - 在buffer中存储的都是二进制数据，但是在显示时都是以16进制的形式显示
            buffer中每一个元素的范围都是从 00 - ff  0-255
            00000000 - 11111111  - 计算机 一个0 或 一个1 称为1位（bit）
            8bit = 1byte（字节）  1024byte = 1kd   1024kb = 1md  1024md = 1gb
        -   buffer中的一个元素，占用内存的一个字节
        - Buffer的大小一旦确定，则不能修改，Buffer实际上是对底层内存的直接操作
*/

/*
    let str = 'Hello 尚硅谷!';
    // 将一个字符串保存到buffer中
    let buf = Buffer.from(str);
    console.log(buf);
    console.log(buf.length);  // 占用内存的大小
    console.log(str.length);  // 字符串的长度
*/
/*
    创建一个指定大小的buffer
    buffer构造函数都是不推荐使用
    let buf2 = new Buffer(10); // 10个字节的buffer
    console.log(buf2.length);
*/
// 创建一个10个字节的buffer
/*
    let buf3 = Buffer.alloc(10); // 类方法
    // 通过索引，来操作buf3中的元素
    buf3[0] = 88;
    buf3[1] = 255;
    buf3[2] = 0xaa;
    buf3[3] = 255;
*/
/*  
buf3[3] = 556; 保留 一字节 其它舍弃
10 0010 1100
    10 1100

// 只要数字在控制台或页面中输出一定是10进制 也可以手动转换其它进制的输出
    console.log(buf3[2].toString(2));
    for(let i = 0 ; i < buf3.length ; i++ ) {
        console.log(buf3[i]);
    }

*/

// Buffer.allocUnsafe(size)  创建一个指定大小的Buffer，但是buffer中可能含有敏感数据
// let buf4 = Buffer.allocUnsafe(10);
// console.log(buf4);
/*
    buf5.toString() 将缓冲区的数据转换为字符串
    Buffer.allocUnsafeSlow(size) 慢且不安全创建指定大小的buffer
    Buffer.byteLength(string[, encoding]) 获取一个字符串占用内存的大小
    Buffer.compare(buf1, buf2) 比较是否是同一个
    Buffer.concat(list[, totalLength]) 链接两个buffer
*/

let buf5 = Buffer.from('我是一段文本字符串！');
console.log(buf5.toString());

File System (文件系统）读写文件

• 文件系统（File System ）
  • 文件系统简单来说就是通过node来操作系统中的文件
  • 使用文件系统。需要引进fs模块，fs是核心模块，直接引入

---

• fs模块中所有的操作都有两种形式可供选择 同步 和异步调用
• 其中同步方法的后面带有Sync，没有Sync则是异步方法
• 同步文件系统会阻塞程序的执行，也就是除非操作完毕，否则不会向下执行代码。
• 异步文件系统不会阻塞程序的执行,而是在操作完成时，通过回调函数将结果返回。

---

同步写入文件 fs.openSync(path[, flags, mode])

/*
    文件系统（File System ）
        - 文件系统简单来说就是通过node来操作系统中的文件
        - 使用文件系统。需要引进fs模块，fs是核心模块，直接引入

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

            2. 向文件写入内容
                - fs.writeSync(fd, string[, position[, encoding]]) 
                    - fd 文件的一个描述符，需要传递要写入的文件的描述符
                    - string 要写入的内容
                    - position 写入的起始位置
                    - encoding 写入的编码，默认UTF-8
            3. 保存并关闭
                - fs.closeSync(fd)
                    - fd 要关闭的文件的描述符
*/

const fs = require('fs');
let fd = fs.openSync('hello.txt','w'); // 接收描述符
// 向文件写入内容
fs.writeSync(fd,"今天的天气真不错~~~明天就可以上学了~~~",2); 
// 关闭文件
fs.closeSync(fd);

异步文件的写入 fs.open(path[, flags[, mode]], callback)

/*
   异步文件的写入
   打开文件：
       fs.open(path[, flags[, mode]], callback)
         - 打开一个文件
         - 异步调用的方法，结果都是通过回调函数返回的
         - 回调函数两个参数：
           - err 错误对象，如果没有错误则返回null
           - fd 文件描述符
   写入文件：
       fs.write(fd, string[, position[, encoding]], callback)
           -  异步写入一个文件
   关闭文件：
       fs.close(fd, callback)
           - 关闭文件
*/
// 引入模块
let fs = require('fs');
// 打开文件
fs.open('hellow.txt','w',function(err, fd) { // 异步 ，同步先走
   // console.log(arguments);
   // 判读是否出错
   if(!err) {
       // 没有出错。则对文件进行写入操作
       fs.write(fd,"这里是异步写入的内容！~~~~~",function(err) {
           if(!err) {
               console.log("写入成功！");
           }
       // 关闭文件
       fs.close(fd,function(err) {
               if(!err) {
                   console.log('文件已关闭！~');
               }
           });

       });
       
       
   }else {
       console.log(err);
   }
});

简单写入文件

/*
    简单写入文件
        fs.writeFile(file, data[, options], callback)
        fs.writeFileSync(file, data[, options])
            - file 要操作的文件的路径
            - data 要写入的数据
            - options 选项，可以对写入进行一下设置
            - callback 当写入完成以后执行函数
            - flag  r 读 w 写 a 追加
*/
// 引入fs模块
let fs = require("fs");
// C:\Users\梁桦键\Desktop\hello.txt
fs.writeFile("C:\\Users\\emilia\Desktop\\hello1.txt",'writeFile写入的内容！',{flag:'w+'},function (err) {
        if(!err) {
            console.log('写入成功!!！');
        }else  {
            console.log(err)
        }
});

// 
fs.writeFileSync("C:\\Users\\emilia\\Desktop\\hello.txt",'这是通过writeFileSync写入的内容！',{flag:'w+'});

---

简单读取文件

/*
*   1. 同步文件的读取
*       - fs.read(fd, [options,] callback)
*   2. 异步文件的读取
*        - fs.readSync(fd, [options,] callback)
*   3. 简单文件的读取
*       - fs.readFile(path[, options], callback)
*       - fs.readFileSync(path[, options]) 需要接收值
*           - path 要读取的文件的路径
*           - options 读取的选项
*           - callback 回调函数，通过回调函数将读取到内容的返回
*               - err 错误对象
*               - data 读取到的数据，会返回一个buffer数据
*   4. 流式文件的读取
* */
let fs = require("fs");
fs.readFile('1.png',function (err,data) {
    if(!err) { // 返回 buffer是因为读取的不一定是 文本文件  可能是图片。MP3等等
        // console.log(data.toString());    console.log(data);
        // 将data的数据写入到文件中
        fs.writeFile('2.png',data,function (err) {
            if(!err) {
                console.log('文件写入成功！');
            }else {
                console.log(err);
            }
        });
    }else {
        console.log(err);
    }
});

---

流式文件写入

/*
*   同步、异步、简单文件的写入都不适合大文件的写入，性能较差，容易导致内存溢出
*     可以用 流式文件的写入代替  创建一个可写流
*   fs.createWriteStream(path[, options])
*       - 可以用来创建一个可写流
*       - path 文件路径
*       - options   配置的参数
*   on(事件字符串，回调函数)
*       - 可以为对象绑定一个事件
*   once(事件字符串,回调函数)
*       - 可以为对象绑定一个一次性的事件，该事件触发一次后自动失效
* */
let fs = require('fs');
let ws = fs.createWriteStream('hello.txt');
// 可以通过监听流的open和close事件来监听流的打开和关闭
ws.once('open',function () {
    console.log('流打开了！~~');
});
ws.once('close',function () {
    console.log('流关闭了！~~');
});
ws.write('可写流写入的文件！');
ws.write('今天天气真不错啊！');
ws.write('红章比青碧');
// 关闭流
ws.end();

---

流式读取文件

/*
*   流式文件读取也适用于一些比较大的文件，可以分多次将文件读取到内存中
* */
let fs = require('fs');

// 创建一个可读流
let rs = fs.createReadStream("1.png",);
// 创建一个可写流
let ws = fs.createWriteStream("3.png");


rs.once('open',function () {
    console.log('可读流打开了~~');
});

rs.once('close',function () {
    console.log('可读流关闭了~~');
    // 可读流关闭的同时关闭可写流
    ws.end();
});

ws.once('open',function () {
    console.log('可写流打开了~~');
});

ws.once('close',function () {
    console.log('可写流关闭了~~');
});

/* 如果要读取一个可读流的数据，必须要为可读流绑定一个事件。
		data事件绑定完毕，它会自动开始读取数据  */
rs.on('data',function (data) {
    // console.log(data.length) 每次读取的长度
    // console.log(data);
    // 将读取到的数据写入到可写流里面
    ws.write(data);
});

简化版–流式读取文件

/*
*   流式文件读取也适用于一些比较大的文件，可以分多次将文件读取到内存中
* */

// 创建fs模块
let fs = require('fs');
// 创建一个可读流
let rs = fs.createReadStream("1.png",);
// 创建一个可写流
let ws = fs.createWriteStream("4.png");
// pipe() 可以将可读流中的数据直接输出到可写流里面
rs.pipe(ws);

/*
*   知道结果不需要事件的监听所以删除
* */

其它的文件操作方法关键字

• fs.existsSync(path) – 检测一个文件是否存在 返回 true 或 false
• fs.stat(path[, options], callback) - fs.statSync(path[, options]) – - 获取文件的状态 它会返回一个对象，这个对象中保存了当前对象状态的相关信息

/*
*       fs.existsSync(path)
*           - 检测一个文件是否存在 返回 true 或 false
*       fs.stat(path[, options], callback)
*       fs.statSync(path[, options])
*           - 获取文件的状态
*           - 它会返回一个对象，这个对象中保存了当前对象状态的相关信息
*       fs.unlink(path, callback)
*       fs.unlinkSync(path)
*           - 删除文件
*       fs.readdir(path[, options], callback)
*       fs.readdirSync(path[, options])
*           - 读取一个目录的目录结构
*               files是一个字符串数组，每一个元素就是一个文件夹或文件名字
*
*       fs.truncate(path[, len], callback)
*       fs.truncateSync(path[, len])
*           - 截断文件,将文件修改为指定大小
*
*       fs.mkdir(path[, options], callback)
*       fs.mkdirSync(path[, options])
*           - 创建一个文件夹或目录
*       fs.rmdir(path[, options], callback)
*       fs.rmdirSync(path[, options])
*           - 删除一个文件夹或目录
*       fs.rename(oldPath, newPath, callback)
*       fs.renameSync(oldPath, newPath)
*           - 相同的路径：重命名一个文件夹或文件
*           - 不同的路径，直接把文件剪切到新路径 需要在相同的根目录下
*           - 参数    oldPath 旧的路径  newPath 新的路径  callback 回调函数
*       fs.watchFile(filename[, options], listener)
*           - 监视文件的修改
*           - 参数
*               filename  要监视的文件名字
*               options   配置选项
*               listener   回调函数，当文件发生变化时，回调函数会执行 会一直监听
*                   在回调函数中有两个参数：
*                       curr 当前文件的状态  prev  文件修改前的状态
*                          - 这两个都是stats的对象
* */

let fs = require('fs');
let isExist = fs.existsSync('4.png');
console.log(isExist);

/*fs.stat('4.png',function (err,stat) {
    // console.log(arguments);
    console.log(stat.size);  // size 文件的大小
    console.log(stat.isFile());  // isFile() 判断是否是文件 true or false
    console.log(stat.isDirectory());  // isDirectory() 判断是否是文件夹（目录） true or false
});*/

// fs.unlinkSync('3.png');

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

// fs.truncateSync('hello.txt',5);

// fs.mkdirSync('he')

// fs.rmdirSync('he');

// fs.renameSync('练习.js','练手.js')

/*fs.rename('hello.txt','D:\\2.txt',function (err) {
    if(!err) {
        console.log('修改成功~~~');
    }else {
        console.log(err);
    }
});*/


fs.watchFile('hello.txt',{interval: 1000},function (curr,prev) {
    console.log('修改后文件的大小：' + curr.size);
    console.log('修改前的文件大小：' + prev.size);
});

权限操作

文件打开状态–文件系统标志

• 当 flag 选项采用字符串时，则以下标志均可用：

  • a: 打开文件用于追加。 如果文件不存在，则创建该文件。

  • ax: 类似于 ‘a’，但如果路径存在，则失败。

  • a+: 打开文件用于读取和追加。 如果文件不存在，则创建该文件。

  • ax+ 类似于 ‘a+’，但如果路径存在，则失败。

  • as: 打开文件用于追加（在同步模式中）。 如果文件不存在，则创建该文件。

  • as+: 打开文件用于读取和追加（在同步模式中）。 如果文件不存在，则创建该文件。

  • r: 打开文件用于读取。 如果文件不存在，则会发生异常。

  • r+: 打开文件用于读取和写入。 如果文件不存在，则会发生异常。

  • rs+ : 打开文件用于读取和写入（在同步模式中）。 指示操作系统绕过本地的文件系统缓存。这对于在 NFS 挂载上打开文件时非常有用，因为它可以跳过可能过时的本地缓存。 它对 I/O 性能有非常实际的影响，因此不建议使用此 标志（除非真的需要）。这不会把 fs.open() 或 fsPromises.open() 变成同步的阻塞调用。 如果需要同步的操作，则应使用 fs.openSync() 之类的。

  • w: 打开文件用于写入。 如果文件不存在则创建文件，如果文件存在则截断文件。

  • wx : 类似于 ‘w’，但如果路径存在，则失败。

  • w+ : 打开文件用于读取和写入。 如果文件不存在则创建文件，如果文件存在则截断文件。

  • wx+ : 类似于 ‘w+’，但如果路径存在，则失败。

文件可访问性的常量

以下常量适用于 fs.access()。

常量	说明
F_OK	表明文件对调用进程可见。 这对于判断文件是否存在很有用，但对 rwx 权限没有任何说明。 如果未指定模式，则默认值为该值。
R_OK	表明调用进程可以读取文件。
W_OK	表明调用进程可以写入文件。
X_OK	表明调用进程可以执行文件。 在 Windows 上无效（表现得像 fs.constants.F_OK）。

文件拷贝的常量

以下常量适用于 fs.copyFile()。

常量	说明
COPYFILE_EXCL	如果目标路径已存在，则拷贝操作将失败。
COPYFILE_FICLONE	拷贝操作将尝试创建写时拷贝链接。 如果底层平台不支持写时拷贝，则使用备选的拷贝机制。
COPYFILE_FICLONE_FORCE	拷贝操作将尝试创建写时拷贝链接。 如果底层平台不支持写时拷贝，则拷贝操作将失败。

文件类型的常量

	以下常量适用于 fs.Stats 对象的 mode 属性，用于决定文件的类型。

常量	说明
S_IFMT	用于提取文件类型代码的位掩码。
S_IFREG	表示普通的文件。
S_IFDIR	表示目录。
S_IFCHR	表示面向字符的设备文件。
S_IFBLK	表示面向块的设备文件。
S_IFIFO	表示 FIFO 或管道。
S_IFLNK	表示符号链接。
S_IFSOCK	表示套接字。

文件模式的常量

以下常量适用于 fs.Stats 对象的 mode 属性，用于决定文件的访问权限。

常量	说明
S_IRWXU	表明所有者可读、可写、可执行。
S_IRUSR	表明所有者可读。
S_IWUSR	表明所有者可写。
S_IXUSR	表明所有者可执行。
S_IRWXG	表明群组可读、可写、可执行。
S_IRGRP	表明群组可读。
S_IWGRP	表明群组可写。
S_IXGRP	表明群组可执行。
S_IRWXO	表明其他人可读、可写、可执行。
S_IROTH	表明其他人可读。
S_IWOTH	表明其他人可写。
S_IXOTH	表明其他人可执行。

其他操作
●验证路径是否存在
一fs.exists(path ，eallback}
一fs.existsSync(path) I
获取文件信息
一fs.stat(path, callback)

• fs.statSync(path)
  删除文件
• fs.unlink(path, callback)
• fs.unlinkSync(path)