陣列

一.建立陣列

1.定義：陣列是值得有序集合。每個值叫做一個元素，而每個元素在陣列中有一個位置，以數字表示——索引
陣列的元素可以是任意型別，並且同一個陣列中的不同元素也可能有不同的型別。第一個元素的索引是0，陣列是js物件的特殊形式。
陣列繼承自Array.prototype中的屬性，他定義了一套豐富的數字操作方法

<script>
        var empty = [];
        var primes  = [2,3,4,5,6];//有5個數組的陣列
        var misc = [1.2,true,"a", ];//3不同型別的元素和結尾的逗號
    </script>
 

2.陣列直接量中的值不一定要是常量，他們可以是任意的表示式，他可以包含物件直接量或其他陣列直接量。（數組裡面可以巢狀陣列）
3.省略的元素會被賦予undefined
var count = [1,3];//中間元素值為undefined
4.三種方式呼叫建構函式

<script>
        var a = new Array();//沒有引數.該方法建立一個沒有任何元素的空陣列，等同於陣列直接量[]
        var a = new Array(10);//呼叫時有一個數值引數，他指定長度
        var a = new Array(5,4,3,2,1,"testing, testing");//顯式指定2個或多個數組元素的非數值元素
    </script>
 

二.陣列元素的讀和寫

1.寫法

  <script>
        var a =["world"];
        var value = a[0];
        a[1]=3.14;
        i=2;
        a[i] = 3;
        a[i+1]="hello";
        a[a[i]]=a[0];
        console.log(a);
    </script>

2.所有的索引都是屬性名，所有的陣列都是物件，可以為其建立任意名字的屬性。但若果使用的屬性是陣列的索引，陣列的特殊行為就是根據需要更新他們的length屬性值
3.可以使用負數或非整數來索引陣列。這種情況，數值轉換為字串，字串作為屬性名來用。

<script>
       a[-1.23]=true;//這將建立一個名為“-1.23” 的屬性
       a["1000"]=0;//這是陣列的第1001個元素
       a[1.00]//a[1]相等
    </script>

三.稀疏陣列

1.定義：包含從0開始的不連續索引的陣列
當陣列是稀疏的，陣列長度length屬性值大於元素的個數、
建立稀疏陣列

 a = new Array(5);//陣列沒有元素，但是a.length是5
 a = [];//建立一個空陣列，length=0
a[1000]=0;//賦值新增一個元素，但是設定length為1001

2.兩者不等效

var a1=[,,,];a[undefined,undefined,undefined]
var a2=new Array(3);

四.陣列長度

 <script>
        a=[1,2,3,4,5];
        console.log(a.length);
        a.length=3;
        console.log(a);
        a.length=0;
        console.log(a);
        a.length=5;
        console.log(a);
    </script>

2.ES5中用Object.defineProperty（）讓陣列的length屬性變成只讀

 <script>
        a=[1,2,3];
        Object.defineProperty(a,"length",{writable:false});
        a.length=0
        console.log(a.length);//3 a長度不變
    </script>

五.陣列元素的新增和刪除

1.新增①為新索引賦值

 <script>
       a = [];
       a[0]="zero";
       a[1]="one";
       console.log(a);
    </script>

新增②使用push（）方法在陣列末尾增加一個或多個元素

 <script>
       a = [1,2,3];
       a.push("zero");
       a.push("one","two");
       console.log(a);
    </script>

還有unshift（）方法是在陣列首部插入一個元素，並將其他元素依次移到更高的索引處
2.刪除元素（可以像刪除物件屬性一樣使用delete來刪除陣列元素）

<script>
       a = [1,2,3];
       delete a[1];
       console.log(a.length);
       console.log(a);
    </script>

splice（）是一個通用的方法來插入，刪除或替換陣列元素。他會根據需要修改length屬性並移動元素到更高或更低的索引處

六.遍歷陣列

1.for最常見

<script>
       var a = ["two","four",4,5];
       for (var i=0;i<a.length;i++){
           console.log(a[i]);
       }
    </script>

2.要排除null和undefined和不存在元素在for迴圈中增加一句

if(!a[i]) continue;
//迴圈體

3.只想跳過不存在元素而仍然要處理存在的undefined

<script>
       var a = ["two","four",4,5];
       for (var i=0;i<a.length;i++){
           if (!(i in a))
               continue;
           //迴圈體
       }
    </script>

3.forEach（）ES5中定義遍歷迴圈的新方法

<script>
       var a = [1,2,3];
       var sum=0;
       a.forEach(function (x) {
           sum+= x*x;
       })
        console.log(sum);
    </script>

七.多維陣列

1.JavaScript不支援真正的多維陣列，但可以用陣列的數字來近似。兩次【】就可以
如下：二維陣列實現九九乘法表

 <script>
       var table = new Array(10);//表格有10行
        for (var i=0;i<table.length;i++){
            table[i]=new Array(10);//每行有10列
        } 
        //初始化陣列row是行，col是列
        for (var row =0;row<table.length;row++){
            for (var col = 0;col<table[row].length;col++){
                table[row][col] = row*col;
            }
        }
    </script>

八.陣列方法

1.join（）
Array.join（）方法將陣列中所有元素都轉化為字串並連線在一起，返回最後生成的字串。可以指定一個可選的字串在生成的字串中來分隔陣列的各個元素。預設為逗號

 <script>
       var a = [1,2,3];
       a.join();
       console.log(a);
    </script>

2.reverse（）
將陣列中元素顛倒順序

<script>
       var a = [1,2,3];
       a.reverse();
       console.log(a);
    </script>

3.sort（）
將陣列中的元素排序並返回排序後的陣列

 <script>
      var a = new Array("banana","pear","apple");
      console.log(a);
      a.sort();
      console.log(a);
    </script>

根據數值大小排序

<script>
      var a = new Array(33,4,1111,222);
      a.sort();
      a.sort(function (a,b) {
          return a-b;
      });
      // a.sort(function (a,b) {
      //     return b-a;//數值大小相反的順序
      // })
      console.log(a);
    </script>

對一個字串陣列執行不區分大小寫的字母表排序，比較函式首先將引數都轉換問小寫字母（toLowerCase（）方法）

<script>
     var a = ['ant','Bug','cat','Dog'];
     a.sort();//區分大小寫
      console.log(a);
      a.sort(function (s,t) {
          var a = s.toLowerCase();
          var b = t.toLowerCase();
          if (a<b) return-1;
          if (a>b) return 1;
          return 0;
      })
     console.log(a);
    </script>

4.concat（）
建立並返回一個新陣列，他的元素包括用concat（）的原始陣列的元素和concat（）的每個元素。concat不會修改呼叫的陣列

 <script>
     var a = [1,2,3];

     console.log(a.concat(4,5));
     console.log(a.concat([4,5]));
     console.log(a.concat([4,5],[6,7]));
     console.log(a.concat(4,[5,[6,7]]));
     console.log(a);

    </script>

concat連線陣列

<script>
        var arr = new Array(3)
        arr[0] = "George"
        arr[1] = "John"
        arr[2] = "Thomas"

        var arr2 = new Array(3)
        arr2[0] = "James"
        arr2[1] = "Adrew"
        arr2[2] = "Martin"
        console.log(arr.concat(arr2));
        console.log(arr);
        console.log(arr2);
    </script>

5.slice（）
返回指定陣列的一個片段或子陣列（兩個引數分別表示片段的開始和結束 。如果引數中有負數，則相對於陣列中最後一個元素的位置（-1）指定最後一個元素，（-3）指定倒數第三個元素）
slice（）不會修改呼叫的陣列

<script>
        var a = [1,2,3,4,5];
        console.log(a.slice(0,3));
        console.log(a.slice(3));
        console.log(a.slice(1,-1));
        console.log(a.slice(-3,-2));
        console.log(a);
    </script>

6.splice（）
在陣列中插入或刪除元素的通用方法（可以插入可以刪除可以同時插入和刪除）。不同於slice（）和concat（）。splice（）會修改呼叫的陣列
裡面有兩個引數，第一個：指定插入或刪除的起始位置。第二個引數：指定刪除的元素的個數。預設第二個引數是從起始點開始到陣列結尾的所有元素都將被刪除。
splice（）返回一個有刪除元素組成的陣列，或者如果沒有刪除元素就返回一個空陣列
刪除

<script>
       var a = [1,2,3,4,5,6,7,8];
       console.log(a.splice(4));
       console.log(a);
       console.log(a.splice(1,2));
       console.log(a);
       console.log(a.splice(1,1));
       console.log(a);
    </script>

插入

 <script>
       var a = [1,2,3,4,5];
       console.log(a.splice(2,0));
       console.log(a);
       
       console.log(a.splice(2,0,'a','b'));
       console.log(a);
       
       // console.log(a.splice(2,2));
       console.log(a.splice(2,2,[1,2],3));
       console.log(a);
    </script>

7.push（）和pop（）方法允許陣列當做棧使用
push（）方法：在陣列的尾部新增一個或多個元素，並返回陣列新的長度。
pop（）：刪除陣列的最後一個元素，減小陣列長度並返回他刪除的值。
組合使用push和pop能夠用JavaScript陣列實現先進後出的棧

<script>
       var stack = [];
       stack.push(1,2);
       console.log(stack);
       stack.pop();
       console.log(stack);
       stack.push(3);
       console.log(stack);
       stack.pop();
       console.log(stack);
       stack.push([4,5]);
       console.log(stack);
       stack.pop();
       console.log(stack);
       stack.pop();
       console.log(stack);
    </script>

8.unshift（）和shift（）
unshift（）在陣列的頭部新增一個或多個元素，並將已存在的元素移動到更高索引的位置來獲取足夠空間，最後返回陣列新的長度。
shift（）刪除陣列的第一個元素並將其返回，然後把所有隨後的元素下移一個位置來填補陣列頭部的空缺

<script>
        var a=[];
        a.unshift(1);
        console.log(a);
        a.unshift(22);
        console.log(a);
        a.shift();
        console.log(a);
        a.unshift(3,[4,5,6]);
        console.log(a);
        a.shift();
        console.log(a);
        a.shift();
        console.log(a);
        a.shift();
        console.log(a);
    </script>

9.toString（）和toLocaleString（）
toString（）將每個元素轉化為字串並輸出用逗號分隔的字串列表。
輸出不包括方括號或其他形式的包裹陣列值得分隔符。這裡與不使用任何引數呼叫join（）方法返回的字串一樣的

//陣列
var array = ["CodePlayer", true, 12, -5];
document.writeln( array.toString() ); // CodePlayer,true,12,-5

// 日期
var date = new Date(2013, 7, 18, 23, 11, 59, 230);
document.writeln( date.toString() ); // Sun Aug 18 2013 23:11:59 GMT+0800 (中國標準時間)

// 日期2
var date2 = new Date(1099, 7, 18, 23, 11, 59, 230);
document.writeln( date2.toString() ); // Fri Aug 18 1099 23:11:59 GMT+0800 (中國標準時間)

// 數字
var num =  15.26540;
document.writeln( num.toString() ); // 15.2654

// 布林
var bool = true;
document.writeln( bool.toString() ); // true

// Object
var obj = {name: "張三", age: 18};
document.writeln( obj.toString() ); // [object Object]

// HTML DOM 節點
var eles = document.getElementsByTagName("body");
document.writeln( eles.toString() ); // [object NodeList]
document.writeln( eles[0].toString() ); // [object HTMLBodyElement]

九.ES5中的陣列方法

1.ES5中定義9個新的陣列方法來遍歷，對映，過濾，檢測，簡化和搜尋陣列
ES5中的陣列方法都不會修改他們呼叫的原始陣列
2.forEach（）
從頭到尾遍歷陣列，為每個元素呼叫指定的函式
傳遞的函式作為forEach（）的第一個引數，然後使用三個引數嗲用該函式：陣列元素，元素的索引和陣列本身（若只想要陣列的值，可以編寫只有一個引數的函式——額外的引數將忽略）

 <script>
        var data = [1,2,3,4,5];
        var sum =0 ;
        data.forEach(function (value) {
            sum+=value;
        });
        console.log(sum);
        //每個陣列元素的值自加1
        data.forEach(function (v,i,a) {
            a[i] = v + 1;
        })
        console.log(data);
    </script>

forEach不能break提前終止結束，要提前終止，必須把他放在try塊中，並丟擲異常
3.map（）
將呼叫的陣列的每個元素傳給特定的函式，並返回一個數組，他包含該函式的返回值
map（）返回的是新陣列：不會修改呼叫的陣列

<script>
        a = [1,2,3];
        b = a.map(function (x) {
            return x*x;
        });
        console.log(b);
        console.log(a);
    </script>

4.filter（）
返回的陣列元素是呼叫的陣列的一個子集。
傳遞的函式是返回的true或false。若返回值是true或能轉換為true的值，則傳遞給判斷函式的元素是這個子集的成員，會被新增到一個作為返回值的陣列中。

 <script>
       a = [5,4,3,2,1];
       smallvalues = a.filter(function (x) {
           return x < 3;
       })
       console.log(smallvalues);
       everytother = a.filter(function (x,i) {
           return i%2==0;
       });
       console.log(everytother);
        console.log(a);
    </script>

5.every（）和some（）
他們對陣列元素應用指定的函式進行判定返回true還是false
every（）== “ 所有” ，當且僅當陣列中的所有元素呼叫判定函式都返回true，他才返回true
some（）===存在“”，當陣列至少有一個元素呼叫判定函式返回true，所有元素都返回false他才返回false

 <script>
       var a = [1,2,3,4,5]
       console.log(a);
       console.log(a.every(function (x) {
            return x < 10;
        })
       );

       console.log(a.every(function (x) {
           return x%2===0;
       }))

        console.log(a.some(function (x) {
            return x%2===0;//至少有一個元素，函式返回true
        }))
        console.log(a.some(isNaN));
    </script>

6.reduce（）和reduceRight（）
使用指定函式將陣列元素進行組合，生成單個值

 <script>
       var a = [1,2,3,4,5];
        var sum = a.reduce(function (x,y) {
            return x+y
        },0);//陣列求和
       console.log(sum);
        var pro = a.reduce(function (x,y) {
            return x*y;
        },1);//陣列求積
        console.log(pro);
        var max = a.reduce(function (x,y) {
            return (x>y)?x:y;
        })
        console.log(max);
    </script>

在空陣列上，不帶初始值引數呼叫reduce（）將導致型別錯誤異常
7.indexOf（）和lastIndexOf（）
搜尋整個陣列中具有給定值的元素，返回找到的第一個元素的索引或者沒有找到就返回-1.indexOf從頭至尾搜尋，二lastIndexOf則反向搜尋

 <script>
       var a = [1,2,3,4,5];
       console.log(a.indexOf(1));//a[0]
       console.log(a.lastIndexOf(3));
       console.log(a.indexOf(4));
    </script>

十.陣列型別

<script>
        var isArray = Function.isArray || function (o) {
            return typeof  o == "object" &&
                    Object.prototype.toString.call(o) === "[object Array]"
        };
    </script>

十一.類陣列物件

例：一個常規物件增加一些屬性使其變成類陣列物件，然後遍歷生成的偽陣列的“元素”

十二.作為陣列的字串