寫 Node.js 之前,先把 JavaScript 的語言基礎補齊會少走很多彎路。本文從變數宣告、迴圈、運算子一路談到物件、JSON、類與原型,適合有 C/C++ 或 PHP 經驗、但 JavaScript 功底較薄的開發者。
Node.js 的底層語言是 JavaScript,而腳本語言最顯著的特徵就是「弱類型」。與 PHP 略有不同的是,PHP 新建變數無需宣告,JavaScript 則仍需要 var(或 let/const)。而這個 var 一統天下,涵蓋了 C++ 裡 int、char、float、string 乃至函式指標的所有語義。
C/C++ 中我們會這樣寫:
void foo() {}
int a = 0;
char b = 'a';
float c = 1.0f;
void (*d)() = foo; ///< 函數指標
而在 Node.js 中,全部用 var 解決:
function foo() {}
var a = 0;
var b = 'a';
var c = 1.0;
var d = foo;
函式在 JavaScript 中是「第一類公民」,可以直接賦值給變數,這也是後面回調機制的基礎。
寫法與 C/C++ 基本一致,只是不需要宣告型別:
for (var i = 0; i < foo; i++) {
//...
}
這是「後置型」迴圈,類似 PHP 的 foreach。假設有一個物件:
var foo = {
"hello" : "world",
"node" : "js",
"blahblah" : "bar"
};
可以用 for...in 遍歷它的鍵名:
for (var key in foo) {
console.log(key + ": " + foo[key]);
}
執行 `node foo.js` 後輸出:
hello: world node: js blahblah: bar
要點在於:for...in 遍歷的是鍵名,而不是鍵值;取值必須透過 `foo[key]` 的形式。這一點與 PHP 的 foreach 有明顯區別。另外,若遍歷陣列,for...in 得到的是索引字串,通常更推薦用 for 迴圈或 forEach。
與其他語言沒有差別,唯一需要注意的是變數宣告要加 var。
+ 既能做數值相加,也能做字串拼接,這是弱類型語言最容易踩坑的地方:
var a = "1"; var b = 2; console.log(a + b); // 12 console.log(parseInt(a) + b); // 3
第一行程式碼中 a 是字串,於是 b 也被轉成字串,結果是兩個字串首尾相接;第二行透過內建的 parseInt 把 a 轉為整數,相加得到真正的數值 3。日常開發中,從表單或 URL 參數拿到的值都是字串,做算術前務必顯式轉型。
雙等號只比較值,不做型別轉換判斷:
var a = 1, b = "1"; console.log(a == b); // true
三等號則是嚴格相等,型別與值都相同才成立:
var a = 1, b = "1"; console.log(a === b); // false
實務上強烈建議一律使用 === 與 !==,避免隱式型別轉換帶來的意外。if 條件語句本身與其他語言無異,差別只在這幾個等號的選擇上。
用來判斷變數型別,回傳一個型別名字串:
function foo() {}
var a = 0;
var b = '噓~蛋花湯在睡覺。';
var c = 1.0;
var d = foo;
var e = { "a" : a };
var f = [ 1, 2, 3 ];
var g = null;
var h = undefined;
console.log(typeof a); // number
console.log(typeof b); // string
console.log(typeof c); // number
console.log(typeof d); // function
console.log(typeof e); // object
console.log(typeof f); // object
console.log(typeof g); // object
console.log(typeof h); // undefined
兩個反直覺之處值得記住:陣列的 typeof 結果是 object,判斷陣列要用 Array.isArray();null 的 typeof 結果也是 object,這是語言歷史遺留的問題。
JavaScript 裡有三個特殊值,含義各不相同。
null 是一個特殊的 object,語義上表示「空」,通常是我們主動把某個變數置空:
var a = null;
與 C/C++ 不同的是,null 並不等於 0。
undefined 表示「這個變數尚未被賦值」,多用來區分「值為空」與「根本沒宣告」:
var a = {
"foo" : null
};
console.log(a["foo"]); // null
console.log(a["bar"]); // undefined
a["foo"] 存在但值為空,a["bar"] 則完全不存在,兩者意義不同。
NaN 全稱 Not a Number,是一個特殊的 number 型別值,通常在數值運算出錯時產生,例如零除、對非數字字串調用 parseInt 等。它有個著名特性:NaN 與任何值(包括自身)都不相等,因此判斷時要用 Number.isNaN()。
Node.js 的基礎型別包括 number、string、boolean、array 等。前三種是值賦值,而陣列是引用賦值:
var foo = [ 1, 2, 3 ]; var bar = foo; bar[0] = 3; console.log(foo); // [ 3, 2, 3 ]
改動 bar 會同步影響 foo,因為兩者指向同一個陣列。要複製一份獨立副本,必須做「深拷貝」而非直接賦值。
陣列有三種常見建立方式:
// 第一種:先建空陣列再逐項賦值
var dog = new Array();
dog[0] = "噓~";
dog[1] = "蛋花湯";
dog[2] = "在睡覺";
// 第二種:建構時傳入元素
var dog = new Array("噓~", "蛋花湯", "在睡覺");
// 第三種:字面量語法
var dog = [
"噓~",
"蛋花湯",
"在睡覺"
];
第三種寫法最簡潔,也是當今的主流選擇。
嚴格說來,JSON 與一般 JavaScript 物件的區別在於「是否只用來存儲資料,而非某個類的實例」。JSON 的全稱就是 JavaScript Object Notation。
var dog = {
"pre" : "噓~",
"sub" : {
"name" : "蛋花湯",
"act" : "在睡覺",
"time" : 12
},
"suf" : [ "我說了", "它在睡覺", "就是在睡覺" ]
};
取值有兩種方式:點記法與中括號記法:
dog.pre; dog["pre"];
點後面直接跟 key;若 key 存在變數中,則只能用 `dog[key]` 的形式。建議自己動手用 for...in 遍歷一次上面的物件,並配合 typeof 觀察每個值的型別。
嚴格意義上 Node.js 沒有 class 概念,所謂「類」其實是一個函式加上一些成員,本質仍是函式。為了表述方便,下文仍稱之為類,其實例稱為物件。
function foo() {
//...
}
這樣就宣告好了一個 foo 類。實例化:
var bar = new foo();
使用 new 呼叫時,foo() 就充當了建構函式的角色。
第一種方式是在建構函式或任何方法中透過 this 宣告:
function foo() {
this.hello = "world";
}
注意:只有加上 this 才是成員變數,否則僅是函式內的區域變數。這兩者的作用域完全不同,切勿混淆。
第二種方式是透過原型宣告:
function foo() {
//...
}
foo.prototype.hello = "world";
兩種方式都能正常取值:
var bar = new foo(); console.log(bar.hello);
如果兩者同時存在:
function foo() {
this.hello = "world";
}
foo.prototype.hello = "蛋花湯";
輸出結果仍然是 world。原因在於屬性查找順序:實例自身的屬性優先於原型上的同名屬性,原型屬性只是「找不到時的兜底」。把建構函式中的賦值去掉,才會讀到原型上的值。
function foo(hello) {
if (hello === undefined) {
this.hello = "world";
} else {
this.hello = hello;
}
}
這裡的 `hello === undefined` 判斷很關鍵。JavaScript 對參數個數極為寬容:多傳的會被自動忽略,少傳的則以 undefined 補足。所以:
var bar1 = new foo();
var bar2 = new foo("蛋花湯");
bar1 等價於 `new foo(undefined)`,因此 hello 取到預設值 world;bar2 則得到蛋花湯。
另外注意,建構函式中的 hello 是區域參數,this.hello 才是成員變數,同名並不衝突——這正是 this 的價值所在。
宣告方式與成員變數的第二種形式類似:
function setHello(hello) {
this.hello = hello;
}
foo.prototype.setHello = setHello;
bar1.setHello("雞蛋餅");
但這樣寫顯得囉嗦,這裡就要引入匿名函式。
很多函式只在一處被引用,為它單獨起名並無必要。JavaScript 允許直接寫出沒有名字的函式:
function(hello) {
this.hello = hello;
}
綁定到原型上就變成:
foo.prototype.setHello = function(hello) {
this.hello = hello;
}
效果與前面的具名寫法完全一致,程式碼卻精簡許多。實務中,類成員方法的宣告幾乎都採用這種匿名函式形式。
匿名函式更常見的用法是作為回調傳入。例如有個函式:
/**
* 傳入 a、b 兩個變數,
* 算出 a+b 的值後,交由 func 進行輸出
*/
function sumab(a, b, func) {
var c = a + b;
func(a, b, c);
}
若準備中英文兩個版本的輸出函式,具名寫法如下:
function zh(a, b, sum) {
console.log(a + " + " + b + " 的值是:" + sum);
}
function en(a, b, sum) {
console.log(a + " plus " + b + " is " + sum);
}
sumab(1, 2, zh);
sumab(3, 4, en);
輸出:
1 + 2 的值是:3 3 plus 4 is 7
改用匿名函式則是:
sumab(1, 2, function(a, b, sum) {
console.log(a + " + " + b + " 的值是:" + sum);
});
sumab(3, 4, function(a, b, sum) {
console.log(a + " plus " + b + " is " + sum);
});
這種形式正是回調函式的典型寫法,而回調機制堪稱 Node.js 的精髓。
JavaScript 允許你在任何位置修改已有的類,這一點與 Ruby 相似。比如 string 本身也是一個類,有 length 屬性和 indexOf、substr 等方法;如果覺得它功能不足,可以直接擴充:
String.prototype.sb = function() {
var newstr = "";
for (var i = 0; i < this.length; i++) {
if (i % 2 === 0) newstr += "s";
else newstr += "b";
}
return newstr;
};
var str = "噓~蛋花湯在睡覺。";
console.log(str.sb()); // sbsbsbsbs
這個方法按字元位置交替填充 s 和 b。當然,實務中修改內建原型容易與第三方庫衝突,僅在教學或受控環境中使用。
所謂深拷貝,就是新建一個陣列或物件,把來源中的基礎型別值逐個複製過去,而不是只複製引用。由於物件可能嵌套,實現上需要遞歸:
function cloneObject(src) {
var dest = {};
for (var key in src) {
if (typeof src[key] === "object") dest[key] = cloneObject(src[key]);
else dest[key] = src[key];
}
return dest;
}
這是教學用的簡化版,未處理 Date、正則、循環引用與陣列型別等情況。實際專案中可直接使用 `structuredClone()`,或 lodash 的 cloneDeep。
回顧全文,JavaScript 的弱類型帶來了靈活性,也埋下了隱式轉換與 this 指向的陷阱。理解值與引用的差別、原型查找機制、以及回調函式的組織方式,是寫好 Node.js 程式的三塊基石。後續可再深入學習閉包、Promise 與非同步流程控制。