域名是什么举个例子seo变现培训

模块化的详解

什么是模块

在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模块     处理urllet 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模块！！！