node.js学习技巧

--save

=== 生产环境 dependencied
npm install xxx
npm install xxx --save
npm install xxx -S
npm i xxx -S

=== 开发环境 devDependencies
在 devDependencies 添加包
npm install --save-dev
npm install -D

package.json~^区别

~version大约相当于版本，将更新到所有未来的补丁版本,而不会增加次要版本

~1.2.3将使用从 1.2.3到 <1.3.0

~1.2.*就是修复的版本

~version向后兼容的新功能

^2.3.4到 <3.0.0的版本

^2.*.*这个形式

关闭端口

npm install -g kill-port关闭一个端口
kill-port 3208
关闭多个端口
kill-port 4208 3200

更强大的功能 fkil-cli

package-lock.json

对于npm修改 node_modules 树或者 package.json
它描述了生成的确切树,以便后续安装能够生成相同的树,而不管
中间依赖项更新如何

忽略整个存储库的差异,你可以添加到 .gitattributes

package-lock.json binany
yarn.lock binary

node.js 退出

process.exit(code)
代码结束进程
code = 0
成功的退出
code = 1
失败的条件退出
命令行退出
node //回车
.exit

把 package.json所有依赖都更新到最新版本

npm instatl -g npa-check-updates
ncu -U
npm install

process.argv

处理命令行的数组
第一个参数 node的位置信息
第二个参数 当前执行文件的位置信息
第三个到n 输入的多个参数用逗号分割

process.argy.slice(2)

node写入文件

const fs = require('fs')

fs.writeFile('./test'，'我是一个文件'，err =>{
    if (err) {
        console.log('报错啦');
    }
})

// 或者
fs.writeFileSync('./test.text','我是一个文件',err=>{
    if (erm) {
        console.log('又报错啦')
    }
})

const stream = fs.createwriteStream('my_file.txt');
stream.once('open',()=>{
    stream.write('我是一个小文件123 \n')
    stream.write('我是一个小文件12333  \n')
    stream.end();
})

node 获取文件夹下的文件名

const fs = require('fs');
fs.readdir('./',(err,files)=>{
    //
})

fs.readdinSync('./')

获取文件夹下所有的目录

fse.readdir('./', {withFileTypes:true},(err,files)=>{
    const vals = files.filter(val => val.isDirectory()).map(dirent => dirent.name);
    console.log(vals);
})
// 同步
const vals = fse,readdirSync('./', {withFileTypes: true}).filter(val => val.isDirectory()).map(dirent=>dirent.name);

glob

使用 shell使用的模式匹配文件,比如星号和其他东西

const glob = require('glob');
glob('./test1/*.js'，{},(er, files) => {
    console.log(er,files);
})

*0到多


?匹配1个


[]匹配一系列字符,跟正则类似


!(aaa|bbb)

module.exports

作为 require调用结果实际返回的对象

test6.js

const myFunc1 = () => {
    console.log(1);
}
const myFunc2 = () => {
    Console.log(2);
}
exports.myFunc1=myFunc1;
exports.myFunc2=myFunc2;

xx.js

const m = require('./test6');
m.myFunc1();
const {myFunc1}=require('./test6');
myFunc1();

如果你想公开一个函数或者一个变量

test6.js

const myFunc1 = () => {
    console.log(1);
}
module.exports = myFunc1

使用

express

const express = require('express');
const app = express();
app.get('/user/:id',(req, res,next) => {
    console.log(reg.url);
    // {id:111}
    console.Log(req.params);
    // ?id=2
    console.log(req.query.id);
    res.send('Hello World')
    next();
})
app.listen(3000)

node 请求接口

const axios=require('axios')
axios.get('http://127.0.0.1:3000/user/2').then(res=>{
    console.log(res.data);
})
// http://172.30.75.144:3800/usen/2

process.env

设置环境变量

prgcess.env.PORT || 3200
"scripts":{
    "start": "PORT=3000 node server.js"
}

判断文件是否存在

const isdtfe = path => {
    try {
        if (fs.existsSync(path)) {
            return true
        }
    }catch (_) {
    }
    return false
}
console.log(isdtfe('./package.json'));

目录不存在,创建目录

const fs = pequire('fs');
const dir ='./tmp';
if (!fs.existsSync(dir)) {
    fs.mkdirSync(dir)
}
// mkdir

查看文件执行文件

eval(fs.readFileSync('./test6.js')+'')

__filename和 dirname

filename

• 当前模块的文件名,解析的是当前模块的绝对路径` (D:\caogao\express01.js)

__dirname

• 当前模块的目录名(D:\caogao)

process.cwd()

• 返回当前目录

拿到文件的地址,上级或者上上级

const path=require('path');
path.join(__dirname,'../../')
path.resolve(__dirname,'..')

拿到当前文件名

const path = require('path');
path.basename(__filename)

import

异步延迟加载

const fn =async()=>{
    const a = await import('./test6.js');
}

web 服务器

const express = require('express');
const app = express();
app.get('/',express.static(--dinname+'/public'))

app.listen(3000,()=>{
    console.log('启动了');
})

插件库
http-server

live-server

Buffer缓冲区

buffer是一个全局对象,不需要 require,

Buffer.from('Hello World').toString('base64')
Buffer.from('SGVsbG8gV29ybG0=','base64').toString('ascii')

下载文件

app.get('/download',(req, res) => {
    res.download(`${__dirname}/test1/1.js`)
})

请求的文件下载到本地

axios.get('http://127.0.0.1:3000/download').then(res => {
    const fileName = res.headers['content-disposition'].split('filename="')[1].slice(0, -1)
    fs.writeFile('./' + fileName, res.data,err=>{
        console.log(err);
    })
})

获取完整的url路径

req.protocol +'://' + req.get('host')+ reg.originalUrl

打印报错位置的信息

console.trace('测试1')

监听文件方法变化

npm install nodemon
nodemon app.js

用到 package.json

{
    "scpipts":{
        "start":"nodemon test8.js"
    }
}

ts-node运行ts文件

{
    "scripts":{
        "start-ts": "ts-node 100.ts"
    }
}

复制文件

fs.copyFile('test2.js','test2.js02',err => {
    console.log(err);
})

fs-extra
文件系统的方法,用于替代 fs， fs 模块的所有方法都附加到 fs-extra上

文件操作

copy文件夹(异步的)

const fse = pequire('fs-extra');
// 同步
fse.copy('./test1','./testCopy1',err=>{
    console.log(err);
}
// promise
fse.copy('./test1','./testCopy2').then(() => {
    console.log('成功');
    }).catch(err => {
        console.log(err);
    })
    try{
        fse.copy('./test1','./testCopy2')
    }
    catch(e){
        console.log(e);
    }

copySync(src,dest[,options]) 同步

添加过滤

fse.copy('./test1','./testCopy5', {
    filter: function (src, dest) {
        // 复制的位置，复制后的所在位置
        console.log(src, dest);
        // 去复制的文件中有1.js
        if(src.includes('1.js')){
            return false
        }
        return true
    }
},
err =>{
console.log(err);
})

空目录(异步)

确保目录为空,如果不为空,则删除目录为空,如果该目录不存在,则会创建它,目录本身不会被删除

fse.emptyDir('./testCopy5',err=>{
    console.log(err);
});
.then().catch()

try{}catch{}

emptyDirSync

确保文件存在(异步)

别名 createFile

如果不存在,则创建这些目录和文件,如果存在则不做改变

fse.ensureFile('./testCopy4/test3/1.Js',err=>{
    console.log(err);
}

ensureFileSync(同步)

确保目录存在(异步)

别名: mkdirs(), mkdirp()
确保目录存在,如果不存在,则创建它

fse.ensureDir('./testCopy4/test5',err=>{
    console.log(err,'xxx');
})

ensureDirSync(同步)

确保链接存在(异步),类似复制黏贴

如果目录不存在则创建它,存在就报错,本质类似于复制黏贴
别名: createLink()

fse.ensureLink('./testCopy4/test3/1.js','./testCopy12/test3/2.js',err=>{
    console.log(err);
})

ensureLinkSync(同步)

移动(异步)

移动文件或者目录

fse.move('./testCopy4/1.js', './testCopy4/test108/2.js').then(() => {
    console.Loe("成功");
}).catch(err =>{
    console.log(err,'失败');
})

{overwrite:true} 默认为false,就是不覆盖

fse.move('./1.js','./testCopy4/test100/2.js', {overwrite: true})

moveSync(同步)

输出文件(异步)

跟 writeFile类似,只是父目录不存在,则创建它,有的话,则覆盖

const file ='./testCopy4/test100/110.js';
fse.outputFile(file,'我是一个内容',err =>{
    console.log(err);
    fse.readFile(file,'utf8',(err,data)=>{
        console.log(err, data);
    })
})
==========
fse.outputFile(file,'我是一个内容').then(()=>fse.readFile(file,'utf8')).then(data=>{
    console.log(data);
})

outputFileSync(同步)

输出json文件(异步)

跟 writeJson一样,不存在,则创建它

fse.outputJson(file, {name: 'xxx'}).then(()=> fse.readJson(file)).then(data =>{
    console.log(data);
}).catch(err=>{
console.log(err);
})

readJson
throws设置为false,当json无效不会抛出

fse.readIson(file, {throws: false}, (err, obj) => {
    console.log(err,obj);
})

writeJsonSync(同步)

readJsonSync(同步)

outputJsonSync(同步)

检测路径是否存在

fse.pathExists(file,(err,exists)=>{
    if (err) {
        return;
    }
    console.log(exists);// true 存在，false 不存在
})

pathExistsSync(同步)

删除

删除文件或者目录,如果路径不存在,则静默不执行

fse.remove('./testCopy4/test100',err=>{
    if (err) {
        console.log(err);
    }
})

removeSync(同步)

node内存不足

node --max-lod-spance-size=4096 xxx.js
1GB 1024
2GB 2048
3GB 3072
4GB 4096
5GB 5120
6GB 6144
7GB 7168
8GB 8192

获取IP

const {networkInterfaces} = require('os');
const getIp = () => {
    const ipObj = {};
    const nets = networkInterfaces();
    for (let name of Object.keys(nets)) {
        const item = nets[name];
        for (let item of nets[name]) {
            const familyV4Value = typeof item.family === 'string' ? 'IPv4' : 4;if (item.family === familyV4Value && !item.internal) {
                if (!ipObj[name]) {
                    ipObj[name] = [];
                }
                ipObj[name].push(item,address);
            }
        }
    }
    return ipObj
}
console.log(getIp());

使用库 npm install ip

const ip = require('ip');
ip.address();

哈希字符串

node内置模块

const crypto = require('crypto');
const hash = crypto.createHash('md5').update('我是谁').digest('hex');
console.log(hash);

流

const Readable = require('stream').Readable;
const s = new Readable();
s.push('我是一个Liud1123')
//流的结尾
s.push(null);
// 查春流
s.on('data',(data)=>{
    console.log(data);
}

逐行读取

fse.readFile(' ./test11.js', 'utf8',(err,files)=>{
    console.log(files.split('\r\n'));
})

在原有数据中新添加数据

fse.appendFile('./test11.js', '\r\n 我是一个新添加的一行')

设置 {flag:'a'}也可以在尾部添加

fse.writeFile('./test11.js', 'hello node', {flag: 'a'}, err =>{
    console.log(err);
})

拿到当前操作系统

process.platform
// 也可以使用os模块
const os = require('os');
os.platform()
返回值
darwin // MacOs
win32  win64 // Windons
linex/// Linux

文件扩展名

const path = require('path');
path.extname(__filename)

_filename.split('.').pop()

特定包是否已全局安装

npm List -g xxx
如果没有全局安装
输出返回为
D:\Program Files\nodejs
`-- (empty)

检查脚本是否在node.js 下运行

window 在node.js 中是没有对象的,所以我们可以判断他是在node环境下
if(typeof window === 'undefined'){
    exports.foo = {};
}else{
    window.foo = {};
}

nwjs

基于 Chromium和Node.js,让你直接从DOM/webWorker 调用所有Node.js模块

解压文件

archiver对 tar和 zip开箱即可支持

glob工具

npm install glob

通配符查找

const glob = require('glob');
// 异步
glob('**/*.js',{},(err,files)=>{
    console.log(files);
})
const a=glob.sync('./test1/**/*.js',{})