process中如何放控制变量

1、process进程对象

process 是一个全局变量，即 global 对象的属性。它用于描述当前Node.js 进程状态的对象，提供了一个与操作系统的简单接口。所以习惯性的称为进程对象;

作为全局变量，它始终可供 Node.js 应用程序使用，无需使用 require()。 它也可以使用 require() 显式地访问：

const process = require('process');

process事件：

exit表示退出事件，一般在退出进程的时候触发

process.on('exit', (code) => { console.log('退出码:', code); }); console.log('进程即将退出');

beforeExit表示在退出前触发的事件，当 node 清空事件循环，并且没有其他安排时触发这个事件；通常，当没有工作被调度时，则 Node.js 进程会退出，但是在 'beforeExit' 事件上注册的监听器可以进行异步的调用，从而使 Node.js 进程继续。也就是说调用了退出事件，但是beforeExit事件能给续接上

process.on('beforeExit', (code) => { console.log('进程 beforeExit 事件的退出码: ', code); }); process.on('exit', (code) => { console.log('进程 exit 事件的退出码: ', code); }); console.log('此消息会最先显示'); // 打印: // 此消息会最先显示 // 进程 beforeExit 事件的退出码: 0 // 进程 exit 事件的退出码: 0

'warning' 事件进程警告与进程错误的相似之处，在于两者都描述了需要引起用户注意的异常条件。区别在于，警告不是 Node.js 和 Javascript 错误处理流程的正式组成部分。 一旦探测到可能导致应用性能问题，缺陷或安全隐患相关的代码实践，Node.js 就可发出警告。

process.on('warning', (warning) => { console.warn(warning.name); // 打印警告名称 console.warn(warning.message); // 打印警告信息 console.warn(warning.stack); // 打印堆栈信息 });

信号事件当 Node.js 进程接收到信号时，则会触发信号事件。信号句柄会接收信号的名称（'SIGINT'， 'SIGTERM' 等）作为第一个参数。

// 开始从 stdin 读取，因此进程不会退出。 process.stdin.resume(); process.on('SIGINT', () => { console.log('接收到 SIGINT。按 Control-D 退出。'); }); // 使用单独的函数处理多个信号。 function handle(signal) { console.log(`接收到 ${signal}`); } process.on('SIGINT', handle); process.on('SIGTERM', handle); /*-----------------------------------------------------*/ process.on('SIGTERM', (signal) => { console.log('收到信号:', signal); }); process.kill(process.pid, 'SIGTERM'); // 延迟进程退出，以便执行 SIGTERM 事件的句柄 setTimeout(() => { });

process属性：

stdout标准输出流。

process.stdout.write("Hello World!" + "\n");

stderr标准错误流。

process.stderr.write('写入内容到控制台 stderr');

stdin标准输入流。

process.stdin.on('readable', () => { console.log('读取输入:', process.stdin.read()); }); process.stdin.on('end', () => { console.log('读取结束'); });

pid当前进程的进程号。

const pid = process.pid; console.log('进程ID是:', pid);

title进程名，默认值为"node"，可以自定义该值。

const title= process.title; console.log('进程title是:', title);

arch当前 CPU 的架构：'arm'、'ia32' 或者 'x64'

const arch = process.arch; console.log('CPU架构是:', arch);

platform运行程序所在的平台系统 'darwin', 'freebsd', 'linux', 'sunos' 或 'win32'

const platform = process.platform; console.log('操作系统平台是:', platform);

process方法：

nextTick(callback)一旦当前事件循环结束，调用回调函数。process.nextTick() 会添加 callback 到下一个时间点队列。

process.nextTick(() => { console.log('下一个时间点'); }); console.log('进程即将退出');

cwd()返回当前进程的工作目录

const cwd = process.cwd(); console.log('当前工作目录是:', cwd);

exit([code])使用指定的 code 结束进程。如果忽略，将会使用 code 0。

process.on('exit', (code) => { console.log('退出码:', code); }); process.exit(1);

kill(pid[, signal])发送信号给进程. pid 是进程id，并且 signal 是发送的信号的字符串描述。信号名是字符串，比如 'SIGINT' 或 'SIGHUP'。如果忽略，信号会是 'SIGTERM'。

process.on('SIGTERM', (signal) => { console.log('收到信号:', signal); }); process.kill(process.pid); // 延迟进程退出，以便执行 SIGTERM 事件的句柄 setTimeout(() => { });

memoryUsage()返回一个对象，描述了 Node 进程所用的内存状况，单位为字节。

const memoryUsage = process.memoryUsage(); console.log('内存使用情况:', memoryUsage);

 

2、Buffer缓冲对象

Buffer 对象用于表示固定长度的字节序列。

Buffer 类在全局作用域中，因此无需使用 require('buffer').Buffer

创建

Buffer 提供了以下 API 来创建 Buffer 类：

• Buffer.alloc(size[, fill[, encoding]])： 返回一个指定大小的 Buffer 实例，如果没有设置 fill，则默认填满 0
• Buffer.allocUnsafe(size)： 返回一个指定大小的 Buffer 实例，但是它不会被初始化，所以它可能包含敏感的数据
• Buffer.allocUnsafeSlow(size)
• Buffer.from(array)： 返回一个被 array 的值初始化的新的 Buffer 实例（传入的 array 的元素只能是数字，不然就会自动被 0 覆盖）
• Buffer.from(arrayBuffer[, byteOffset[, length]])： 返回一个新建的与给定的 ArrayBuffer 共享同一内存的 Buffer。
• Buffer.from(buffer)： 复制传入的 Buffer 实例的数据，并返回一个新的 Buffer 实例
• Buffer.from(string[, encoding])： 返回一个被 string 的值初始化的新的 Buffer 实例

创建指定填充的缓冲区（安全）：

// 创建一个长度为 10、以零填充的 Buffer。
const buf1 = Buffer.alloc(10);

// 创建一个长度为 10 的 Buffer，
// 其中全部填充了值为 `1` 的字节。
const buf2 = Buffer.alloc(10, 1);

创建不安全的缓冲区：

// 创建一个长度为 10、且未初始化的 buffer。
// 这个方法比调用 Buffer.alloc() 更快，
// 但返回的 Buffer 实例可能包含旧数据，
// 因此需要使用 fill()、write() 或其他能填充 Buffer 的内容的函数进行重写。

const buf3 = Buffer.allocUnsafe(10);

创建指定包含指定字节的缓冲区：

// 创建一个包含字节 [1, 2, 3] 的 Buffer

const buf4 = Buffer.from([1, 2, 3]);

编码

指定编码方式：

当在 Buffer 和字符串之间转换时，可以指定字符编码。 如果未指定字符编码，则使用 UTF-8 作为默认值

const buf = Buffer.from('hello world', 'utf8');
/*
Node.js 目前支持的字符编码包括：
ascii - 仅支持 7 位 ASCII 数据。如果设置去掉高位的话，这种编码是非常快的。
utf8 - 多字节编码的 Unicode 字符。许多网页和其他文档格式都使用 UTF-8 。
utf16le - 2 或 4 个字节，小字节序编码的 Unicode 字符。支持代理对（U+10000 至 U+10FFFF）。
ucs2 - utf16le 的别名。
base64 - Base64 编码。
latin1 - 一种把 Buffer 编码成一字节编码的字符串的方式。
binary - latin1 的别名。
hex - 将每个字节编码为两个十六进制字符。
*/

Buffer 实例可以使用 for..of 语法进行迭代：

const buf = Buffer.from([1, 2, 3]);

for (const b of buf) {
  console.log(b);
}

3、buffer数据写入、读取

写入语法：buf.write(string[, offset[, length]][, encoding])

参数：

string-需要写入缓冲的字符串

offset：缓冲区开始写入的索引值，默认0

length：写入的字节数

encoding：使用的编码，默认utf8

buf = Buffer.alloc(256);
len = buf.write("www.runoob.com");

console.log("写入字节数 : "+  len);

读取语法：buf.toString([encoding[, start[, end]]])

参数：

encoding：表示编码格式

start：表示开始索引

end：表示结束索引

buf = Buffer.alloc(26);
for (var i = 0 ; i < 26 ; i++) {
  buf[i] = i + 97;
}

console.log( buf.toString('ascii'));       // 输出: abcdefghijklmnopqrstuvwxyz
console.log( buf.toString('ascii',0,5));   //使用 'ascii' 编码, 并输出: abcde
console.log( buf.toString('utf8',0,5));    // 使用 'utf8' 编码, 并输出: abcde
console.log( buf.toString(undefined,0,5)); // 使用默认的 'utf8' 编码, 并输出: abcde

4、Buffer的常用方法：

将 Buffer 转换为 JSON 对象

语法：buf.toJSON()

返回：JSON对象

返回 buf 的 JSON 格式。 当字符串化 Buffer 实例时，JSON.stringify() 会调用该函数。

Buffer.from() 接受此方法返回的格式的对象。 特别是， Buffer.from(buf.toJSON()) 的工作方式类似于 Buffer.from(buf)。

const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
const json = JSON.stringify(buf);

console.log(json);
// 打印: {"type":"Buffer","data":[1,2,3,4,5]}

const copy = JSON.parse(json, (key, value) => {
  return value && value.type === 'Buffer' ?
    Buffer.from(value) :
    value;
});

console.log(copy);
// 打印: <Buffer 01 02 03 04 05>

//不如直接使用JSON对象来处理

缓冲区合并

语法：Buffer.concat(list[, totalLength])

返回值：一个新的Buffer对象

var buffer1 = Buffer.from(('菜鸟教程'));
var buffer2 = Buffer.from(('www.runoob.com'));
var buffer3 = Buffer.concat([buffer1,buffer2]);
console.log("buffer3 内容: " + buffer3.toString());

缓冲区比较

语法：buf.compare(otherBuffer);

返回值：返回一个数字，表示 buf 在 otherBuffer 之前，之后或相同。

var buffer1 = Buffer.from('ABC');
var buffer2 = Buffer.from('ABCD');
var result = buffer1.compare(buffer2);

if(result < 0) {
   console.log(buffer1 + " 在 " + buffer2 + "之前");
}else if(result == 0){
   console.log(buffer1 + " 与 " + buffer2 + "相同");
}else {
   console.log(buffer1 + " 在 " + buffer2 + "之后");

拷贝缓冲区

语法：buf.copy(targetBuffer[, targetStart[, sourceStart[, sourceEnd]]])

参数描述如下：

targetBuffer - 要拷贝的 Buffer 对象。

targetStart - 数字, 可选, 默认: 0

sourceStart - 数字, 可选, 默认: 0

sourceEnd - 数字, 可选, 默认: buffer.length

var buf1 = Buffer.from('abcdefghijkl');
var buf2 = Buffer.from('RUNOOB');

//将 buf2 插入到 buf1 指定位置上
buf2.copy(buf1, 2);

console.log(buf1.toString());

缓冲区裁剪

语法：buf.slice([start[, end]])

参数描述如下：

start - 数字, 可选, 默认: 0

end - 数字, 可选, 默认: buffer.length

返回值：返回一个新的缓冲区，它和旧缓冲区指向同一块内存，但是从索引 start 到 end 的位置剪切。

var buffer1 = Buffer.from('runoob');
// 剪切缓冲区
var buffer2 = buffer1.slice(0,2);
console.log("buffer2 content: " + buffer2.toString());

缓冲区长度：

语法：buf.length

返回：缓冲区长度

var buffer = Buffer.from('www.runoob.com');
//  缓冲区长度
console.log("buffer length: " + buffer.length);