Array的总结

Array

Array的属性:

Array.length

Array的方法：

Array.of

arrary新建数组

//of新建
Array.of(7);       // [7] 
Array.of(1, 2, 3); // [1, 2, 3]
//传统新建
Array(7);          // [ , , , , , , ]
Array(1, 2, 3);    // [1, 2, 3]

Array.isArray

检验是否数组

Array.isArray([1, 2, 3]); 

Array.from

从一个类似数组（如NodeList,arguments）或可迭代对象（如map，set,string既是数组又是可迭代对象）创建一个新的数组实例。

//字符串转换
Array.from('foo');
// ["f", "o", "o"]

//map转换
var m = new Map([[1, 2], [2, 4], [4, 8]]);
Array.from(m);      //[[1,2],[2,4],[4,8]]

// 使用 map 函数转换数组元素
Array.from([1, 2, 3], x => x + x);      // [2, 4, 6]

// 生成一个数字序列
Array.from({length:5}, (v, k) => k);    // [0, 1, 2, 3, 4]

//数组去重
var arr = [1,2,1,2,2,1];
//new Set 数组去重
function unique(arr){
  return Array.from(new Set(arr));//去重复
};
console.log(unique(arr));

//es6
(function(first,...rest){
    log('first',first);//1
    log('rest',rest);//['Second,3']
})(1,'Second',3);


//es5
(function(){
    var first = arguments[0];
    var rest = Array.from(arguments).slice(1);
    log('first',first);
    log('rest',rest);
})(1,'Second',3)

Array.prototype.concat()

用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。

let arr1 = ["a", "b", "c"];
let arr2 = ["d", "e", "f"];
let arr3 = arr1.concat(arr2);
console.log(arr3);
// results in a new array 
// [ "a", "b", "c", "d", "e", "f" ]
console.log(arr1);
// ["a", "b", "c"]
console.log(arr2);
// ["d", "e", "f"]

Array.prototype.entries

返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对。

var arr = ["a", "b", "c"];
var iterator = arr.entries();
// undefined
console.log(iterator);
// Array Iterator {}
console.log(iterator.next().value); 
// [0, "a"]
console.log(iterator.next().value); 
// [1, "b"]
console.log(iterator.next().value); 
// [2, "c"]
var arr = ["a", "b", "c"];
var iterator = arr.entries();
// undefined
for (let e of iterator) {
    console.log(e);
}
// [0, "a"] 
// [1, "b"] 
// [2, "c"]

Array.prototype.every()

every() 方法测试数组的所有元素是否都通过了指定函数的测试。都通过就返回true，否则返回false

function isBigEnough(element, index, array) {
  return (element >= 10);
}
var passed = [12, 5, 8, 130, 44].every(isBigEnough);
// passed is false
passed = [12, 54, 18, 130, 44].every(isBigEnough);
// passed is true

让不支持every的浏览器支持：

if (!Array.prototype.every)
{
  Array.prototype.every = function(fun /*, thisArg */)
  {
    'use strict';
    if (this === void 0 || this === null)
      throw new TypeError();
    var t = Object(this);
    var len = t.length >>> 0;
    if (typeof fun !== 'function')
        throw new TypeError();
    var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
    for (var i = 0; i < len; i++)
    {
      if (i in t && !fun.call(thisArg, t[i], i, t))
        return false;
    }
    return true;
  };
}

Array.prototype.some()

some()方法测试数组中的某些元素是否通过由提供的函数实现的测试。

与every的区别就是或||和与&&的区别

function isBiggerThan10(element, index, array) {
  return element > 10;
}
[2, 5, 8, 1, 4].some(isBiggerThan10);  // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true

Array.prototype.fill()

数组填充

arr .fill（value(填充的值)，start(开始索引，可选) ，end(结束索引)）

[1, 2, 3].fill(4);               // [4, 4, 4]
[1, 2, 3].fill(4, 1);            // [1, 4, 4]
[1, 2, 3].fill(4, 1, 2);         // [1, 4, 3]
[1, 2, 3].fill(4, 1, 1);         // [1, 2, 3]
[1, 2, 3].fill(4, -3, -2);       // [4, 2, 3]
[1, 2, 3].fill(4, NaN, NaN);     // [1, 2, 3]
Array(3).fill(4);                // [4, 4, 4]
[].fill.call({ length: 3 }, 4);  // {0: 4, 1: 4, 2: 4, length: 3}
[].fill.call(new Array(100),0) // [0,0,0,0,...,0] //100项

Array.prototype.map()

//数组每个平方
function pow(x) {
    return x * x;
}
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
arr.map(pow); // [1, 4, 9, 16, 25, 36, 49, 64, 81]

Array.prototype.reduce() Array.prototype.reduceRight()

按照某种规则减少数组的数量

//求和
var arr = [1, 3, 5, 7, 9];
arr.reduce(function (x, y) {
    return x + y;
}); // 25

//传统数组求和
Array.prototype.sum = function (){
 var result = 0;
 for(var i = 0; i < this.length; i++) {
  result += this[i];
 }
 return result;
};
[1,4,7,2,10].sum(); // 24

//不传统求和，在数组极长的时候效率会指数提高
eval([1,4,7,2,10].join('+'))//24

Array .prototype .filter()

过滤不符合要求的元素，filter是不会改变远数组的，有点类似every()，但every返回的是boolean

function isBigEnough(value) {
  return value >= 10;
}

var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
// filtered is [12, 130, 44]

Array.prototype.find()

find()方法返回数组中满足提供的测试功能的第一个元素的值。否则返回undefined。

//一个求素数函数
function isPrime(element, index, array) {
  var start = 2;
  while (start <= Math.sqrt(element)) {
    if (element % start++ < 1) {
      return false;
    }
  }
  return element > 1;
}

console.log([4, 6, 8, 12].find(isPrime)); // undefined, not found
console.log([4, 5, 8, 12].find(isPrime)); // 5

Array.prototype.findIndex()

findIndex()方法返回数组中满足提供的测试功能的第一个元素的索引。否则返回-1。与find方法十分的相似。

Array.prototype.findIndex()

Array.prototype.forEach()

function logArrayElements(element, index, array) {
  console.log('a[' + index + '] = ' + element);
}

// undefined的项会被略过。
[2, 5, , 9].forEach(logArrayElements);
// a[0] = 2
// a[1] = 5
// a[3] = 9

function Counter() {
  this.sum = 0;
  this.count = 0;
}
Counter.prototype.add = function(array) {
  array.forEach(function(entry) {
    this.sum += entry;
    ++this.count;
  }, this);
  // ^---- Note
};
var obj = new Counter();
obj.add([2, 5, 9]);
obj.count
// 3 
obj.sum
// 16

Array.prototype.includes()

includes()方法确定数组是否包含某个元素，返回true或false。

[1, 2, 3].includes(2);     // true
[1, 2, 3].includes(4);     // false
[1, 2, 3].includes(3, 3);  // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true

Array.prototype.indexOf()

indexOf()方法返回在数组中可以找到给定元素的第一个索引，如果不存在则返回-1。

var array = [2, 9, 9];
array.indexOf(2);     // 0
array.indexOf(7);     // -1
array.indexOf(9, 2);  // 2
array.indexOf(2, -1); // -1
array.indexOf(2, -3); // 0

Array.prototype.join()

把数组（或数组类对象）的所有元素连接到字符串中。

var a = ['Wind', 'Rain', 'Fire'];
a.join();      // 'Wind,Rain,Fire'
a.join(', ');  // 'Wind, Rain, Fire'
a.join(' + '); // 'Wind + Rain + Fire'
a.join('');    // 'WindRainFire'

Array.prototype.lastIndexOf()

Array.prototype.pop()

该pop()方法从数组中删除最后一个元素，并返回该元素。此方法更改数组的长度。

Array.prototype.push()

该push()方法将一个或多个元素添加到数组的末尾并返回数组的新长度。

Array.prototype.shift()

该shift()方法从数组中删除第一个元素并返回该元素。此方法更改数组的长度。

Array.prototype.unshift()

unshift()方法将一个或多个元素添加到数组的开头，并返回新数组的新长度。

Array.prototype.reserve()

该reverse()方法将阵列反转到位。第一个数组元素成为最后一个数组元素，最后一个数组元素成为第一个。

Array.prototype.splice()

array .splice（start，deleteCount，item1，item2，...）
//从下标start开始，删除deleteCount个元素，然后插入item1,item2...

通过删除现有元素和/或添加新元素来更改数组的内容。

Array.prototype.slice()

arr.slice(begin, end)
//begin,end可省略，默认为开始和结尾

把数组从begin到end（并不包括end）的部分浅拷贝到新的数组对象。原始数组不会被修改。

silce省略参数，可以把类数组的形式(具有length)转换到数组

function list() {
  return Array.prototype.slice.call(arguments);
}

var list1 = list(...[1,2,3,4]); // [1, 2, 3,4]

Array.prototype.sort()

sort()方法排序的数组的元素代替，并返回该数组。
参数为定义排序顺序的函数。如果省略，则根据每个字符的Unicode代码点值，根据每个元素的字符串转换对数组进行排序。

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


var items = [
  { name: 'Edward', value: 21 },
  { name: 'Sharpe', value: 37 },
  { name: 'And', value: 45 },
  { name: 'The', value: -12 },
  { name: 'Magnetic', value: 13 },
  { name: 'Zeros', value: 37 }
];
// sort by value
items.sort(function (a, b) {
  return a.value - b.value;
});
// sort by name
items.sort(function(a, b) {
  var nameA = a.name.toUpperCase(); // ignore upper and lowercase
  var nameB = b.name.toUpperCase(); // ignore upper and lowercase
  if (nameA < nameB) {
    return -1;
  }
  if (nameA > nameB) {
    return 1;
  }

  // names must be equal
  return 0;
});