JavaScript學習筆記1—快速入門

weixin_33935777發表於2018-11-02

第一部分：快速入門
JS學習中的一些注意點：
2018.8.16
基礎知識：

入門
JavaScript是世界上最流行的指令碼語言，因為你在電腦、手機、平板上瀏覽的所有的網頁，以及無數基於HTML5的手機App，互動邏輯都是由JavaScript驅動的。簡單地說，JavaScript是一種執行在瀏覽器中的解釋型的程式語言。 (這句話怎麼理解呢？html文字、php語言，有點懵逼)
ES6: ECMA（European Computer Manufacturers Association）組織定製了JavaScript語言的標準，被稱為ECMAScript標準。簡稱ES6, 為了讓JavaScript成為全球標準.
JavaScript程式碼可以直接嵌在網頁的任何地方，不過通常我們都把JavaScript程式碼放到<head>中：
由<script>...</script>包含的程式碼就是JavaScript程式碼，它將直接被瀏覽器執行。
第二種方法是把JavaScript程式碼放到一個單獨的.js檔案，然後在HTML中通過<script src="..."></script>引入這個檔案：
把JavaScript程式碼放入一個單獨的.js檔案中更利於維護程式碼，並且多個頁面可以各自引用同一份.js檔案。
可以在同一個頁面中引入多個.js檔案，還可以在頁面中多次編寫<script> js程式碼... </script>，瀏覽器按照順序依次執行。
有些時候你會看到<script>標籤還設定了一個type屬性：
因為預設的type就是JavaScript，所以不必顯式地把type指定為JavaScript。

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

類似於OC,將OC物件一個模型轉字典。 (以上驗證過沒有問題，取值)

2.9 變數
變數在JavaScript中就是用一個變數名錶示，變數名是大小寫英文、數字、$和_的組合，且不能用數字開頭。變數名也不能是JavaScript的關鍵字，如if、while等。申明一個變數用var語句，

var a; // 申明瞭變數a，此時a的值為undefined
var b，同時給b的值為1
var s_007 = '007'; // s_007是一個字串
var Answer = true; // Answer是一個布林值true
var t = null; // t的值是null
變數名也可以用中文，但是，請不要給自己找麻煩。(驗證過，可以，但最好不要這樣幹！！！)
在JavaScript中，使用等號=對變數進行賦值。可以把任意資料型別賦值給變數，同一個變數可以反覆賦值，而且可以是不同型別的變數，但是要注意只能用var申明一次(瀏覽器執行，好像沒有什麼問題。。。)，例如：
var a = 123; // a的值是整數123
a = 'ABC'; // a變為字串
(是的，驗證過了，同一個變數可以被不同型別的變數賦值。)
這種變數本身型別不固定的語言稱之為動態語言，與之對應的是靜態語言。靜態語言在定義變數時必須指定變數型別，如果賦值的時候型別不匹配，就會報錯。例如Java是靜態語言，賦值語句如下：
int a = 123; // a是整數型別變數，型別用int申明
a = "ABC"; // 錯誤：不能把字串賦給整型變數
和靜態語言相比，動態語言更靈活，就是這個原因。(OC很好地做好了在靜態語言和動態語言之間的平衡，以上面的定義而言，OC是一種靜態語言，PHP、JavaScript均是動態語言。如果說OC在靜態語言與動態語言之間很好地做到了平衡，那麼可以這樣理解：OC在定義變數時必須指定變數型別，但是可以定義為id型別，而在執行時真正決定變數的型別。)
strict模式(驗證自身瀏覽器暫不支援strict模式，有待後期深入瞭解)
JavaScript在設計之初，為了方便初學者學習，並不強制要求用var申明變數。這個設計錯誤帶來了嚴重的後果：如果一個變數沒有通過var申明就被使用，那麼該變數就自動被申明為全域性變數：
i = 10; // i現在是全域性變數
在同一個頁面的不同的JavaScript檔案中，如果都不用var申明，恰好都使用了變數i，將造成變數i互相影響，產生難以除錯的錯誤結果。
使用var申明的變數則不是全域性變數，它的範圍被限制在該變數被申明的函式體內（函式的概念將稍後講解），同名變數在不同的函式體內互不衝突。
為了修補JavaScript這一嚴重設計缺陷，ECMA在後續規範中推出了strict模式，在strict模式下執行的JavaScript程式碼，強制通過var申明變數，未使用var申明變數就使用的，將導致執行錯誤。
不用var申明的變數會被視為全域性變數，為了避免這一缺陷，所有的JavaScript程式碼都應該使用strict模式.
3.0 字串
JavaScript的字串就是用’’或""括起來的字元表示。
一般在程式碼中用單引號, 也可以用雙引號。如果字串中又包含了字串，或者既包含了’又包含"怎麼辦？可以用轉義字元\來標識，比如：
console.log('I'm \”ok"')
哪裡有引號，哪裡就轉義。
轉義字元\可以轉義很多字元，比如\n表示換行，\t表示製表符，字元\本身也要轉義，所以\表示的字元就是\。

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

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

要獲取字串某個指定位置的字元，使用類似Array的下標操作，索引號從0開始：
var s = 'Hello, world!';

s[0]; // 'H'
s[6]; // ' '
s[7]; // 'w'
s[12]; // '!'
s[13]; // undefined 超出範圍的索引不會報錯，但一律返回undefined （這點類似於陣列）如果在OC中，程式直接報異常。

需要特別注意的是，字串是不可變的，如果對字串的某個索引賦值，不會有任何錯誤，但是，也沒有任何效果：
var s = 'Test';
s[0] = 'X';
alert(s); // s仍然為'Test'
JavaScript為字串提供了一些常用方法，注意，呼叫這些方法本身不會改變原有字串的內容，而是返回一個新字串。（類似於OC中的不可變字串，可以拼接，擷取等等，但獲取得到的是一個新字串，估計JavaScript中不會有可變字串。）

toUpperCase
toUpperCase()把一個字串全部變為大寫：
var s = 'Hello';
s.toUpperCase(); // 返回'HELLO'
toLowerCase
toLowerCase()把一個字串全部變為小寫：
var s = 'Hello';
var lower = s.toLowerCase(); // 返回'hello'並賦值給變數lower
lower; // 'hello'
indexOf
indexOf()會搜尋指定字串出現的位置：
var s = 'hello, world';
s.indexOf('world'); // 返回7
s.indexOf('World'); // 沒有找到指定的子串，返回-1
substring
substring()返回指定索引區間的子串：
var s = 'hello, world'
s.substring(0, 5); // 從索引0開始到5（不包括5），返回'hello'
s.substring(7); // 從索引7開始到結束，返回'world'

4.0 陣列
一、陣列的基礎知識
JavaScript的Array可以包含任意資料型別，並通過索引來訪問每個元素。
4.1 要取得Array的長度，直接訪問length屬性：
var arr = [1, 2, 3.14, 'Hello', null, true];
arr.length; // 6

4.2 請注意，直接給Array的length賦一個新的值會導致Array大小的變化：
var arr = [1, 2, 3];
arr.length; // 3
arr.length = 6;
arr; // arr變為[1, 2, 3, undefined, undefined, undefined]
arr.length = 2;
arr; // arr變為[1, 2]
4.3 Array可以通過索引把對應的元素修改為新的值，因此，對Array的索引進行賦值會直接修改這個Array：
var arr = ['A', 'B', 'C'];
arr[1] = 99;
arr; // arr現在變為['A', 99, 'C']
4.4 請注意，如果通過索引賦值時，索引超過了範圍，同樣會引起Array大小的變化：
var arr = [1, 2, 3];
arr[5] = 'x';
arr; // arr變為[1, 2, 3, undefined, undefined, ‘x']
非常需要注意的如下：
大多數其他程式語言(OC和C)不允許直接改變陣列的大小，越界訪問索引會報錯。然而，JavaScript的Array卻不會有任何錯誤。
在編寫程式碼時，不建議直接修改Array的大小(長度賦值)，訪問索引時要確保索引不會越界。因為這樣會直接修改這個Array陣列。

二、indexOf

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

三、slice
slice()就是對應String的substring()版本，它擷取Array的部分元素，然後返回一個新的Array
var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
arr.slice(0, 3); // 從索引0開始，到索引3結束，但不包括索引3: ['A', 'B', 'C']
arr.slice(3); // 從索引3開始到結束: ['D', 'E', 'F', ‘G'] 因為未指定擷取長度，所以，預設從索引3開始，一直擷取到陣列末尾。
3.1 注意到slice()的起止引數包括開始索引，不包括結束索引。
3.2 如果不給slice()傳遞任何引數，它就會從頭到尾擷取所有元素。利用這一點，我們可以很容易地複製一個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的最後一個元素刪除掉：
var arr = [1, 2];
arr.push('A', 'B'); // 返回Array新的長度: 4 // 確實，返回4，很奇怪，與OC不同，不知為啥不直接返回新陣列(用新值接收返回返回值列印所得)
arr; // [1, 2, 'A', ‘B'] 直接列印arr
arr.pop(); // pop()返回’B' // 確實，同樣用新陣列接收返回值列印
arr; // [1, 2, ‘A'] // 確實
arr.pop(); arr.pop(); arr.pop(); // 連續pop 3次
arr; // [] // 空陣列
arr.pop(); // 空陣列繼續pop不會報錯，而是返回undefined // 但是儘量不要這樣做
arr; // []

五、unshift和shift（運算元組的頭部）
如果要往Array的頭部新增若干元素，使用unshift()方法，shift()方法則把Array的第一個元素刪掉：
var arr = [1, 2];
arr.unshift('A', 'B'); // 返回Array新的長度: 4
arr; // ['A', 'B', 1, 2]
arr.shift(); // 'A'
arr; // ['B', 1, 2]
arr.shift(); arr.shift(); arr.shift(); // 連續shift 3次
arr; // []
arr.shift(); // 空陣列繼續shift不會報錯，而是返回undefined
arr; // []
即：unshift和shift方法其實與push和pop方法一樣。

六 sort
sort()可以對當前Array進行排序，它會直接修改當前Array的元素位置，直接呼叫時，按照預設順序排序：
var arr = ['B', 'C', 'A'];
arr.sort();
arr; // ['A', 'B', 'C']

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

八 splice
splice()方法是修改Array的“萬能方法”，它可以從指定的索引開始刪除若干元素，然後再從該位置新增若干元素：
var arr = ['Microsoft', 'Apple', 'Yahoo', 'AOL', 'Excite', 'Oracle'];
// 從索引2開始刪除3個元素,然後再新增兩個元素:
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'); // 返回[],因為沒有刪除任何元素同上
arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']

九
concat
concat()方法把當前的Array和另一個Array連線起來，並返回一個新的Array：
var arr = ['A', 'B', 'C'];
var added = arr.concat([1, 2, 3]);
added; // ['A', 'B', 'C', 1, 2, 3]
arr; // ['A', 'B', 'C']
請注意，concat()方法並沒有修改當前Array，而是返回了一個新的Array。
實際上，concat()方法可以接收任意個元素和Array，並且自動把Array拆開，然後全部新增到新的Array裡：
var arr = ['A', 'B', 'C'];
arr.concat(1, 2, [3, 4]); // ['A', 'B', 'C', 1, 2, 3, 4]

join
join()方法是一個非常實用的方法，它把當前Array的每個元素都用指定的字串連線起來，然後返回連線後的字串：
var arr = ['A', 'B', 'C', 1, 2, 3];
arr.join('-'); // ‘A-B-C-1-2-3' 注意：進行此步操作後，直接列印arr會獲得這個值。如果用新陣列接收返回值，列印新陣列則得到原陣列。(????)
如果Array的元素不是字串，將自動轉換為字串後再連線。

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

小結：陣列
閱讀: 281795

JavaScript的Array可以包含任意資料型別，並通過索引來訪問每個元素。
要取得Array的長度，直接訪問length屬性：
var arr = [1, 2, 3.14, 'Hello', null, true];
arr.length; // 6
請注意，直接給Array的length賦一個新的值會導致Array大小的變化：
var arr = [1, 2, 3];
arr.length; // 3
arr.length = 6;
arr; // arr變為[1, 2, 3, undefined, undefined, undefined]
arr.length = 2;
arr; // arr變為[1, 2]
Array可以通過索引把對應的元素修改為新的值，因此，對Array的索引進行賦值會直接修改這個Array：
var arr = ['A', 'B', 'C'];
arr[1] = 99;
arr; // arr現在變為['A', 99, 'C']
請注意，如果通過索引賦值時，索引超過了範圍，同樣會引起Array大小的變化：
var arr = [1, 2, 3];
arr[5] = 'x';
arr; // arr變為[1, 2, 3, undefined, undefined, 'x']
大多數其他程式語言不允許直接改變陣列的大小，越界訪問索引會報錯。然而，JavaScript的Array卻不會有任何錯誤。在編寫程式碼時，不建議直接修改Array的大小，訪問索引時要確保索引不會越界。
indexOf
與String類似，Array也可以通過indexOf()來搜尋一個指定的元素的位置：
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
注意了，數字30和字串'30'是不同的元素。
slice
slice()就是對應String的substring()版本，它擷取Array的部分元素，然後返回一個新的Array：
var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
arr.slice(0, 3); // 從索引0開始，到索引3結束，但不包括索引3: ['A', 'B', 'C']
arr.slice(3); // 從索引3開始到結束: ['D', 'E', 'F', 'G']
注意到slice()的起止引數包括開始索引，不包括結束索引。
如果不給slice()傳遞任何引數，它就會從頭到尾擷取所有元素。利用這一點，我們可以很容易地複製一個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的最後一個元素刪除掉：
var arr = [1, 2];
arr.push('A', 'B'); // 返回Array新的長度: 4
arr; // [1, 2, 'A', 'B']
arr.pop(); // pop()返回'B'
arr; // [1, 2, 'A']
arr.pop(); arr.pop(); arr.pop(); // 連續pop 3次
arr; // []
arr.pop(); // 空陣列繼續pop不會報錯，而是返回undefined
arr; // []
unshift和shift
如果要往Array的頭部新增若干元素，使用unshift()方法，shift()方法則把Array的第一個元素刪掉：
var arr = [1, 2];
arr.unshift('A', 'B'); // 返回Array新的長度: 4
arr; // ['A', 'B', 1, 2]
arr.shift(); // 'A'
arr; // ['B', 1, 2]
arr.shift(); arr.shift(); arr.shift(); // 連續shift 3次
arr; // []
arr.shift(); // 空陣列繼續shift不會報錯，而是返回undefined
arr; // []
sort
sort()可以對當前Array進行排序，它會直接修改當前Array的元素位置，直接呼叫時，按照預設順序排序：
var arr = ['B', 'C', 'A'];
arr.sort();
arr; // ['A', 'B', 'C']
能否按照我們自己指定的順序排序呢？完全可以，我們將在後面的函式中講到。
reverse
reverse()把整個Array的元素給掉個個，也就是反轉：
var arr = ['one', 'two', 'three'];
arr.reverse();
arr; // ['three', 'two', 'one']
splice
splice()方法是修改Array的“萬能方法”，它可以從指定的索引開始刪除若干元素，然後再從該位置新增若干元素：
var arr = ['Microsoft', 'Apple', 'Yahoo', 'AOL', 'Excite', 'Oracle'];
// 從索引2開始刪除3個元素,然後再新增兩個元素:
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'); // 返回[],因為沒有刪除任何元素
arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']
concat
concat()方法把當前的Array和另一個Array連線起來，並返回一個新的Array：
var arr = ['A', 'B', 'C'];
var added = arr.concat([1, 2, 3]);
added; // ['A', 'B', 'C', 1, 2, 3]
arr; // ['A', 'B', 'C']
請注意，concat()方法並沒有修改當前Array，而是返回了一個新的Array。
實際上，concat()方法可以接收任意個元素和Array，並且自動把Array拆開，然後全部新增到新的Array裡：
var arr = ['A', 'B', 'C'];
arr.concat(1, 2, [3, 4]); // ['A', 'B', 'C', 1, 2, 3, 4]
join
join()方法是一個非常實用的方法，它把當前Array的每個元素都用指定的字串連線起來，然後返回連線後的字串：
var arr = ['A', 'B', 'C', 1, 2, 3];
arr.join('-'); // 'A-B-C-1-2-3'
如果Array的元素不是字串，將自動轉換為字串後再連線。
多維陣列
如果陣列的某個元素又是一個Array，則可以形成多維陣列，例如：
var arr = [[1, 2, 3], [400, 500, 600], '-'];
上述Array包含3個元素，其中頭兩個元素本身也是Array。
練習：如何通過索引取到500這個值：
var arr = [[1, 2, 3], [400, 500, 600], '-'];
console.log(x); // x應該為500

小結
Array提供了一種順序儲存一組元素的功能，並可以按索引來讀寫。
物件
一、物件概念
JavaScript的物件是一種無序的集合資料型別，它由若干鍵值對組成。JavaScript的物件用於描述現實世界中的某個物件。例如，為了描述“小明”這個淘氣的小朋友，我們可以用若干鍵值對來描述他：
var xiaoming = {
name: '小明',
birth: 1990,
school: 'No.1 Middle School',
height: 1.70,
weight: 65,
score: null
};
JavaScript用一個{...}表示一個物件，鍵值對以xxx: xxx形式申明，用,隔開。注意，最後一個鍵值對不需要在末尾加,
二、物件屬性訪問
上述物件申明瞭一個name屬性，值是’小明'，birth屬性，值是1990，以及其他一些屬性。最後，把這個物件賦值給變數xiaoming後，就可以通過變數xiaoming來獲取小明的屬性了：
xiaoming.name; // '小明'
xiaoming.birth; // 1990
訪問屬性是通過.操作符完成的，但這要求屬性名必須是一個有效的變數名。
這句話的言外之意：有效的變數名必須是一個簡單的字串(字串不包含特殊字元)
如果屬性名包含特殊字元，就必須用’’括起來：
var xiaohong = {
name: '小紅',
'middle-school': 'No.1 Middle School'
};
xiaohong的屬性名middle-school不是一個有效的變數，就需要用''括起來。訪問這個屬性也無法使用.操作符，必須用['xxx']來訪問：
xiaohong['middle-school']; // 'No.1 Middle School'
xiaohong['name']; // '小紅'
xiaohong.name; // '小紅'
也可以用xiaohong['name']來訪問xiaohong的name屬性，不過xiaohong.name的寫法更簡潔。我們在編寫JavaScript程式碼的時候，屬性名儘量使用標準的變數名，這樣就可以直接通過object.prop的形式訪問一個屬性了。
實際上JavaScript物件的所有屬性都是字串，不過屬性對應的值可以是任意資料型別。
如果訪問一個不存在的屬性會返回什麼呢？JavaScript規定，訪問不存在的屬性不報錯，而是返回undefined：（和OC相比，訪問不存在的屬性，直接報錯，這種方式有利亦有弊）
三、物件屬性新增/刪除
由於JavaScript的物件是動態型別，你可以自由地給一個物件新增或刪除屬性：
var xiaoming = {
name: '小明'
};
xiaoming.age; // undefined
xiaoming.age = 18; // 新增一個age屬性
xiaoming.age; // 18
delete xiaoming.age; // 刪除age屬性
xiaoming.age; // undefined
delete xiaoming['name']; // 刪除name屬性
xiaoming.name; // undefined
delete xiaoming.school; // 刪除一個不存在的school屬性也不會報錯
(這個相比靜態語言OC,確實很爽，操作起來，很自由)

四、檢測物件是否有某一屬性(涉及到繼承)
如果我們要檢測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判斷一個屬性存在，這個屬性不一定是xiaoming的，它可能是xiaoming繼承得到的：
'toString' in xiaoming; // true
因為toString定義在object物件中，而所有物件最終都會在原型鏈上指向object，所以xiaoming也擁有toString屬性。
要判斷一個屬性是否是xiaoming自身擁有的，而不是繼承得到的，可以用hasOwnProperty()方法：
var xiaoming = {
name: '小明'
};
xiaoming.hasOwnProperty('name'); // true
xiaoming.hasOwnProperty('toString'); // false

五、條件判斷、迴圈、Map和Set、iterable(這些類似於C語言、OC語言，C語言是所有程式語言的基礎)

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

}
JavaScript把null、undefined、0、NaN和空字串’’視為false，其他值一概視為true，因此上述程式碼條件判斷的結果是true
5.2 迴圈
for迴圈
JavaScript的迴圈有兩種，一種是for迴圈，通過初始條件、結束條件和遞增條件來迴圈執行語句塊：

通過add(key)方法可以新增元素到Set中，可以重複新增，但不會有效果：
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}

小結
Map和Set是ES6標準新增的資料型別，請根據瀏覽器的支援情況決定是否要使用。
5.4 iterable
遍歷Array可以採用下標迴圈，遍歷Map和Set就無法使用下標。為了統一集合型別，ES6標準引入了新的iterable型別，Array、Map和Set都屬於iterable型別。
具有iterable型別的集合可以通過新的for ... of迴圈來遍歷。
for ... of迴圈是ES6引入的新的語法
用for ... of迴圈遍歷集合，用法如下：
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迴圈由於歷史遺留問題，它遍歷的實際上是物件的屬性名稱。一個Array陣列實際上也是一個物件，它的每個元素的索引被視為一個屬性。
當我們手動給Array物件新增了額外的屬性後，for ... in迴圈將帶來意想不到的意外效果：
var a = ['A', 'B', 'C'];
a.name = 'Hello';
for (var x in a) {
console.log(x); // '0', '1', '2', 'name'
}
for ... in迴圈將把name包括在內，但Array的length屬性卻不包括在內。
for ... of迴圈則完全修復了這些問題，它只迴圈集合本身的元素：
var a = ['A', 'B', 'C'];
a.name = 'Hello';
for (var x of a) {
console.log(x); // 'A', 'B', 'C'
}
這就是為什麼要引入新的for ... of迴圈。// 即for in遍歷陣列時會發生奇怪的想象。但是用for…in迴圈遍歷集合時，並不列印集合元素（？？？）
然而，更好的方式是直接使用iterable內建的forEach方法，它接收一個函式，每次迭代就自動回撥該函式
// 陣列
a.forEach(function (element, index, array) {
// element: 指向當前元素的值
// index: 指向當前索引
// array: 指向Array物件本身
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標準引入的
Set與Array類似，但Set沒有索引，因此回撥函式的前兩個引數都是元素本身：Map的回撥函式引數依次為value、key和map本身：
如果對某些引數不感興趣，由於JavaScript的函式呼叫不要求引數必須一致，因此可以忽略它們。例如，只需要獲得Array的element：
var a = ['A', 'B', 'C'];
a.forEach(function (element) {
console.log(element);
});

flask文件學習筆記1-快速入門
2019-02-16
Flask筆記
JavaScript入門學習學習筆記（上）
2020-10-23
JavaScript筆記
JavaScript入門-學習筆記(一)
2021-01-04
JavaScript筆記
【MongoDB學習筆記】MongoDB 快速入門
2021-12-21
MongoDB筆記
substrate學習筆記2：substrate快速入門
2022-03-21
筆記
java學習筆記1（入門級）
2021-06-20
Java筆記
【Laravel 入門教程】學習筆記 1
2018-04-23
Laravel筆記
redis學習筆記1: Redis入門
2024-05-14
Redis筆記
Scala 學習筆記（1）之入門篇
2013-08-11
筆記
DG學習筆記(1)_入門介紹
2010-03-19
筆記
Thinkphp5.0快速入門筆記（1）
2019-08-02
PHP筆記
TS入門學習筆記
2020-01-19
筆記
【PostgreSQL】入門學習筆記
2022-04-19
SQL筆記
git入門學習筆記
2018-11-15
Git筆記
Docker入門學習筆記
2018-07-25
Docker筆記
Unity學習筆記--入門
2023-10-29
Unity筆記
ActionScript 學習筆記(入門)
2009-09-15
筆記
JavaScript入門學習之旅(二)——JavaScript DOM程式設計藝術學習筆記(上)
2017-07-13
JavaScript程式設計筆記
Go 入門指南學習筆記
2019-12-27
Go筆記
React入門指南(學習筆記)
2019-09-05
React筆記
pandas 學習筆記 (入門篇)
2019-10-18
筆記
HTML入門學習筆記（二）
2019-02-16
HTML筆記
MySQL學習筆記---入門使用
2020-10-24
MySql筆記
Dubbo學習筆記(一) 入門
2018-04-13
筆記
golang入門學習筆記（一）
2017-11-21
Golang筆記
Kotlin 入門學習筆記
2018-01-03
Kotlin筆記
LDA入門級學習筆記
2016-05-08
LDA筆記
Swift快速入門筆記
2017-03-17
Swift筆記
Three.js學習1_快速入門
2020-08-30
JS
JavaScript學習筆記1: JS引入方法
2024-03-18
JavaScript筆記JS
快速入門NativeScript，超詳細的NativeScript學習筆記
2019-05-08
筆記
JavaScript入門筆記（2）
2017-08-06
JavaScript筆記
Spring Boot 學習筆記(1)：快速上手
2018-09-26
Spring Boot筆記
Elasticsearch入門學習重點筆記
2019-05-15
Elasticsearch筆記
安卓學習筆記20：Fragment入門
2020-10-27
安卓筆記Fragment
爬蟲入門學習筆記3
2021-01-05
爬蟲筆記
node 學習筆記基礎入門
2020-10-13
筆記
webpack 學習筆記：入門介紹
2020-09-26
Web筆記

JavaScript學習筆記1—快速入門

相關文章