本章將聚焦于 JavaScript 中的基本概念，這些概念與傳統(tǒng)語言有比較大的不同，因此單獨(dú)列出一章來做專門描述，理解本章的概念對書中后續(xù)章節(jié)的概念，代碼的行為等會(huì)有很大的幫助，讀者不妨花比較大的時(shí)間在本章，即使你對 JavaScript 已經(jīng)比較熟悉，也建議通讀本章。
本章主要講述 JavaScript 中的數(shù)據(jù)類型(基本類型與引用類型)，變量(包括變量的作用域)，操作符(主要是一些較為常見，但是不容易從字面上理解的操作符)。由于 JavaScript 中的“一切皆對象”，在掌握了這些基本的概念之后，讀者就可以較為輕松的理解諸如作用域，調(diào)用對象，閉包，currying 等等較難理解的概念了。
有程序設(shè)計(jì)經(jīng)驗(yàn)的讀者肯定知道，在 C 或者 Java 這樣的語言中，數(shù)據(jù)是有類型的，比如用以表示用戶名的屬性是字符串，而一個(gè)雇員的年齡則是一個(gè)數(shù)字，表示 UI 上的一個(gè)開關(guān)按鈕的數(shù)據(jù)模型則為布爾值等等，對數(shù)字可能還可以細(xì)分為浮點(diǎn)數(shù)，整型數(shù)，整型數(shù)又可能分為長整型和短整型，總而言之，它們都表示語言中的數(shù)據(jù)的值的類型。
JavaScript 中的數(shù)據(jù)類型分為兩種：基本數(shù)據(jù)類型和對象類型，其中對象類型包含對象，數(shù)組，以及函數(shù)(事實(shí)上，函數(shù)，數(shù)組等也都是對象，這個(gè)在后邊的章節(jié)詳述)。
在 JavaScript 中，包含三種基本的數(shù)據(jù)類型，字符串(String)，數(shù)值(Number)，布爾值(boolean)，下面是一些簡單的例子：
var str = "Hello, world";//字符串
var i = 10;//整型數(shù)
var f = 2.3;//浮點(diǎn)數(shù)
var b = true;//布爾值 我們可以分別查看變量的值及變量的類型：
print(str);
print(i);
print(f);
print(b);
print(typeof str);
print(typeof i);
print(typeof f);
print(typeof b); 注意，在此處使用的 print()函數(shù)為 rhino 解釋器的頂層對象的方法，可以用來打印字符串，通常情況下，在客戶端，程序員多使用 alert()進(jìn)行類似的動(dòng)作，alert()是瀏覽器中 JavaScript 解釋器的頂層對象(window)的一個(gè)方法。
Hello, world
10
2.3
true
string
number
number
Boolean 在 JavaScript 中，所有的數(shù)字，不論是整型浮點(diǎn)，都屬于“數(shù)字”基本類型。typeof 是一個(gè)一元的操作符，在本章的另外一個(gè)小節(jié)會(huì)專門講到。
這里提到的對象不是對象本身，而是指一種類型，我們在第三章會(huì)對對象進(jìn)行詳細(xì)的討論，此處的對象包括，對象(屬性的集合，即鍵值的散列表)，數(shù)組(有序的列表)，函數(shù)(包含可執(zhí)行的代碼)。
對象類型是一種復(fù)合的數(shù)據(jù)類型，其基本元素由基本數(shù)據(jù)類型組成，當(dāng)然不限于基本類型，比如對象類型中的值可以是其他的對象類型實(shí)例，我們通過例子來說明：
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.str, obj.num，這些屬性的值可以是基本類型，事實(shí)上還可以更復(fù)雜，我們來看看他們的類型：
print(typeof obj);
print(typeof array);
print(typeof func);
//將打印出
object
object
function 讀者可能會(huì)對 print(typeof array)打印出 object 感到奇怪，事實(shí)上，對象和數(shù)組的界限并不那么明顯(事實(shí)上它們是屬于同一類型的)，但是他們的行為卻非常不同，本書的后續(xù)章節(jié)將兩個(gè)重要的數(shù)據(jù)類型做了分別介紹。
類似與 Java 中基本數(shù)據(jù)類型的自動(dòng)裝箱拆箱，JavaScript 也有類似的動(dòng)作，基本數(shù)據(jù)類型在做一些運(yùn)算時(shí)，會(huì)臨時(shí)包裝一個(gè)對象，做完運(yùn)算后，又自動(dòng)釋放該對象。我們可以通過幾個(gè)例子來說明：
var str = "JavaScript Kernal";
print(str.length);//打印17 str 為一個(gè)字符串，通過 typeof 運(yùn)算符可知其 type 為”string”，而：
var str2 = new String("JavaScript Kernal");
print(typeof str2); 可知，str2 的 type 為”object”，即這兩者并不相同，那么為什么可以使用 str.length 來的到 str 的長度呢？事實(shí)上，當(dāng)使用 str.length 時(shí)，JavaScript 會(huì)自動(dòng)包裝一個(gè)臨時(shí)的 String 對象，內(nèi)容為 str 的內(nèi)容，然后獲取該對象的 length 屬性，最后，這個(gè)臨時(shí)的對象將被釋放。
而將對象轉(zhuǎn)換為基本類型則是通過這樣的方式：通過調(diào)用對象的 valueOf()方法來取得對象的值，如果和上下文的類型匹配，則使用該值。如果 valueOf 取不到值的話，則需要調(diào)用對象的 toString()方法，而如果上下文為數(shù)值型，則又需要將此字符串轉(zhuǎn)換為數(shù)值。由于 JavaScript 是弱類型的，所以 JavaScript 引擎需要根據(jù)上下文來“猜測”對象的類型，這就使得 JavaScript 的效率比編譯型的語言要差一些。
valueOf()的作用是，將一個(gè)對象的值轉(zhuǎn)換成一種合乎上下文需求的基本類型，toString()則名副其實(shí)，可以打印出對象對應(yīng)的字符串,當(dāng)然前提是你已經(jīng)“重載”了 Object的toString()方法。
事實(shí)上，這種轉(zhuǎn)換規(guī)則會(huì)導(dǎo)致很多的問題，比如，所有的非空對象，在布爾值環(huán)境下，都會(huì)被轉(zhuǎn)成 true，比如：
function convertTest(){
if(new Boolean(false) && new Object() &&
new String("") && new Array()){
print("convert to boolean")
}
}
convertTest();//convert to Boolean初學(xué)者容易被 JavaScript 中的類型轉(zhuǎn)換規(guī)則搞暈掉，很多情況下會(huì)覺得那種寫法看著非常別扭，其實(shí)只需要掌握了規(guī)則，這些古怪的寫法會(huì)大大的提高代碼的性能，我們通過例子來學(xué)習(xí)這些規(guī)則：
var x = 3;
var y = x + "2";// => 32
var z = x + 2;// => 5
print(y);
print(z); 通?？梢栽?JS 代碼中發(fā)現(xiàn)這樣的代碼：
if(datamodel.item){
//do something...
}else{
datamodel.item = new Item();
} 這種寫法事實(shí)上具有更深層次的含義：
應(yīng)該注意到，datamodel.item 是一個(gè)對象(字符串，數(shù)字等)，而if需要一個(gè) boolean 型的表達(dá)式，所以這里進(jìn)行了類型轉(zhuǎn)換。在 JavaScript中，如果上下文需要 boolean 型的值，則引擎會(huì)自動(dòng)將對象轉(zhuǎn)換為 boolean 類型。轉(zhuǎn)換規(guī)則為，如果該對象非空，則轉(zhuǎn)換為 true,否則為 false.因此我們可以采取這種簡寫的形式。
而在傳統(tǒng)的編程語言(強(qiáng)類型)中，我們則需要：
if(datamodel.item != null){
//do something...
}else{
datamodel.item = new Item();
} 前面講到 JavaScript 特性的時(shí)候，我們說過，JavaScript 是一個(gè)弱類型的語言，但是有時(shí)我們需要知道變量在運(yùn)行時(shí)的類型，比如，一個(gè)函數(shù)的參數(shù)預(yù)期為另一個(gè)函數(shù)：
function handleMessage(message, handle){
return handle(message);
} 當(dāng)調(diào)用 handleMessage 的函數(shù)傳遞的 handle 不是一個(gè)函數(shù)則 JavaScript 引擎會(huì)報(bào)錯(cuò)，因此我們有必要在調(diào)用之前進(jìn)行判斷：
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 運(yùn)行結(jié)果顯示，對象 obj 和數(shù)組 array 的 typeof 值均為”object”，這樣我們就無法準(zhǔn)確判斷了，這時(shí)候，可以通過調(diào)用 instanceof 來進(jìn)行進(jìn)一步的判斷：
print(obj instanceof Array);//false
print(array instanceof Array);//true
第一行代碼返回 false,第二行則返回 true。因此，我們可以將 typeof 操作符和 instanceof 操作符結(jié)合起來進(jìn)行判斷。
變量，即通過一個(gè)名字將一個(gè)值關(guān)聯(lián)起來，以后通過變量就可以引用到該值，比如：
var str = "Hello, World";
var num = 2.345;當(dāng)我們下一次要引用”Hello, Wrold”這個(gè)串進(jìn)行某項(xiàng)操作時(shí)，我們只需要使用變量 str 即可，同樣，我們可以用10*num來表示10*2.345。變量的作用就是將值“存儲(chǔ)”在這個(gè)變量上。
在上一小節(jié)，我們介紹了 JavaScript 中的數(shù)據(jù)類型，其中基本類型如數(shù)字，布爾值，它們在內(nèi)存中都有固定的大小，我們通過變量來直接訪問基本類型的數(shù)據(jù)。而對于引用類型，如對象，數(shù)組和函數(shù)，由于它們的大小在原則上是不受任何限制的，故我們通過對其引用的訪問來訪問它們本身，引用本身是一個(gè)地址，即指向真實(shí)存儲(chǔ)復(fù)雜對象的位置。
基本類型和引用類型的區(qū)別是比較明顯的，我們來看幾個(gè)例子：
var x = 1;//數(shù)字x，基本類型
var y = x;//數(shù)字y，基本類型
print(x);
print(y);
x = 2;//修改x的值
print(x);//x的值變?yōu)?
print(y);//y的值不會(huì)變化 運(yùn)行結(jié)果如下：
1
1
2
1這樣的運(yùn)行結(jié)果應(yīng)該在你的意料之內(nèi)，沒有什么特別之處，我們再來看看引用類型的例子，由于數(shù)組的長度非固定，可以動(dòng)態(tài)增刪，因此數(shù)組為引用類型：
var array = [1,2,3,4,5];
var arrayRef = array;
array.push(6);
print(arrayRef); 引用指向的是地址，也就是說，引用不會(huì)指向引用本身，而是指向該引用所對應(yīng)的實(shí)際對象。因此通過修改array指向的數(shù)組，則arrayRef指向的是同一個(gè)對象，因此運(yùn)行效果如下：
1,2,3,4,5,6變量被定義的區(qū)域即為其作用域，全局變量具有全局作用域；局部變量，比如聲明在函數(shù)內(nèi)部的變量則具有局部作用域，在函數(shù)的外部是不能直接訪問的。比如：
var variable = "out";
function func(){
var variable = "in";
print(variable);//打印”in”
}
func();
print(variable);//打印”out”應(yīng)該注意的是，在函數(shù)內(nèi)var關(guān)鍵字是必須的，如果使用了變量而沒有寫var關(guān)鍵字，則默認(rèn)的操作是對全局對象的，比如：
var variable = "out";
function func(){
variable = "in";//注意此variable前沒有var關(guān)鍵字
print(variable);
}
func();
print(variable);//全局的變量variable被修改 由于函數(shù) func 中使用 variable 而沒有關(guān)鍵字 var,則默認(rèn)是對全局對象 variable 屬性做的操作(修改 variable 的值為 in)，因此此段代碼會(huì)打?。?/p>
in
in運(yùn)算符，通常是容易被忽略的一個(gè)內(nèi)容，但是一些比較古怪的語法現(xiàn)象仍然可能需要用到運(yùn)算符的結(jié)合率或者其作用來進(jìn)行解釋，JavaScript中，運(yùn)算符是一定需要注意的地方，有很多具有JS編程經(jīng)驗(yàn)的人仍然免不了被搞得暈頭轉(zhuǎn)向。
我們在這一節(jié)主要講解這樣幾個(gè)運(yùn)算符：
[]運(yùn)算符可用在數(shù)組對象和對象上，從數(shù)組中按下標(biāo)取值：
var array = ["one", "two", "three", "four"];
array[0] 而[]同樣可以作用于對象，一般而言，對象中的屬性的值是通過點(diǎn)(.)運(yùn)算符來取值，如：
var object = {
field : "self",
printInfo : function(){
print(this.field);
}
}
object.field;
object.printInfo();
但是考慮到這樣一種情況，我們在遍歷一個(gè)對象的時(shí)候，對其中的屬性的鍵(key)是一無所知的，我們怎么通過點(diǎn)(.)來訪問呢？這時(shí)候我們就可以使用[]運(yùn)算符：
for(var key in object){
print(key + ":" + object[key]);
}
運(yùn)行結(jié)果如下：
field:slef
printInfo:function (){
print(this.field);
} 點(diǎn)運(yùn)算符的左邊為一個(gè)對象(屬性的集合)，右邊為屬性名，應(yīng)該注意的是右邊的值除了作為左邊的對象的屬性外，同時(shí)還可能是它自己的右邊的值的對象：
var object = {
field : "self",
printInfo : function(){
print(this.field);
},
outter:{
inner : "inner text",
printInnerText : function(){
print(this.inner);
}
}
}
object.outter.printInnerText(); 這個(gè)例子中，outter作為object的屬性，同時(shí)又是printInnerText()的對象。 2.3.3 == 和 === 以及 != 和 !==
運(yùn)算符==讀作相等，而運(yùn)算符===則讀作等同。這兩種運(yùn)算符操作都是在 JavaScript 代碼中經(jīng)常見到的，但是意義則不完全相同，簡而言之，相等操作符會(huì)對兩邊的操作數(shù)做類型轉(zhuǎn)換，而等同則不會(huì)。我們還是通過例子來說明：
print(1 == true);
print(1 === true);
print("" == false);
print("" === false);
print(null == undefined);
print(null === undefined); 運(yùn)行結(jié)果如下：
true
false
true
false
true
false 相等和等同運(yùn)算符的規(guī)則分別如下：
如果操作數(shù)具有相同的類型，則判斷其等同性，如果兩個(gè)操作數(shù)的值相等，則返回 true(相等)，否則返回 false(不相等). 如果操作數(shù)的類型不同，則按照這樣的情況來判斷：
如果操作數(shù)的類型不同，則不進(jìn)行值的判斷，直接返回false
如果操作數(shù)的類型相同，分下列情況來判斷：
true/false，則等同，否則不等同null/undefined，則等同，否則不等同比如：
var obj = {
id : "self",
name : "object"
};
var oa = obj;
var ob = obj;
print(oa == ob);
print(oa === ob);會(huì)返回：
true
true再來看一個(gè)對象的例子：
var obj1 = {
id : "self",
name : "object",
toString : function(){
return "object 1";
}
}
var obj2 = "object 1";
print(obj1 == obj2);
print(obj1 === obj2);返回值為：
true
falseobj1 是一個(gè)對象，而 obj2 是一個(gè)結(jié)構(gòu)與之完全不同的字符串，而如果用相等操作符來判斷，則兩者是完全相同的，因?yàn)?obj1 重載了頂層對象的 toString()方法。
而!=不等和!==不等同，則與==/!==相反。因此，在 JavaScript 中，使用相等/等同，不等/不等同的時(shí)候，一定要注意類型的轉(zhuǎn)換，這里推薦使用等同/不等同來進(jìn)行判斷，這樣可以避免一些難以調(diào)試的 bug。
掃碼關(guān)注鍍金池微信號(hào)
手機(jī)訂課，優(yōu)惠多多