JavaScript簡介
JavaScript（簡稱“JS”） 是一種具有函數(shù)優(yōu)先的輕量級(jí)，解釋型或即時(shí)編譯型的編程語言。雖然它是作為開發(fā)Web頁面的腳本語言而出名的，但是它也被用到了很多非瀏覽器環(huán)境中，JavaScript 基于原型編程、多范式的動(dòng)態(tài)腳本語言，并且支持面向?qū)ο蟆⒚钍胶吐暶魇剑ㄈ绾瘮?shù)式編程）風(fēng)格。
JavaScript用法
- HTML 中的腳本必須位于 <script> 與 </script> 標(biāo)簽之間。
- 腳本可被放置在 HTML 頁面的 <body> 和 <head> 部分中。
那些老舊的實(shí)例可能會(huì)在 <script> 標(biāo)簽中使用 type="text/javascript"。現(xiàn)在已經(jīng)不必這樣做了。JavaScript 是所有現(xiàn)代瀏覽器以及 HTML5 中的默認(rèn)腳本語言。
外部的 JavaScript
也可以把腳本保存到外部文件中。外部文件通常包含被多個(gè)網(wǎng)頁使用的代碼。
外部 JavaScript 文件的文件擴(kuò)展名是 .js。
如需使用外部文件，請(qǐng)?jiān)?<script> 標(biāo)簽的 "src" 屬性中設(shè)置該 .js 文件。
JavaScript 輸出
JavaScript 沒有任何打印或者輸出的函數(shù)。
JavaScript 顯示數(shù)據(jù)
JavaScript 可以通過不同的方式來輸出數(shù)據(jù)：
- 使用 window.alert() 彈出警告框。
- 使用 document.write() 方法將內(nèi)容寫到 HTML 文檔中。
- 使用 innerHTML 寫入到 HTML 元素。
- 使用 console.log() 寫入到瀏覽器的控制臺(tái)。
請(qǐng)使用 document.write() 僅僅向文檔輸出寫內(nèi)容。
如果在文檔已完成加載后執(zhí)行 document.write，整個(gè) HTML 頁面將被覆蓋。
JavaScript 語法
JavaScript 字面量
在編程語言中，一般固定值稱為字面量，如 3.14。
- 數(shù)字（Number）字面量 可以是整數(shù)或者是小數(shù)，或者是科學(xué)計(jì)數(shù)(e)。
- 字符串（String）字面量 可以使用單引號(hào)或雙引號(hào)。
- 表達(dá)式字面量 用于計(jì)算。
- 數(shù)組（Array）字面量 定義一個(gè)數(shù)組。
- 對(duì)象（Object）字面量 定義一個(gè)對(duì)象。
- 函數(shù)（Function）字面量 定義一個(gè)函數(shù)。
JavaScript 變量
在編程語言中，變量用于存儲(chǔ)數(shù)據(jù)值。
JavaScript 使用關(guān)鍵字 var 來定義變量（ES6出現(xiàn)let，在ES6部分詳細(xì)說明）， 使用等號(hào)來為變量賦值。
當(dāng)聲明新變量時(shí)，可以使用關(guān)鍵詞 "new" 來聲明其類型
var carname=new String;
var x= new Number;
var y= new Boolean;
var cars= new Array;
var person= new Object;
變量可以通過變量名訪問。在指令式語言中，變量通常是可變的。字面量是一個(gè)恒定的值。
JavaScript 操作符
- JavaScript使用 算術(shù)運(yùn)算符 來計(jì)算值
- JavaScript使用賦值運(yùn)算符給變量賦值
| 類型 | 實(shí)例 | 描述 |
|---|---|---|
| 賦值，算術(shù)和位運(yùn)算符 | = + - * / | 在 JS 運(yùn)算符中描述 |
| 條件，比較及邏輯運(yùn)算符 | == != < > | 在 JS 比較運(yùn)算符中描述 |
JavaScript 語句
在 HTML 中，JavaScript 語句向?yàn)g覽器發(fā)出的命令。
語句是用分號(hào)分隔;
JavaScript 注釋
不是所有的 JavaScript 語句都是"命令"。雙斜杠 // 后的內(nèi)容將會(huì)被瀏覽器忽略
JavaScript 數(shù)據(jù)類型
值類型(基本類型)：字符串（String）、數(shù)字(Number)、布爾(Boolean)、對(duì)空（Null）、未定義（Undefined）、Symbol。
引用數(shù)據(jù)類型：對(duì)象(Object)、數(shù)組(Array)、函數(shù)(Function)。
注：Symbol 是 ES6 引入了一種新的原始數(shù)據(jù)類型，表示獨(dú)一無二的值。
Undefined 和 Null
Undefined 這個(gè)值表示變量不含有值。
可以通過將變量的值設(shè)置為 null 來清空變量。
JavaScript 對(duì)象
JavaScript 對(duì)象是擁有屬性和方法的數(shù)據(jù)。
對(duì)象定義
你可以使用字符來定義和創(chuàng)建 JavaScript 對(duì)象:
var person = {
firstName:"John",
lastName:"Doe",
age:50,
eyeColor:"blue"
};
對(duì)象屬性
可以說 "JavaScript 對(duì)象是變量的容器"。
但是，我們通常認(rèn)為 "JavaScript 對(duì)象是鍵值對(duì)的容器"。
鍵值對(duì)通常寫法為 name : value (鍵與值以冒號(hào)分割)。
鍵值對(duì)在 JavaScript 對(duì)象通常稱為 對(duì)象屬性。
訪問對(duì)象屬性
person.lastName;
person["lastName"];
對(duì)象方法
對(duì)象的方法定義了一個(gè)函數(shù)，并作為對(duì)象的屬性存儲(chǔ)。
對(duì)象方法通過添加 () 調(diào)用 (作為一個(gè)函數(shù))。
name = person.fullName();
JavaScript 函數(shù)
函數(shù)是由事件驅(qū)動(dòng)的或者當(dāng)它被調(diào)用時(shí)執(zhí)行的可重復(fù)使用的代碼塊。
JavaScript 函數(shù)語法
函數(shù)就是包裹在花括號(hào)中的代碼塊，前面使用了關(guān)鍵詞 function
function functionname()
{
// 執(zhí)行代碼
}
JavaScript 對(duì)大小寫敏感。關(guān)鍵詞 function 必須是小寫的，并且必須以與函數(shù)名稱相同的大小寫來調(diào)用函數(shù)。
調(diào)用帶參數(shù)的函數(shù)
在調(diào)用函數(shù)時(shí)，您可以向其傳遞值，這些值被稱為參數(shù)。
這些參數(shù)可以在函數(shù)中使用。
您可以發(fā)送任意多的參數(shù)，由逗號(hào) (,) 分隔。
帶有返回值的函數(shù)
有時(shí)，我們會(huì)希望函數(shù)將值返回調(diào)用它的地方。
通過使用 return 語句就可以實(shí)現(xiàn)。
在使用 return 語句時(shí)，函數(shù)會(huì)停止執(zhí)行，并返回指定的值。
JavaScript 作用域
作用域是可訪問變量的集合。
在 JavaScript 中, 對(duì)象和函數(shù)同樣也是變量。
在 JavaScript 中, 作用域?yàn)榭稍L問變量，對(duì)象，函數(shù)的集合。
JavaScript 函數(shù)作用域: 作用域在函數(shù)內(nèi)修改。
JavaScript 局部作用域
變量在函數(shù)內(nèi)聲明，變量為局部作用域。
局部變量：只能在函數(shù)內(nèi)部訪問。
因?yàn)榫植孔兞恐蛔饔糜诤瘮?shù)內(nèi)，所以不同的函數(shù)可以使用相同名稱的變量。
局部變量在函數(shù)開始執(zhí)行時(shí)創(chuàng)建，函數(shù)執(zhí)行完后局部變量會(huì)自動(dòng)銷毀。
JavaScript 全局變量
變量在函數(shù)外定義，即為全局變量。
全局變量有 全局作用域: 網(wǎng)頁中所有腳本和函數(shù)均可使用。
如果變量在函數(shù)內(nèi)沒有聲明（沒有使用 var 關(guān)鍵字），該變量為全局變量。
以下實(shí)例中 carName 在函數(shù)內(nèi)，但是為全局變量。
JavaScript 變量的生存期
JavaScript 變量的生命期從它們被聲明的時(shí)間開始。
局部變量會(huì)在函數(shù)運(yùn)行以后被刪除。
全局變量會(huì)在頁面關(guān)閉后被刪除。
向未聲明的 JavaScript 變量分配值
如果您把值賦給尚未聲明的變量，該變量將被自動(dòng)作為 window 的一個(gè)屬性。
這條語句：
carname="Volvo";
將聲明 window 的一個(gè)屬性 carname。
非嚴(yán)格模式下給未聲明變量賦值創(chuàng)建的全局變量，是全局對(duì)象的可配置屬性，可以刪除。
var var1 = 1; // 不可配置全局屬性
var2 = 2; // 沒有使用 var 聲明，可配置全局屬性
console.log(this.var1); // 1
console.log(window.var1); // 1
delete var1; // false 無法刪除
console.log(var1); //1
delete var2;
console.log(delete var2); // true
console.log(var2); // 已經(jīng)刪除 報(bào)錯(cuò)變量未定義
JavaScript 事件
HTML 事件是發(fā)生在 HTML 元素上的事情。
當(dāng)在 HTML 頁面中使用 JavaScript 時(shí)， JavaScript 可以觸發(fā)這些事件。
HTML 事件
HTML 事件可以是瀏覽器行為，也可以是用戶行為。
在事件觸發(fā)時(shí) JavaScript 可以執(zhí)行一些代碼。
HTML 元素中可以添加事件屬性，使用 JavaScript 代碼來添加 HTML 元素。
常見的HTML事件
| 事件 | 描述 |
|---|---|
| onchange | HTML 元素改變 |
| onclick | 用戶點(diǎn)擊 HTML 元素 |
| onmouseover | 用戶在一個(gè)HTML元素上移動(dòng)鼠標(biāo) |
| onmouseout | 用戶從一個(gè)HTML元素上移開鼠標(biāo) |
| onkeydown | 用戶按下鍵盤按鍵 |
| onload | 瀏覽器已完成頁面的加載 |
JavaScript 字符串
JavaScript 字符串用于存儲(chǔ)和處理文本。
- 字符串可以是插入到引號(hào)中的任何字符。你可以使用單引號(hào)或雙引號(hào)
- 可以使用索引位置來訪問字符串中的每個(gè)字符
字符串的索引從 0 開始，這意味著第一個(gè)字符索引值為 [0],第二個(gè)為 [1], 以此類推。 - 可以在字符串中使用引號(hào)，字符串中的引號(hào)不要與字符串的引號(hào)相同,也可以在字符串添加轉(zhuǎn)義字符（反斜杠 \）來使用引號(hào)。
字符串長度
可以使用內(nèi)置屬性 length 來計(jì)算字符串的長度
特殊字符
| 代碼 | 輸出 |
|---|---|
| ' | 單引號(hào) |
| " | 雙引號(hào) |
| |反斜杠 | |
| \n | 換行 |
| \r | 回車 |
| \t | tab(制表符) |
| \b | 退格符 |
| \f | 換頁符 |
字符串可以是對(duì)象
通常， JavaScript 字符串是原始值，可以使用字符創(chuàng)建： var firstName = "John"
但我們也可以使用 new 關(guān)鍵字將字符串定義為一個(gè)對(duì)象： var firstName = new String("John")
var x = "John";
var y = new String("John");
typeof x // 返回 String
typeof y // 返回 Object
不要?jiǎng)?chuàng)建 String 對(duì)象。它會(huì)拖慢執(zhí)行速度，并可能產(chǎn)生其他副作用：
var x = "John";
var y = new String("John");
(x === y) // 結(jié)果為 false，因?yàn)?x 是字符串，y 是對(duì)象
字符串屬性
| 屬性 | 描述 |
|---|---|
| constructor | 返回創(chuàng)建字符串屬性的函數(shù) |
| length | 返回字符串的長度 |
| prototype | 允許您向?qū)ο筇砑訉傩院头椒?/td> |
字符串方法
| 方法 | 描述 |
|---|---|
| charAt() | 返回指定索引位置的字符 |
| charCodeAt() | 返回指定索引位置字符的 Unicode 值 |
| concat() | 連接兩個(gè)或多個(gè)字符串，返回連接后的字符串 |
| fromCharCode() | 將 Unicode 轉(zhuǎn)換為字符串 |
| indexOf() | 返回字符串中檢索指定字符第一次出現(xiàn)的位置 |
| lastIndexOf() | 返回字符串中檢索指定字符最后一次出現(xiàn)的位置 |
| localeCompare() | 用本地特定的順序來比較兩個(gè)字符串 |
| match() | 找到一個(gè)或多個(gè)正則表達(dá)式的匹配 |
| replace() | 替換與正則表達(dá)式匹配的子串 |
| search() | 檢索與正則表達(dá)式相匹配的值 |
| slice() | 提取字符串的片斷，并在新的字符串中返回被提取的部分 |
| split() | 把字符串分割為子字符串?dāng)?shù)組 |
| substr() | 從起始索引號(hào)提取字符串中指定數(shù)目的字符 |
| substring() | 提取字符串中兩個(gè)指定的索引號(hào)之間的字符 |
| toLocaleLowerCase() | 根據(jù)主機(jī)的語言環(huán)境把字符串轉(zhuǎn)換為小寫，只有幾種語言（如土耳其語）具有地方特有的大小寫映射 |
| toLocaleUpperCase() | 根據(jù)主機(jī)的語言環(huán)境把字符串轉(zhuǎn)換為大寫，只有幾種語言（如土耳其語）具有地方特有的大小寫映射 |
| toLowerCase() | 把字符串轉(zhuǎn)換為小寫 |
| toString() | 返回字符串對(duì)象值 |
| toUpperCase() | 把字符串轉(zhuǎn)換為大寫 |
| trim() | 移除字符串首尾空白 |
| valueOf() | 返回某個(gè)字符串對(duì)象的原始值 |
JavaScript 運(yùn)算符
運(yùn)算符 = 用于賦值。
運(yùn)算符 + 用于加值。
JavaScript 算術(shù)運(yùn)算符
| 運(yùn)算符 | 描述 |
|---|---|
| + | 加法 |
| - | 減法 |
| * | 乘法 |
| / | 除法 |
| % | 取模（余數(shù)） |
| ++ | 自增 |
| -- | 自減 |
JavaScript 賦值運(yùn)算符
賦值運(yùn)算符用于給 JavaScript 變量賦值。
=、+=、-=、*=、/=、%=
用于字符串的 + 運(yùn)算符
- 運(yùn)算符用于把文本值或字符串變量加起來（連接起來）。
對(duì)字符串和數(shù)字進(jìn)行加法運(yùn)算
兩個(gè)數(shù)字相加，返回?cái)?shù)字相加的和，如果數(shù)字與字符串相加，返回字符串。
JavaScript 比較 和 邏輯運(yùn)算符
比較運(yùn)算符
比較運(yùn)算符在邏輯語句中使用，以測定變量或值是否相等。
| 運(yùn)算符 | 描述 |
|---|---|
| == | 等于 |
| x==5 | true |
| === | 絕對(duì)等于（值和類型均相等） |
| x===5 | true |
| != | 不等于 |
| !== | 不絕對(duì)等于（值和類型有一個(gè)不相等，或兩個(gè)都不相等） |
| x!==5 | false |
| > | 大于 |
| < | 小于 |
| >= | 大于或等于 |
| <= | 小于或等于 |
邏輯運(yùn)算符
邏輯運(yùn)算符用于測定變量或值之間的邏輯。
| 運(yùn)算符 | 描述 |
|---|---|
| && | and |
| || | or |
| ! | not |
JavaScript 循環(huán)
JavaScript 支持不同類型的循環(huán)：
- for - 循環(huán)代碼塊一定的次數(shù)
- for/in - 循環(huán)遍歷對(duì)象的屬性
- while - 當(dāng)指定的條件為 true 時(shí)循環(huán)指定的代碼塊
- do/while - 同樣當(dāng)指定的條件為 true 時(shí)循環(huán)指定的代碼塊
For 循環(huán)
for (語句 1; 語句 2; 語句 3)
{
被執(zhí)行的代碼塊
}
語句 1 （代碼塊）開始前執(zhí)行
語句 2 定義運(yùn)行循環(huán)（代碼塊）的條件
語句 3 在循環(huán)（代碼塊）已被執(zhí)行之后執(zhí)行
語句 1
通常我們會(huì)使用語句 1 初始化循環(huán)中所用的變量 (var i=0)。
語句 1 是可選的，也就是說不使用語句 1 也可以。
您可以在語句 1 中初始化任意（或者多個(gè)）值。
for (var i=0,len=cars.length; i<len; i++)
{
document.write(cars[i] + "<br>");
}
var i=2,len=cars.length;
for (; i<len; i++)
{
document.write(cars[i] + "<br>");
}
語句 2
通常語句 2 用于評(píng)估初始變量的條件。
語句 2 同樣是可選的。
如果語句 2 返回 true，則循環(huán)再次開始，如果返回 false，則循環(huán)將結(jié)束。
如果省略了語句 2，那么必須在循環(huán)內(nèi)提供 break。否則循環(huán)就無法停下來。這樣有可能令瀏覽器崩潰。
語句 3
通常語句 3 會(huì)增加初始變量的值。
語句 3 也是可選的。
語句 3 有多種用法。增量可以是負(fù)數(shù) (i--)，或者更大 (i=i+15)。
語句 3 也可以省略（比如當(dāng)循環(huán)內(nèi)部有相應(yīng)的代碼時(shí)）
var i=0,len=cars.length;
for (; i<len; )
{
document.write(cars[i] + "<br>");
i++;
}
For/In 循環(huán)
var person={fname:"John",lname:"Doe",age:25};
for (x in person) // x 為屬性名
{
txt=txt + person[x];
}
while 循環(huán)
while 循環(huán)會(huì)在指定條件為真時(shí)循環(huán)執(zhí)行代碼塊。
while (條件)
{
需要執(zhí)行的代碼
}
do/while 循環(huán)
do/while 循環(huán)是 while 循環(huán)的變體。該循環(huán)會(huì)在檢查條件是否為真之前執(zhí)行一次代碼塊，然后如果條件為真的話，就會(huì)重復(fù)這個(gè)循環(huán)。
do
{
需要執(zhí)行的代碼
}
while (條件);
JavaScript break 和 continue 語句
break 語句用于跳出循環(huán)。
continue 用于跳過循環(huán)中的一個(gè)迭代。
JavaScript 標(biāo)簽
如需標(biāo)記 JavaScript 語句，請(qǐng)?jiān)谡Z句之前加上冒號(hào)：
break 和 continue 語句僅僅是能夠跳出代碼塊的語句。
continue 語句（帶有或不帶標(biāo)簽引用）只能用在循環(huán)中。
break 語句（不帶標(biāo)簽引用），只能用在循環(huán)或 switch 中。
通過標(biāo)簽引用，break 語句可用于跳出任何 JavaScript 代碼塊：
JavaScript typeof, null, 和 undefined
typeof 操作符
typeof 操作符來檢測變量的數(shù)據(jù)類型。
typeof "John" // 返回 string
typeof 3.14 // 返回 number
typeof NaN // 返回 number
typeof false // 返回 boolean
typeof [1,2,3,4] // 返回 object
typeof {name:'John', age:34} // 返回 object
typeof new Date() // 返回 object
typeof function () {} // 返回 function
typeof myCar // 返回 undefined (如果 myCar 沒有聲明)
typeof null // 返回 object
- NaN 的數(shù)據(jù)類型是 number
- 數(shù)組(Array)的數(shù)據(jù)類型是 object
- 日期(Date)的數(shù)據(jù)類型為 object
- null 的數(shù)據(jù)類型是 object
- 未定義變量的數(shù)據(jù)類型為 undefined
如果對(duì)象是 JavaScript Array 或 JavaScript Date ，我們就無法通過 typeof 來判斷他們的類型，因?yàn)槎际?返回 object。
null
在 JavaScript 中 null 表示 "什么都沒有"。
null是一個(gè)只有一個(gè)值的特殊類型。表示一個(gè)空對(duì)象引用。
主動(dòng)釋放一個(gè)變量引用的對(duì)象，表示一個(gè)變量不再指向任何對(duì)象地址。
當(dāng)使用完一個(gè)比較大的對(duì)象時(shí)，需要對(duì)其進(jìn)行釋放內(nèi)存時(shí)，設(shè)置為 null。
用 typeof 檢測 null 返回是object。
你可以設(shè)置為 null 來清空對(duì)象
var person = null; // 值為 null(空), 但類型為對(duì)象
undefined
在 JavaScript 中, undefined 是一個(gè)沒有設(shè)置值的變量。
typeof 一個(gè)沒有值的變量會(huì)返回 undefined。
var person; // 值為 undefined(空), 類型是undefined
任何變量都可以通過設(shè)置值為 undefined 來清空。 類型為 undefined。
person = undefined; // 值為 undefined, 類型是undefined
undefined 和 null 的區(qū)別
共同點(diǎn)：都是原始類型，保存在棧中變量本地。
不同點(diǎn)：
（1）undefined——表示變量聲明過但并未賦過值。
它是所有未賦值變量默認(rèn)值，例如：
var a; // a 自動(dòng)被賦值為 undefined
（2）null——表示一個(gè)變量將來可能指向一個(gè)對(duì)象。
一般用于主動(dòng)釋放指向?qū)ο蟮囊茫纾?/p>
var emps = ['ss','nn'];
emps = null; // 釋放指向數(shù)組的引用
null 和 undefined 的值相等，但類型不等：
typeof undefined // undefined
typeof null // object
null === undefined // false
null == undefined // true
JavaScript 類型轉(zhuǎn)換
JavaScript 數(shù)據(jù)類型
在 JavaScript 中有 6 種不同的數(shù)據(jù)類型：
- string
- number
- boolean
- object
- function
- symbol
3 種對(duì)象類型：
- Object
- Date
- Array
2 個(gè)不包含任何值的數(shù)據(jù)類型：
- null
- undefined
constructor 屬性
constructor 屬性返回所有 JavaScript 變量的構(gòu)造函數(shù)。
"John".constructor // 返回函數(shù) String() { [native code] }
(3.14).constructor // 返回函數(shù) Number() { [native code] }
false.constructor // 返回函數(shù) Boolean() { [native code] }
[1,2,3,4].constructor // 返回函數(shù) Array() { [native code] }
{name:'John', age:34}.constructor // 返回函數(shù) Object() { [native code] }
new Date().constructor // 返回函數(shù) Date() { [native code] }
function () {}.constructor // 返回函數(shù) Function(){ [native code] }
你可以使用 constructor 屬性來查看對(duì)象是否為數(shù)組 (包含字符串 "Array")
function isArray(myArray) {
return myArray.constructor.toString().indexOf("Array") > -1;
}
你可以使用 constructor 屬性來查看對(duì)象是否為日期 (包含字符串 "Date")
function isDate(myDate) {
return myDate.constructor.toString().indexOf("Date") > -1;
}
JavaScript 類型轉(zhuǎn)換
JavaScript 變量可以轉(zhuǎn)換為新變量或其他數(shù)據(jù)類型：
- 通過使用 JavaScript 函數(shù)
- 通過 JavaScript 自身自動(dòng)轉(zhuǎn)換
將數(shù)字轉(zhuǎn)換為字符串
全局方法 String() 可以將數(shù)字轉(zhuǎn)換為字符串。
該方法可用于任何類型的數(shù)字，字母，變量，表達(dá)式
String(x) // 將變量 x 轉(zhuǎn)換為字符串并返回
String(123) // 將數(shù)字 123 轉(zhuǎn)換為字符串并返回
String(100 + 23) // 將數(shù)字表達(dá)式轉(zhuǎn)換為字符串并返回
Number 方法 toString() 也是有同樣的效果。
x.toString()
(123).toString()
(100 + 23).toString()
更多數(shù)字轉(zhuǎn)換為字符串的方法
| 方法 | 描述 |
|---|---|
| toExponential() | 把對(duì)象的值轉(zhuǎn)換為指數(shù)計(jì)數(shù)法。 |
| toFixed() | 把數(shù)字轉(zhuǎn)換為字符串，結(jié)果的小數(shù)點(diǎn)后有指定位數(shù)的數(shù)字。 |
| toPrecision() | 把數(shù)字格式化為指定的長度。 |
將布爾值轉(zhuǎn)換為字符串
全局方法 String() 可以將布爾值轉(zhuǎn)換為字符串。
String(false) // 返回 "false"
String(true) // 返回 "true"
Boolean 方法 toString() 也有相同的效果。
false.toString() // 返回 "false"
true.toString() // 返回 "true"
將日期轉(zhuǎn)換為字符串
Date() 返回字符串。
Date() // 返回 Thu Jul 17 2014 15:38:19 GMT+0200 (W. Europe Daylight Time)
全局方法 String() 可以將日期對(duì)象轉(zhuǎn)換為字符串。
String(new Date()) // 返回 Thu Jul 17 2014 15:38:19 GMT+0200 (W. Europe Daylight Time)
Date 方法 toString() 也有相同的效果。
obj = new Date()
obj.toString() // 返回 Thu Jul 17 2014 15:38:19 GMT+0200 (W. Europe Daylight Time)
更多關(guān)于日期轉(zhuǎn)換為字符串的函數(shù)：
| 方法 | 描述 |
|---|---|
| getDate() | 從 Date 對(duì)象返回一個(gè)月中的某一天 (1 ~ 31)。 |
| getDay() | 從 Date 對(duì)象返回一周中的某一天 (0 ~ 6)。 |
| getFullYear() | 從 Date 對(duì)象以四位數(shù)字返回年份。 |
| getHours() | 返回 Date 對(duì)象的小時(shí) (0 ~ 23)。 |
| getMilliseconds() | 返回 Date 對(duì)象的毫秒(0 ~ 999)。 |
| getMinutes() | 返回 Date 對(duì)象的分鐘 (0 ~ 59)。 |
| getMonth() | 從 Date 對(duì)象返回月份 (0 ~ 11)。 |
| getSeconds() | 返回 Date 對(duì)象的秒數(shù) (0 ~ 59)。 |
| getTime() | 返回 1970 年 1 月 1 日至今的毫秒數(shù)。 |
將字符串轉(zhuǎn)換為數(shù)字
全局方法 Number() 可以將字符串轉(zhuǎn)換為數(shù)字。
字符串包含數(shù)字(如 "3.14") 轉(zhuǎn)換為數(shù)字 (如 3.14).
空字符串轉(zhuǎn)換為 0。
其他的字符串會(huì)轉(zhuǎn)換為 NaN (不是個(gè)數(shù)字)。
Number("3.14") // 返回 3.14
Number(" ") // 返回 0
Number("") // 返回 0
Number("99 88") // 返回 NaN
更多關(guān)于字符串轉(zhuǎn)為數(shù)字的方法：
| 方法 | 描述 |
|---|---|
| parseFloat() | 解析一個(gè)字符串，并返回一個(gè)浮點(diǎn)數(shù)。 |
| parseInt() | 解析一個(gè)字符串，并返回一個(gè)整數(shù)。 |
一元運(yùn)算符 +
Operator + 可用于將變量轉(zhuǎn)換為數(shù)字
var y = "5"; // y 是一個(gè)字符串
var x = + y; // x 是一個(gè)數(shù)字
如果變量不能轉(zhuǎn)換，它仍然會(huì)是一個(gè)數(shù)字，但值為 NaN (不是一個(gè)數(shù)字)
var y = "John"; // y 是一個(gè)字符串
var x = + y; // x 是一個(gè)數(shù)字 (NaN)
將布爾值轉(zhuǎn)換為數(shù)字
全局方法 Number() 可將布爾值轉(zhuǎn)換為數(shù)字。
Number(false) // 返回 0
Number(true) // 返回 1
將日期轉(zhuǎn)換為數(shù)字
全局方法 Number() 可將日期轉(zhuǎn)換為數(shù)字。
d = new Date();
Number(d) // 返回 1404568027739
日期方法 getTime() 也有相同的效果。
d = new Date();
d.getTime() // 返回 1404568027739
自動(dòng)轉(zhuǎn)換類型
當(dāng) JavaScript 嘗試操作一個(gè) "錯(cuò)誤" 的數(shù)據(jù)類型時(shí)，會(huì)自動(dòng)轉(zhuǎn)換為 "正確" 的數(shù)據(jù)類型。
5 + null // 返回 5 null 轉(zhuǎn)換為 0
"5" + null // 返回"5null" null 轉(zhuǎn)換為 "null"
"5" + 1 // 返回 "51" 1 轉(zhuǎn)換為 "1"
"5" - 1 // 返回 4 "5" 轉(zhuǎn)換為 5
自動(dòng)轉(zhuǎn)換為字符串
嘗試輸出一個(gè)對(duì)象或一個(gè)變量時(shí) JavaScript 會(huì)自動(dòng)調(diào)用變量的 toString() 方法：
document.getElementById("demo").innerHTML = myVar;
myVar = {name:"Fjohn"} // toString 轉(zhuǎn)換為 "[object Object]"
myVar = [1,2,3,4] // toString 轉(zhuǎn)換為 "1,2,3,4"
myVar = new Date() // toString 轉(zhuǎn)換為 "Fri Jul 18 2014 09:08:55 GMT+0200"
數(shù)字和布爾值也經(jīng)常相互轉(zhuǎn)換：
myVar = 123 // toString 轉(zhuǎn)換為 "123"
myVar = true // toString 轉(zhuǎn)換為 "true"
myVar = false // toString 轉(zhuǎn)換為 "false"
| 原始值 | 轉(zhuǎn)換為數(shù)字 | 轉(zhuǎn)換為字符串 | 轉(zhuǎn)換為布爾值 |
|---|---|---|---|
| false | 0 | "false" | false |
| true | 1 | "true" | true |
| 0 | 0 | "0" | false |
| 1 | 1 | "1" | true |
| "0" | 0 | "0" | true |
| "000" | 0 | "000" | true |
| "1" | 1 | "1" | true |
| NaN | NaN | "NaN" | false |
| Infinity | Infinity | "Infinity" | true |
| -Infinity | -Infinity | "-Infinity" | true |
| "" | 0 | "" | false |
| "20" | 20 | "20" | true |
| "Runoob" | NaN | "Runoob" | true |
| [ ] | 0 | "" | true |
| [20] | 20 | "20" | true |
| [10,20] | NaN | "10,20" | true |
| ["Runoob"] | NaN | "Runoob" | true |
| ["Runoob","Google"] | NaN | "Runoob,Google" | true |
| function(){} | NaN | "function(){}" | true |
| { } | NaN | "[object Object]" | true |
| null | 0 | "null" | false |
| undefined | NaN | "undefined" | false |
JavaScript 正則表達(dá)式
使用單個(gè)字符串來描述、匹配一系列符合某個(gè)句法規(guī)則的字符串搜索模式。
搜索模式可用于文本搜索和文本替換。
什么是正則表達(dá)式？
正則表達(dá)式是由一個(gè)字符序列形成的搜索模式。
當(dāng)你在文本中搜索數(shù)據(jù)時(shí)，你可以用搜索模式來描述你要查詢的內(nèi)容。
正則表達(dá)式可以是一個(gè)簡單的字符，或一個(gè)更復(fù)雜的模式。
正則表達(dá)式可用于所有文本搜索和文本替換的操作。
/正則表達(dá)式主體/修飾符(可選)
/runoob/i 是一個(gè)正則表達(dá)式。
runoob 是一個(gè)正則表達(dá)式主體 (用于檢索)。
i 是一個(gè)修飾符 (搜索不區(qū)分大小寫)。
使用字符串方法
在 JavaScript 中，正則表達(dá)式通常用于兩個(gè)字符串方法 : search() 和 replace()。
search() 方法 用于檢索字符串中指定的子字符串，或檢索與正則表達(dá)式相匹配的子字符串，并返回子串的起始位置。
replace() 方法 用于在字符串中用一些字符替換另一些字符，或替換一個(gè)與正則表達(dá)式匹配的子串。
正則表達(dá)式修飾符
修飾符可以在全局搜索中不區(qū)分大小寫:
| 修飾符 | 描述 |
|---|---|
| i | 執(zhí)行對(duì)大小寫不敏感的匹配。 |
| g | 執(zhí)行全局匹配（查找所有匹配而非在找到第一個(gè)匹配后停止）。 |
| m | 執(zhí)行多行匹配。 |
正則表達(dá)式模式
方括號(hào)用于查找某個(gè)范圍內(nèi)的字符：
| 表達(dá)式 | 描述 |
|---|---|
| [abc] | 查找方括號(hào)之間的任何字符。 |
| [^abc] | 查找任何不在方括號(hào)之間的字符。 |
| [0-9] | 查找任何從 0 至 9 的數(shù)字。 |
| [a-z] | 查找任何從小寫 a 到小寫 z 的字符。 |
| [A-Z] | 查找任何從大寫 A 到大寫 Z 的字符。 |
| [A-z] | 查找任何從大寫 A 到小寫 z 的字符。 |
| [adgk] | 查找給定集合內(nèi)的任何字符。 |
| [^adgk] | 查找給定集合外的任何字符。 |
| (red|blue|green) | 查找任何指定的選項(xiàng)。 |
元字符是擁有特殊含義的字符
| 元字符 | 描述 |
|---|---|
| \d | 查找數(shù)字。 |
| \s | 查找空白字符。 |
| \b | 匹配單詞邊界。 |
| \uxxxx | 查找以十六進(jìn)制數(shù) xxxx 規(guī)定的 Unicode 字符。 |
量詞:
| 量詞 | 描述 |
|---|---|
| n+ | 匹配任何包含至少一個(gè) n 的字符串。 |
| n* | 匹配任何包含零個(gè)或多個(gè) n 的字符串。 |
| n? | 匹配任何包含零個(gè)或一個(gè) n 的字符串。 |
使用 RegExp 對(duì)象
在 JavaScript 中，RegExp 對(duì)象是一個(gè)預(yù)定義了屬性和方法的正則表達(dá)式對(duì)象。
使用 test()
test() 方法是一個(gè)正則表達(dá)式方法。
test() 方法用于檢測一個(gè)字符串是否匹配某個(gè)模式，如果字符串中含有匹配的文本，則返回 true，否則返回 false。
使用 exec()
exec() 方法是一個(gè)正則表達(dá)式方法。
exec() 方法用于檢索字符串中的正則表達(dá)式的匹配。
該函數(shù)返回一個(gè)數(shù)組，其中存放匹配的結(jié)果。如果未找到匹配，則返回值為 null。
JavaScript 變量提升
JavaScript 中，函數(shù)及變量的聲明都將被提升到函數(shù)的最頂部。
JavaScript 中，變量可以在使用后聲明，也就是變量可以先使用再聲明。
函數(shù)聲明和變量聲明總是會(huì)被解釋器悄悄地被"提升"到方法體的最頂部。
JavaScript 只有聲明的變量會(huì)提升，初始化的不會(huì),也就是賦值不會(huì)提升。
JavaScript 嚴(yán)格模式(strict mode)不允許使用未聲明的變量。
JavaScript 嚴(yán)格模式(use strict)
JavaScript 嚴(yán)格模式（strict mode）即在嚴(yán)格的條件下運(yùn)行。
使用 "use strict" 指令
"use strict" 指令在 JavaScript 1.8.5 (ECMAScript5) 中新增。
它不是一條語句，但是是一個(gè)字面量表達(dá)式，在 JavaScript 舊版本中會(huì)被忽略。
"use strict" 的目的是指定代碼在嚴(yán)格條件下執(zhí)行。
嚴(yán)格模式下你不能使用未聲明的變量。
嚴(yán)格模式聲明
嚴(yán)格模式通過在腳本或函數(shù)的頭部添加 "use strict"; 表達(dá)式來聲明。
實(shí)例中我們可以在瀏覽器按下 F12 (或點(diǎn)擊"工具>更多工具>開發(fā)者工具") 開啟調(diào)試模式，查看報(bào)錯(cuò)信息。
為什么使用嚴(yán)格模式
- 消除Javascript語法的一些不合理、不嚴(yán)謹(jǐn)之處，減少一些怪異行為;
- 消除代碼運(yùn)行的一些不安全之處，保證代碼運(yùn)行的安全；
- 提高編譯器效率，增加運(yùn)行速度；
- 為未來新版本的Javascript做好鋪墊。
"嚴(yán)格模式"體現(xiàn)了Javascript更合理、更安全、更嚴(yán)謹(jǐn)?shù)陌l(fā)展方向，包括IE 10在內(nèi)的主流瀏覽器，都已經(jīng)支持它，許多大項(xiàng)目已經(jīng)開始全面擁抱它。
嚴(yán)格模式的限制
不允許使用未聲明的變量
"use strict";
x = 3.14; // 報(bào)錯(cuò) (x 未定義)
對(duì)象也是一個(gè)變量。
不允許刪除變量或?qū)ο蟆?/p>
"use strict";
var x = 3.14;
delete x; // 報(bào)錯(cuò)
不允許刪除函數(shù)。
"use strict";
function x(p1, p2) {};
delete x; // 報(bào)錯(cuò)
不允許變量重名
"use strict";
function x(p1, p1) {}; // 報(bào)錯(cuò)
不允許使用八進(jìn)制。
"use strict";
var x = 010; // 報(bào)錯(cuò)
不允許使用轉(zhuǎn)義字符。
"use strict";
var x = \010; // 報(bào)錯(cuò)
不允許對(duì)只讀屬性賦值。
"use strict";
var obj = {};
Object.defineProperty(obj, "x", {value:0, writable:false});
obj.x = 3.14; // 報(bào)錯(cuò)
不允許對(duì)一個(gè)使用getter方法讀取的屬性進(jìn)行賦值。
"use strict";
var obj = {get x() {return 0} };
obj.x = 3.14; // 報(bào)錯(cuò)
不允許刪除一個(gè)不允許刪除的屬性。
"use strict";
delete Object.prototype; // 報(bào)錯(cuò)
變量名不能使用 "eval" 字符串。
"use strict";
var eval = 3.14; // 報(bào)錯(cuò)
變量名不能使用 "arguments" 字符串。
"use strict";
var arguments = 3.14; // 報(bào)錯(cuò)
由于一些安全原因，在作用域 eval() 創(chuàng)建的變量不能被調(diào)用
"use strict";
eval ("var x = 2");
alert (x); // 報(bào)錯(cuò)
禁止this關(guān)鍵字指向全局對(duì)象。
function f(){
return !this;
}
// 返回false，因?yàn)?this"指向全局對(duì)象，"!this"就是false
function f(){
"use strict";
return !this;
}
// 返回true，因?yàn)閲?yán)格模式下，this的值為undefined，所以"!this"為true。
因此，使用構(gòu)造函數(shù)時(shí)，如果忘了加new，this不再指向全局對(duì)象，而是報(bào)錯(cuò)。
function f(){
"use strict";
this.a = 1;
};
f();// 報(bào)錯(cuò)，this未定義
"use strict" 指令只允許出現(xiàn)在腳本或函數(shù)的開頭。
JavaScript 使用誤區(qū)
賦值運(yùn)算符應(yīng)用錯(cuò)誤
在 JavaScript 程序中如果你在 if 條件語句中使用賦值運(yùn)算符的等號(hào) (=) 將會(huì)產(chǎn)生一個(gè)錯(cuò)誤結(jié)果, 正確的方法是使用比較運(yùn)算符的兩個(gè)等號(hào) (==)。
比較運(yùn)算符常見錯(cuò)誤
在常規(guī)的比較中，數(shù)據(jù)類型是被忽略的，在嚴(yán)格的比較運(yùn)算中，=== 為恒等計(jì)算符，同時(shí)檢查表達(dá)式的值與類型。
加法與連接注意事項(xiàng)
加法是兩個(gè)數(shù)字相加。
連接是兩個(gè)字符串連接。
JavaScript 的加法和連接都使用 + 運(yùn)算符。
浮點(diǎn)型數(shù)據(jù)使用注意事項(xiàng)
JavaScript 中的所有數(shù)據(jù)都是以 64 位浮點(diǎn)型數(shù)據(jù)(float) 來存儲(chǔ)。
所有的編程語言，包括 JavaScript，對(duì)浮點(diǎn)型數(shù)據(jù)的精確度都很難確定
var x = 0.1;
var y = 0.2;
var z = x + y // z 的結(jié)果為 0.30000000000000004
if (z == 0.3) // 返回 false
定義數(shù)組元素，最后不能添加逗號(hào)
數(shù)組最后一個(gè)值的后面添加逗號(hào)雖然語法沒有問題，但是在不同的瀏覽器可能得到不同的結(jié)果。
var colors = [5, 6, 7,]; //這樣數(shù)組的長度可能為3 也可能為4。
正確的定義方式：
points = [40, 100, 1, 5, 25, 10];
Undefined 不是 Null
在 JavaScript 中, null 用于對(duì)象, undefined 用于變量，屬性和方法。
對(duì)象只有被定義才有可能為 null，否則為 undefined。
如果我們想測試對(duì)象是否存在，在對(duì)象還沒定義時(shí)將會(huì)拋出一個(gè)錯(cuò)誤。
錯(cuò)誤的使用方式：
if (myObj !== null && typeof myObj !== "undefined")
正確的方式是我們需要先使用 typeof 來檢測對(duì)象是否已定義：
if (typeof myObj !== "undefined" && myObj !== null)
JavaScript 表單
JavaScript 表單驗(yàn)證
HTML 表單驗(yàn)證可以通過 JavaScript 來完成。
以下實(shí)例代碼用于判斷表單字段(fname)值是否存在， 如果不存在，就彈出信息，阻止表單提交
function validateForm() {
var x = document.forms["myForm"]["fname"].value;
if (x == null || x == "") {
alert("需要輸入名字。");
return false;
}
}
HTML 表單自動(dòng)驗(yàn)證
HTML 表單驗(yàn)證也可以通過瀏覽器來自動(dòng)完成。
如果表單字段 (fname) 的值為空, required 屬性會(huì)阻止表單提交
數(shù)據(jù)驗(yàn)證
數(shù)據(jù)驗(yàn)證用于確保用戶輸入的數(shù)據(jù)是有效的。
典型的數(shù)據(jù)驗(yàn)證有：
- 必需字段是否有輸入?
- 用戶是否輸入了合法的數(shù)據(jù)?
- 在數(shù)字字段是否輸入了文本?
大多數(shù)情況下，數(shù)據(jù)驗(yàn)證用于確保用戶正確輸入數(shù)據(jù)。
數(shù)據(jù)驗(yàn)證可以使用不同方法來定義，并通過多種方式來調(diào)用。
HTML 約束驗(yàn)證
HTML5 新增了 HTML 表單的驗(yàn)證方式：約束驗(yàn)證（constraint validation）。
約束驗(yàn)證是表單被提交時(shí)瀏覽器用來實(shí)現(xiàn)驗(yàn)證的一種算法。
HTML 約束驗(yàn)證基于：
- HTML 輸入屬性
- CSS 偽類選擇器
- DOM 屬性和方法
約束驗(yàn)證 HTML 輸入屬性
| 約束驗(yàn)證 | HTML 輸入屬性 |
|---|---|
| 屬性 | 描述 |
| disabled | 規(guī)定輸入的元素不可用 |
| max | 規(guī)定輸入元素的最大值 |
| min | 規(guī)定輸入元素的最小值 |
| pattern | 規(guī)定輸入元素值的模式 |
| required | 規(guī)定輸入元素字段是必需的 |
| type | 規(guī)定輸入元素的類型 |
約束驗(yàn)證 CSS 偽類選擇器
| 選擇器 | 描述 |
|---|---|
| :disabled | 選取屬性為 "disabled" 屬性的 input 元素 |
| :invalid | 選取無效的 input 元素 |
| :optional | 選擇沒有"required"屬性的 input 元素 |
| :required | 選擇有"required"屬性的 input 元素 |
| :valid | 選取有效值的 input 元素 |
JavaScript 驗(yàn)證 API
| 約束驗(yàn)證 | DOM 方法 |
|---|---|
| Property | Description |
| checkValidity() | 如果 input 元素中的數(shù)據(jù)是合法的返回 true，否則返回 false。 |
| setCustomValidity() | 設(shè)置 input 元素的 validationMessage 屬性，用于自定義錯(cuò)誤提示信息的方法。 使用 setCustomValidity 設(shè)置了自定義提示后，validity.customError 就會(huì)變成true，則 checkValidity 總是會(huì)返回false。如果要重新判斷需要取消自定義提示。 |
約束驗(yàn)證 DOM 屬性
| 屬性 | 描述 |
|---|---|
| validity | 布爾屬性值，返回 input 輸入值是否合法 |
| validationMessage | 瀏覽器錯(cuò)誤提示信息 |
| willValidate | 指定 input 是否需要驗(yàn)證 |
Validity 屬性
input 元素的 validity 屬性包含一系列關(guān)于 validity 數(shù)據(jù)屬性:
| 屬性 | 描述 |
|---|---|
| customError | 設(shè)置為 true, 如果設(shè)置了自定義的 validity 信息。 |
| patternMismatch | 設(shè)置為 true, 如果元素的值不匹配它的模式屬性。 |
| rangeOverflow | 設(shè)置為 true, 如果元素的值大于設(shè)置的最大值。 |
| rangeUnderflow | 設(shè)置為 true, 如果元素的值小于它的最小值。 |
| stepMismatch | 設(shè)置為 true, 如果元素的值不是按照規(guī)定的 step 屬性設(shè)置。 |
| tooLong | 設(shè)置為 true, 如果元素的值超過了 maxLength 屬性設(shè)置的長度。 |
| typeMismatch | 設(shè)置為 true, 如果元素的值不是預(yù)期相匹配的類型。 |
| valueMissing | 設(shè)置為 true，如果元素 (required 屬性) 沒有值。 |
| valid | 設(shè)置為 true，如果元素的值是合法的。 |
JavaScript this 關(guān)鍵字
面向?qū)ο笳Z言中 this 表示當(dāng)前對(duì)象的一個(gè)引用。
但在 JavaScript 中 this 不是固定不變的，它會(huì)隨著執(zhí)行環(huán)境的改變而改變。
- 在方法中，this 表示該方法所屬的對(duì)象。
- 如果單獨(dú)使用，this 表示全局對(duì)象。
- 在函數(shù)中，this 表示全局對(duì)象。
- 在函數(shù)中，在嚴(yán)格模式下，this 是未定義的(undefined)。
- 在事件中，this 表示接收事件的元素。
- 類似 call() 和 apply() 方法可以將 this 引用到任何對(duì)象。
方法中的 this
在對(duì)象方法中， this 指向調(diào)用它所在方法的對(duì)象。
單獨(dú)使用 this
單獨(dú)使用 this，則它指向全局(Global)對(duì)象。
在瀏覽器中，window 就是該全局對(duì)象為 [object Window]:
嚴(yán)格模式下，如果單獨(dú)使用，this 也是指向全局(Global)對(duì)象。
函數(shù)中使用 this（默認(rèn)）
在函數(shù)中，函數(shù)的所屬者默認(rèn)綁定到 this 上。
在瀏覽器中，window 就是該全局對(duì)象為 [object Window]:
函數(shù)中使用 this（嚴(yán)格模式）
嚴(yán)格模式下函數(shù)是沒有綁定到 this 上，這時(shí)候 this 是 undefined。
事件中的 this
在 HTML 事件句柄中，this 指向了接收事件的 HTML 元素：
對(duì)象方法中綁定
下面實(shí)例中，this 是 person 對(duì)象，person 對(duì)象是函數(shù)的所有者
var person = {
firstName : "John",
lastName : "Doe",
id : 5566,
myFunction : function() {
return this;
}
};
顯式函數(shù)綁定
在 JavaScript 中函數(shù)也是對(duì)象，對(duì)象則有方法，apply 和 call 就是函數(shù)對(duì)象的方法。這兩個(gè)方法異常強(qiáng)大，他們?cè)试S切換函數(shù)執(zhí)行的上下文環(huán)境（context），即 this 綁定的對(duì)象。
在下面實(shí)例中，當(dāng)我們使用 person2 作為參數(shù)來調(diào)用 person1.fullName 方法時(shí), this 將指向 person2, 即便它是 person1 的方法：
var person1 = {
fullName: function() {
return this.firstName + " " + this.lastName;
}
}
var person2 = {
firstName:"John",
lastName: "Doe",
}
person1.fullName.call(person2); // 返回 "John Doe"
JavaScript JSON
JSON 是用于存儲(chǔ)和傳輸數(shù)據(jù)的格式。
JSON 通常用于服務(wù)端向網(wǎng)頁傳遞數(shù)據(jù) 。
什么是 JSON?
JSON 英文全稱 JavaScript Object Notation
JSON 是一種輕量級(jí)的數(shù)據(jù)交換格式。
JSON是獨(dú)立的語言 *
JSON 易于理解。
JSON 使用 JavaScript 語法，但是 JSON 格式僅僅是一個(gè)文本。
文本可以被任何編程語言讀取及作為數(shù)據(jù)格式傳遞。
JSON 格式化后為 JavaScript 對(duì)象
JSON 格式在語法上與創(chuàng)建 JavaScript 對(duì)象代碼是相同的。
由于它們很相似，所以 JavaScript 程序可以很容易的將 JSON 數(shù)據(jù)轉(zhuǎn)換為 JavaScript 對(duì)象。
JSON 語法規(guī)則
數(shù)據(jù)為 鍵/值 對(duì)。
數(shù)據(jù)由逗號(hào)分隔。
大括號(hào)保存對(duì)象
方括號(hào)保存數(shù)組
JSON 數(shù)據(jù) - 一個(gè)名稱對(duì)應(yīng)一個(gè)值
JSON 數(shù)據(jù)格式為 鍵/值 對(duì)，就像 JavaScript 對(duì)象屬性。
鍵/值對(duì)包括字段名稱（在雙引號(hào)中），后面一個(gè)冒號(hào)，然后是值：
"name":"joel"
JSON 對(duì)象
JSON 對(duì)象保存在大括號(hào)內(nèi)。
就像在 JavaScript 中, 對(duì)象可以保存多個(gè) 鍵/值 對(duì)：
{"name":"Runoob", "url":"www.runoob.com"}
JSON 數(shù)組
JSON 數(shù)組保存在中括號(hào)內(nèi)。
就像在 JavaScript 中, 數(shù)組可以包含對(duì)象
JSON 字符串轉(zhuǎn)換為 JavaScript 對(duì)象
使用 JavaScript 內(nèi)置函數(shù) JSON.parse() 將字符串轉(zhuǎn)換為 JavaScript 對(duì)象
相關(guān)函數(shù)
| 函數(shù) | 描述 |
|---|---|
| JSON.parse() | 用于將一個(gè) JSON 字符串轉(zhuǎn)換為 JavaScript 對(duì)象。 |
| JSON.stringify() | 用于將 JavaScript 值轉(zhuǎn)換為 JSON 字符串。 |
javascript:void(0) 含義
javascript:void(0) 中最關(guān)鍵的是 void 關(guān)鍵字， void 是 JavaScript 中非常重要的關(guān)鍵字，該操作符指定要計(jì)算一個(gè)表達(dá)式但是不返回值。
但是括號(hào)內(nèi)的表達(dá)式還是要運(yùn)行
當(dāng)用戶點(diǎn)擊以后不會(huì)發(fā)生任何事。
<a href="javascript:void(0)">單擊此處什么也不會(huì)發(fā)生</a>
當(dāng)用戶鏈接時(shí)，void(0) 計(jì)算為 0，但 Javascript 上沒有任何效果。
以下實(shí)例中，在用戶點(diǎn)擊鏈接后顯示警告信息：
<head>
<script type="text/javascript">
<!--
//-->
</script>
</head>
<body>
<a href="javascript:void(alert('Warning!!!'))">點(diǎn)我!</a>
</body>
a = void ( b = 5, c = 7 );
a 將返回 undefined
href="#"與href="javascript:void(0)"的區(qū)別
# 包含了一個(gè)位置信息，默認(rèn)的錨是#top 也就是網(wǎng)頁的上端。
而javascript:void(0), 僅僅表示一個(gè)死鏈接。
在頁面很長的時(shí)候會(huì)使用 # 來定位頁面的具體位置，格式為：# + id。
如果你要定義一個(gè)死鏈接請(qǐng)使用 javascript:void(0) 。
