瀏覽器上有自己的全局對象 window，同理， nodejs 下也有自己的全局對象 global，并且在各個模塊下 都可以直接訪問 global 對象。

在 nodejs 中，除了可以直接使用 V8 JavaScript 引擎中所支持的原生 JavaScript 的函數(shù)和對象外，它還追加了一些其他的函數(shù)和對象（比如：Buffer 對象、require 函數(shù)等）。

1. Buffer 對象： 用于處理二進制數(shù)據(jù)
2. module 對象： 用于訪問當前模塊的信息
3. process 對象： 用于訪問進程信息
4. console 對象： 用于向控制端輸出某些信息
5. 6 個計時器相關(guān)函數(shù)

需要注意的是，可以在不引入模塊的情況下直接使用 nodejs 追加的這些函數(shù)和對象。

下面將對上面的這些對象和函數(shù)的使用進行簡單的解釋。

Buffer 對象

在 ES6 之前，原生的 JavaScript 并沒有專門用來處理二進制數(shù)據(jù)的機制，所以為了方便地處理二進制數(shù)據(jù)，nodejs 才引入了 Buffer 對象。

ES6 之后，原生的 JavaScript 引入了 TypedArray，用來處理二進制數(shù)據(jù)。注意 TypedArray 并不是以一個單一的對象的形式而存在，而是以一系列值的類型為 TypedArray 的對象而存在。在這一系列對象中，Uint8Array 對象和 Buffer 對象最為相似，但是 Buffer 對象更加適用于 nodejs。

Buffer 對象的實例很像一個各個元素都是整數(shù)的數(shù)組，但是與真正的數(shù)組的區(qū)別在于它的大小固定的（即在實例創(chuàng)建時決定大小），并且為它分配的內(nèi)存是原生的，并且存在于 V8 的堆內(nèi)存外。
在 nodejs 6.0 版本之前，是使用 new Buffer() 語法來創(chuàng)建一個實例，但是因為一些安全問題，以這種形式創(chuàng)建實例的方法被廢除了，取而代之的是一些 Buffer 對象的一些靜態(tài)方法。

創(chuàng)建 Buffer 實例

1. Buffer.alloc(size[, fill[, encoding]])： 返回一個指定大小的 Buffer 實例，如果沒有設(shè)置 fill，則默認填滿 0
2. Buffer.allocUnsafe(size)： 返回一個指定大小的 Buffer 實例，但是它不會被初始化，所以它可能包含敏感的數(shù)據(jù)
3. Buffer.allocUnsafeSlow(size)
4. Buffer.from(array)： 返回一個被 array 的值初始化的新的 Buffer 實例（傳入的 array 的元素只能是數(shù)字，不然就會自動被 0 覆蓋）
5. Buffer.from(arrayBuffer[, byteOffset[, length]])： This creates a view of the ArrayBuffer without copying the underlying memory
6. Buffer.from(buffer)： 復制傳入的 Buffer 實例的數(shù)據(jù)，并返回一個新的 Buffer 實例
7. Buffer.from(string[, encoding])： 返回一個被 string 的值初始化的新的 Buffer 實例
   

const buf1 = Buffer.alloc(5);
const buf2 = Buffer.allocUnsafe(5);
const buf3 = Buffer.from([1, '2a', 230]);
const buf4 = Buffer.from('abcdggg');
console.log(buf1); // <Buffer 00 00 00 00 00>
console.log(buf2); // <Buffer b8 ed a3 80 58> （這只是一種可能的結(jié)果）
console.log(buf3); // <Buffer 01 00 e6>
console.log(buf4); // <Buffer 61 62 63 64 67 67 67>
console.log(buf4.toString()); // abcdggg
buf2.fill(0);
console.log(buf2); // <Buffer 00 00 00 00 00>

上面講的不太清楚（以后再優(yōu)化），因為我是初學，TypedArray 都沒玩過呢！

但是放心，大腿在這呢 — Node源碼解析 – buffer

源碼鏈接： buffer.js

Buffer.byteLength(string[, encoding])： 返回 string 的實際的字節(jié)長度（注意不是字符長度）

let str1 = 'a';
let str2 = '小';
let str3 = 'aa';
let str4 = '小a';
console.log(str1.length);    // 1
console.log(Buffer.byteLength(str1)); // 1
console.log(str2.length);    // 1
console.log(Buffer.byteLength(str2)); // 3
console.log(str3.length);    // 2
console.log(Buffer.byteLength(str3)); // 2
console.log(str4.length);    // 2
console.log(Buffer.byteLength(str4)); // 4

上面的漢字 小 的 UTF-8 碼正好占用三個字節(jié)（\xE5\xB0\x8F），所以才會有上面的結(jié)果。

Buffer.concat(list[, totalLength])： 連接多個 Buffer 實例或 Uint8Array 實例，并返回一個新的 Buffer 實例

const buf1 = Buffer.alloc(10);
const buf2 = Buffer.alloc(14);
const totalLength = buf1.length + buf2.length;
console.log(totalLength); // 24
const buf = Buffer.concat([buf1, buf2], totalLength);
console.log(buf.length); // 24

Buffer.isBuffer(obj)： 判斷一個對象是不是 Buffer 實例

Buffer.isEncoding(encoding)： 判斷是否支持指定的編碼方式

console.log(Buffer.isEncoding('utf8')); // true
console.log(Buffer.isEncoding('utf9')); // false

Buffer.poolSize： 指定預分配的字節(jié)數(shù)的大小，默認為 8192（即 8 KB）

Buffer.prototype.buffer： 一個指向 ArrayBuffer 的引用

const arrayBuffer = new ArrayBuffer(16);
const buffer = Buffer.from(arrayBuffer);
console.log(buffer.buffer === arrayBuffer); // true

Buffer.prototype.equals(otherBuffer)： 比較兩個 Buffer 實例是否擁有完全相同的 bytes

const buf1 = Buffer.from('hello');
const buf2 = Buffer.from('hello');
console.log(buf1.equals(buf2)); // true

用于迭代的方法

1. Buffer.prototype.entries()
2. Buffer.prototype.keys()
3. Buffer.prototype.values()

Buffer.prototype.fill(value[, offset[, end]][, encoding])： 用指定的值填充滿 Buffer 實例

const b = Buffer.allocUnsafe(25).fill('abc呵呵');
// 注意下面因為不夠容納全部的漢字字節(jié)，所以亂碼
console.log(b.toString()); // abc呵呵abc呵呵abc呵�

Buffer.prototype.includes(value[, byteOffset][, encoding])

Buffer.prototype.indexOf(value[, byteOffset][, encoding])

Buffer.prototype.toJSON()： 返回一個 JSON 對象

當 JSON.stringify(buf) 的參數(shù)為一個 Buffer 實例時，會隱式地調(diào)用上面的方法

const b = Buffer.from('hell')
let json = b.toJSON();
console.log(json); // { type: 'Buffer', data: [ 104, 101, 108, 108 ] }
console.log(JSON.stringify(b)); // {"type":"Buffer","data":[104,101,108,108]}

Buffer.prototype.toString([encoding[, start[, end]]])： 以指定的 encoding 解碼 Buffer 實例，返回解碼后的字符串

const buf = Buffer.from([104, 101, 108, 108]);
console.log(buf.toString()); // hell
console.log(buf.toString('base64')); // aGVsbA==
console.log(buf.toString('hex')); // 68656c6c

字符串不能被修改，但是 Buffer 實例卻可以被修改。

const buf = Buffer.from('abcd');
console.log(buf.toString()); // abcd
buf[1] = 122;
console.log(buf.toString()); // azcd

Buffer.prototype.write(string[, offset[, length]][, encoding])： 將指定字符串寫入到 Buffer 中

const buf = Buffer.from('abcdefg');
console.log(buf); // <Buffer 61 62 63 64 65 66 67>
console.log(buf.toString()); // abcdefg
buf.write('和', 1);
console.log(buf); // <Buffer 61 e5 92 8c 65 66 67>
console.log(buf.toString()); // a和efg

好了，還有一堆方法就不一一列出來了，Buffer 就到這里了。

module 對象

在使用 require 函數(shù)加載模塊文件時，將運行該模塊文件中的每一行代碼

模塊在首次加載后將緩存在內(nèi)存緩存區(qū)中，所以對于相同模塊的多次引用得到的都是同一個模塊對象，即對于相同模塊的多次引用不會引起該模塊內(nèi)代碼的多次執(zhí)行。

在編譯的過程中，Node 會對獲取的 JavaScript 文件內(nèi)容進行頭尾包裝！

// 包裝前 module666.js
const PI = 6666;
module.exports = PI;
// 包裝后，注意下面不是立即執(zhí)行函數(shù)
(function(exports, require, module, __filename, __dirname) {
 const PI = 6666;
 module.exports = PI;
});

__filename & __dirname

1. __filename： 返回當前模塊文件的絕對路徑（帶文件名）
2. __dirname： 返回當前模塊文件所在目錄的絕對路徑

// 1.js
console.log(__filename); // c:\Users\percy\Desktop\nodejs\1.js
console.log(__dirname); // c:\Users\percy\Desktop\nodejs

Process 對象

process 對象是 nodejs 的一個全局對象，提供當前 nodejs 進程的信息。

屬性

1. process.arch： 返回當前處理器的架構(gòu)
2. process.env： 返回一個包含用戶環(huán)境變量的對象
3. process.argv： 返回一個數(shù)組，數(shù)組的第一個元素總是 node 程序的絕對路徑，第二個元素是當前執(zhí)行腳本的絕對路徑
4. process.execPath： 返回 node 程序的絕對路徑
5. process.argv0： 返回 node 程序的絕對路徑
6. process.pid： 返回當前進程的進程號
7. process.platform： 返回當前的系統(tǒng)平臺標識符（比如：'darwin', ‘freebsd', ‘linux', ‘sunos' or ‘win32'）
8. process.version： 返回當前 node 的版本號
9. process.versions： 返回一個對象，列出了 nodejs 和其相關(guān)依賴的版本號

三個重要的屬性

1. process.stdin： 返回一個指向標準輸入流的可讀流（Readable Stream）
2. process.stdout： 返回一個指向標準輸出流的可寫流（Writable Stream）
3. process.stderr： 返回一個指向標準錯誤流的可寫流（Writable Stream）

方法

1. process.cwd()： 返回進程當前的工作目錄
2. process.chdir(path)： 改變進程當前的工作目錄
3. process.cpuUsage()： 返回當前 CPU 的使用情況
4. process.memoryUsage()： 返回當前內(nèi)存的使用情況
5. process.uptime()： 返回 Node 程序已運行的秒數(shù)
6. process.nextTick(callback[, …args])： 指定回調(diào)函數(shù)在當前執(zhí)行棧的尾部、下一次Event Loop之前執(zhí)行
7. process.emitWarning(warning[, options])： 觸發(fā)一個 warning 事件，可以自定義一些警告信息
8. process.exit([code])： 立即結(jié)束當前進程，但是會觸發(fā) process 的 exit 事件
9. process.abort()： 立即結(jié)束當前進程，不會觸發(fā) exit 事件

console.log(process.cwd()); // c:\Users\percy\Desktop\nodejs
process.chdir('../');
console.log(process.cwd()); // c:\Users\percy\Desktop

process.emitWarning('Something happened!', {
 code: 'MY_WARNING',
 detail: 'This is some additional information'
});
process.on('warning', (warning) => {
 console.log(warning);
})

process.on('exit', function(code) {
 console.log('exit~', code);
});
process.exit(); // exit~

process 對象還有一些方法沒列出來，因為我現(xiàn)在看不懂怎么用，以后補 >_<

Console 對象

這個對象就是用來在控制臺下面打印一些信息而已，挑幾個有用但沒記牢的方法來玩玩。

console.dir(value)： 打印一個對象的詳細信息

const buf = Buffer.from('abcdefg');
console.log(buf); // <Buffer 61 62 63 64 65 66 67>
console.dir(buf); // Buffer [ 97, 98, 99, 100, 101, 102, 103 ]

console.time(label) & console.timeEnd(label)： 用來統(tǒng)計代碼執(zhí)行時間

let label = 'time';
let str = 'hello';
console.time(label);
while (str.length < 999999) {
 str += 'a';
}
console.timeEnd(label); // time: 133.724ms

6 個計時器函數(shù)

在瀏覽器上，就有相應的 4 個計時器函數(shù)（setInterval、clearInterval、setTimeout、clearTimeout），只不過它們是 window 全局對象的屬性。

在 nodejs 中，除過上面的 4 個計時器，還增加了兩個（setImmediate，clearImmediate）。

這六個計時器函數(shù)被定義在了全局對象 global 下，即可以直接在代碼中進行使用。

以上就是本文的全部內(nèi)容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。

最新評論