大香蕉在线视频99,国产情色欧美制服丝袜

第一部分：快速入門
JS學(xué)習(xí)中的一些注意點(diǎn)：
2018.8.16
基礎(chǔ)知識(shí)：

入門
JavaScript是世界上最流行的腳本語言，因?yàn)槟阍陔娔X、手機(jī)、平板上瀏覽的所有的網(wǎng)頁，以及無數(shù)基于HTML5的手機(jī)App，交互邏輯都是由JavaScript驅(qū)動(dòng)的。簡(jiǎn)單地說，JavaScript是一種運(yùn)行在瀏覽器中的解釋型的編程語言。 (這句話怎么理解呢？html文本、php語言，有點(diǎn)懵逼)
ES6: ECMA（European Computer Manufacturers Association）組織定制了JavaScript語言的標(biāo)準(zhǔn)，被稱為ECMAScript標(biāo)準(zhǔn)。簡(jiǎn)稱ES6, 為了讓JavaScript成為全球標(biāo)準(zhǔn).
JavaScript代碼可以直接嵌在網(wǎng)頁的任何地方，不過通常我們都把JavaScript代碼放到<head>中：
由<script>...</script>包含的代碼就是JavaScript代碼，它將直接被瀏覽器執(zhí)行。
第二種方法是把JavaScript代碼放到一個(gè)單獨(dú)的.js文件，然后在HTML中通過<script src="..."></script>引入這個(gè)文件：
把JavaScript代碼放入一個(gè)單獨(dú)的.js文件中更利于維護(hù)代碼，并且多個(gè)頁面可以各自引用同一份.js文件。
可以在同一個(gè)頁面中引入多個(gè).js文件，還可以在頁面中多次編寫<script> js代碼... </script>，瀏覽器按照順序依次執(zhí)行。
有些時(shí)候你會(huì)看到<script>標(biāo)簽還設(shè)置了一個(gè)type屬性：
因?yàn)槟J(rèn)的type就是JavaScript，所以不必顯式地把type指定為JavaScript。

基本語法：
JavaScript的語法和Java語言類似，每個(gè)語句以;結(jié)束，語句塊用{…}。但是，JavaScript并不強(qiáng)制要求在每個(gè)語句的結(jié)尾加;，瀏覽器中負(fù)責(zé)執(zhí)行JavaScript代碼的引擎會(huì)自動(dòng)在每個(gè)語句的結(jié)尾補(bǔ)上;
2.數(shù)據(jù)類型和變量
2.1 Number
JavaScript不區(qū)分整數(shù)和浮點(diǎn)數(shù)，統(tǒng)一用Number表示，以下都是合法的Number類型：
整數(shù)、浮點(diǎn)數(shù)、科學(xué)計(jì)數(shù)法1.2345e3、-99
NaN; // NaN表示Not a Number，當(dāng)無法計(jì)算結(jié)果時(shí)用NaN表示
Infinity; // Infinity表示無限大，當(dāng)數(shù)值超過了JavaScript的Number所能表示的最大值時(shí)，就表示為Infinity
Number可以直接做四則運(yùn)算，規(guī)則和數(shù)學(xué)一致。
1 + 2; // 3
(1 + 2) * 5 / 2; // 7.5
2 / 0; // Infinity
0 / 0; // NaN (這兩個(gè)結(jié)果確實(shí)是這樣)
10 % 3; // 1
10.5 % 3; // 1.5
2.2 字符串
字符串是以單引號(hào)’或雙引號(hào)"括起來的任意文本，比如'abc'，"xyz"等等。請(qǐng)注意，''或""本身只是一種表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c這3個(gè)字符。
2.3 布爾值
布爾值和布爾代數(shù)的表示完全一致，一個(gè)布爾值只有true、false兩種值，要么是true，要么是false，可以直接用true、false表示布爾值，也可以通過布爾運(yùn)算計(jì)算出來：
false; // 這是一個(gè)false值
2 > 1; // 這是一個(gè)true值
2.4 邏輯運(yùn)算符
&&運(yùn)算是與運(yùn)算，只有所有都為true，&&運(yùn)算結(jié)果才是true：（有假則假，同真則真）
||運(yùn)算是或運(yùn)算，只要其中有一個(gè)為true，||運(yùn)算結(jié)果就是true （有真則真）
!運(yùn)算是非運(yùn)算，它是一個(gè)單目運(yùn)算符，把true變成false，false變成true：
2.5 比較運(yùn)算符
當(dāng)我們對(duì)Number做比較時(shí)，可以通過比較運(yùn)算符得到一個(gè)布爾值：（大于、小于、大于等于、小于等于）
JavaScript允許對(duì)任意數(shù)據(jù)類型做比較：
false == 0; // true
false === 0; // false (這兩個(gè)也已經(jīng)驗(yàn)證過了)
要特別注意相等運(yùn)算符==。JavaScript在設(shè)計(jì)時(shí)，有兩種比較運(yùn)算符：
第一種是==比較，它會(huì)自動(dòng)轉(zhuǎn)換數(shù)據(jù)類型再比較，很多時(shí)候，會(huì)得到非常詭異的結(jié)果（這個(gè)說的好詭異）；（ES6是否有所變化？）
第二種是===比較，它不會(huì)自動(dòng)轉(zhuǎn)換數(shù)據(jù)類型，如果數(shù)據(jù)類型不一致，返回false，如果一致，再比較。
由于JavaScript這個(gè)設(shè)計(jì)缺陷，不要使用==比較，始終堅(jiān)持使用===比較。
另一個(gè)例外是NaN這個(gè)特殊的Number與所有其他值都不相等，包括它自己：
NaN === NaN; // false 是的，已經(jīng)驗(yàn)證，果然自己不能和自己比較。
唯一能判斷NaN的方法是通過isNaN()函數(shù)：
isNaN(NaN); // true 是的，已經(jīng)驗(yàn)證
最后要注意浮點(diǎn)數(shù)的相等比較：
1 / 3 === (1 - 2 / 3); // false （是的，已經(jīng)驗(yàn)證過，猜想其他語言也一樣。）
這不是JavaScript的設(shè)計(jì)缺陷。浮點(diǎn)數(shù)在運(yùn)算過程中會(huì)產(chǎn)生誤差，因?yàn)橛?jì)算機(jī)無法精確表示無限循環(huán)小數(shù)。要比較兩個(gè)浮點(diǎn)數(shù)是否相等，只能計(jì)算它們之差的絕對(duì)值，看是否小于某個(gè)閾值：
Math.abs(1 / 3 - (1 - 2 / 3)) < 0.0000001; // true (是的，果然是對(duì)的)
2.6 null和undefined
null表示一個(gè)“空”的值，它和0以及空字符串''不同，0是一個(gè)數(shù)值，''表示長(zhǎng)度為0的字符串，而null表示“空”。
在其他語言中，也有類似JavaScript的null的表示，例如Java也用null，Swift用nil，Python用None表示。(類似于OC的nil ? ) 但是，在JavaScript中，還有一個(gè)和null類似的undefined，它表示“未定義”。
JavaScript的設(shè)計(jì)者希望用null表示一個(gè)空的值，而undefined表示值未定義。事實(shí)證明，這并沒有什么卵用，區(qū)分兩者的意義不大。大多數(shù)情況下，我們都應(yīng)該用null。undefined僅僅在判斷函數(shù)參數(shù)是否傳遞的情況下有用。
2.7 數(shù)組
數(shù)組是一組按順序排列的集合，集合的每個(gè)值稱為元素。JavaScript的數(shù)組可以包括任意數(shù)據(jù)類型。例如：
[1, 2, 3.14, 'Hello', null, true];
數(shù)組中的元素之間以逗號(hào)分隔，用[]表示數(shù)組
數(shù)組的元素可以通過索引來訪問。請(qǐng)注意，索引的起始值為0：
arr[0]; // 返回索引為0的元素，即1
arr[5]; // 返回索引為5的元素，即true
arr[6]; // 索引超出了范圍，返回undefined
最后一句代碼，要是OC,直接crash掉，報(bào)出數(shù)組越界異常。(以上驗(yàn)證過，是沒有問題的，數(shù)組越界居然可以完全不報(bào)錯(cuò)，好驚喜。)
2.8 對(duì)象
JavaScript的對(duì)象是一組由鍵-值組成的無序集合，例如：
var person = {
name: 'Bob',
age: 20,
tags: ['js', 'web', 'mobile'],
city: 'Beijing',
hasCar: true,
zipcode: null
};
JavaScript對(duì)象的鍵都是字符串類型，值可以是任意數(shù)據(jù)類型。上述person對(duì)象一共定義了6個(gè)鍵值對(duì)，其中每個(gè)鍵又稱為對(duì)象的屬性，例如，person的name屬性為'Bob'，zipcode屬性為null。
要獲取一個(gè)對(duì)象的屬性，我們用對(duì)象變量.屬性名的方式：
person.name; // 'Bob'
person.zipcode; // null

類似于OC,將OC對(duì)象一個(gè)模型轉(zhuǎn)字典。 (以上驗(yàn)證過沒有問題，取值)

2.9 變量
變量在JavaScript中就是用一個(gè)變量名表示，變量名是大小寫英文、數(shù)字、$和_的組合，且不能用數(shù)字開頭。變量名也不能是JavaScript的關(guān)鍵字，如if、while等。申明一個(gè)變量用var語句，

var a; // 申明了變量a，此時(shí)a的值為undefined
var $b = 1; // 申明了變量$ b，同時(shí)給 $b賦值，此時(shí)$ b的值為1
var s_007 = '007'; // s_007是一個(gè)字符串
var Answer = true; // Answer是一個(gè)布爾值true
var t = null; // t的值是null
變量名也可以用中文，但是，請(qǐng)不要給自己找麻煩。(驗(yàn)證過，可以，但最好不要這樣干?。。?
在JavaScript中，使用等號(hào)=對(duì)變量進(jìn)行賦值?？梢园讶我鈹?shù)據(jù)類型賦值給變量，同一個(gè)變量可以反復(fù)賦值，而且可以是不同類型的變量，但是要注意只能用var申明一次(瀏覽器運(yùn)行，好像沒有什么問題。。。)，例如：
var a = 123; // a的值是整數(shù)123
a = 'ABC'; // a變?yōu)樽址?br> (是的，驗(yàn)證過了，同一個(gè)變量可以被不同類型的變量賦值。)
這種變量本身類型不固定的語言稱之為動(dòng)態(tài)語言，與之對(duì)應(yīng)的是靜態(tài)語言。靜態(tài)語言在定義變量時(shí)必須指定變量類型，如果賦值的時(shí)候類型不匹配，就會(huì)報(bào)錯(cuò)。例如Java是靜態(tài)語言，賦值語句如下：
int a = 123; // a是整數(shù)類型變量，類型用int申明
a = "ABC"; // 錯(cuò)誤：不能把字符串賦給整型變量
和靜態(tài)語言相比，動(dòng)態(tài)語言更靈活，就是這個(gè)原因。(OC很好地做好了在靜態(tài)語言和動(dòng)態(tài)語言之間的平衡，以上面的定義而言，OC是一種靜態(tài)語言，PHP、JavaScript均是動(dòng)態(tài)語言。如果說OC在靜態(tài)語言與動(dòng)態(tài)語言之間很好地做到了平衡，那么可以這樣理解：OC在定義變量時(shí)必須指定變量類型，但是可以定義為id類型，而在運(yùn)行時(shí)真正決定變量的類型。)
strict模式(驗(yàn)證自身瀏覽器暫不支持strict模式，有待后期深入了解)
JavaScript在設(shè)計(jì)之初，為了方便初學(xué)者學(xué)習(xí)，并不強(qiáng)制要求用var申明變量。這個(gè)設(shè)計(jì)錯(cuò)誤帶來了嚴(yán)重的后果：如果一個(gè)變量沒有通過var申明就被使用，那么該變量就自動(dòng)被申明為全局變量：
i = 10; // i現(xiàn)在是全局變量
在同一個(gè)頁面的不同的JavaScript文件中，如果都不用var申明，恰好都使用了變量i，將造成變量i互相影響，產(chǎn)生難以調(diào)試的錯(cuò)誤結(jié)果。
使用var申明的變量則不是全局變量，它的范圍被限制在該變量被申明的函數(shù)體內(nèi)（函數(shù)的概念將稍后講解），同名變量在不同的函數(shù)體內(nèi)互不沖突。
為了修補(bǔ)JavaScript這一嚴(yán)重設(shè)計(jì)缺陷，ECMA在后續(xù)規(guī)范中推出了strict模式，在strict模式下運(yùn)行的JavaScript代碼，強(qiáng)制通過var申明變量，未使用var申明變量就使用的，將導(dǎo)致運(yùn)行錯(cuò)誤。
不用var申明的變量會(huì)被視為全局變量，為了避免這一缺陷，所有的JavaScript代碼都應(yīng)該使用strict模式.
3.0 字符串
JavaScript的字符串就是用’’或""括起來的字符表示。
一般在代碼中用單引號(hào), 也可以用雙引號(hào)。如果字符串中又包含了字符串，或者既包含了’又包含"怎么辦？可以用轉(zhuǎn)義字符\來標(biāo)識(shí)，比如：
console.log('I'm \”ok"')
哪里有引號(hào)，哪里就轉(zhuǎn)義。
轉(zhuǎn)義字符\可以轉(zhuǎn)義很多字符，比如\n表示換行，\t表示制表符，字符\本身也要轉(zhuǎn)義，所以\表示的字符就是\。

ASCII字符可以以\x##形式的十六進(jìn)制表示，例如：
'\x41'; // 完全等同于 'A'
還可以用\u####表示一個(gè)Unicode字符：
'\u4e2d\u6587'; // 完全等同于 '中文'
多行字符串
由于多行字符串用\n寫起來比較費(fèi)事，所以最新的ES6標(biāo)準(zhǔn)新增了一種多行字符串的表示方法，用反引號(hào) ... 表示：
console.log(This a test of number of lines string)
模板字符串
要把多個(gè)字符串連接起來，可以用+號(hào)連接：
var name = '小明';
var age = 20;
var message = '你好, ' + name + ', 你今年' + age + '歲了!';
alert(message);

注意：可以理解為字符串中需要拼接的部分先加單引號(hào)，再加+號(hào)。將' + name + '和' + age + ‘這兩個(gè)部分看成一個(gè)整體。
如果有很多變量需要連接，用+號(hào)就比較麻煩。ES6新增了一種模板字符串，表示方法和上面的多行字符串一樣，但是它會(huì)自動(dòng)替換字符串中的變量：
注意下面字符串中用的是用反引號(hào)
var name = '小明';
var age = 20;
var message = 你好, ${name}, 你今年${age}歲了!;
alert(message);
操作字符串
常見字符串操作如下：
var s = 'Hello, world!';
s.length; // 13 計(jì)算長(zhǎng)度，注意中間有空格

要獲取字符串某個(gè)指定位置的字符，使用類似Array的下標(biāo)操作，索引號(hào)從0開始：
var s = 'Hello, world!';

s[0]; // 'H'
s[6]; // ' '
s[7]; // 'w'
s[12]; // '!'
s[13]; // undefined 超出范圍的索引不會(huì)報(bào)錯(cuò)，但一律返回undefined （這點(diǎn)類似于數(shù)組）如果在OC中，程序直接報(bào)異常。

需要特別注意的是，字符串是不可變的，如果對(duì)字符串的某個(gè)索引賦值，不會(huì)有任何錯(cuò)誤，但是，也沒有任何效果：
var s = 'Test';
s[0] = 'X';
alert(s); // s仍然為'Test'
JavaScript為字符串提供了一些常用方法，注意，調(diào)用這些方法本身不會(huì)改變?cè)凶址膬?nèi)容，而是返回一個(gè)新字符串。（類似于OC中的不可變字符串，可以拼接，截取等等，但獲取得到的是一個(gè)新字符串，估計(jì)JavaScript中不會(huì)有可變字符串。）

toUpperCase
toUpperCase()把一個(gè)字符串全部變?yōu)榇髮懀?br> var s = 'Hello';
s.toUpperCase(); // 返回'HELLO'
toLowerCase
toLowerCase()把一個(gè)字符串全部變?yōu)樾懀?br> var s = 'Hello';
var lower = s.toLowerCase(); // 返回'hello'并賦值給變量lower
lower; // 'hello'
indexOf
indexOf()會(huì)搜索指定字符串出現(xiàn)的位置：
var s = 'hello, world';
s.indexOf('world'); // 返回7
s.indexOf('World'); // 沒有找到指定的子串，返回-1
substring
substring()返回指定索引區(qū)間的子串：
var s = 'hello, world'
s.substring(0, 5); // 從索引0開始到5（不包括5），返回'hello'
s.substring(7); // 從索引7開始到結(jié)束，返回'world'

4.0 數(shù)組
一、數(shù)組的基礎(chǔ)知識(shí)
JavaScript的Array可以包含任意數(shù)據(jù)類型，并通過索引來訪問每個(gè)元素。
4.1 要取得Array的長(zhǎng)度，直接訪問length屬性：
var arr = [1, 2, 3.14, 'Hello', null, true];
arr.length; // 6

4.2 請(qǐng)注意，直接給Array的length賦一個(gè)新的值會(huì)導(dǎo)致Array大小的變化：
var arr = [1, 2, 3];
arr.length; // 3
arr.length = 6;
arr; // arr變?yōu)閇1, 2, 3, undefined, undefined, undefined]
arr.length = 2;
arr; // arr變?yōu)閇1, 2]
4.3 Array可以通過索引把對(duì)應(yīng)的元素修改為新的值，因此，對(duì)Array的索引進(jìn)行賦值會(huì)直接修改這個(gè)Array：
var arr = ['A', 'B', 'C'];
arr[1] = 99;
arr; // arr現(xiàn)在變?yōu)閇'A', 99, 'C']
4.4 請(qǐng)注意，如果通過索引賦值時(shí)，索引超過了范圍，同樣會(huì)引起Array大小的變化：
var arr = [1, 2, 3];
arr[5] = 'x';
arr; // arr變?yōu)閇1, 2, 3, undefined, undefined, ‘x']
非常需要注意的如下：
大多數(shù)其他編程語言(OC和C)不允許直接改變數(shù)組的大小，越界訪問索引會(huì)報(bào)錯(cuò)。然而，JavaScript的Array卻不會(huì)有任何錯(cuò)誤。
在編寫代碼時(shí)，不建議直接修改Array的大小(長(zhǎng)度賦值)，訪問索引時(shí)要確保索引不會(huì)越界。因?yàn)檫@樣會(huì)直接修改這個(gè)Array數(shù)組。

二、indexOf

與String類似，Array也可以通過indexOf()來搜索一個(gè)指定的元素的位置：
var arr = [10, 20, '30', 'xyz'];
arr.indexOf(10); // 元素10的索引為0
arr.indexOf(20); // 元素20的索引為1
arr.indexOf(30); // 元素30沒有找到，返回-1 和OC一樣，如果所查找元素在特定數(shù)組找不到，則會(huì)返回一個(gè)數(shù)組下標(biāo)無效數(shù)字。數(shù)組下標(biāo)有效數(shù)字（0~數(shù)組長(zhǎng)度-1）
arr.indexOf('30'); // 元素'30'的索引為2

三、slice
slice()就是對(duì)應(yīng)String的substring()版本，它截取Array的部分元素，然后返回一個(gè)新的Array
var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
arr.slice(0, 3); // 從索引0開始，到索引3結(jié)束，但不包括索引3: ['A', 'B', 'C']
arr.slice(3); // 從索引3開始到結(jié)束: ['D', 'E', 'F', ‘G'] 因?yàn)槲粗付ń厝￠L(zhǎng)度，所以，默認(rèn)從索引3開始，一直截取到數(shù)組末尾。
3.1 注意到slice()的起止參數(shù)包括開始索引，不包括結(jié)束索引。
3.2 如果不給slice()傳遞任何參數(shù)，它就會(huì)從頭到尾截取所有元素。利用這一點(diǎn)，我們可以很容易地復(fù)制一個(gè)Array：
var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
var aCopy = arr.slice();
aCopy; // ['A', 'B', 'C', 'D', 'E', 'F', 'G']
aCopy === arr; // false 不知道為什么，此二者為何會(huì)不相等？

// 以下兩對(duì)方法正好互為補(bǔ)充
四、push和pop（操作數(shù)組的尾部）
push()向Array的末尾添加若干元素，pop()則把Array的最后一個(gè)元素刪除掉：
var arr = [1, 2];
arr.push('A', 'B'); // 返回Array新的長(zhǎng)度: 4 // 確實(shí)，返回4，很奇怪，與OC不同，不知為啥不直接返回新數(shù)組(用新值接收返回返回值打印所得)
arr; // [1, 2, 'A', ‘B'] 直接打印arr
arr.pop(); // pop()返回’B' // 確實(shí)，同樣用新數(shù)組接收返回值打印
arr; // [1, 2, ‘A'] // 確實(shí)
arr.pop(); arr.pop(); arr.pop(); // 連續(xù)pop 3次
arr; // [] // 空數(shù)組
arr.pop(); // 空數(shù)組繼續(xù)pop不會(huì)報(bào)錯(cuò)，而是返回undefined // 但是盡量不要這樣做
arr; // []

五、unshift和shift（操作數(shù)組的頭部）
如果要往Array的頭部添加若干元素，使用unshift()方法，shift()方法則把Array的第一個(gè)元素刪掉：
var arr = [1, 2];
arr.unshift('A', 'B'); // 返回Array新的長(zhǎng)度: 4
arr; // ['A', 'B', 1, 2]
arr.shift(); // 'A'
arr; // ['B', 1, 2]
arr.shift(); arr.shift(); arr.shift(); // 連續(xù)shift 3次
arr; // []
arr.shift(); // 空數(shù)組繼續(xù)shift不會(huì)報(bào)錯(cuò)，而是返回undefined
arr; // []
即：unshift和shift方法其實(shí)與push和pop方法一樣。

六 sort
sort()可以對(duì)當(dāng)前Array進(jìn)行排序，它會(huì)直接修改當(dāng)前Array的元素位置，直接調(diào)用時(shí)，按照默認(rèn)順序排序：
var arr = ['B', 'C', 'A'];
arr.sort();
arr; // ['A', 'B', 'C']

七 reverse
reverse()把整個(gè)Array的元素給掉個(gè)個(gè)，也就是反轉(zhuǎn)
var arr = ['one', 'two', 'three'];
arr.reverse();
arr; // ['three', 'two', 'one']

八 splice
splice()方法是修改Array的“萬能方法”，它可以從指定的索引開始刪除若干元素，然后再從該位置添加若干元素：
var arr = ['Microsoft', 'Apple', 'Yahoo', 'AOL', 'Excite', 'Oracle'];
// 從索引2開始刪除3個(gè)元素,然后再添加兩個(gè)元素:
arr.splice(2, 3, 'Google', ‘Facebook'); // 返回刪除的元素 ['Yahoo', 'AOL', ‘Excite'] // 用新數(shù)組接收返回值
arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']
// 只刪除,不添加: // 直接打印舊數(shù)組
arr.splice(2, 2); // // ['Google', ‘Facebook'] 同上，返回刪除的元素
arr; // ['Microsoft', 'Apple', 'Oracle']
// 只添加,不刪除:
arr.splice(2, 0, 'Google', 'Facebook'); // 返回[],因?yàn)闆]有刪除任何元素同上
arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']

九
concat
concat()方法把當(dāng)前的Array和另一個(gè)Array連接起來，并返回一個(gè)新的Array：
var arr = ['A', 'B', 'C'];
var added = arr.concat([1, 2, 3]);
added; // ['A', 'B', 'C', 1, 2, 3]
arr; // ['A', 'B', 'C']
請(qǐng)注意，concat()方法并沒有修改當(dāng)前Array，而是返回了一個(gè)新的Array。
實(shí)際上，concat()方法可以接收任意個(gè)元素和Array，并且自動(dòng)把Array拆開，然后全部添加到新的Array里：
var arr = ['A', 'B', 'C'];
arr.concat(1, 2, [3, 4]); // ['A', 'B', 'C', 1, 2, 3, 4]

join
join()方法是一個(gè)非常實(shí)用的方法，它把當(dāng)前Array的每個(gè)元素都用指定的字符串連接起來，然后返回連接后的字符串：
var arr = ['A', 'B', 'C', 1, 2, 3];
arr.join('-'); // ‘A-B-C-1-2-3' 注意：進(jìn)行此步操作后，直接打印arr會(huì)獲得這個(gè)值。如果用新數(shù)組接收返回值，打印新數(shù)組則得到原數(shù)組。(????)
如果Array的元素不是字符串，將自動(dòng)轉(zhuǎn)換為字符串后再連接。

十、多維數(shù)組
如果數(shù)組的某個(gè)元素又是一個(gè)Array，則可以形成多維數(shù)組，例如：
var arr = [[1, 2, 3], [400, 500, 600], '-'];
上述Array包含3個(gè)元素，其中頭兩個(gè)元素本身也是Array。
練習(xí)：如何通過索引取到500這個(gè)值：
var arr = [[1, 2, 3], [400, 500, 600], '-'];
x = arr[1][1]; // 所以其他元素的取值一樣
console.log(x); // x應(yīng)該為500

小結(jié)：數(shù)組
閱讀: 281795

JavaScript的Array可以包含任意數(shù)據(jù)類型，并通過索引來訪問每個(gè)元素。
要取得Array的長(zhǎng)度，直接訪問length屬性：
var arr = [1, 2, 3.14, 'Hello', null, true];
arr.length; // 6
請(qǐng)注意，直接給Array的length賦一個(gè)新的值會(huì)導(dǎo)致Array大小的變化：
var arr = [1, 2, 3];
arr.length; // 3
arr.length = 6;
arr; // arr變?yōu)閇1, 2, 3, undefined, undefined, undefined]
arr.length = 2;
arr; // arr變?yōu)閇1, 2]
Array可以通過索引把對(duì)應(yīng)的元素修改為新的值，因此，對(duì)Array的索引進(jìn)行賦值會(huì)直接修改這個(gè)Array：
var arr = ['A', 'B', 'C'];
arr[1] = 99;
arr; // arr現(xiàn)在變?yōu)閇'A', 99, 'C']
請(qǐng)注意，如果通過索引賦值時(shí)，索引超過了范圍，同樣會(huì)引起Array大小的變化：
var arr = [1, 2, 3];
arr[5] = 'x';
arr; // arr變?yōu)閇1, 2, 3, undefined, undefined, 'x']
大多數(shù)其他編程語言不允許直接改變數(shù)組的大小，越界訪問索引會(huì)報(bào)錯(cuò)。然而，JavaScript的Array卻不會(huì)有任何錯(cuò)誤。在編寫代碼時(shí)，不建議直接修改Array的大小，訪問索引時(shí)要確保索引不會(huì)越界。
indexOf
與String類似，Array也可以通過indexOf()來搜索一個(gè)指定的元素的位置：
var arr = [10, 20, '30', 'xyz'];
arr.indexOf(10); // 元素10的索引為0
arr.indexOf(20); // 元素20的索引為1
arr.indexOf(30); // 元素30沒有找到，返回-1
arr.indexOf('30'); // 元素'30'的索引為2
注意了，數(shù)字30和字符串'30'是不同的元素。
slice
slice()就是對(duì)應(yīng)String的substring()版本，它截取Array的部分元素，然后返回一個(gè)新的Array：
var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
arr.slice(0, 3); // 從索引0開始，到索引3結(jié)束，但不包括索引3: ['A', 'B', 'C']
arr.slice(3); // 從索引3開始到結(jié)束: ['D', 'E', 'F', 'G']
注意到slice()的起止參數(shù)包括開始索引，不包括結(jié)束索引。
如果不給slice()傳遞任何參數(shù)，它就會(huì)從頭到尾截取所有元素。利用這一點(diǎn)，我們可以很容易地復(fù)制一個(gè)Array：
var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
var aCopy = arr.slice();
aCopy; // ['A', 'B', 'C', 'D', 'E', 'F', 'G']
aCopy === arr; // false
push和pop
push()向Array的末尾添加若干元素，pop()則把Array的最后一個(gè)元素刪除掉：
var arr = [1, 2];
arr.push('A', 'B'); // 返回Array新的長(zhǎng)度: 4
arr; // [1, 2, 'A', 'B']
arr.pop(); // pop()返回'B'
arr; // [1, 2, 'A']
arr.pop(); arr.pop(); arr.pop(); // 連續(xù)pop 3次
arr; // []
arr.pop(); // 空數(shù)組繼續(xù)pop不會(huì)報(bào)錯(cuò)，而是返回undefined
arr; // []
unshift和shift
如果要往Array的頭部添加若干元素，使用unshift()方法，shift()方法則把Array的第一個(gè)元素刪掉：
var arr = [1, 2];
arr.unshift('A', 'B'); // 返回Array新的長(zhǎng)度: 4
arr; // ['A', 'B', 1, 2]
arr.shift(); // 'A'
arr; // ['B', 1, 2]
arr.shift(); arr.shift(); arr.shift(); // 連續(xù)shift 3次
arr; // []
arr.shift(); // 空數(shù)組繼續(xù)shift不會(huì)報(bào)錯(cuò)，而是返回undefined
arr; // []
sort
sort()可以對(duì)當(dāng)前Array進(jìn)行排序，它會(huì)直接修改當(dāng)前Array的元素位置，直接調(diào)用時(shí)，按照默認(rèn)順序排序：
var arr = ['B', 'C', 'A'];
arr.sort();
arr; // ['A', 'B', 'C']
能否按照我們自己指定的順序排序呢？完全可以，我們將在后面的函數(shù)中講到。
reverse
reverse()把整個(gè)Array的元素給掉個(gè)個(gè)，也就是反轉(zhuǎn)：
var arr = ['one', 'two', 'three'];
arr.reverse();
arr; // ['three', 'two', 'one']
splice
splice()方法是修改Array的“萬能方法”，它可以從指定的索引開始刪除若干元素，然后再從該位置添加若干元素：
var arr = ['Microsoft', 'Apple', 'Yahoo', 'AOL', 'Excite', 'Oracle'];
// 從索引2開始刪除3個(gè)元素,然后再添加兩個(gè)元素:
arr.splice(2, 3, 'Google', 'Facebook'); // 返回刪除的元素 ['Yahoo', 'AOL', 'Excite']
arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']
// 只刪除,不添加:
arr.splice(2, 2); // ['Google', 'Facebook']
arr; // ['Microsoft', 'Apple', 'Oracle']
// 只添加,不刪除:
arr.splice(2, 0, 'Google', 'Facebook'); // 返回[],因?yàn)闆]有刪除任何元素
arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']
concat
concat()方法把當(dāng)前的Array和另一個(gè)Array連接起來，并返回一個(gè)新的Array：
var arr = ['A', 'B', 'C'];
var added = arr.concat([1, 2, 3]);
added; // ['A', 'B', 'C', 1, 2, 3]
arr; // ['A', 'B', 'C']
請(qǐng)注意，concat()方法并沒有修改當(dāng)前Array，而是返回了一個(gè)新的Array。
實(shí)際上，concat()方法可以接收任意個(gè)元素和Array，并且自動(dòng)把Array拆開，然后全部添加到新的Array里：
var arr = ['A', 'B', 'C'];
arr.concat(1, 2, [3, 4]); // ['A', 'B', 'C', 1, 2, 3, 4]
join
join()方法是一個(gè)非常實(shí)用的方法，它把當(dāng)前Array的每個(gè)元素都用指定的字符串連接起來，然后返回連接后的字符串：
var arr = ['A', 'B', 'C', 1, 2, 3];
arr.join('-'); // 'A-B-C-1-2-3'
如果Array的元素不是字符串，將自動(dòng)轉(zhuǎn)換為字符串后再連接。
多維數(shù)組
如果數(shù)組的某個(gè)元素又是一個(gè)Array，則可以形成多維數(shù)組，例如：
var arr = [[1, 2, 3], [400, 500, 600], '-'];
上述Array包含3個(gè)元素，其中頭兩個(gè)元素本身也是Array。
練習(xí)：如何通過索引取到500這個(gè)值：
var arr = [[1, 2, 3], [400, 500, 600], '-'];
console.log(x); // x應(yīng)該為500

小結(jié)
Array提供了一種順序存儲(chǔ)一組元素的功能，并可以按索引來讀寫。
對(duì)象
一、對(duì)象概念
JavaScript的對(duì)象是一種無序的集合數(shù)據(jù)類型，它由若干鍵值對(duì)組成。JavaScript的對(duì)象用于描述現(xiàn)實(shí)世界中的某個(gè)對(duì)象。例如，為了描述“小明”這個(gè)淘氣的小朋友，我們可以用若干鍵值對(duì)來描述他：
var xiaoming = {
name: '小明',
birth: 1990,
school: 'No.1 Middle School',
height: 1.70,
weight: 65,
score: null
};
JavaScript用一個(gè){...}表示一個(gè)對(duì)象，鍵值對(duì)以xxx: xxx形式申明，用,隔開。注意，最后一個(gè)鍵值對(duì)不需要在末尾加,
二、對(duì)象屬性訪問
上述對(duì)象申明了一個(gè)name屬性，值是’小明'，birth屬性，值是1990，以及其他一些屬性。最后，把這個(gè)對(duì)象賦值給變量xiaoming后，就可以通過變量xiaoming來獲取小明的屬性了：
xiaoming.name; // '小明'
xiaoming.birth; // 1990
訪問屬性是通過.操作符完成的，但這要求屬性名必須是一個(gè)有效的變量名。
這句話的言外之意：有效的變量名必須是一個(gè)簡(jiǎn)單的字符串(字符串不包含特殊字符)
如果屬性名包含特殊字符，就必須用’’括起來：
var xiaohong = {
name: '小紅',
'middle-school': 'No.1 Middle School'
};
xiaohong的屬性名middle-school不是一個(gè)有效的變量，就需要用''括起來。訪問這個(gè)屬性也無法使用.操作符，必須用['xxx']來訪問：
xiaohong['middle-school']; // 'No.1 Middle School'
xiaohong['name']; // '小紅'
xiaohong.name; // '小紅'
也可以用xiaohong['name']來訪問xiaohong的name屬性，不過xiaohong.name的寫法更簡(jiǎn)潔。我們?cè)诰帉慗avaScript代碼的時(shí)候，屬性名盡量使用標(biāo)準(zhǔn)的變量名，這樣就可以直接通過object.prop的形式訪問一個(gè)屬性了。
實(shí)際上JavaScript對(duì)象的所有屬性都是字符串，不過屬性對(duì)應(yīng)的值可以是任意數(shù)據(jù)類型。
如果訪問一個(gè)不存在的屬性會(huì)返回什么呢？JavaScript規(guī)定，訪問不存在的屬性不報(bào)錯(cuò)，而是返回undefined：（和OC相比，訪問不存在的屬性，直接報(bào)錯(cuò)，這種方式有利亦有弊）
三、對(duì)象屬性添加/刪除
由于JavaScript的對(duì)象是動(dòng)態(tài)類型，你可以自由地給一個(gè)對(duì)象添加或刪除屬性：
var xiaoming = {
name: '小明'
};
xiaoming.age; // undefined
xiaoming.age = 18; // 新增一個(gè)age屬性
xiaoming.age; // 18
delete xiaoming.age; // 刪除age屬性
xiaoming.age; // undefined
delete xiaoming['name']; // 刪除name屬性
xiaoming.name; // undefined
delete xiaoming.school; // 刪除一個(gè)不存在的school屬性也不會(huì)報(bào)錯(cuò)
(這個(gè)相比靜態(tài)語言O(shè)C,確實(shí)很爽，操作起來，很自由)

四、檢測(cè)對(duì)象是否有某一屬性(涉及到繼承)
如果我們要檢測(cè)xiaoming是否擁有某一屬性，可以用in操作符：
var xiaoming = {
name: '小明',
birth: 1990,
school: 'No.1 Middle School',
height: 1.70,
weight: 65,
score: null
};
'name' in xiaoming; // true
'grade' in xiaoming; // false
不過要小心，如果in判斷一個(gè)屬性存在，這個(gè)屬性不一定是xiaoming的，它可能是xiaoming繼承得到的：
'toString' in xiaoming; // true
因?yàn)閠oString定義在object對(duì)象中，而所有對(duì)象最終都會(huì)在原型鏈上指向object，所以xiaoming也擁有toString屬性。
要判斷一個(gè)屬性是否是xiaoming自身擁有的，而不是繼承得到的，可以用hasOwnProperty()方法：
var xiaoming = {
name: '小明'
};
xiaoming.hasOwnProperty('name'); // true
xiaoming.hasOwnProperty('toString'); // false

五、條件判斷、循環(huán)、Map和Set、iterable(這些類似于C語言、OC語言，C語言是所有編程語言的基礎(chǔ))

5.1 條件判斷
JavaScript使用if () { ... } else { ... }來進(jìn)行條件判斷。
多行條件判斷
如果還要更細(xì)致地判斷條件，可以使用多個(gè)if…else...的組合：
var s = '123';
if (s.length) { // 條件計(jì)算結(jié)果為3

}
JavaScript把null、undefined、0、NaN和空字符串’’視為false，其他值一概視為true，因此上述代碼條件判斷的結(jié)果是true
5.2 循環(huán)
for循環(huán)
JavaScript的循環(huán)有兩種，一種是for循環(huán)，通過初始條件、結(jié)束條件和遞增條件來循環(huán)執(zhí)行語句塊：

通過add(key)方法可以添加元素到Set中，可以重復(fù)添加，但不會(huì)有效果：
s.add(4);
s; // Set {1, 2, 3, 4}
s.add(4);
s; // 仍然是 Set {1, 2, 3, 4}
通過delete(key)方法可以刪除元素：
var s = new Set([1, 2, 3]);
s; // Set {1, 2, 3}
s.delete(3);
s; // Set {1, 2}

小結(jié)
Map和Set是ES6標(biāo)準(zhǔn)新增的數(shù)據(jù)類型，請(qǐng)根據(jù)瀏覽器的支持情況決定是否要使用。
5.4 iterable
遍歷Array可以采用下標(biāo)循環(huán)，遍歷Map和Set就無法使用下標(biāo)。為了統(tǒng)一集合類型，ES6標(biāo)準(zhǔn)引入了新的iterable類型，Array、Map和Set都屬于iterable類型。
具有iterable類型的集合可以通過新的for ... of循環(huán)來遍歷。
for ... of循環(huán)是ES6引入的新的語法
用for ... of循環(huán)遍歷集合，用法如下：
var a = ['A', 'B', 'C'];
var s = new Set(['A', 'B', 'C']);
var m = new Map([[1, 'x'], [2, 'y'], [3, 'z']]);
for (var x of a) { // 遍歷Array
console.log(x);
}
for (var x of s) { // 遍歷Set
console.log(x);
}
for (var x of m) { // 遍歷Map
console.log(x[0] + '=' + x[1]);
}
for ... in循環(huán)由于歷史遺留問題，它遍歷的實(shí)際上是對(duì)象的屬性名稱。一個(gè)Array數(shù)組實(shí)際上也是一個(gè)對(duì)象，它的每個(gè)元素的索引被視為一個(gè)屬性。
當(dāng)我們手動(dòng)給Array對(duì)象添加了額外的屬性后，for ... in循環(huán)將帶來意想不到的意外效果：
var a = ['A', 'B', 'C'];
a.name = 'Hello';
for (var x in a) {
console.log(x); // '0', '1', '2', 'name'
}
for ... in循環(huán)將把name包括在內(nèi)，但Array的length屬性卻不包括在內(nèi)。
for ... of循環(huán)則完全修復(fù)了這些問題，它只循環(huán)集合本身的元素：
var a = ['A', 'B', 'C'];
a.name = 'Hello';
for (var x of a) {
console.log(x); // 'A', 'B', 'C'
}
這就是為什么要引入新的for ... of循環(huán)。// 即for in遍歷數(shù)組時(shí)會(huì)發(fā)生奇怪的想象。但是用for…in循環(huán)遍歷集合時(shí)，并不打印集合元素（？？？）
然而，更好的方式是直接使用iterable內(nèi)置的forEach方法，它接收一個(gè)函數(shù)，每次迭代就自動(dòng)回調(diào)該函數(shù)
// 數(shù)組
a.forEach(function (element, index, array) {
// element: 指向當(dāng)前元素的值
// index: 指向當(dāng)前索引
// array: 指向Array對(duì)象本身
console.log(element + ', index = ' + index);
});
// 集合
var s = new Set(['A', 'B', 'C']);
s.forEach(function (element, sameElement, set) {
console.log(sameElement);
});
// Map
var m = new Map([[1,'x'], [2, 'Y'], [3, ‘Z']])
// 遍歷map
m.forEach(function (value, key, map) {
console.log(value);
});

forEach()方法是ES5.1標(biāo)準(zhǔn)引入的
Set與Array類似，但Set沒有索引，因此回調(diào)函數(shù)的前兩個(gè)參數(shù)都是元素本身：Map的回調(diào)函數(shù)參數(shù)依次為value、key和map本身：
如果對(duì)某些參數(shù)不感興趣，由于JavaScript的函數(shù)調(diào)用不要求參數(shù)必須一致，因此可以忽略它們。例如，只需要獲得Array的element：
var a = ['A', 'B', 'C'];
a.forEach(function (element) {
console.log(element);
});

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

JavaScript學(xué)習(xí)筆記1—快速入門

JavaScript學(xué)習(xí)筆記1—快速入門

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

JavaScript學(xué)習(xí)筆記1—快速入門

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av