Common.js和Node.js模块（文件系统、第三方包）

以你之姓@ 2023-06-19 11:06 7阅读 0赞

> cnpm init –yes 强制启动

### 简介 ###

> 1.  `Commonjs`规范的提出，弥补`javascript`没有标准的缺陷，提供一个类似后端语言的标准库，也就是说`commonjs`是模块化的标准，`nodejs`就是`commonjs`模块化的**实现**。在nodejs中http，url，fs等等都是nodejs的内置模块，可以直接使用。
> 2.  `commonjs`中**自定义模块的实现**：  
>     在`nodejs`中将公共的功能抽离为单独的js文件作为模块，在外部是没有办法访问的（类似后端的私有的属性和方法）;
> 3.  要想使用模块，就必须在模块里面通过`exports`或者`module.exports`暴露属性或者方法。在需要的模块使用`require`引入模块。  
>     ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5_size_16_color_FFFFFF_t_70]

### 使用 ###

1.  新建app.js文件，因为默认启动时加载的是app.js文件。  
    ![这是后面强制启动cnpm时的显示选项][cnpm]

> 接口暴露方法：`export default http`或者 `module.export = http;`

//1. 发送请求
    const http = require("http");
    const url = require("url");
    
    http.createServer((req, res) => { 
        if (req.url != "/favicon.ico") { 
            let path = url.parse(req.url,true);
            let query=path.query;
            console.log(path.query);
            res.writeHead(200, {  "Content-Type": "text/html;charset=utf-8" });
            // 响应的数据
            res.write("解析路径传值："+JSON.stringify(query));
            res.end();
    }).listen(8080, "localhost", () => { 
        console.log("creat success");
    })
    //接口暴露
    module.export=http;//或者使用 export default http

1.  在自定义的外部文件中如果想使用app.js里的接口，`require`请求，通过**相对路径**引入暴露的接口`let server=require('app');`

> 怎样require直接使用（自定义）文件名，像使用本地接口直接 `let url =require('url')`，不用写明相对路径？

解决：  
`nodejs` 可以自动找`node_modules`文件下的文件，将自己的代码封装在node\_modules目录下的文件里，在外部文件中就可以通过文件名请求  
![在这里插入图片描述][20191206093029273.png]

步骤：函数暴露示例

*  `cnpm init` 启动cnpm ，根据自己的情况选择合适选项  
    执行后目录下出现package.json文件  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5_size_16_color_FFFFFF_t_70 1]
 *  我把上文代码中的请求服务函数内容封装在了node\_modules下的新文件`createServer`中（并给这个方法配置他需要的模块）

*  这样就可以简化`server`里的代码，因为将方法暴露出去，所以再使用时`require（‘文件名’）`引入就可使用

//1. 发送请求
    const http = require("http");
    let server=require('createServer'); //直接通过名称引入
    
    //2. 使用api的方法 创建服务器(请求服务)
    http.createServer(server).listen(8080, "localhost", () => { //使用封装在米快里的方法server
        console.log("creat success");
    })

对象暴露

1.  在node\_modules下新建`getData.js`,并将对象暴露出去

let stu=[
        { 
            "name":"张三",
            "sex":"男",
            "age":18
        },
        { 
            "name":"李四",
            "sex":"男",
            "age":23
        },
        { 
            "name":"五三",
            "sex":"男",
            "age":22
        },
    
    ]
    module.exports=stu;

1.  在`node_modules`下的`createServer.js`里请求数据

let stu = require('../model/getUserData');

1.  输出数据测试即可

### 后台模拟操作数据库增删改查的封装方法 ###

//模拟操作数据库的增删改查
    let connection=(callback)=>{ 
    //连接数据库
    
    }
    //封装方法二
    module.exports.insertData=(res)=>{ 
        connection(()=>{ 
    
        });
    }
    //封装方法三 自执行函数
    modulu.exports=(()=>{ 
    
    })();
    //es6类封装
    class mysql{ 
        constructor(){ 
    
        }
        insert(){ 
            
        }
        updata(){ 
    
        }
        delete(){ 
    
        }
    }

### 加密解密 ###

#### md5-node包 单向加密 ####

1.  安装 `cnpm install md5-node –save-dev`  
    安装完之后项目里面生成一个node\_modules依赖文件
2.  使用：

//单向加密模块 不能解密
    let md5 = require('md5-node')

#### base64 双向加密模块 ####

1.  安装 `cnpm install –-save-dev js-base64`  
    安装完之后项目里面生成一个node\_modules依赖文件
2.  使用：

> 一定要`.Base64`

//双向加密模块
    let base = require('js-base64').Base64
    
     //base64
            let test = base.encode(JSON.stringify(stu));//encode加密
            console.log(test);
            let str = base.decode(test);//decode 解密
            console.log(str);

### 文件流系统 ###

> 1.  文件流模块 fs 是node的内置模块
> 2.  文件读写等操作
> 3.  fs中的方法分为同步或异步
> 4.  \_\_dirname 是当前文件的相对上级目录  
>     例如下图：`console.log(__dirname ); // D:\node\Mystudy1\model`![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5_size_16_color_FFFFFF_t_70 2]
> 5.  `mode` \- 文件创建默认权限为 `0666`(可读，可写)。设置目录权限，默认为 `0777`（可读可写可执行）。

1.  新建文件`filestream.js`
2.  `//引入文件模块 let fs=require('fs')`
3.  暴露接口（以函数方法）

#### 1. 文件读取 ####

> 异步读取文件（已经新建了静态资源文件目录，新建文本文档txt：这是我的一小段测试文字）
> 
> `Buffer` ：一个缓冲池

module.exports=()=>{ 
        console.log("文件流系统正在运行");
        //1. 异步读取文件
        fs.readFile("public/test.txt",(err,data)=>{ 
            if(err){ 
                throw err;
            }
            console.log(data);//<Buffer e8 bf 99 e6 98 af e6 88 91 e7 9a 84 e4 b8 80 e5 b0 8f e6 ae b5 e6 b5 8b e8 af 95 e6 96 87 e5 ad 97 0d 0a>
        });
    }

结果输出数据为16进制码，在上段代码中加修改，需要转换成字符串后输出

> `tostring` 里的格式和源文件一致即可  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5_size_16_color_FFFFFF_t_70 3]

console.log(data.toString('utf-8'));  //这是我的一小段测试文字

> 1.  同步读取文件

//2. 同步读取文件
        let tb=fs.readFileSync("public/test.txt",'utf-8');
        console.log(tb);

异步读取和同步读取的区别：**异步读取文件的时候由操作系统在后台进行读取，不会阻碍下面的代码执行。同步读取的时候会阻碍下面的代码执行。**

输出结果为：  
![在这里插入图片描述][20191212173756889.png]

> 可见：异步读取开始、同步读取开始、同步读取结束、异步读取结束。  
> 异步读取没有结束，同步读取就完成了。  
> 结论：异步读取没有阻塞下面代码的执行。

#### 2. 打开文件 ####

##### 2.1 异步打开文件 #####

同步和异步的区别上文已经提过

1.  格式

fs.open(path, flags , [mode], callback)

1.  参数含义

> `path` \- 文件的路径。
> 
> `flags` \- 文件打开的行为。
> 
> `mode` \- 设置文件模式(权限)，文件创建默认权限为 0666(可读，可写)。
> 
> `callback` \- 回调函数，带有两个参数如：callback(err, fd)。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5_size_16_color_FFFFFF_t_70 4]

1.  实例  
    我们在之前创建的`filestream.js` 文件里打开 `test.txt` 文件进行读写

let fs = require("fs");
    
      //异步打开文件
        fs.open("public/test.txt", 'r+', (err, fd) => { 
            if (err) { 
                console.log("文件打开失败");
                throw err;
            }
            console.log("当前文件已打开");
        });
    执行结果为:
    当前文件已打开

##### 2.2 同步打开文件（不常用） #####

//同步打开文件
        let tb=fs.openSync("public/test.txt", 'r+');
        console.log(tb);
        返回值为随机数字时说明返回成功

#### 3. 获取文件信息 ####

1.  格式（异步）

fs.stat(path, callback)

1.  参数含义

> `path` \- 文件路径。
> 
> `callback` \- 回调函数，带有两个参数如：`(err, stats)`, stats 是 `fs.Stats` 对象。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5_size_16_color_FFFFFF_t_70 5]

1.  实例

fs.stat("public/test.txt", (err, stats) => { 
            if (err) { 
                console.log("文件打开失败");
                throw err;
            }
            console.log(stats.isFile());//true
        });

#### 4. 写入文件 ####

> 当前写入内容会覆盖文件原有内容

##### 4.1 异步 #####

fs.writeFile("public/test.txt", "这是我写入的数据", (err) => { 
            if (err) { 
                throw err;
            }
        });

> 直接追加到文件中的写入方法不会覆盖原有的内容

fs.appendFile ("public/test.txt", "再一次写入看看会不会覆盖", (err) => { 
            if (err) { 
                throw err;
            }
        });

##### 4.2 同步 #####

//同步
        fs.writeFileSync("public/test.txt","这是我同步写入的数据");

#### 5. 读取文件 ####

> 1.  不断地将文件中的一小块内容读入缓存区，最后从该缓存区中读取文件内容
> 2.  一个汉字或中文字符3个字节，英文字母或符号1个字节
> 3.  什么是文件描述符fd？  
>     文件描述符（file descriptor）在形式上是一个非负整数。实际上，它是一个索引值，**每一个文件描述符会与一个打开文件相对应。**

1.  语法

> 该方法使用了文件描述符来读取文件。

fs.read(fd, buffer, offset, length, position, callback)

1.  参数

> `fd` \- 通过 `fs.open()` 方法返回的文件描述符。
> 
> `buffer` \- 数据写入的缓冲区。
> 
> `offset` \- 缓冲区写入的写入偏移量。
> 
> `length` \- 要从文件中读取的字节数。
> 
> `position` \- 文件读取的起始位置，如果 `position` 的值为 `null`，则会从当前文件指针的位置读取。
> 
> `callback` \- 回调函数，有三个参数`err, bytesRead, buffer`，`err` 为错误信息， `bytesRead`表示读取的字节数，`buffer` 为缓冲区对象。

1.  底层源码：

fs.read = function(fd, buffer, offset, length, position, callback) { 
      if (!util.isBuffer(buffer)) { 
        // legacy string interface (fd, length, position, encoding, callback)
        var cb = arguments[4],
            encoding = arguments[3];
        assertEncoding(encoding);
        position = arguments[2];
        length = arguments[1];
        buffer = new Buffer(length);
        offset = 0;
        callback = function(err, bytesRead) { 
          if (!cb) return;
          var str = (bytesRead > 0) ? buffer.toString(encoding, 0, bytesRead) : '';
          (cb)(err, str, bytesRead);
        };
      }
      function wrapper(err, bytesRead) { 
        // Retain a reference to buffer so that it can't be GC'ed too soon.
        callback && callback(err, bytesRead || 0, buffer);
      }
      binding.read(fd, buffer, offset, length, position, wrapper);
    };

1.  实例

#### 6. 关闭文件 ####

1.  语法（异步）

fs.close(fd, callback)

1.  参数

> `fd` \- 通过 `fs.open()` 方法返回的文件描述符。  
> `callback` \- 回调函数，**没有参数**。

1.  实例

//文件关闭
        fs.open("public/data.txt", 'r+', (err, fd) => { 
            if (err) { 
                throw err;
            };
            console.log("文件打开成功！");
            fs.close(fd,(err)=>{ 
                if (err) { 
                    throw err;
                };
                console.log("文件关闭成功");
            });
        });

#### 7. 截取文件 ####

1.  语法（异步模式）

fs.ftruncate(fd, len, callback)

1.  参数

> `fd` \- 通过 `fs.open()` 方法返回的文件描述符。
> 
> `len` \- 文件内容截取的长度。
> 
> `callback` \- 回调函数，没有参数。

1.  实例

//存储截取后的字符
        let buffer = new Buffer(1024);
        //打开文件
        fs.open("public/test.txt", 'r+', (err, fd) => { 
            if (err) { 
                throw err;
            };
            //截取文件
            fs.ftruncate(fd, 100, (err) => { 
                if (err) { 
                    throw err;
                };
                console.log("文件截取成功");
            });
            //读取截取后的文件
            fs.read(fd, buffer, 0, buffer.length, 0, (err, bytes) => { 
                if (err) { 
                    console.log(err);
                }
                console.log(buffer.toString('utf-8'));
            });
            //关闭文件
            fs.close(fd,(err)=>{ 
                if(err){ 
                    throw err;
                }
            });
        });

#### 8.删除文件 ####

1.  语法（异步）

fs.unlink(path, callback)

1.  参数

> `path` \- 文件路径。
> 
> `callback` \- 回调函数，没有参数。

1.  实例

fs.unlink("public/data.txt",(err)=>{ 
            if(err){ 
                throw err;
            }
            console.log("文件删除成功!");
        });

#### 9.创建目录 ####

1.  语法

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

1.  参数

> `path` \- 文件路径。
> 
> `options` 参数可以是：
> 
> `recursive` \- 是否以递归的方式创建目录，默认为 false。  
> `mode` \- 设置目录权限，默认为 `0777`。  
> `callback` \-> 回调函数，没有参数。

1.  实例

// 创建目录
       fs.mkdir("public/${testname}",(err)=>{ 
           if(err){ 
               throw err;
           }
           console.log("文件创建成功");
       });
    
       
        //反编译绑定文件名
        let testname="zmttesttwo";
       fs.mkdir(`public/${ testname}`,(err)=>{  //注意反编译的写法 没有双引号！
           if(err){ 
               throw err;
           }
           console.log("文件创建成功");
       });

![在这里插入图片描述][20191215234337131.png]

#### 10.读取目录 ####

1.  语法

fs.readdir(path, callback)

1.  参数

> `path` \- 文件路径。
> 
> `callback` \- 回调函数，回调函数带有**两个参数**`err`, `files`  
> err 为错误信息，files 为 目录下的文件数组列表。

1.  实例

fs.readdir("public", (err, files) => { 
            if (err) { 
                console.log(err);
            }
            console.log(files);//[ 'test.txt', 'zmtTest', 'zmttesttwo' ]
            //遍历数组输出
            files.forEach((file) => { 
                console.log(file);
            });
        });

1.  **读取固定目录，判断里面的所有子目录是文件还是文件夹：**

//递归遍历目录里面的每一层
        let pathinfo = "public"
        let method = (path) => { 
            fs.readdir(path, (err, files) => { 
                if (err) { 
                    throw err;
                }
               //遍历子目录
                files.map((value, index) => { 
                    fs.stat(path + `/${ value}`, (error, stats) => { 
                        if (error) { 
                            throw error;
                        }
                        //开始判断是否是目录还是文件
                        if (stats.isFile()) { 
                            console.log(value + "是文件");
                        }
                        else if (stats.isDirectory()) { 
                            console.log(value + "是目录");
                            method(path + `/${ value}`);
                        }
                    });
                });
            });
        }
        method(pathinfo);

#### 11.删除目录 ####

1.  语法

> 区分此方法（删除**目录**）和删除单文件`unlink`

fs.rmdir(path, callback)

1.  参数

> `path` \- 文件路径。
> 
> `callback` \-> 回调函数，没有参数。

1.  实例

fs.rmdir("public/zmtTest",function(err){ 
            if (err) { 
                return console.error(err);
            }
            console.log("读取 /public 目录");
            //读取删除后的文件
            fs.readdir("public/",function(err, files){ 
               if (err) { 
                   return console.error(err);
               }
               files.forEach( function (file){ 
                   console.log( file );
               });
            });
         });

#### 优化：检测目录 ####

检测文件是否存在

fs.exists("public/zmt", (exist) => { 
            //如果文件不存在
            if (!exist) { 
                // 创建目录
                fs.mkdir("public/zmtTest", {  mode: 0777 }, (err) => { 
                    if (err) { 
                        throw err;
                    }
                    console.log("文件创建成功");
                  
                });
            } else { 
                console.log("该文件存在");
            }
            //执行相关操作 如添加子目录写入内容等
            fs.appendFile("public/zmtTest/addfile", "我正在写入内容！", (err) => { 
                if (err) { 
                    throw err;
                }
                console.log('写入成功');
            });
        });

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2019120609053991.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5,size_16,color_FFFFFF,t_70
[cnpm]: https://img-blog.csdnimg.cn/20191206091824147.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5,size_16,color_FFFFFF,t_70
[20191206093029273.png]: https://img-blog.csdnimg.cn/20191206093029273.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191206092055157.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191211003216567.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2019121217253272.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5,size_16,color_FFFFFF,t_70
[20191212173756889.png]: https://img-blog.csdnimg.cn/20191212173756889.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191212174524195.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20191212181339438.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzAxOTk5,size_16,color_FFFFFF,t_70
[20191215234337131.png]: https://img-blog.csdnimg.cn/20191215234337131.png