DIV CSS 佈局教程網

JavaScript 內核:資料型別、變數與運算子
編輯:JavaScript基礎知識     

這一章的任務是處理三件容易被視為理所當然、卻處處藏著陷阱的事:資料型別(基本型別與引用型別)、變數(含作用域),以及運算子(尤其是那些看字面不太容易理解的部分)。

JavaScript 有「一切皆物件」的特質,一旦把這些基礎吃透,後續那些讓人頭痛的概念——作用域鏈、呼叫物件、閉包、柯里化——都會變得好懂許多。

資料型別

寫過 C 或 Java 的人都知道,資料是有型別的:使用者名稱是字串,員工年齡是數字,UI 上的開關按鈕對應到布林值;數字還能再細分為浮點數、整數,整數又分長整數與短整數。這些講的都是「值屬於哪一類」。

JavaScript 把資料型別分成兩大類:基本資料型別與物件型別。物件型別底下包含物件、陣列與函式——事實上函式與陣列也都是物件,後續章節會細談。

基本資料型別

JavaScript 有三種基本資料型別:字串(String)、數值(Number)、布林值(Boolean)。

var str = "Hello, world";// 字串
var i = 10;// 整數
var f = 2.3;// 浮點數

var b = true;// 布林值

用 typeof 可以檢視型別:

print(typeof str);
print(typeof i);
print(typeof f);
print(typeof b);

輸出:

string
number
number
boolean

注意:不論整數還是浮點數,在 JavaScript 裡都屬於 number。另外,上面用到的 print() 是 Rhino 直譯器頂層物件的方法;在瀏覽器端,工程師通常用 alert(),它是瀏覽器 JavaScript 直譯器頂層物件(window)的方法。

物件型別

這裡講的「物件」指的是一個型別分類,不是某個具體物件。它包括:物件(屬性的集合,也就是鍵值散列表)、陣列(有序清單)、函式(含可執行程式碼)。

物件型別是複合型別,構成元素可以是基本型別,也可以不是——物件型別的值本身就可以是另一個物件型別的實例。

var str = "Hello, world";
var obj = new Object();
obj.str = str;
obj.num = 2.3;

var array = new Array("foo", "bar", "zoo");

var func = function(){
print("I am a function here");
}

obj 有 obj.str、obj.num 這些屬性,值可以是基本型別,也可以更複雜。來看看它們的型別:

print(typeof obj);
print(typeof array);
print(typeof func);

輸出:

object
object
function

看到 print(typeof array) 印出 object,很多人會愣一下。其實物件與陣列的界線並不明顯(它們本來就同屬一類),但行為差異很大,所以後續章節會分別介紹。

基本型別與物件型別之間的轉換

類似 Java 的自動裝箱/拆箱,JavaScript 也有類似的動作:基本型別在做某些運算時,會臨時被包裝成物件,算完之後又自動釋放。

var str = "JavaScript Kernal";
print(str.length);// 印出 17

用 typeof 檢查,str 的型別是 string;但下面這個:

var str2 = new String("JavaScript Kernal");
print(typeof str2);

str2 的型別是 object。兩者顯然不同,那為什麼 str.length 取得到長度?因為存取 str.length 時,JavaScript 會自動包裝一個內容相同的臨時 String 物件,取出它的 length 屬性,然後把這個臨時物件丟掉。

反向轉換——物件轉基本型別——的做法是呼叫物件的 valueOf() 取得值,若與上下文型別相符就直接採用;valueOf 取不到值时,改呼叫 toString();若上下文是數值型,還得再把這個字串轉成數字。

因為 JavaScript 是弱型別語言,引擎必須根據上下文「猜」物件的型別,這也是它執行效率不如編譯型語言的原因之一。

簡單記:valueOf() 負責把物件轉成符合上下文需求的基本型別;toString() 則顧名思義,印出物件對應的字串——前提是你已經覆寫了 Object 的 toString()。

這套規則會引發一些反直覺的結果。例如所有非空物件在布林環境下都會被轉成 true:

function convertTest(){
if(new Boolean(false) && new Object() && new String("") && new Array()){
print("convert to boolean");
}
}
convertTest();// 印出 convert to boolean

初學者常被這些轉換規則搞得頭暈,覺得一堆寫法別扭至極。但規則一旦掌握,這些看似古怪的寫法反而能大幅提升程式碼效率。透過例子來記最有效:

var x = 3;
var y = x + "2";// 結果是 "32"
var z = x + 2;// 結果是 5

print(y);
print(z);

你會在 JavaScript 程式碼裡反覆看到這種寫法:

if(datamodel.item){
// do something
}else{
datamodel.item = new Item();
}

它其實有更深一層的含義。datamodel.item 是一個物件(字串、數字等),而 if 需要一個布林運算式,所以這裡發生了型別轉換。JavaScript 在需要布林值時會自動轉換:物件非空則為 true,否則為 false。於是這種簡寫形式就成立了。

在強型別語言裡,同樣的意思得寫成:

if(datamodel.item != null){
// do something
}else{
datamodel.item = new Item();
}

型別判斷

JavaScript 是弱型別語言,但有時候我們確實需要知道執行期的型別。例如某個函式的參數預期是另一個函式:

function handleMessage(message, handle){
return handle(message);
}

若呼叫時傳進來的 handle 不是函式,引擎就會報錯。所以呼叫之前最好先判斷:

function handleMessage(message, handle){
if(typeof handle == "function"){
return handle(message);
}else{
throw new Error("the 2nd argument should be a function");
}
}

但 typeof 並非萬靈丹:

var obj = {};
var array = ["one", "two", "three", "four"];

print(typeof obj);// object
print(typeof array);// object

兩者都印出 object,根本分不出來。這時就要請 instanceof 出馬:

print(obj instanceof Array);// false
print(array instanceof Array);// true

把 typeof 與 instanceof 結合起來判斷,實務上就夠用了。

變數

變數做的事,就是把一個名字和一個值綁在一起,之後用這個名字就能引用到那個值。

var str = "Hello, World";
var num = 2.345;

下次要對 "Hello, World" 做什麼,用 str 就好;要算 10 倍的 num,寫 10*num 即可。

基本型別 vs. 引用型別

基本型別(數字、布林值等)在記憶體中佔固定大小,我們透過變數直接存取它們。引用型別(物件、陣列、函式)大小原則上不受限制,所以我們存的是一個「引用」——一個指向真實資料位置的位址。

先看基本型別:

var x = 1;
var y = x;
print(x);
print(y);

x = 2;// 修改 x

print(x);// 2
print(y);// 1

一如預期,y 不受 x 影響。

再看引用型別。陣列長度不固定、可動態增刪,屬於引用型別:

var array = [1,2,3,4,5];
var arrayRef = array;

array.push(6);
print(arrayRef);

輸出:

1,2,3,4,5,6

因為引用指向的是位址,arrayRef 與 array 指向的是同一個物件,透過其中一個做的修改,另一個立刻看得到。

變數的作用域

變數被定義的區域就是它的作用域。全域變數有全域作用域;函式內部宣告的局部變數則只有局部作用域,函式外拿不到。

var variable = "out";

function func(){
var variable = "in";
print(variable);// 印出 in
}

func();
print(variable);// 印出 out

這裡有個務必記牢的規則:函式內宣告變數時,var 關鍵字是必須的。少了 var,操作預設會落到全域物件上:

var variable = "out";

function func(){
variable = "in";// 注意這裡沒有 var
print(variable);
}

func();
print(variable);// 全域的 variable 被改掉了

輸出:

in
in

少了 var,func 裡的赋值改的是全域物件的 variable 屬性,於是函式外的值也跟著變了。

運算子

運算子常被忽略,但很多古怪的語法現象,最後都得靠運算子的優先順序或作用來解釋。即使寫了幾年 JavaScript,也還是有人會在這裡栽跟頭。

中括號運算子([])

[] 可以用在陣列上按下標取值:

var array = ["one", "two", "three", "four"];
array[0]

它同樣能作用在物件上。一般物件屬性用點運算子取值:

var object = {
field : "self",
printInfo : function(){
print(this.field);
}
}

object.field;
object.printInfo();

但如果你在遍歷一個物件,對它的鍵一無所知,點運算子就無能為力了。這時改用中括號:

for(var key in object){
print(key + ":" + object[key]);
}

輸出:

field:self
printInfo:function (){
print(this.field);
}

點運算子(.)

點運算子左邊是物件,右邊是屬性名。值得留意的是,右邊的屬性值本身可能又是一個物件,於是形成多層結構:

var object = {
field : "self",
printInfo : function(){
print(this.field);
},
outter:{
inner : "inner text",
printInnerText : function(){
print(this.inner);
}
}
}

object.outter.printInnerText();

這裡的 outter 既是 object 的屬性,同時又是 printInnerText() 的呼叫主體。

== 與 ===,!= 與 !==

== 讀作「相等」,=== 讀作「等同」。兩者長得很像,意義卻不同:相等運算子會先做型別轉換,等同運算子不會。

print(1 == true);
print(1 === true);
print("" == false);
print("" === false);

print(null == undefined);
print(null === undefined);

輸出:

true
false
true
false
true
false

相等運算子(==)的規則

· 兩側型別相同時,直接比對值,相等回傳 true。
· 型別不同時:
 - null 與 undefined 相等
 - 一邊是數字、一邊是字串時,把字串轉數字再比
 - 一邊是 true 時先轉成 1(false 轉成 0)再比
 - 一邊是物件、另一邊是數字/字串時,用 toString() 或 valueOf() 把物件轉成原始值
 - 其他情況一律回傳 false

等同運算子(===)的規則

· 型別不同,直接回傳 false,不做任何值判斷。
· 型別相同時:
 - 都是數字:值相同即等同(唯一例外是 NaN,它連和自己都不相等)
 - 都是字串:值相同即等同
 - 都是布林值且值同為 true 或 false,即等同
 - 兩個運算元引用同一個物件(陣列、函式)時完全等同
 - 兩者同為 null 或 undefined 時等同

例如:

var obj = {
id : "self",
name : "object"
};

var oa = obj;
var ob = obj;

print(oa == ob);
print(oa === ob);

兩行都印 true,因為 oa 與 ob 引用同一個物件。

再看一個容易翻車的例子:

var obj1 = {
id : "self",
name : "object",
toString : function(){
return "object 1";
}
}

var obj2 = "object 1";

print(obj1 == obj2);
print(obj1 === obj2);

輸出:

true
false

obj1 是物件,obj2 是完全不同結構的字串,用相等運算子比對卻判定相同——因為 obj1 覆寫了 toString()。這正是 == 最容易埋雷的地方。

!= 與 !== 則與 ==/=== 恰好相反。結論很明確:在 JavaScript 中做相等性判斷時,務必留意型別轉換,實務上建議一律使用 ===/!==,能省下大量難以追蹤的 bug。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved