Node之基本内置模块

Node之基本内置模块

const os = require('os');
// console.log(os.EOL);
// console.log(os.arch());
// console.log(os.cpus().length);
// console.log(os.freemem()/2**20);
// console.log(os.homedir())
// console.log(os.hostname());
console.log(os.tmpdir())

除了全局对象，Node 还提供了一些内置模块供我们使用。
EOL ，分隔符，不同操作系统可能不同。
arch() ，cpu 的架构名。
cpus() ，获取 cpu 的每一个核的信息。
freemem() ，剩余内存。
homedir() ，用户目录。
hostname() ，用户的主机名。
tmpdir() ，获取操作系统的临时目录。不同操作系统不一样。

const path = require('path');
// console.log(path.basename('/a/b/c/d.txt','.txt'))
// console.log(process.env.PATH.split(path.delimiter))
// console.log(path.dirname('/a/b/c/d.txt'));
// console.log(path.extname('/a/b/c/d.txt'));
// const basePath='a/b';
// const fullPath=path.join(basePath,'../','d.txt')
// console.log(fullPath)
// const rel=path.relative('a/b/c','a/b/d')
// console.log(rel)
const absPath = path.resolve(__dirname, 'a/b/c', 'd.txt');
console.log(absPath);

basename() ，filename 是绝对路径，path 是url地址后面一部分，basename 是最后面的一块路径，加上第二个参数可以去掉后缀，不进行实际判断。
sep，是进行外部分割的分割符。
delimiter ，是内部进行的分割符。
dirname ，是将前面的目录拿出来，不进行实际判断。
extname ，将最后面的后缀名拿出来，不进行实际检测。
join() ，是把参数里的路径按照当前的分割符拼接起来，可以使用 ../ 返回上一级路径。
normalize ，会将传入的路径进行规范化处理。
relative() ，表示参数传入两个路径中右边相对左边路径的相对路径。
resolve() ，根据路径去找绝对路径，路径是可以拼接的。如果不加入 __dirname ，则会依据 process.cwd() 的当前进程命令行的路径，设置了之后，会依据 _dirname 的当前模块的目录进行拼接。

const URL = require('url');
// const url = URL.parse('https://www.baidu.com/s?wd=hello');
const url = new URL.URL('https://www.baidu.com/s?wd=hello')
// console.log(url.searchParams.has('wd'));
const obj = {
    href: 'https://www.baidu.com/s?wd=hello',
    origin: 'https://www.baidu.com',
    protocol: 'https:',
    username: '',
    password: '',
    host: 'www.baidu.com',
    hostname: 'www.baidu.com',
    port: '',
    pathname: '/s',
    search: '?wd=hello',
    hash: ''
}
const url2 = URL.format(obj);
console.log(url2);

url 可以将 url 路径解析为域名，端口，主机名，参数，哈希等信息。参数是一个类似于 map 的结构，可以调用has，get 等方法。还可以通过 format(obj) 方法将一个对象转化为一个 url 地址。

const util = require('util');
// async function delay(duration=1000){
//     return new Promise((resolve,reject)=>{
//         setTimeout(()=>{
//             resolve(duration);
//         },duration)
//     })
// }
// delay().then(d=>console.log(d))
// const delayCallback = util.callbackify(delay);
// delayCallback(500,(err,d)=>{
//     if(err) throw err;
//     console.log(d);
// })
function delayCallback(duration, callback) {
    setTimeout(() => {
        callback(null, duration);
    }, duration)
}
const delay = util.promisify(delayCallback);
// delay(500).then(d => console.log(d))
// (async()=>{
//     const r=await delay(500);
//     console.log(r);
// })()
const obj1={
    a:1,
    b:{
        c:2,
    }
}
const obj2={
    a:1,
    b:{
        c:2,
    }
}
console.log(util.isDeepStrictEqual(obj1,obj2));

callbackify 可以将 promise 转化为回调模式，返回一个回调函数。第一个参数是传入的参数，第二个参数是一个回调函数。
promisify 可以将回调模式转化为 promise 模式。因为以前的很多框架都是基于回调模式写的，这样用起来很方便。
inherits 继承，第一个参数为子类，第二个参数为父类。
isDeepStrictEqual 是对两个对象进行内部嵌套模式的深度比较。