摘要：學(xué)習(xí)筆記一入門篇最近正在看高級程序設(shè)計，一直沒來得及總結(jié)一下，順便對之前看的編程藝術(shù)進(jìn)行一些簡單的總結(jié)，如有一些不正確的地方還請多指出討論。其他字符可以是字母下劃線美元符號或者數(shù)字。

最近正在看《JavaScript高級程序設(shè)計》，一直沒來得及總結(jié)一下，順便對之前看的《JavaScript DOM編程藝術(shù)》進(jìn)行一些簡單的總結(jié)，如有一些不正確的地方還請多指出討論。

在學(xué)習(xí) JavaScript 之前要理解的第一個概念就是在 ECMAScript 中所有的一切（變量、函數(shù)名和操作符）都是區(qū)分大小寫的。比如變量 test 和 Test 是兩個不同的變量，typeof 不能用在函數(shù)名上，因為它是一個關(guān)鍵字，但 typeOf 完全可以是一個函數(shù)名，因為在 ECMAScript 中變量、函數(shù)名和操作符等等都是區(qū)分大小寫的。

在學(xué)習(xí)之前還需要了解的第二個概念就是「標(biāo)識符」，所謂標(biāo)識符就是指變量、函數(shù)、函數(shù)的參數(shù)和屬性的名字，標(biāo)識符可以下列格式規(guī)則組合起來的一個或多個字符：

第一個字符必須是是字母、下劃線（_）或者美元符號（$）。

其他字符可以是字母、下劃線、美元符號或者數(shù)字。

按照慣例，ECMAScript 標(biāo)識符采用駝峰大小寫格式，也就是第一個字母小寫，剩下的每個單詞的首字母大寫，例如：

firstSecond

myCar

doSomethingImportant

ECMAScript 中有 5 種基本數(shù)據(jù)類型：Undefined、 Null、 Boolean、 String 和 Number。還有 1 種復(fù)雜數(shù)據(jù)類型：Obect，Object 本質(zhì)上是由一組無序的名值對組成。ECMAScript 不支持任何創(chuàng)建自定義類型的機制，而所有值最終都將是上述 6 種數(shù)據(jù)類型之一。

由于 ECMAScript 是松散類型的，所以需要有一種方法來檢測給定變量的數(shù)據(jù)類型，typeof 就是負(fù)責(zé)提供這方面信息的操作符。對一個值使用 typeof 操作符可能返回下列某個字符串：

"undefined"，如果這個值未定義；

"boolean"，如果這個值是布爾值；

"string"，如果這個值是字符串；

"number"，如果這個值是數(shù)值；

"object"，如果這個值是對象或 null；

"function"，如果這個值是函數(shù)。

例如：

var message = "Some Message!"

alert(typeof message); // "string"
alert(typeof(message)); // "string"
alert(typeof 95); // "number"

由此可以看出 typeof 操作符的操作數(shù)可以是變量（message），也可以是數(shù)值字面量。注意，typeof 是一個操作符而不是函數(shù)，所以例子中的圓括號盡管可以使用，但不是必需的。

這里需要注意一下的是，如果對 null 進(jìn)行 typeof 操作的話，會返回 "object"，因為 null 會被認(rèn)為是一個空的對象引用。還有一些比較奇怪的返回值，比如 Safari 5 及之前的版本、 Chrome 7 及之前的版本在對正則表達(dá)式調(diào)用 typeof 操作符時會返回 "function"，而在其他瀏覽器下則會返回 "object"。

Undefined 類型的值只有一個，即特殊的 undefined。當(dāng)用 var 關(guān)鍵字聲明一個變量但未對它進(jìn)行初始化時，這個變量的值就是 undefined，例如：

var message;
alert(message == undefined); // true

這個例子只對 message 進(jìn)行了聲明，但未對其進(jìn)行賦值操作，此時 message 的值就是 undefined，這個例子和下面這個例子是等價的：

var message = undefined;
alert(message == undefined); // true

這個例子使用 undefined 值顯式初始化了變量 message。但我們沒有必要這么做，因為未經(jīng)初始化的值默認(rèn)就會取得 undefined 值。

對于 Undefined 類型還有一點需要注意的就是，聲明了變量但是未對其進(jìn)行初始化賦值操作和根本就沒有聲明變量是不同的：

var message; // 聲明變量后默認(rèn)取得 undefined

// 下面這個變量根本沒有聲明
// var age;

alert(message); // undefined
alert(age);// Uncaught ReferenceError: age is not defined

對于第一個警告框大家肯定沒疑問，彈出的應(yīng)該是 "undefined"，由于傳遞給第二個警告框的是一個未申明的變量，所以在這里會導(dǎo)致一個錯誤。

對于尚未申明的變量，只能對其進(jìn)行一項操作，即使用 typeof 對其進(jìn)行數(shù)據(jù)類型的判斷。不過有一點比較奇怪的就是，對未進(jìn)行初始化賦值操作的變量和未申明的變量使用 typeof 操作符，都會返回 "undefined"：

var message; // 聲明變量后默認(rèn)取得 undefined

// 下面這個變量根本沒有聲明
// var age;

alert(typeof message); // "undefined"
alert(typeof age); // "undefined"

結(jié)果表明對未進(jìn)行初始化賦值操作的變量和未申明的變量使用 typeof 操作符，都會返回 "undefined"。

Null 類型是第二個只有一個值的數(shù)據(jù)類型，這個特殊的值是 null。從邏輯角度來看，null 值表示一個空對象指針，而這也正是使用 typeof 操作符檢測 null 值時會返回 "object" 的原因，如下面的例子所示：

var car = null;
alert(typeof car); // "object"

如果定義的變量準(zhǔn)備在將來用于保存對象，那么最好將該變量初始化為 null 而不是其他值。這樣一來，只要直接檢查 null 值就可以知道相應(yīng)的變量是否已經(jīng)保存了一個對象的引用，如下面的例子所示：

if (car != null){
    // 對 car 對象執(zhí)行某些操作
}

實際上，undefined 值是派生自 null 值的，因此 ECMA-262 規(guī)定對它們的相等性測試要返回 true：

alert(null == undefined); //true 

這里有一點也要注意的是，這里的相等操作符（==）出于比較的目的，會對比較的兩個類型進(jìn)行類型轉(zhuǎn)換（后面會對這個知識點進(jìn)行一些詳細(xì)的總結(jié)）。

盡管 undefined 派生自 null，但它們的用途卻不相同，無論在什么情況下都沒有必要對一個變量的值顯示的賦值為 undefined，而同樣的道理對 null 卻不適用，換句話說，只要意在保存對象的變量還沒有真正的保存對象，就應(yīng)該明確地地讓該變量保存 null 值。這樣做不僅可以體現(xiàn) null 作為空對象指針的慣例，也有助于進(jìn)一步的區(qū)分 undefined 和 null。

Boolean 類型的值有兩個，分別是 true 和 false，這兩個值和數(shù)字值不是一回事，也就是說 true 不一定等于 1，false 不一定等于 0，還有一點值得注意的是文章一開始就強調(diào)的一個概念，在 ECMAScript 中所有的一切都是區(qū)分大小寫的，所以 True 和 False （以及其他混合大小寫的形式）并不是 Boolean 類型的兩個值，只是標(biāo)識符。以下是為變量賦 Boolean 類型值的例子：

var found = true;
var lost = false;

盡管 Boolean 類型的值只有兩個，但是在 ECMAScript 中，所有類型的值都有與這兩個 Boolean 值等價的值，將任意一種類型的值轉(zhuǎn)換為對應(yīng)的 Boolean 值，可以調(diào)用轉(zhuǎn)型函數(shù) Boolean()，例如：

var message = "Hello World!";
var messageAsBoolean = Boolean(message);

上面這個例子中，message 字符串被轉(zhuǎn)換成了 Boolean 值，轉(zhuǎn)換后的 Boolean 值被儲存在變量 messageAsBoolean 中?？梢詫θ魏螖?shù)據(jù)類型的值調(diào)用 Boolean() 函數(shù)，而且總會返回一個 Boolean 值。至于具體返回是 true 還是 false 則要要具體的情況而定，下面給出了轉(zhuǎn)換的規(guī)則：

Number 類型應(yīng)該算是幾種基本數(shù)據(jù)類型中比較復(fù)雜的類型吧。

在 Number 類型中，最簡單的應(yīng)該算是十進(jìn)制整數(shù)吧，十進(jìn)制整數(shù)可以直接像下面這樣在代碼中輸入：

var intNum = 9; // 整數(shù) 9

除了十進(jìn)制以外，整數(shù)還可以用二進(jìn)制、八進(jìn)制和十六進(jìn)制來表示。

其中八進(jìn)制必須以 0 開頭，然后是八進(jìn)制數(shù)字序列（0-7），如果字面中的值超出了范圍，則第一個 0 將被忽略，后面的數(shù)值將被當(dāng)成十進(jìn)制數(shù)值解析。

var num1 = 070; // 八進(jìn)制 56
var num2 = 079 // 無效的八進(jìn)制數(shù)，被解析成十進(jìn)制數(shù) 79
var num3 = 08; // 無效的八進(jìn)制數(shù)，被解析成十進(jìn)制數(shù) 8

八進(jìn)制字面量在嚴(yán)格模式下是無效的，會導(dǎo)致支持的 JavaScript 引擎拋出錯誤。

十六進(jìn)制必須以 0x 開頭，然后是十六進(jìn)制數(shù)字序列（0-9 及 A-F），其中字母可以大寫也可以小寫，例如：

var num1 = 0xA; // 十六進(jìn)制的 10
var num2 = 0x1f; // 十六進(jìn)制的 31

在進(jìn)行算數(shù)計算時，所有的八進(jìn)制和十六進(jìn)制表示的數(shù)值最終都將被轉(zhuǎn)換成十進(jìn)制數(shù)值。

浮點數(shù)值必須包含一個小數(shù)點，且小數(shù)點后面必須要有一位**非 0 **數(shù)字才算是浮點數(shù)值，如果小數(shù)點后沒有數(shù)字，則 ECMAScript 會自動忽略這個小數(shù)點，小數(shù)點前面則不一定要有數(shù)字，但不推薦這種寫法：

var num1 = 1.1;
var num2 = 0.1;
var num3 = .1; // 有效但不推薦
var num4 = 1.; // 小數(shù)點后面沒有數(shù)字，被解析為 1
var num5 = 1.0; // 被解析成整數(shù) 1

由于浮點數(shù)值所需的內(nèi)存是整數(shù)數(shù)值所需要的內(nèi)存的兩倍，所以 ECMAScript 會不失時機的將浮點數(shù)值轉(zhuǎn)化為整數(shù)。

還有一點需要注意的是，浮點數(shù)值的最高精度是 17 位小數(shù)，在進(jìn)行算術(shù)計算的時候其精度遠(yuǎn)遠(yuǎn)不如整數(shù)數(shù)值。比如，0.1 加上 0.2 的結(jié)果并不是 0.3，而是 0.30000000000000004。這個小小的舍入誤差會導(dǎo)致無法測試特定的浮點數(shù)值，例如：

var a = 0.1;
var b = 0.2;

if (a + b = 0.3) { // 不要這么測試
    alert("You got 0.3.");
}

由于內(nèi)存的限制，ECMAScript 并不能保存所有的數(shù)值，ECMAScript 能夠表示的最小數(shù)值保存在 Number.MIN_VALUE 中，能夠表示的最大數(shù)值保存在 Number.MAX_VALUE 中，具體的來說，如果一個數(shù)值超出了 ECMAScript 所能保存的數(shù)值范圍，并且如果這個值是負(fù)數(shù)，則會被轉(zhuǎn)換成 -Infinity（負(fù)無窮），如果這個值是正數(shù)，則會被轉(zhuǎn)換成 +Infinity（正無窮）。

如果一個數(shù)被轉(zhuǎn)換成了無窮大（Infinity），則不能進(jìn)行下一次運算，因為 Infinity 是不能被運算的數(shù)值。要想確定一個數(shù)值是不是有窮的（是不是最大值和最小值之間），可以使用 isFinite() 函數(shù)來確定，如果處于最大值和最小值之間，則會返回 true，例如：

var result = Number.MAX_VALUE + Number.MAX_VALUE;
var min = Number.MIN_VALUE;
var max = Number.MAX_VALUE;
alert(isFinite(result)); // false
alert(isFinite(min)); // true
alert(isFinite(max)); // true

由上可知，最大值和最小值也算是有窮的。

NaN 即非數(shù)值（Not a Number）是一個特殊的數(shù)值，NaN 是用來表示本來應(yīng)該返回一個數(shù)值卻沒有返回數(shù)值的情況（這樣就不會拋出異常了），例如在 ECMAScript 中，0 除以 0 并不會報錯，而是會返回 NaN，因此不會影響其他代碼的執(zhí)行。在這里有一點需要注意的是，并不是任意數(shù)值除以 0 都會返回 NaN 的，例如：

alert(0 / 0); // "NaN"
alert(1 / 0); // "Infinity"
alert(-1 / 0); // "-Infinity"
alert(NaN / NaN); //"NaN"

由上可知，當(dāng)正數(shù)除以 0 的時候，返回的是 Infinity，當(dāng)負(fù)數(shù)除以 0 的時候，返回的是 -Infinity，只有 NaN 或者 0 初除以 0 的時候返回的才是 NaN。

NaN 有兩個特點，首先，任何涉及 NaN 的操作都會返回 NaN；其次，NaN 與任何值都不相等，包括 NaN 本身。例如下面代碼會返回 false:

alert(NaN = NaN); // false

為了判斷某個數(shù)值是否是「非數(shù)值」，ECMAScript 定義了 isNaN() 函數(shù)，該函數(shù)接受一個任意類型的參數(shù)，如果這個參數(shù)是 NaN，則返回 true，如果不是 NaN，則返回 false，例如：

alert(isNaN(NaN)); // true
alert(isNaN(10)); // false（10 是一個數(shù)值）
alert(isNaN("10")); // false（可以被轉(zhuǎn)換成數(shù)值 10）
alert(isNaN("blue")); // true（不能轉(zhuǎn)換成數(shù)值）
alert(isNaN(true)); // false（可以被轉(zhuǎn)換成數(shù)值 1）

由上可知，如果一個參數(shù)不能被轉(zhuǎn)換成數(shù)值，則 isNaN() 函數(shù)會返回 true。

值得一提的是，isNaN() 函數(shù)同樣適用于對象，在對對象調(diào)用 isNaN() 時，會首先調(diào)用對象的 valueOf() 方法試圖把對象轉(zhuǎn)換為數(shù)值，如果不能轉(zhuǎn)換為數(shù)值，則基于這個對象再調(diào)用 toString() 方法，在測試返回的值。

可以把非數(shù)值轉(zhuǎn)換成數(shù)值的函數(shù)有 3 個，分別是 Number()、 parseInt() 和 parseFloat()。其中 Number() 適用于任何數(shù)據(jù)類型，另外兩個則專門用于把字符串轉(zhuǎn)換成數(shù)值。

Number() 函數(shù)的轉(zhuǎn)換規(guī)則如下：

如果是 Boolean 值，true 和 false 將分別被轉(zhuǎn)換為 1 和 0。

如果是數(shù)字值，只是簡單的傳入和返回。

如果是 null 值，返回 0。

如果是 undefined，返回 NaN。

如果是字符串，遵循下列規(guī)則：

如果字符串中只包含數(shù)字（包括前面帶正號或負(fù)號的情況），則將其轉(zhuǎn)換為十進(jìn)制數(shù)值，即"1"會變成 1，"123"會變成 123，而"011"會變成 11（注意：前導(dǎo)的零被忽略了）；

如果字符串中包含有效的浮點格式，如"1.1"，則將其轉(zhuǎn)換為對應(yīng)的浮點數(shù)值（同樣，也會忽略前導(dǎo)零）；

如果字符串中包含有效的十六進(jìn)制格式，例如"0xf"，則將其轉(zhuǎn)換為相同大小的十進(jìn)制整數(shù)值；

如果字符串是空的（不包含任何字符），則將其轉(zhuǎn)換為 0；

如果字符串中包含除上述格式之外的字符，則將其轉(zhuǎn)換為 NaN。

如果是對象，則調(diào)用對象的 valueOf()方法，然后依照前面的規(guī)則轉(zhuǎn)換返回的值。如果轉(zhuǎn)換的結(jié)果是 NaN，則調(diào)用對象的 toString() 方法，然后再次依照前面的規(guī)則轉(zhuǎn)換返回的字符串值。

下面則是一些具體的例子：

var num1 = Number("Hello world!"); //NaN
var num2 = Number(""); //0
var num3 = Number("000011"); //11
var num4 = Number(true); //1 

parseInt() 的轉(zhuǎn)換規(guī)則如下：

var num1 = parseInt("1234blue"); // 1234
var num2 = parseInt(""); // NaN
var num3 = parseInt("0xA"); // 10（十六進(jìn)制數(shù)）
var num4 = parseInt(22.5); // 22
var num5 = parseInt("070"); // 56（八進(jìn)制數(shù)）
var num6 = parseInt("70"); // 70（十進(jìn)制數(shù)）
var num7 = parseInt("0xf"); // 15（十六進(jìn)制數(shù)）

parseInt() 在轉(zhuǎn)換字符串的時候會忽略字符串前面的空格，直到找到第一個非空格字符，如果第一個字符不是數(shù)字字符或者負(fù)號，parseInt() 就會返回 NaN；如果第一個字符是數(shù)字字符，parseInt() 會繼續(xù)解析第二個字符，知道解析完所有后足字符或遇到了一個非數(shù)字字符。有一點應(yīng)該注意的是 parseInt() 轉(zhuǎn)換空字符串時會返回一個 NaN，而 Number() 轉(zhuǎn)換一個空字符串則會返回數(shù)字 0。

parseInt() 默認(rèn)解析的是十進(jìn)制數(shù)，但也可以解析指定的進(jìn)制，例如：

var num1 = parseInt("10", 2); //2 （按二進(jìn)制解析）
var num2 = parseInt("10", 8); //8 （按八進(jìn)制解析）
var num3 = parseInt("10", 10); //10 （按十進(jìn)制解析）
var num4 = parseInt("10", 16); //16 （按十六進(jìn)制解析）

parseInt() 可以接受第二個參數(shù)，第二個參數(shù)只能是 2、 8、 10 和 16，分別對應(yīng)相應(yīng)的進(jìn)制。為了避免錯誤，當(dāng)我們用 parseInt() 轉(zhuǎn)換數(shù)值時指定相應(yīng)的進(jìn)制是非常有必要的。

parseFloat() 的轉(zhuǎn)換規(guī)則如下：

var num3 = parseFloat("22.5"); //22.5
var num4 = parseFloat("22.34.5"); //22.34
var num5 = parseFloat("0908.5"); //908.5
var num6 = parseFloat("3.125e7"); //31250000 

與 parseInt() 類似，parseFloat() 也是從第一個字符開始解析每個字符，一直解析到字符串的末尾，或者解析到一個無效浮點數(shù)字字符為止。與 parseInt() 不同的是，parseFloat() 解析到的第一個小數(shù)點是有效的，而第二個小數(shù)點則無效，因此它后面的字符串也將被忽略。與 parseInt() 第二個不同的是 parseFloat() 會始終忽略第一個 0。

還有一點需要注意的是，如果字符串包含的是一個可解析為整數(shù)的數(shù)（沒有小數(shù)點，或者小數(shù)點后都是零），parseFloat() 會返回整數(shù)：

var num1 = parseFloat("1234blue"); //1234 （整數(shù)）
var num2 = parseFloat("1234.000"); //1234 （整數(shù)）

parseFloat() 只解析十進(jìn)制數(shù)，所以它不接受第二個參數(shù)，這也是為什么 parseFloat() 始終會把十六進(jìn)制的數(shù)值轉(zhuǎn)換成 0 的原因：

var num2 = parseFloat("0xA"); // 0

String 類型表示字符串，可以由雙引號（""）或單引號（""）表示，所以下面這兩種字符串都是有效的：

var firstName = "Clear";
var lastName = "Design"; 

但有一點需要注意的是，以什么引號開頭就必須以什么引號結(jié)尾，比如下面這種寫法就是錯誤的：

var name = "Clear Design";

String 數(shù)據(jù)類型包含一些特殊的字符字面量，也叫轉(zhuǎn)義序列，如下：

ECMAScript 中的字符串是不可變的，字符串一旦創(chuàng)建，它們的值就不能改變。要改變某個變量保存的字符串，首先要銷毀原來的字符串，然后再用另一個包含新值的字符串填充該變量，例如：

var lang = "Java";
lang = lang + "Script"; 

上面的 lang 開始時包含 "Java"，而第二行代碼把 lang 重新定義為 "Java" 和 "Script" 的組合，即 "JavaScript"。第二行代碼并不是把原來的 lang 的值改變了，而是首先創(chuàng)建一個能容納 10 個字符的新字符串，然后在這個字符串中填充 "Java" 和 "Script"，由于新的字符串拼接完成后，原來的字符串已經(jīng)沒有用了，所以原來的字符串 "Java" 和 "Script" 會被銷毀，這些都是發(fā)生在后臺的。

前面提到 Number 數(shù)據(jù)類型的時候有提到 parseInt() 和 parseFloat() 兩個函數(shù)，這兩個函數(shù)的作用是將可轉(zhuǎn)換成數(shù)值的字符串轉(zhuǎn)換成數(shù)值，而 String 數(shù)據(jù)類型同樣也提供了一個 toString() 函數(shù)，它的作用是把可轉(zhuǎn)換為字符串的數(shù)據(jù)類型轉(zhuǎn)換成字符串：

var age = 22;
var ageAsString = age.toString(); // "22"

var found = true;
var foundAsString = found.toString(); // "true"

Number、 Boolean、 Object 和 String（沒錯，String 本身也具有 toString() 方法，該方法返回該字符串的一個副本）都有 toString() 方法，但 Null 和 Undefined 沒有這個方法。

toString() 方法接受一個參數(shù)，參數(shù)只能是 2、 8、 10 和 16，分別對應(yīng)相應(yīng)的進(jìn)制。例如：

var num = 10;
alert(num.toString()); // "10"
alert(num.toString(2)); // "1010"
alert(num.toString(8)); // "12"
alert(num.toString(10)); // "10"
alert(num.toString(16)); // "a" 

默認(rèn)情況（沒有傳入?yún)?shù)）下 toString() 方法以十進(jìn)制格式返回數(shù)值的字符串表示。在不知道傳入的值是不是 Null 或 Undefined 的時候，可以使用 String() 轉(zhuǎn)型函數(shù)，該函數(shù)支持把任意數(shù)據(jù)類型的值轉(zhuǎn)換為字符串，String() 函數(shù)的轉(zhuǎn)換規(guī)則如下：

如果值有 toString() 方法，則調(diào)用該方法（沒有參數(shù)）并返回相應(yīng)的結(jié)果；

如果值是 null，則返回 "null"；

如果值是 undefined，則返回 "undefined"。

下面再看幾個例子：

var value1 = 10;
var value2 = true;
var value3 = null;
var value4;

alert(String(value1)); // "10"
alert(String(value2)); // "true"
alert(String(value3)); // "null"
alert(String(value4)); // "undefined" 

Object 類型是 ECMAScript 中 6 種數(shù)據(jù)類型中唯一一種復(fù)雜數(shù)據(jù)類型，簡單的說的話 ECMAScript 中對象就是一組數(shù)據(jù)和功能的集合。創(chuàng)建對象的方法有很多，這里說一下比較常用的一種方法，就是通過執(zhí)行 new 操作符后跟要創(chuàng)建的對象類型的名稱來創(chuàng)建：

var o = new Object();

在了解對象之前，首先要先理解一個重要的思想：在 ECMAScript 中，Object 類型是所有它的實例的基礎(chǔ)。也就是說，Object 類型所具有的任何屬性和方法也同樣存在于更具體的對象中。

Object 的每個實例都具有下列屬性和方法：

constructor：保存著用于創(chuàng)建當(dāng)前對象的函數(shù)。對于前面的例子而言，構(gòu)造函數(shù)（constructor）就是 Object()。

hasOwnProperty(propertyName)：用于檢查給定的屬性在當(dāng)前對象實例中（而不是在實例的原型中）是否存在。其中，作為參數(shù)的屬性名（propertyName）必須以字符串形式指定（例如：o.hasOwnProperty("name")）。

isPrototypeOf(object)：用于檢查傳入的對象是否是傳入對象的原型（第 5 章將討論原型）。

propertyIsEnumerable(propertyName)：用于檢查給定的屬性是否能夠使用 for-in 語句
（本章后面將會討論）來枚舉。與 hasOwnProperty() 方法一樣，作為參數(shù)的屬性名必須以字符串形式指定。

toLocaleString()：返回對象的字符串表示，該字符串與執(zhí)行環(huán)境的地區(qū)對應(yīng)。

toString()：返回對象的字符串表示。

valueOf()：返回對象的字符串、數(shù)值或布爾值表示。通常與 toString() 方法的返回值相同。

在 ECMAScript 中，Object 是所有對象的基礎(chǔ)，也是 ECMAScript 中需要掌握的重點，所以筆者將在后面的學(xué)習(xí)筆記中詳細(xì)地對 Object 進(jìn)行總結(jié)，這里就先了解一些 Object 類型的基本概念的方法。

以上部分主要是筆者對 ECMAScript 中的一些基本概念的簡單總結(jié)，本篇主要寫的還是在進(jìn)一步學(xué)習(xí) ECMAScript 中需要了解的一些基本且重要的概念。

如有寫的不好的地方還請多指出討論。

原文地址：http://www.cleardesign.me/javascript-study-note-1