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: "男"
}

导入文件
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);

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
}

导出文件
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}`);

模块的分类

在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);

一个小知识

在新的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); //<Buffer e5 ad 99 e6 82 9f e7 a9 ba>
console.log(res1); //<Buffer e9 bd 90 e5 a4 a9 e5 a4 a7 e5 9c a3 ef bc 9a>


let result = Buffer.concat([res1, res])
console.log(result); //<Buffer e9 bd 90 e5 a4 a9 e5 a4 a7 e5 9c a3 ef bc 9a e5 ad 99 e6 82 9f e7 a9 ba>

console.log(result.toString()); //齐天大圣孙悟空

事件监听模块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')

FS内置模块

文件模块 fs 读与写

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

文件操作

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

同步	异步
readFile	readFileSync 读取文件
writeFile	WriteFileSync 写入文件
rename	renameSync 剪切 重命名文件
unlink	unlinkSync 删除文件

代码实例

/* 
    文件操作
        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());
})

文件夹操作

同步	异步
mkdir	mkdirSync 创建文件夹
rmdir	rmdirSync 删除文件夹
readdir	readdirSync剪切 重命名文件
unlink	unlinkSync 删除文件
stat	读取文件信息 isDirectory() 是否为文件夹 isFile是否为文件

代码实例

首先创建与入口文件同级一个文件夹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') //这里面由于文件加存在内容 所以没有办法删除文件夹 这里只能删除空文件夹

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