数组的属性和方法

数组的属性和方法

要取得数组的长度，直接访问 length 属性。

需要注意的是，直接给数组的 length 赋一个新的值会导致数组大小的变化：

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]

数组可以通过索引把对应的元素修改为新的值。

同样需要注意的是，如果通过索引赋值时，索引超过了范围，同样会引起数组大小的变化：

var arr = [1, 2, 3];
arr[5] = "x";
arr; // arr 变为 [1, 2, 3, undefined, undefined, "x"]

其它多数编程语言不允许直接改变数组的大小，越界访问索引会报错。然而，JavaScript 的数组却不会有任何错误。在编写代码时，不建议直接修改数组的大小，访问索引时要确保索引不会越界。

数组的方法

push 和 pop

push() 向数组的末尾添加若干元素，pop() 则删除数组的末元素：

var arr = [1, 2];
arr.push("A", "B");                 // 返回数组新的长度: 4
arr;                                // [1, 2, "A", "B"]
arr.pop();                          // pop() 返回 "B"
arr;                                // [1, 2, "A"]
arr.pop(); arr.pop(); arr.pop();    // 连续 pop 三次
arr;                                // []
arr.pop();                          // 空数组继续 pop 不会报错，而是返回 undefined
arr;                                // []

unshift 和 shift

unshift() 往数组的头部添加若干元素，shift() 则删除数组的首元素：

var arr = [1, 2];
arr.unshift("A", "B");                  // 返回数组新的长度: 4
arr;                                    // ["A", "B", 1, 2]
arr.shift();                            // "A"
arr;                                    // ["B", 1, 2]
arr.shift(); arr.shift(); arr.shift();  // 连续 shift 三次
arr;                                    // []
arr.shift();                            // 空数组继续 shift 不会报错，而是返回 undefined
arr;                                    // []

splice

splice() 是修改数组的“万能方法”，它可以从指定的索引开始删除若干元素，然后再从该位置添加若干元素：

var arr = ["Microsoft", "Apple", "Yahoo", "AOL", "Excite", "Oracle"];
// 从索引 2 开始删除三个元素，然后再添加两个元素：
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"]

reverse

reverse() 把整个数组的元素反转：

var arr = ["one", "two", "three"];
arr.reverse();
arr; // ["three", "two", "one"]

sort

sort() 可以对当前数组进行排序，它会直接修改当前数组的元素位置。直接调用时，按照默认顺序排序：

var arr = ["B", "C", "A"];
arr.sort();
arr; // ["A", "B", "C"]

至于按照指定的顺序排序，将会在后面的函数中讲到。

slice

slice() 对应于对应字符串中的 substring()，它截取数组的部分元素，然后返回一个新的数组：

var arr = ["A", "B", "C", "D", "E", "F", "G"];
arr.slice(0, 3);    // 索引范围 [0, 3): ["A", "B", "C"]
arr.slice(3);       // 从索引 3 开始到结束: ["D", "E", "F", "G"]

如果不给 slice() 传递任何参数，就会从头到尾截取所有元素。利用这一点可以很容易地复制一个数组：

var arr = ["A", "B", "C", "D", "E", "F", "G"];
var aCopy = arr.slice();
aCopy;          // ["A", "B", "C", "D", "E", "F", "G"]
aCopy === arr;  // false

同理，也可以不给字符串的 substring() 传递参数以得到复制的字符串：

var s = "Hello, World!";
var sCopy = s.substring();
sCopy; // "Hello, World!"
sCopy === s; // true

concat

concat() 把当前数组和另一个数组连接起来，并返回一个新的数组：

var arr = ["A", "B", "C"];
var added = arr.concat([1, 2, 3]);
added;  // ["A", "B", "C", 1, 2, 3]
arr;    // ["A", "B", "C"]

实际上，concat() 可以接收任意个元素和数组，并且自动把数组拆开，然后全部添加到新的数组里：

var arr = ["A", "B", "C"];
arr.concat(1, 2, [3, 4]); // ["A", "B", "C", 1, 2, 3, 4]

join

join() 是一个非常实用的方法，它把当前数组的每个元素都用指定的字符串连接起来，然后返回连接后的字符串：

var arr = ["A", "B", "C", 1, 2, 3];
arr.join("-"); // "A-B-C-1-2-3"

如果数组的元素不是字符串，将自动转换为字符串后再连接。

ES5新增数组方法

forEach(匿名函数) 遍历数组 没有返回值

    arr.forEach(function(item,index,array){
        item:数组的元素
        index:数组的下标
        array:遍历的数组
    })
    案例：
      var arr = [23,2,1,4,5,6,89]; 
      arr.forEach(function(item,index,array){
            if( item%2 ){
                  console.log( item );
            }
      })
      //取数组中的最小值
      var min = arr.shift();//[2,1,4,5,6,89]
      arr.forEach(function(item){
            if( item < min ){
                  min = item;
            }
            //min = item<min ? item : min;
      })
      alert( min );

indexOf()

如果存在 返回这个数在数组中的下标，如果要检索的字符串值没有出现，则该方法返回 -1。

       var arr = [2,23,2,1,4,1,5,6,89]; 
      // indexOf 判断一个数在数组中是否存在，
     //如果存在 返回这个数在数组中的下标，
    //如果不存在就返回-1
      var res =  arr.indexOf(1);
      // alert( res );//
      function noRepeat(arr){
            var newArr = [];
            for( var i = 0 ; i < arr.length ; i++ ){
                  //判断原数组中的某个数 在新数组 中是否存在
                  if( newArr.indexOf( arr[i] ) == -1 ){
                      newArr.push( arr[i] );
                  }
            }
            return newArr;
      }

      alert( noRepeat(arr) );

filter( )：过滤方法,根据过滤条件返回新的数组 不会对空数组进行检测。 不会改变原始数组。

案例：
        var arr = [2,23,2,1,4,1,5,6,89]; 
      var brr = arr.filter(function(item，index，array){//参数没用到可以不传
            console.log(item);
            return item%2; // item > 5
      })
      alert( brr );
map()//映射 遍历数组--修改数组--返回数组
        var arr = [2,23,2,1,4,1,5,6,89];
      var brr = arr.map(function(item，index，array){
            return item*1.3;
      })

      alert( brr );

reduce() // 归并 从数组下标为1的位置开始循环

        var arr = [1,2,3,4,5,6];
      document.write("pre------next<br>")
      var res = arr.reduce(function(pre,next){
            document.write(pre+"------"+next + "<br>");
            //pre 表示上一次操作返回的结果
            //next 表示 下一个数
            return pre+next;//每一次操作的结果 传递给pre  计算数组的和
      })

      alert( res );

多维数组
如果数组的某个元素又是一个数组，则可以形成多维数组，例如：

var arr = [[1, 2, 3], [400, 500, 600], "-"];

上述数组包含三个元素，其中头两个元素本身也是数组。