Array 构造函数

Array.isArray(obj)

定义:判断传入对象是否未数组，如果是返回true，如果不是返回false
用法

function validate (a){
    Array.isArray(arguments);  //返回:false
    Array.isArray(a);  //返回true
}
var arr = [1, 2, 3];
validate(arr);

Array Prototype Methods

破坏性的:会改变原来数组
非破坏性:不会改变操作数组

添加或者移除元素(破坏性)

Array.prototype.shift()[ECMAScript 3]
- 定义:删除数组的第一个元素并将其返回,然后把随后的元素下移一个位置来填补数组头部的空缺.
- 用法
```
var arr = ['a', 'b'];
arr.shift(); // arr:['b'],返回'a'
```
Array.prototype.unshift(elem1?, elem2?, ...)[ECMAScript 3]
- 定义:在数组的头部添加一个或多个元素,并将已存在的元素移动到更高索引位置来获得足够的空间,返回数组新长度.
- 用法
```
var arr = ['a', 'b'];
arr.unshift('c',['d', 'e', 'f']); // arr:["c", ["d", "e", "f"], "a", "b"], 返回:4
```
- 注意点
  - 如果存在多个参数,则参数是一次性插入的,因此插入数组的元素顺序与他们在参数列表中的顺序一致.
  - 插入的元素可以是单个元素，也可以是一整个数组.
Array.prototype.pop()[ECMAScript 3]
- 定义:删除数组的最后一个元素,减小数组长度并返回它删除的值.
- 用法
```
var arr = ['a', 'b'];
arr.pop(); // arr:['a'],返回'b'
```
Array.prototype.push([elem1, elem2, ...])[ECMAScript 3]
- 定义:在数组的尾部添加一个或多个元素,并返回数组新长度.
- 用法
```
var arr = ['a', 'b'];
arr.push('c',['d', 'e', 'f']); // arr:["a", "b", "c", ["d", "e", "f"]], 返回:4
```
Array.prototype.splice(start[, deleteCount, elem1, elem2, ...])[ECMAScript 3]
- 定义:在数组中插入或者删除元素,最后返回一个由删除元素组成的数组,如果没有删除元素则返回一个空数组.
  - 从start开始，先删除deleteCount个元素，接着插入指定的elem1...元素，最后返回删除的元素.
- 参数介绍
  - 从start:插入或删除起始位置(必须),可以为0
  - deleteCount: 删除元素个数(可以省略),如果省略表示从起始开始到数组结束的所有元素都会被删除.
  - elem1,elem2...:第三个参数开始的任意多个参数指定了需要插入到数组中的元素(可以省略)。从第一个参数指定位置开始插入.
- 注意点:如果需要从某一位置开始插入数据，那么第二位参数不能省略，应该设置为0.
- 用法
```
var arr = ['a', 'b', 'c', 'd', 'e'];
arr.splice(3);   //从第三位开始,不指定第二个参数。 arr:['a', 'b', 'c'], 返回:["d", "e"]
// arr:['a', 'b', 'c']
arr.splice(1, 1, 'f', 'g', 'h'); //从第一位开始,删除一个元素,插入三个元素。 arr:["a", "f", "g", "h", "c"], 返回['b']
// arr:["a", "f", "g", "h", "c"]
arr.splice(0, 0, 'x', 'y', 'z');  // arr:["x", "y", "z", "a", "b", "c", "d", "e"], 返回:[]
```

排序与反转(破坏性)

Array.prototype.reverse()[ECMAScript 3]
- 定义:将数组中元素颠倒顺序，返回逆序的数组
- 用法
```
var arr = ['a', 'b', 'c'];
arr.reverse(); //arr:['c', 'b', 'd'],返回['c', 'b', 'd']
```

Array.prototype.sort([compareFunction])[ECMAScript 3]

定义:将数组中的元素排序并返回排序后的数组,如果不传递参数,则数组元素以字母表顺序排序。如果需要按其他方式排序，必须给sort()方法传递一个比较函数.
注意点
- 如果不传递参数,所有数组元素被转化成字符串,按照字母表顺序进行排序.
- 如果数组包含undefined元素,它们会被排到数组的末尾.
- 给sort传递一个比较函数function compareFunction(a, b):函数对a和b进行比较，并返回结果
  - 如果a < b,则返回一个负值(通常返回-1):表示第一个参数(a)在前
  - 如果a = b,则返回0
  - 如果a > b,则返回一个正值(通常返回1):表示第一个参数(a)在后
- 传递的比较函数只使用一次,因此使用匿名表达式
用法

// 不传递比较函数
var arr = ['apple', 'banana', 'pear', 'orange'];
arr.sort(); //arr:["apple", "banana", "orange", "pear"],返回:["apple", "banana", "orange", "pear"]
// 不传递比较函数:数字
var arr = [-1, -20, 50, 7];
arr.sort();  //arr:[-1, -20, 50, 7],返回:[-1, -20, 50, 7]
// 传递比较函数

几种常见比较－比较数字

function compareCanonically(a, b){
    return a < b ? -1 : (a > b ? 1 : 0);
}
var arr = [-1, -20, 50, 7];
arr.sort(compareCanonically);  // arr:[-20, -1, 7, 50],返回:[-20, -1, 7, 50]

－比较字符串:可以使用String.prototype.localeCompare

var arr = ['c', 'a', 'b'];
arr.sort(function(a , b){ return a.localeCompare(b);});  // arr:["a", "b", "c"],返回:["a", "b", "c"]

－比较对象

var arr = [
    {name: 'Tarzan'},
    {name: 'Cheeta'},
    {name: 'Jane'}];
function compareNames(a, b){
    return a.name.localeCompare(b.name);
}
arr.sort(compareNames); // arr:[{name: 'Cheeta'}, {name: 'Jane'}, {name: 'Tarzan'}].返回同arr

实现降序排列

var arr = [
    {name: 'Tarzan', age: 39},
    {name: 'Cheeta', age: 79},
    {name: 'Jane', age: 19}];
function compareAge(a, b){
    return a.age < b.age ? 1 : (a.age > b.age ? -1 : 0);
}
arr.sort(compareAge); // arr:[{name: 'Cheeta', age: 79}, {name: 'Tarzan', age: 39}, {name: 'Jane', age: 19}].返回同arr

链接与分割(非破坏性)

Array.prototype.concat([arr1, arr2, ...])[ECMAScript 3]
- 定义:创建并返回一个新数组.它的元素包括调用concat()的原始数组和传入concat()的每个参数.
- 注意点
  - 如果concat()传递的参数中的任何一个自身是数组,则链接的是数组元素,而非数组本身.
  - 如果concat()不传递任何参数则实现数组的复制(浅拷贝).
- 用法
```
var arr = ['a', 'b'];
arr.concat('c',['d', 'e']); // arr:["a", "b"],返回:["a", "b", "c", "d", "e"]
```
Array.prototype.slice([begin, end])[ECMAScript 3]
- 定义:返回指定数组的一个片段或子数组.返回的数组包含第一个参数指定的位置和所有到但不包含第二个参数指定位置之前的所有数组元素
- 参数
  - begin:片段的开始位置(包括)
  - end:片段的开始位置(不包括)
- 注意点
  - 如果只指定一个参数,返回的数组将包含从开始位置到数组结尾的所有元素.
  - 如果参数中出现负数,它表示相对于数组中最后一个元素的位置(任何一个出现负数都可以加上数组长度).-1表示倒数第一个元素(arr.length-1).
  - 如果两个参数都不指定，则表示复制数组(浅拷贝).
- 用法
```
var arr = ['a', 'b', 'c', 'd'];
arr.slice(1, 3); // 返回["b", "c"]
// 省略结束位置
arr.slice(1);  // 返回["b", "c", "d"]
// 没有传递参数:实现copy
arr.slice();  // 返回:['a', 'b', 'c', 'd']
// 只使用一个负数(-2+4=2),从index为2开始截取
arr.slice(-2); // 返回:["c", "d"]
arr.slice(1, -1); // 返回:["b", "c"]
```

Array.prototype.join([separator])[ECMAScript 3]

定义:将数组中所有元素都转化为字符串并链接在一起,返回最后生成的字符串.
参数
- separator(可选):字符串,在生成的字符串中来分割数组的各个元素.如果不指定默认为逗号(,)

注意点

Array.join()方法是String.split()方法的逆向操作。
Array.join()方法会将undefined和null转换为空字符串.

Array.join()方法会将数组中的空洞也转化为空字符串。

理解空洞:可以有两种方式创建一个hole

// 方式一
var arr = [];
    arr[0] = 'a';
    arr[2] = 'c';
1 in arr;  // false, hole at index 1
arr.length;  //3
// 方式二
var arr = ['a',,'c'];
1 in arr;   //false, hole at index 1
arr.length;   //3
// 如果最后一位是hole则会被忽略
var arr = ['a',];
arr.length;   // 1
var arr = ['a',,];
arr.length;  // 2

用法

var arr = [3, 4, 5];
arr.join();      // 返回:3,4,5
arr.join('-');  // 返回:3-4-5
arr.join('');  //返回:345
// 包含undefined和null
var arr = [3, undefined, 5, null, 7];
arr.join('-'); // 返回:3--5--7
// 包含hole
var arr = [3,, 5];
arr.join('-'); // 返回:3--5

元素查找(非破坏性)

Array.prototype.indexOf(searchValue[, startIndex])[ECMAScript 5]
- 定义:从给定位置开始向后搜索整个数组中具有给定值的元素,返回找到的第一个元素的索引,如果没找到则返回-1。
- 参数
  - searchValue(必须):需要搜索的值.
  - startIndex(可选):指定数组中一个索引,从哪个位置开始搜索.如果省略,则从第一个元素开始搜索。可以为负值,它代表相对数组末尾的偏移量.
- 注意点:查找过程中使用严格相等(===)进行相等判断.
- 用法
```
var arr = ['a', 'b', 'c', 'd', 'a'];
arr.indexOf('a',0); //返回:0
arr.indexOf('a',1); //返回:4
arr.indexOf('a',-1); //返回:4
arr.indexOf('b',-1); // 返回:-1
// true:'1' == 1; false: '1' === 1
var arr = ['1', 1, '2'];
arr.indexOf(1); //返回:1
```
Array.prototype.lastIndexOf(searchElement[, startIndex])[ECMAScript 5]
- 定义:从给定位置开始向前搜索整个数组中具有给定值的元素,返回找到的第一个元素的索引,如果没找到则返回-1。
- 参数
  - searchValue(必须):需要搜索的值.
  - startIndex(可选):指定数组中一个索引,从哪个位置开始搜索(包含该位置).如果省略,则从最后一个元素开始搜索。可以为负值,它代表相对数组末尾的偏移量(-1表示最后一位).
- 注意点:查找过程中使用严格相等(===)进行相等判断.
- 用法
```
var arr = ['b', 'a', 'c', 'd', 'a'];
arr.lastIndexOf('a',0); //返回:-1
arr.lastIndexOf('a',1); //返回:1
arr.lastIndexOf('a',-1); //返回:4
arr.lastIndexOf('c',-3); // 返回:2
```

迭代(非破坏性)

Array.prototype.forEach(callback[, thisValue])[ECMAScript 5]
- 定义:从头至尾遍历数组,为每个元素调用指定的函数.
- 参数
  - callback(必须):遍历每个元素时调用的函数,不返回数据
    - function callback(element, index, arr):接收3个参数
      - element:当前遍历元素
      - index: 当前遍历元素索引
      - arr: 遍历数组
  - thisValue(选填):用来当作callback函数内this的值的对象
- 注意点:forEach()无法在所有元素都传递给调用函数之前终止遍历.
- 用法
```
var arr = [1, 2, 3, 4];
var sum = 0;
arr.forEach(function(elem){
    sum += elem;
});
sum; //10
```
Array.prototype.every(callback[, thisValue])[ECMAScript 5]
- 定义:对数组元素应用指定的函数进行判定,返回true或false.当数组中每一个元素调用判定函数返回true,则返回true(可以理解所有元素都要满足)
- 参数
  - callback(必须):遍历每个元素时调用的函数,返回true或false
    - function callback(element, index, arr):接收3个参数
      - element:当前遍历元素
      - index: 当前遍历元素索引
      - arr: 遍历数组
  - thisValue(选填):用来当作callback函数内this的值的对象
- 注意点:确认返回什么值就会停止遍历数组元素.
  - every()函数中传递的callback一旦返回false，就停止遍历数组元素.(因为一旦有一个callback返回false,则false()方法就会返回false).
  - 在空数组上调用时,返回true。
- 用法
```
function isEven(x){
   return x % 2 === 0;
}
var arr = [1, 3, 4];
arr.every(isEven); //返回:false
var evenArr = [2, 4, 6];
evenArr.every(isEven); //返回:true
var arr = [];
arr.every(isEven); //返回:true
```
Array.prototype.some(callback[, thisValue])[ECMAScript 5]
- 定义:对数组元素应用指定的函数进行判定,返回true或false.当数组中至少有一个元素调用判定函数返回true,则返回true(可以理解为至少有一个满足)
- 参数
  - callback(必须):遍历每个元素时调用的函数,返回true或false
    - function callback(element, index, arr):接收3个参数
      - element:当前遍历元素
      - index: 当前遍历元素索引
      - arr: 遍历数组
  - thisValue(选填):用来当作callback函数内this的值的对象
- 注意点:确认返回什么值就会停止遍历数组元素.
  - some()函数中传递的callback一旦返回true，就停止遍历数组元素.(因为一旦有一个callback返回true,则some()方法就会返回true).
  - 在空数组上调用时,返回false。
- 用法
```
function isEven(x){
    return x % 2 === 0;
}
var arr = [1, 3, 4];
arr.some(isEven); //返回:true
var arr = [];
arr.some(isEven); //返回:false
```
Array.prototype.map(callback[, thisValue])[ECMAScript 5]
- 定义:将调用的数组的每个元素传递给指定的函数,并返回一个数组,它包含该函数的返回值.
- 参数
  - callback(必须):遍历每个元素时调用的函数,返回数据
    - function callback(element, index, arr):接收3个参数
      - element:当前遍历元素
      - index: 当前遍历元素索引
      - arr: 遍历数组
  - thisValue(选填):用来当作callback函数内this的值的对象
- 注意点
  - map()方法传递的函数返回一个新数组，不修改调用数组.
  - 如果原数组是一个稀疏数组,则返回一个相同的具有相同长度,相同缺失元素的稀疏数组.
- 用法
```
var arr = [1, 2, 3, 4];
arr.map(function(elem){
    return 2*elem;
}); //返回:[2, 4, 6, 8]
```
Array.prototype.filter(callback[, thisValue])[ECMAScript 5]
- 定义:返回的数组是调用的数组的一个子集(callback返回值==true的元素)
- 参数
  - callback(必须):遍历每个元素时调用的函数,该函数是用来进行逻辑判断的.返回true或false
    - function callback(element, index, arr):接收3个参数
      - element:当前遍历元素
      - index: 当前遍历元素索引
      - arr: 遍历数组
  - thisValue(选填):用来当作callback函数内this的值的对象
- 注意点:filter()会跳过稀疏数组中缺少的元素,它返回的数组重视稠密的,因此可以用来压缩稀疏数组中的空缺.
- 用法
```
// 压缩稀疏数组(arr)的空缺
var arr = ['a', ,'c', 'd']  // ["a", 2: "c", 3: "d"]
arr.filter(function(){
   return true;
}); // 返回:['a', 'c', 'd']
// 压缩或者删除undefined和null元素
var arr = ['a', 'b', undefined, null];
arr.filter(function(elem){
   return elem !== undefined && elem != null;
});  // 返回:['a', 'b']
```

缩减

Array.prototype.reduce(callback[, initialValue])[ECMAScript 5]
- 定义:使用指定的函数将数组进行组合,生成单个值。
- 参数
  - callback(必须):指定化简操作的函数.其作用是用某种方法把两个值组合或化简为一个值,并返回化简后的值。
    - function callback(param1, param2, param3, param4)
      - param1: 到目前为止化简操作累积对的结果,第一次调用函数时，该值为一个初始值(如果reduce有第二个参数，则为第二个参数，如果没有，则为数组的第一个元素)
      - param2: 数组元素
      - param3: 数组元素索引
      - param4: 数组本身
  - initialValue(可选):传递给函数一个初始值。
- 注意点
  - 当不指定初始值调用reduce()时,它将使用数组的第一个元素作为其初始值。
  - 在空数组上，不带初始值参数调用reduce()将导致类型错误异常.
  - 如果在空数组上，传递传递一个初始值，则reduce()返回初始值,而不调用简化函数(callback).
  - 如果在只有一个元素的数组上不传递初始值，则reduce()返回初始值而不调用简化函数(callback).
- 用法
```
function add(prev, cur){
    return prev + cur;
}
var arr = [10, 3, -1];
arr.reduce(add); //返回:12
var arr = [1];
arr.reduce(add); // 返回:1
var arr = [];
arr.reduce(add, 1); // 返回:1
```
Array.prototype.reduceRight(callback[, initialValue])[ECMAScript 5]
- 定义:按照数组索引从高到低(从右到左)处理数组。其工作原理同reduce();
- 用法
```
function pow(pre, cur){
    return Math.pow(pre, cur);
}
var arr = [1, 2, 3];
arr.reduce(pow); //返回:1((1^2)^3)
arr.reduceRight(pow); //返回:9((3^2)^1)
```

转换(非破坏性)

Array.prototype.toString()[ECMAScript 3]
- 定义: 将其每个元素转化为字符串,并且输入用逗号分割的字符串列表。返回转换后字符串。
- 注意点
  - 输出不包括方括号和其他任何形式的包裹数组值的分隔符。
  - 与调用不使用任何参数的join()返回的字符串一样。
  - Object.prototype的方法
- 用法
```
var arr = ['a', 'b', 'c', 'd'];
arr.toString(); //返回:a,b,c,d
```
Array.prototype.toLocaleString()[ECMAScript 3]
- 定义:toString()方法的本地化版本。
- 注意点:Object.prototype的方法

ECMAScript 6

兼容性

根据在MDN查到的兼容性，感觉不是特别准确，因为在本地chrome浏览器测试，只有values()方法不支持，其他都可以。

static方法

Array.from(arrayLike[, mapFunc, thisArg])
- 定义:用于将两类对象(类数组对象:array-like object;可遍历对象:iterable)转为真正的数组.
- 参数:
- 注意点
  - 常见类数组对象:DOM操作返回的NodeList集合、arguments对象等。
  - 类数组对象:具有index和length。
  - 可遍历对象:Set 和 Map
- 浏览器兼容性
  - PC:Chrome(45)、Firefox(32)、IE(未实现)、Opera(未实现)、Safari(9.0)
  - mobile:除了FF Mobile(32)其他都未实现
- 用法
```
<body>
    <ul>
        <li>1</li>
        <li>2</li>
        <li>3</li>
    </ul>
    <script>
        var liEle = document.getElementsByTagName('li');
        Array.from(liEle).forEach(function(item, index){
            item.innerHTML = 'array-' + (index + 1);
        });
    </script>
</body>
```
Array.of(item0, item1, ...)
- 定义:用于将一组值，转换为数组。
- 注意点
  - 这个方法主要是弥补数组构造函数Array()的不足，参数个数的不同会导致Array()返回不同结果
```
Array();  // [],length:0
Array(3);  // [],length:3
Array(3, 11, 8);  // [3, 11, 8]
```
  - Array.of()可以用来替代Array()或new Array().并且布存在由于参数不同而导致的重载.
  - Array.of()总是返回参数值组成的数组,如果没有参数就返回一个空数组.
- 浏览器兼容性
  - PC:Chrome(45)、Firefox(25)、IE(未实现)、Opera(未实现)、Safari(未实现)
  - mobile:除了FF Mobile(25)和Chrome for Android(39)其他都未实现
- 用法
```
Array.of();  // []
Array.of(3);  // [3]
Array.of(3, 11, 8);  // [3, 11, 8]
```

prototype方法

迭代(非破坏性)

定义:三个方法都是用于遍历数组，返回一个遍历器对象(可以使用for..of进行遍历,也可以使用next()方法遍历)
区别
- Array.prototype.entries():对键值对的遍历
  - 浏览器兼容性
    - PC:Chrome(38)、Firefox(28)、IE(未实现)、Opera(25)、Safari(7.1)
    - mobile:除了FF Mobile(28)和 Safari Mobile(iOS 8 )其他都未实现
- Array.prototype.keys():对键名的遍历
  - 浏览器兼容性
    - PC:Chrome(38)、Firefox(28)、IE(未实现)、Opera(25)、Safari(7.1)
    - mobile:除了FF Mobile(28)和 Safari Mobile(iOS 8 )其他都未实现
- Array.prototype.values():对键值的遍历。[没有浏览器支持]

用法

"use strict";

var indexArr = ['a', 'b'].keys();  // 迭代对象
indexArr.next().value;  // 0
indexArr.next().value;   // 1
let letter = ['a', 'b', 'c'];
let entries = letter.entries();
entries.next().value; // [0, 'a']
entries.next().value; // [1, 'b']
entries.next().value; // [2, 'c']

查询(非破坏性)

Array.prototype.find(predicate[, thisArg])
- 定义:找出第一个符合条件的数组成员。所有数组成员调用predicate函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined.
- 参数
  - predicate:回调函数.所有数组成员依次执行该回调函数。
    - function predicate(value, index, arr)
      - value:当前数组元素
      - index:当前数组元素的index
      - arr: 数组本身－ thisArg(可选):用来绑定回调函数的this对象
- 注意点:借助Object.is()方法可以查到NaN.
- 浏览器兼容性
  - PC:Chrome(未实现)、Firefox(25)、IE(未实现)、Opera(未实现)、Safari(未实现)[但是我的chrome可以:47+]
  - mobile:除了FF Mobile(25)其他都未实现
- 用法
```
var arr = [6, -5, 8];
arr.find(function(value){
    return value < 0;
}); //返回-5
arr.find(function(value){
 return value > 10;
}); //返回undefined
var arr = [6, -5, 8, NaN];
arr.find(function(value){
    return Object.is(NaN, value);
}); //返回NaN
```
Array.prototype.findIndex(predicate[, thisArg])
- 定义:同find方法类似,只是它返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1.
- 注意点:借助Object.is()方法可以查到NaN.
- 参数:同find函数
- 浏览器兼容性
  - PC:Chrome(未实现)、Firefox(25)、IE(未实现)、Opera(未实现)、Safari(未实现)[但是我的chrome:47+可以]
  - mobile:除了FF Mobile(25)其他都未实现
- 用法
```
var arr = [6, -5, 8, NaN];
arr.findIndex(function(value){
    return  Object.is(NaN, value);
}); //返回3
arr.findIndex(function(value){
    return  value > 10;
}); //返回-1
```
Array.prototype.includes(value, start)
- 定义:判定数组是否包含给定值
- 参数
  - value:指定要查找的值
  - start(可选):搜索的起始位置,默认为0。如果为负值,表示相对于最后一位元素。
- 注意点
  - 如果第二个参数的绝对值(负数情况)大于数组长度，则会重置为0.
- 兼容性
  - PC:Chrome(47)、Firefox(43)、IE(未实现)、Opera(34)、Safari(9)
  - mobile:Android(未实现)、Android Webview(47)、FF Mobile(43)、IE Mobile(未实现)、Opera Mobile(34)、Safari Mobile(9)、Chrome for Android(47)
- 用法
```
[1, 2, 3].includes(3,-3);     // 返回:true
[1, 2, 3].includes(3,-5);     //返回:true
[1, 2, 3].includes(4);     // 返回:false
[1, 2, NaN].includes(NaN); // 返回:true
```

其它(破坏性)

Array.prototype.copyWithin(target, start, end)
- 定义: 将指定位置([start, end))的元素复制到其他位置(target开始),然后返回当前数组.
- 参数:这三个参数都应该是数值,如果不是,会自动转为数值.
  - target(必须):从该位置开始替换元素
  - start(可选):从该位置开始读取数据,默认为0。如果为负值,表示相对于最后一位元素。
  - end(可选):到该位置前停止读取数据,默认等于数组长度.如果为负值,表示相对于最后一位元素.
- 注意点
  - 如果start大于等于length,或者start大于等于end,则数组不变.
  - 如果参数为负值，则表示相对于最后一位,index = 参数+length
- 浏览器兼容性
  - PC:Chrome(未实现)、Firefox(31)、IE(未实现)、Opera(未实现)、Safari(未实现)
  - mobile:除了FF Mobile(31)其他都未实现
- 用法
```
var arr = [1, 2, 3, 4, 5];
// 从index=3开始查找元素，到index=4.则查找元素为4,5.从index为0开始替换
arr.copyWithin(0, 3, 5);  //返回:[4, 5, 3, 4, 5];arr:[4, 5, 3, 4, 5]
```
Array.prototype.fill(value, start, end)
- 定义:使用给定值填充数组.
- 参数:[start, end)
  - value(可选):指定要替换的值，如果不传递，则默认为undefined.
  - start(可选):从该位置开始填充数据,默认为0,如果为负值,表示相对于最后一位元素。
  - end(可选):到该位置前停止填充数据,默认等于数组长度,如果为负值,表示相对于最后一位元素.
- 注意点
  - fill方法用于空数组的初始化非常方便，数组中已有的元素会全部被抹去.
- 用法
```
var arr = [1, 2, 3, 4, 5];
arr.fill('*', 1, 2); //返回:[1, "*", 3, 4, 5],arr:[1, "*", 3, 4, 5]
arr.fill(); //返回:[undefined, undefined, undefined, undefined, undefined],arr一样
```

参考资料

javascript权威指南(犀牛书)
speaking javascript
阮一峰:ECMAScript6入门
ECMAScript6数组新特性
MDN