Javascrpt之Array

Array的构造器

new Array()

• 可以是多个参数

  new Array(1, 2, 3); // [1, 2, 3]
  

• 参数也可以说length，生成的长度为length的数组，内容为undefined

  new Array(3); // [undefined*3]
  

Array的实例的属性

length

• 数组对象的 length 属性是个数据属性，其值总是在数值上大于任何属性名是数组索引的可删除属性的属性名。

Array的构造器属性

Array.prototype

• Array.prototype 的初始值是数组原型对象。

ES5.1新增 Array.isArray(value)

• 用来判断某个值是否为数组。

• 返回值是true和false

  Array.isArray([]); // true
  Array.isArray(123); // false
  // 鲜为人知的事实：其实 Array.prototype 也是一个数组。
  Array.isArray(Array.prototype);
  

Array的原型对象方法

Array.prototype.constructor

• Array.prototype.constructor 的初始值是标准内置 Array 构造器。

Array.prototype.toString()

• 返回一个字符串，表示指定的数组及其元素。

  var arr = [1, 2, 3];
  arr.toString(); // "1,2,3"
  

Array.prototype.toLocaleString()

• 返回一个字符串表示数组中的元素。数组中的元素将使用各自的 toLocaleString 方法转成字符串，这些字符串将使用一个特定语言环境的字符串（例如一个逗号 ","）隔开。

  var num = 1;
  var date = new Date();
  var arr = [num, date, 'str'];
  arr.toLocaleString(); // "1,2016/3/3 上午11:45:30,str"
  //Date对象的具体效果以浏览器为准这里是chrome的例子
  

Array.prototype.concat(value1, value2.. valueN)

• 将传入的数组或非数组值与原数组合并,组成一个新的数组并返回。

  //连接2个数组
  var arr1 = [1, 2, 3];
  var arr2 = ['a', 'b', 'c'];
  arr1.concat(arr2); // [1, 2, 3, 'a', 'b', 'c']
  //连接3个数组
  var arr1 = [1, 2, 3];
  var arr2 = ['a', 'b', 'c'];
  var arr3 = ['arr']
  arr1.concat(arr2, arr3); // [1, 2, 3, 'a', 'b', 'c', 'arr']
  //连接非组值
  var str = 'str';
  var arr1 = [1, 2, 3];
  arr1.concat(str); // [1, 2, 3, 'str']
  

Array.prototype.join(separator)

• 将数组中的所有元素连接成一个字符串。

  var arr = [1, 2, 3];
  arr.json(','); // "1,2,3"
  arr.json('-'); // "1-2-3"
  

Array.prototype.pop()

• 方法删除一个数组中的最后的一个元素，并且返回这个元素。

  var arr = [1, 2, 3];
  arr.pop(); // 3 
  console.log(arr); // [1, 2]
  

Array.prototype.push(element1, .., elementN)

• 添加一个或多个元素到数组的末尾，并返回数组新的长度（length 属性值）。

  var arr = [1, 2, 3];
  arr.push(4); // 4
  arr.push(5, 6); // 6
  console.log(arr); // [1, 2, 3, 4, 5, 6]
  

Array.prototype.reverse()

• 颠倒数组中元素的位置。第一个元素会成为最后一个，最后一个会成为第一个。

  var arr = [1, 2, 3];
  arr.reverse(); // [3, 2, 1]
  

Array.prototype.shift()

• 方法删除数组的 第一个 元素，并返回这个元素。该方法会改变数组的长度。

  var arr = [1, 2, 3];
  arr.shift(); // 1
  console.log(arr); // [2, 3]
  

Array.prototype.unshift(element1, .., elementN)

• 在数组的开头添加一个或者多个元素，并返回数组新的 length 值。

  var arr = [1, 2, 3];
  arr.unshift('a', 'r'); // 5
  console.log(arr); // ['a', 'r', 1, 2, 3]
  

Array.prototype.slice(begin [, end])

• 把数组中一部分的浅复制（shallow copy）存入新的数组对象中，并且返回新的数组。

• begin

  • 从该索引处开始提取原数组中的元素（从0开始）。
  • 如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2)表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。
  • 如果省略 begin，则 slice 从索引 0 开始。

• end

  • 在该索引处结束提取原数组元素（从0开始）。slice会提取原数组中索引从 begin 到 end 的所有元素（包含begin，但不包含end）。

  • slice(1,4) 提取原数组中的第二个元素开始直到第四个元素的所有元素 （索引为 1, 2, 3的元素）。

  • 如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1)表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。

  • 如果 end 被省略，则slice 会一直提取到原数组末尾。

    var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
    var citrus = fruits.slice(1, 3); // ["Orange", "Lemon"]
    var citrus2 = fruits.slice(-2,-1);// ["Apple"]
    

• 转换类数组对象（Array-like）

  function list() {
    return Array.prototype.slice.call(arguments);
  }
  var list1 = list(1, 2, 3); // [1, 2, 3]
  

Array.prototype.splice(start, deleteCount[, item1[, item2[, ...]]])

• 用新元素替换旧元素，以此修改数组的内容。

  • start删除的起始位置
  • deleteCount删除个数
  • item插入元素

  var arr = [1, 2, 3, 4];
  arr.splice(0, 2, 'num'); // [1, 2]
  console.log(arr); // ['num', 3, 4]
  

Array.prototype.sort([compareFunction])

• 对数组的元素做原地的排序，并返回这个数组。 sort 可能不是稳定的。默认按照字符串的Unicode码位点（code point）排序。

  • 基础用法

    var arr = [1, 3, 2];
    arr.sort();
    console.log(arr); // [1, 2, 3]
    

  • sort可以接受一个函数作为参数

    var arr = [1, 3, 2];
    arr.sort(function(a,b) {
        return b - a;
    });
    console.log(arr); // [3, 2, 1]
    

ES5.1新增 Array.prototype.indexOf(searchElement[, fromIndex = 0])

• 返回给定元素能找在数组中找到的第一个索引值，否则返回-1。

  var arr = [1, 2, 3];
  arr.indexOf(1); // 0
  arr.indexOf(4); // -1
  

ES5.1新增 Array.prototype.lastIndexOf(searchElement[, fromIndex = arr.length - 1])

• 返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从 fromIndex 处开始。

  var arr = [2, 1, 2, 3];
  arr.lastIndexOf(2); // 2
  arr.lastIndexOf(4); // -1
  

ES5.1新增 Array.prototype.filter(callback[, thisArg])

• 使用指定的函数测试所有元素，并创建一个包含所有通过测试的元素的新数组。

  var arr = [1, 2, 3, 4, 5, 6];
  var arr2 = arr.filter(function(item) {
      return item >= 3;
  });
  console.log(arr2); // [3, 4, 5, 6]
  

ES5.1新增 Array.prototype.forEach(callback[, thisArg])

• 让数组的每一项都执行一次给定的函数。

  var arr = [1, 2, 3];
  var arr1 = [];
  var arr2 = arr.forEach(function(item, index, array) {
      arr1[index] = item * 2;
  });
  console.log(arr1); // [2, 4, 6]
  

ES5.1新增 Array.prototype.some(callback[, thisArg])

• 测试数组中的某些元素是否通过了指定函数的测试。

• 测试数组中的每一项，如果返回值中有一个true则返回true如果没有返回false。

  //测试是否有项目等于1 
  var arr = [1, 2, 3, 4];
  console.log(arr.some(function(item, index, array){
      return (item == 1);
  })); // true
  

ES5.1新增 Array.prototype.every(callback[, thisArg])

• 测试数组的所有元素是否都通过了指定函数的测试。

• 测试数组中的每一项，如果返回值中全部为true则返回true否则返回false。

  var arr = [1, 2, 3, 4];
  console.log(arr.some(function(item, index, array){
      return (item == 1);
  })); // false
  

ES5.1新增 Array.prototype.map(callback[, thisArg])

• 返回一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组。

  var arr = [1, 2, 3];
  var arr2 = arr.map(function(item, index, array) {
      return item * 2;
  });
  console.log(arr2); // [2, 4, 6]
  

ES5.1新增 Array.prototype.reduce()

• 接收一个函数作为累加器（accumulator），数组中的每个值（从左到右）开始合并，最终为一个值。
• 见火狐标准库。

ES5.1新增 Array.prototype.reduceRight()

• 接受一个函数作为累加器（accumulator），让每个值（从右到左，亦即从尾到头）缩减为一个值。（与 reduce() 的执行方向相反）
• 见火狐标准库。

详细内容参考API 火狐标准库