likes
comments
collection
share

node常用内置模块(一)

作者站长头像
站长
· 阅读数 25

node常用内置模块(一)

1.nodejs的全局对象global

全局对象可看做是全局变量的宿主(部分属性设置了不可枚举),不用点语法,可直接访问常用全局变量:

__filename:返回正在执行脚本文件的绝对路径
__dirname:返回正在执行脚本文件所在目录
timer类函数:执行顺序与事件循环间的关系
process:提供与当前进程互动的接口
require:实现模块的加载
module、exports:处理模块的导出

类似于,在执行.js文件的时候,将js代码放在了一个立即执行函数里面,并传入了这些变量,所以可以直接使用这些变量了。

// console.log(global);
console.log('fileName@',__filename);
console.log('dirName@',__dirname);
console.log('process.cwd@',process.cwd());
console.log('process.env@',process.env);


// 默认情况下 this 是空对象 和global不是一个对象
console.log('this@',this);

(function(){
    console.log('fun@',this===global);  // true
})();

2.process模块

获取进程信息:

// 1.资源:
console.log(process.memoryUsage()); // 内存
/*
{
  rss: 20045824,        // 常驻内存
  heapTotal: 4476928,   // 堆内存
  heapUsed: 2686544,    // 已使用堆内存
  external: 889742,     // 外部内存 使用的C++的常用库
  arrayBuffers: 9898    // 数组缓冲区大小
}
*/
console.log(process.cpuUsage()); //  CPU        系统与用户操作cpu时间片的使用情况{ user: 31000,system: 31000 }


// 2运行环境:
console.log(process.cwd());         // 运行目录
console.log(process.version);       // node版本
console.log(process.versions);      // node环境(v8版本、uv版本、zlib版本、openssl版本、ares版本、modules版本)
console.log(process.env.NODE_ENV);  // 判别是生产环境还是开发环境(undefined,在使用打包工具是,会自动配置)
console.log(process.env.PATH);      // 环境变量 
console.log(process.env.USERPROFILE); // (部分平台使用HOME获取)获取用户目录 写脚手架工具的时候,利用cri命令的时候可以使用
console.log(process.arch);          // cpu架构
console.log(process.platform);      // 系统平台


// 3.运行状态: 
console.log(process.argv);          // 启动参数
console.log(process.argv0);         // 快捷获取参数的第一个参数  execArgv
console.log(process.pid);          // 进程ID    ppid
console.log(process.uptime());     // 运行时间

执行进程操作:

// 4.事件   订阅、监听事件
process.on('beforeExit', (code) => {
    // 可以写异步代码
    console.log(`beforeExit:${code}`); // 正常退出 code=0
})

process.on('exit', (code) => {
    console.log(`exit:${code}`);
    // 不可写异步代码
    setTimeout(()=>{
        console.log('exit timeout');
    },0);
})

console.log('代码执行完了');
process.exit() // 手动退出      不能触发 beforeExit 事件




// 5.标准输出  错误
console.log = function(data){
    // process.stdout  返回一个流对象
    process.stdout.write('--'+data+'\n');
}
console.log(1);
const fs = require('fs');
// 创建一个流对象                  管道    标准输出流
fs.createReadStream('05-test.txt').pipe(process.stdout);

// 输入流
// process.stdin.pipe(process.stdout);

process.stdin.setEncoding('utf8');

process.stdin.on('readable',()=>{
    let chunk = process.stdin.read();
    if(chunk !== null){
        process.stdout.write('data '+chunk);
    }
})

3.path模块

常用API:

basename()        获取路径中基础路径名称
dirname()        获取路径中目录名称
extname()        获取路径中扩展名称
isAbsoulute()    判断路径是否为绝对路径
join()            拼接多个路径片段
resolve()        返回一个绝对路径
parse()            解析路径
format()        序列化路径
normalize()        规范化路径

代码展示:

const path = require('path');

// 1.获取路径中的基础名称       
/** 
 * 01 返回的就是接受路径当中的最后一个部分
 * 02 第二个参数表示拓展名,如果没有指定,默认返回完整的文件名
 * 03 第二个参数作为后缀时,如果没有在当前路径中匹配到,那么就会忽略掉
 * 04 处理目录路径时,如果结尾处有路径分隔符,则也会忽略掉
 */
console.log(__filename);                            // D:\Users\小江\Desktop\nodejs_test\06-path.js
console.log(path.basename(__filename));             // 06-path.js
console.log(path.basename(__filename, '.js'));      // 06-path
console.log(path.basename(__filename, '.css'));     // 06-path.js
console.log(path.basename('/a/b/c'));               // c
console.log(path.basename('/a/b/c/'));               // c


// 2.获取路径中的目录名称
/**
 * 01 返回的是路径中最后一个部分的上一层目录所在路径
 */
console.log(path.dirname(__filename));              // D:\Users\小江\Desktop\nodejs_test


// 3.获取路径中的拓展名
console.log(path.extname(__filename));                  // .js


// 4.解析路径
/**
 * 01 返回一个对象,包含路径的基本信息,相对路径的root为' '
 */
const obj = path.parse(__filename);
console.log(obj);
/**
 * {
 *  root: 'D:\\',
 *  dir: 'D:\\Users\\小江\\Desktop\\nodejs_test',
 *  base: '06-path.js',
 *  ext: '.js',
 *  name: '06-path'
 * }
 */

// 5.序列化路径  解析路径的反向操作
console.log(path.format(obj));


// 6.判断当前路径是否为绝对路径
console.log(path.isAbsolute(__filename));       // true
console.log(path.isAbsolute('/a/b/c'));         // true

// 7.路径拼接
/**
 * 01 自动确定路径分隔符
 * 02 可以判断相对路径(返回上一级,当前目录)
 */
console.log(path.join('/a/b/c', 'd', 'e.html'));     // /a/b/c/d/e.html   
console.log(path.join('/a/b/c', '../', 'e.html'));   // /a/b/e.html   
console.log(path.join(''))

// 8.规范化路径
/**
 * 规范化路径,去除路径中的多余的路径分隔符,修改成该平台下的路径分隔符
 */
console.log(path.normalize('/a\\b/c///d/e.html'));   // /a/b/d/e.html
console.log(path.normalize(''))     // .


// 9.返回绝对路径
console.log(path.resolve('./'));   
console.log(path.resolve('data.ts'));   

4.buffer

buffer简介:

  01 无须require的一个全局变量
  02 Nodejs平台下的二进制数据操作
  03 不占据v8堆内存大小的内存空间
  04 内存的使用由node来控制,由v8的GC回收
  05 一般配合Stream流使用,充当数据缓冲区

node常用内置模块(一)创建Buffer:

// 1. alloc 
const bu1 = Buffer.alloc(10)        //  allocate 分配
// 2. allocUnsafe
const bu2 = Buffer.allocUnsafe(10)  //  allocateUnsafeUnsafe 随机分配的内存,未被清理的内存,有初始值


console.log(bu1)                    //  <Buffer 00 00 00 00 00 00 00 00 00 00>
console.log(bu2)                    // <Buffer 98 bf fc 2c c8 01 00 00 04 00>   


// 3. from
//  from 创建一个Buffer对象,可以传入一个数组或者字符串或Buffer对象
// from 创建的Buffer对象的大小与传入的参数所占空间有关
const bu3 = Buffer.from([1,2,'中'],'utf-8')    // 数组中的汉字,默认不能识别
console.log(bu3)                    //  <Buffer 01 02 03>
console.log(Buffer.from('hello world','utf-8'))  //  <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>



const bu10 = Buffer.from('中');
console.log(bu10);  //<Buffer e4 b8 ad>
console.log(Buffer.from([0xe4,0xb8,0xad]))  //  <Buffer e4 b8 ad>   这样才能将汉字存入Buffer对象中



const tempBu = Buffer.alloc(3);     
const tempBu4 = Buffer.from(tempBu);        // 并不会共享空间
tempBu[0] = 1;
console.log(tempBu,tempBu4);

Buffer实例方法

let buf = Buffer.alloc(6);

// fill 使用指定的值填充缓冲区,填充到指定的范围,顾头不顾尾
buf.fill('12345467589',1,5);
// buf.fill(123)   // {


// wite 从缓冲区写入数据,写道指定的位置,长度
buf.write('123',2,4);


// toString 从缓冲区读取数据,读取指定的范围,顾头不顾尾
buf = Buffer.from('江江学习');
console.log(buf.toString('utf-8',3,9));


// slice  截取缓冲区的一部分,返回一个新的缓冲区,顾头不顾尾,可写负数
buf = Buffer.from('江江学习');
let buf2 = buf.slice(3,9);      // 注意汉字占3个字节


// indexOf  查找指定的字符串,返回第一个匹配的索引,没有返回-1
buf = Buffer.from('江江学习');
buf2 = Buffer.from('学习');
// console.log(buf.indexOf(buf2));
console.log(buf.indexOf('江',1));


// copy 拷贝缓冲区,拷贝到指定的位置,顾头不顾尾
buf = Buffer.from('江江学习');
buf2 = Buffer.alloc(6);
buf.copy(buf2,0,3,9);   // 写入的起始位置、源缓冲区的起始位置、源缓冲区的结束位置
console.log(buf2.toString());

Buffer的常用静态方法:

// concat // 拼接buffer,设置缓冲区的长度(可不写)
let b1 = Buffer.from('江江学习');
let b2 = Buffer.from('打游戏');
let b = Buffer.concat([b1,b2],18);      


//isBuffer 判断是否是缓冲区
let b3 = Buffer.alloc(18);
console.log(Buffer.isBuffer(b3));


// 封装split方法
Buffer.prototype.split = function(sep){
    let sepLen = Buffer.from(sep).length;
    let ret = [];
    let start = 0;

    let offset = 0;

    while((offset = this.indexOf(sep,start)) !== -1 ){
        ret.push(this.slice(start,offset));
        start = offset + sepLen;
    }
    ret.push(this.slice(start));        // 将最后一个分割的结果放入数组中
    return ret;
}

let buftest = Buffer.from('江江c学习c打游戏');
let arr = buftest.split('c');