NodeJS入门以及文件模块fs模块

模块化的详解

什么是模块

在NodeJS中一个js文件就是一个模块，将一个比较复杂的程序查分成相互依赖的文件 最后拼接为一个完整的程序

什么是模块化

模块化主要是用于管理代码，解决解耦、变量依赖与复用问题
在NodeJS中可以使用两个模块化操作
一种是ESM模块化（ES6模块化开发）
另外一种是CommonJS模块化开发

ESM模块化开发

即是ES6模块发开发 使用export 和import

1. 单个导出 export.名称=值
2. 多个导出 export{值}
3. 默认导出 export defalut {}

导出文件
persons.js文件

// let obj = {
//     name: "张三",
//     age: 20,
//     gender: "男"
// }
// // 默认导出文件
// export default { obj }

// export let name = '孙悟空'
// export let age = 500
// export let attr = "大闹天宫"

let name = '孙悟空'
let age = 500
let attr = "大闹天宫"

// 批量导出
// 我们在声明的时候 或许导出的文件较多 可以进行批量的导出
export { name, age, attr }


// 还有一个默认导出 export default
export default {
    name: "小王",
    age: 30,
    gender: "男"
}

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

导入文件
index.js文件

// 总文件 入口文件

// 使用Import导入文件 导出个导入是一起存在的 缺一不可
//1.导入单个导出
import { name, age, attr } from "./person.js";
console.log(`我的名字叫做：${name},我的岁数为：${age} 岁,技能为：${attr}`);

// 2.批量导出引入的话 与单个导出引入的方式基本一样

// 3.默认导出的引入
import xx from './person.js'
console.log(xx);
console.log(xx.name);
console.log(xx.age);
console.log(xx.gender);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

CommonJS模块化操作

导入 classRoom.js文件

// module.exports = {

// }  批量导出

function fn() {
    console.log('哈哈哈哈');
}
function fnx() {
    console.log('aaaaaaaaaaa');
}

let arr = [10, 203, 40, 540]
let obj = {
    name: "李强"
    , age: 200,
    attr: "社会你大哥"
}

// 这样书写的话 会发现一个问题 内容被对象多层嵌套
// module.exports.xx = {
//     fn, fnx, arr, obj
// }

// 可以使用如下方案
module.exports = {
    fn, fnx, arr, obj
}

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

导出文件
index.js文件

// CommonJS中的模块化操作
/* 
    导入：
      require() 参数跟的是地址
    导出：
      exports 单个导出
      module.exports批量导出  

     导出两者不能同时混用 因为exports是module.exports的一个引用

*/

// const rst = require('./student') //这里面后缀可以省略
// console.log(rst);
// // 我们使用node查看信息的时候发现 打印出来的是一个对象 因此我们可以使用对象的结构
// const { obj } = rst
// console.log(obj);

// console.log(`我的名字是：${obj.name},我有${obj.attr},一步可去十万八千里`);



//导入多个导出模块
let res = require('./classRoom')
console.log(res);

const { obj } = res
console.log(`我叫做：${obj.name},我今年${obj.age}岁,我是${obj.attr}`);

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

模块的分类

在NodeJs中，模块大致分为两类：核心模块和文件模块（这里又分为自定义模块和第三方模块）

内置模块

在NodeJS中，里面封装了一些内置的方法提供我们去使用，我们只需要引入即可，比如：url path querystring fs http等等

//内置模块  NodeJS中自带的模块，可以直接使用
/*
    require("模块名")

    fs/url/querystring/qs/path/http....
*/

//url模块     处理url

let myUrl="http://192.168.1.1:3000/admin/login?username=jack&pwd=2342#main";
//协议
//主机名
//端口
//路径
//参数

// const url=require("url");

// // console.log(url);
// let newUrl=url.parse(myUrl)
// // console.log(newUrl);

// let {host,port,protocol,query,pathname} =newUrl;
// console.log(protocol);//协议
// console.log(pathname);//路径名
// console.log(port);//端口号
// console.log(host); //主机名
// console.log(query); //参数

// let mmUrl=new URL(myUrl)
// console.log(mmUrl);

//qs模块
const qs=require('querystring');
// console.log(qs);

let str="username=jack&pwd=2342";// -->   对象格式
let rst=qs.parse(str)
// console.log(rst);

let queryObj={
    id:1,
    username:"admin",
    pwd:1123234
}

let ss=qs.stringify(queryObj)

console.log(ss);
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

一个小知识

在新的Node版本中 我们可以使用require（“node:path”）进行导入内置模块，在传统模式中一般使用的是 require（“path”）来导入模块 这样会等待所有的内置模块加载完毕去执行 在新的导入方式中，不会等待 直接去node中寻找该模块 加载速度比传统模式快

buffer是将文件转换为二进制的存在 通常是一种加密的方式

Buffer的使用

buffer常见的方法

1. concat()
2. form()
3. toString()

/* 
    buffer的使用 是将文件转换为进制的存在
    Buffer是核心API


    里面有三个方法
    form() //将字符串转换为进制
    concat() //拼接 进制  里面的参数使用数组
    toString() //转换为字符串

*/


let str = "孙悟空"
let str1 = '齐天大圣：'

let res = Buffer.from(str)
let res1 = Buffer.from(str1)
console.log(res); //
console.log(res1); //


let result = Buffer.concat([res1, res])
console.log(result); //

console.log(result.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

事件监听模块events

常用的方法

1. on() 绑定事件
2. off() 解绑事件
3. once() 绑定一次性事件
4. addListener() 绑定事件
5. removeListener() 移除事件
6. removeAllListener（） 移除所有事件

/* 
    events是键盘事件机制  是核心模块需要导入使用

    on()绑定事件
    once()绑定多个事件
    off()解绑事件
    addListener()绑定事件
    removeListner()移除事件
    removeAllListener()移除所有事件

    emit()触发事件

*/

// 使用的时候 导入 new一下就可以去使用
const emiterrs = require('node:events')

const emitter = new emiterrs()

// 绑定多个事件
// emitter.on('xx', () => {
//     console.log('你触发了xx事件');
//     console.log('当当当.........');
// })

// 声明一个变量
let fn = () => {
    console.log('你触发了xx事件');
    console.log('我需要结束此事件');
}
emitter.on('click', fn)

//绑定一次性事件
emitter.once('yy', () => {
    console.log('你触发了yy事件');
    console.log('啦啦啦啦啦............');
})
// 可以触发多个事件
// emitter.emit('xx')
// emitter.emit('xx')
// emitter.emit('xx')
// 以下只能发现只能触发一次事件
// emitter.emit('yy')
// emitter.emit('yy')
// emitter.emit('yy')
// emitter.emit('yy')


// 解绑事件
// emitter.off('xx',
//     () => {
//         console.log('你触发了yy事件');
//         console.log('啦啦啦啦啦............');

//     })
// 此时我们发现解绑事件并没有成功，原因类似于我们使用的jquery中的on 和off 注册事件和绑定事件的处理函数并不一致 所以我们可以声明一个变量 将函数赋值给这个变量

// 解绑click事件
emitter.off('click', fn) //这样就保证了注册和解绑事件的一致
emitter.emit('click')
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

FS内置模块

文件模块 fs （读与写）

Nodejs中内置了文件的操作 ：fs
常见的操作一般是文件和文件夹的操作
文件的操作一般分为：同步操作 异步操作

文件操作

二中的方式做的事情都是一样的 。只不过做的方式不同

代码实例

/* 
    文件操作
        fs.writeFile()  写入并创建文件
        fs.rename()  重命名 剪切
        fs.unlink() 删除文件
        readFile()  阅读内容
        

*/



const fs = require('fs')

// 异步写法
// fs.writeFile('../info.txt', "我是无敌暴龙兽", { flag: 'w' }, err => {
//     if (err) {
//         console.log('写入文件失败');
//         return
//     }
// })

// 同步写法
// fs.writeFileSync('../msg.txt', "我是凹凸曼", { flag: 'w' })
// console.log('成功');


// 剪切
// 异步写法
// fs.rename('../data.txt', './dta.txt', err => {
//     if (err) {
//         console.log('剪切文件失败');
//         return
//     }
// })

// 同步写法
// fs.renameSync('./dta.txt', '../data.txt')
// console.log('成功了');


// 删除文件
// 异步写法
// fs.unlink('../msg.txt', err => {
//     if (err) {
//         console.log('删除文件失败了');
//         return
//     }
// })

//同步写法
// fs.unlinkSync('../info.txt')
// console.log('成功了');

//异步写法
// fs.readFile('../data.txt', (err, dataStr) => {
//     if (err) {
//         console.log('阅读文件失败');
//         return
//     }
//     console.log(dataStr); //转换为buffer数据 直接使用toString 转换为字符串
//     console.log(dataStr.toString());
// })

// 同步写法
fs.readFileSync('../data.txt', (err, dataStr) => {
    if (err) {
        console.log('阅读文件失败');
        return
    }
    console.log(dataStr); //转换为buffer数据 直接使用toString 转换为字符串
    console.log(dataStr.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
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

文件夹操作

代码实例

首先创建与入口文件同级一个文件夹mock
里面存放一些文件

这是入口文件index.js

/*
    操作文件夹

        makdir 创建文件夹
        rmdir 删除文件夹
        readdir 读取文件夹

    同样这里也有两种操作方案  一种是同步 另外一种是异步
*/

// 异步方案

const fs = require('fs')
// fs.mkdir('./mock', err => {
//     if (!err) {
//         console.log('创建成功！');
//         return
//     }
// })
// // 同步方案

// fs.mkdirSync('./data')
// console.log('成功了');



// 读取文件夹
// fs.readdir('./mock', (err, data) => {
//     if (err) {
//         console.log('文件夹读取失败');
//     } else {
//         console.log(data); /*
//         [
//   'index.eslint.js',
//   'index.html',
//   'index.js',
//   'index.json',
//   'index.jsx',
//   'shad.vue'
// ]
// 读取的内容是一个数组
//         */
//     }
// })


// let res = fs.readdirSync('./mock')
// console.log('成功了：' + res);


// 删除文件夹
// fs.rmdir('./data', err => {
//     if (err) {
//         console.log('删除文件失败 轻稍后再试');
//         return
//     }
// })

// fs.rmdirSync('./mock') //这里面由于文件加存在内容 所以没有办法删除文件夹 这里只能删除空文件夹

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

以上就是NodeJS入门以及文件模块fs模块！！！