js对象 数组Array详解 （参照MDN官网：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find）

一：数组的创建方式：
　　1、采用直接量创建

　　var arr = [];//创建一个空数组

　　var arr2 = [1,2,3];//创建一个有三个元素的数组

　　2、采用构造函数创建

　　a、var arr1 = new Array();//创建空数组
　　
　　b、var arr2 = new Array(10)；//创建一个长度为10的数组

　　c、var arr3 =  new Array(5,4,3,2,1)；//创建数组并初始化
二：数组的方法
　　据最新的chrome浏览器提供的方法可以在控制台看到：
　　
接下来就一一讲解：
　　1.Array.prototype.concat（）方法：

　　　　concat() 方法用于连接两个或多个数组。该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。

　　　　var m = [1,2,3,4,5];
　　　　document.write(a.concat(6,8));//1,2,3,4,5,6,8

　　　　var n=[4,5,6];

　　　　console.log(m.concat(n))//1,2,3,4,5,4,5,6;

　　.constructor:当前数组通过__proto__指向Array这个构造函数的prototype,这个构造函数就是他自己Array,数组的所有方法都是通过继承数组Array原型得到的

　　2.Array.prototype.entries()方法：

　　　   var ary=[1,2,3,4,5,6];
　　　   var ary2=ary.entries();  
　　　   console.log(ary);
　  　　 console.log(ary2);//Array Iterator返回一个数组迭代器  ，这个迭代器的原型上有next方法
　 　　　console.log(ary2.next());//Object {value: Array[2], done: false}  value:Array[2] ----[0:0,1:1];
　　　　 console.log(ary2.next());//Object {value: Array[2], done: false}  value:Array[2] ----[0:1,1:2];
　　　　//可以看出每次执行这个next().都会返回一个该数组的索引和值组成的新的数组，被包在一个对象的value属性里
　　　　//所以可以通过ary2.next().value获取当前的值和索引
 3.Array.prototype.every()方法：

　　　　every() 方法用于检测数组所有元素是否都符合指定条件（通过函数提供）。

　　　　every() 方法使用指定函数检测数组中的所有元素：如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。如果所有元素都满足条件，则返回 true。

　　　　注意： every() 不会对空数组进行检测。

　　　　注意： every() 不会改变原始数组。

　　　　array.every(function(Value,index,arr), obj)

 　　该函数接受五个参数第一个function，返回boolea值，就是通过every方法里面函数进行去判断，所以function是必须的，
　　　 第二个参数就是Value,当前数组循环比较的每一项值，第三个index就是该值对应的索引，第四个arr就是当前元素所在的数组，第五个参数就是可以改变function关键字的，如果不传默认的this就是window,如果传入值，那this就是你传入的值，用作 "this" 的值。

　　　 除了函数和当前值value，其他的参数都是可选　　
　　　　以下事例传入了所有参数，返回是值是要求element>3的，所以当第一个值的时候1就不满足条件，直接返回了false
　　　　var ary=[1,2,3,4,5,6];
　　　　ary.every(function(element,index,array){
　　　　   console.log(element);//1
  　　　　 console.log(index);//0
  　　　　 console.log(array);//[1,2,3,4,5,6]
  　　　　 console.log(this);//[1,2,3,4,5,6]
  　　　　 return  element>3;
 　　　　},ary);

　　　　　以下事例传入了不传this对应的参数，返回是值是要求element<3的，所以当这个值是3的时候就不满足条件，才返回了false
　　　　var ary=[1,2,3,4,5,6];
　　　　ary.every(function(element,index,array){
　　　　   console.log(element);//1,2,3
  　　　　 console.log(index);//0,1,2
  　　　　 console.log(array);//[1,2,3,4,5,6]
  　　　　 console.log(this);//window
  　　　　 return  element<3;
 　　　　});


　　　　console.log( ary.every(function(element,index,array){
    　　　　console.log(element);
   　　　　 console.log(index);
   　　　　 console.log(array);
    　　　　console.log(this);
    　　　　return  element<3;
}　　　　));//false
4.Array.prototype..fill()方法：
此方法就是给数组填充值
fill(value,start,end)
有三个参数,value:就是需要填充的值，start需要填充起始位置，默认从0开始，负数就是倒数位置开始，end就是结束为止，默认就是数组的length，后两个参数可选
[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]
5.Array.prototype.filter()方法：
返回数组，包含了符合条件的所有元素。如果没有符合条件的元素则返回空数组。
ary.filter(function(Value, index,arr),this)
该方法有执行函数function,内部参数有数组的每项值，以及对应的索引，和该数组，后两个可选，this这个参数就是执行function的时候，内部的this指向；
注意： filter() 不会对空数组进行检测， filter() 不会改变原始数组。
//过滤掉大于 10 的数组元素：

function isBig(element, index, array) {
    return (element >= 10);
}
var filary = [12, 5, 8, 13, 40].filter(isBig);
console.log(filary);// 12, 13, 40
//数组的每一项执行这个方法，把比较完后的值放到一个新数组，执行完之后，把这个数组在返回出来赋值给这个filary变量接受；
6.Array.prototype.find()方法：
找出数组中满足条件的第一个值，如果存在就返回，如果不存在就返回undefined.
arr.find(callback(element,index,array));
callback:需要比较处理的函数，element，数组当前传进的每一项值，array当前数组；
function isBigEnough(element) {
  return element >= 15;
}

[12, 5, 8, 130, 44].find(isBigEnough); // 130  返回满足条件的第一个值
function isBigEnough(element) {
  return element >= 150;//这个值改为150，数组中的每一项都不满足条件
}

[12, 5, 8, 130, 44].find(isBigEnough); //都不满足条件，返回undefined
也可以对数组中的对象进行find方法
ar inventory = [
    {name: 'apples', quantity: 2},
    {name: 'bananas', quantity: 0},
    {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
    return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries)); 
// { name: 'cherries', quantity: 5 }

在数组中可以找一个期望值：
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
7.Array.prototype.findIndex()方法：
和上面的find方法对应，上面函数返回第一个满足条件的值，这个函数是返回满足条件的值在数组中的索引，如果不存在就返回-1；
function isBigEnough(element) {
  return element >= 15;
}

[12, 5, 8, 130, 44].find(isBigEnough); // 3  返回满足条件的第一个值的索引值


function isBigEnough(element) {
  return element >= 150;//这个值改为150，数组中的每一项都不满足条件
}

[12, 5, 8, 130, 44].find(isBigEnough); //都不满足条件，返回-1
8.Array.prototype.forEach()方法：
该方法对数组中的每一项对提供的函数执行一次。


arr.forEach(function callback(currentValue, index, array) {
    //your iterator
}[, thisArg]);
callback:需要执行的函数，element，数组当前传进的每一项值，array当前数组；
注意：该函数没有返回值，返回值都是undefined。


 


var a = ['a', 'b', 'c'];

a.forEach(function(element) {
    console.log(element);
});

// a
// b
// c
每一项都执行一次function,一次输出每一项。


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

// Notice that index 2 is skipped since there is no item at
// that position in the array.
[2, 5, , 9].forEach(logArrayElements);
// logs:
// a[0] = 2
// a[1] = 5
// a[3] = 9


　9.Array.prototype.includes()的方法：


　　该方法用来判断数组中是否包含某一个值，如果包含返回true，如果不包含，返回false;


　　arr.includes(searchElement)
　　arr.includes(searchElement, fromIndex)


　　该方法有两个参数,第一个就是需要查找的值，第二个就是从数组那个索引开始查找


　　var a = [1, 2, 3]; a.includes(2); // true    a.includes(4); // 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


10.Array.prototype.indexOf()方法：


　　参数和includes类似


 


　arr.indexOf(searchElement)
　arr.indexOf(searchElement, fromIndex)；
  第一个参数，就是需要查询的值，第二个参数就是从数组那个位置开始查找，　　

  该方法就是判断数组中是否有该值，如果存在，就将该值在数组中的索引值返回，如果不存在就返回-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
11.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'；

12.Array.prototype.keys()方法：
该方法不需要参数。
该方法返回的是一个新的数组，数组里每一项都是含有每项索引值的对象。
例如：


var arr = ['a', 'b', 'c'];
var iterator = arr.keys();
console.log(iterator.next()); // { value: 0, done: false }
console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: undefined, done: true }
13.Array.prototype.lastIndexOf()方法：
该方法与indexof类似，查找元素是从数组的最后一项往第一项找，而indexOf是从数组的第一项开始找。如果存在该值，就返回当前值的索引值，如果不存在，就返回-1
也是有两个参数：
arr.indexOf(searchElement)
arr.indexOf(searchElement, fromIndex)；
第一个参数，就是需要查询的值，第二个参数就是从数组那个位置开始查找，　　


var numbers = [2, 5, 9, 2];
numbers.lastIndexOf(2); // 3
numbers.lastIndexOf(7); // -1；
14.Array.prototype.map()方法：
该方法将会将数组的每一项按照function执行，将执行结果放到一个新数组，然后将这个数组返回到外部。


var new_array = arr.map(callback[, thisArg])；


callback:需要执行的函数，thisArg:element，数组当前传进的每一项值，index:每一项的索引，array当前数组；


var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);
// roots is now [1, 2, 3]
// numbers is still [1, 4, 9]


var kvArray = [{key: 1, value: 10}, 
               {key: 2, value: 20}, 
               {key: 3, value: 30}];

var reformattedArray = kvArray.map(function(obj) { 
   var rObj = {};
   rObj[obj.key] = obj.value;
   return rObj;
});

// reformattedArray is now [{1: 10}, {2: 20}, {3: 30}], 

// kvArray is still: 
// [{key: 1, value: 10}, 
//  {key: 2, value: 20}, 
//  {key: 3, value: 30}]


var numbers = [1, 4, 9];
var doubles = numbers.map(function(num) {
  return num * 2;
});

// doubles is now [2, 8, 18]
// numbers is still [1, 4, 9]




var elems = document.querySelectorAll('select option:checked');
var values = Array.prototype.map.call(elems, function(obj) {
  return obj.value;
});


 


var str = '12345';
Array.prototype.map.call(str, function(x) {
  return x;
}).reverse().join(''); 
15.Array.prototype.pop()方法：
该方法作用就是删除数组的最后一项，返回结果是被删除的值。
该方法没有参数。


var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];

var popped = myFish.pop();

console.log(myFish); // ['angel', 'clown', 'mandarin' ] 

console.log(popped); // 'sturgeon'
16.Array.prototype.push()方法：
该方法是给当前数组末尾加单个或者多个值。返回数组的新长度。


arr.push([element1[, ...[, elementN]]]);


var sports = ['soccer', 'baseball'];
var total = sports.push('football', 'swimming');

console.log(sports); // ['soccer', 'baseball', 'football', 'swimming']
console.log(total);  // 4

利用appl也可以合并两个数组


var vegetables = ['parsnip', 'potato'];
var moreVegs = ['celery', 'beetroot'];

// Merge the second array into the first one
// Equivalent to vegetables.push('celery', 'beetroot');
Array.prototype.push.apply(vegetables, moreVegs);

console.log(vegetables); // ['parsnip', 'potato', 'celery', 'beetroot'];
17.Array.prototype.reduce()方法：


　　reduce() 方法接收一个函数作为累加器（accumulator），数组中的每个值（从左到右）开始合并，最终为一个值。


参数callback


执行数组中每个值的函数，包含四个参数
previousValue
上一次调用回调返回的值，或者是提供的初始值（initialValue）
currentValue
数组中当前被处理的元素
index
当前元素在数组中的索引
array
调用 reduce 的数组
initialValue
作为第一次调用 callback 的第一个参数。


reduce 为数组中的每一个元素依次执行回调函数，不包括数组中被删除或从未被赋值的元素，接受四个参数：初始值（或者上一次回调函数的返回值），当前元素值，当前索引，调用 reduce 的数组。


回调函数第一次执行时，previousValue 和 currentValue 可以是一个值，如果 initialValue 在调用 reduce 时被提供，那么第一个 previousValue 等于 initialValue ，并且currentValue 等于数组中的第一个值；如果initialValue 未被提供，那么previousValue 等于数组中的第一个值，currentValue等于数组中的第二个值


例如执行下面的代码


[0,1,2,3,4].reduce(function(previousValue, currentValue, index, array){
  return previousValue + currentValue;
});


回调被执行四次，每次的参数和返回值如下表：








 previousValuecurrentValueindexarrayreturn value








first call
0
1
1
[0,1,2,3,4]
1







second call
1
2
2
[0,1,2,3,4]
3







third call
3
3
3
[0,1,2,3,4]
6







fourth call
6
4
4
[0,1,2,3,4]
10
































　　例子:将数组所有项相加：


var total = [0, 1, 2, 3].reduce(function(a, b) {
    return a + b;
});
// total == 6；


　　例子: 数组扁平化：


　　var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
　　    return a.concat(b);
　　});
　　// flattened is [0, 1, 2, 3, 4, 5]；


18.Array.prototype.reduceRight()方法：
reduce方法是从左到右，而reduceRight()从右到左形成累加器；
var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) { return a.concat(b); }, []); // flattened is [4, 5, 2, 3, 0, 1]；


执行数组中每个值的函数，包含四个参数
previousValue
上一次调用回调返回的值，或者是提供的初始值（initialValue）
currentValue
数组中当前被处理的元素
index
当前元素在数组中的索引
array
调用 reduce 的数组
initialValue
作为第一次调用 callback 的第一个参数。


[0, 1, 2, 3, 4].reduceRight(function(previousValue, currentValue, index, array) {
  return previousValue + currentValue;
});
每一次执行对应的参数：






callbackpreviousValuecurrentValueindexarrayreturn value




first call
4
3
3
[0, 1, 2, 3, 4]
7



second call
7
2
2
[0, 1, 2, 3, 4]
9



third call
9
1
1
[0, 1, 2, 3, 4]
10



fourth call
10
0
0
[0, 1, 2, 3, 4]
10






 


[0, 1, 2, 3, 4].reduceRight(function(previousValue, currentValue, index, array) {
  return previousValue + currentValue;
}, 10);//提供初始值10，执行结果





callbackpreviousValuecurrentValueindexarrayreturn value




first call
10
4
4
[0, 1, 2, 3, 4]
14



second call
14
3
3
[0, 1, 2, 3, 4]
17



third call
17
2
2
[0, 1, 2, 3, 4]
19



fourth call
19
1
1
[0, 1, 2, 3, 4]
20



fifth call
20
0
0
[0, 1, 2, 3, 4]
20











19.Array.prototype.reverse()方法：
该方法将数组的每一项反向，将第一个放到最后，最后一个放到最前，将整个数组倒序排列：
无参数；
var a = ['one', 'two', 'three']; a.reverse(); console.log(a); // ['three', 'two', 'one']
var a = ['one', 'two', 'three']; var reversed = a.reverse(); console.log(a); // ['three', 'two', 'one'] console.log(reversed); // ['three', 'two', 'one']；
//会改变原来的数组；
20.Array.prototype.shift()方法：
该方法就是删除数组的第一项；
无参数；


var a = [1, 2, 3];
var b = a.shift();

console.log(a); // [2, 3]
console.log(b); // 1


var myFish = ['angel', 'clown', 'mandarin', 'surgeon']; console.log('myFish before:', myFish);
 // myFish before: ['angel', 'clown', 'mandarin', 'surgeon'] ；

var shifted = myFish.shift(); console.log('myFish after:', myFish); // myFish after: ['clown', 'mandarin', 'surgeon']
 console.log('Removed this element:', shifted); // Removed this element: angel 
21.Array.prototype.slice()方法：
该方法用来复制数组，可以复制其中一段，也可以全部复制；


arr.slice()
arr.slice(begin)
arr.slice(begin, end)


参数：begin,end
begin:复制数组的起始位置，可以是负数，负数就是数组长度+begin的位置开始复制，正数就是索引值；
end:复制数组的终点位置，可以是负数，负数就是数组长度+begin的位置复制终点，正数就是索引值；但是不包含该索引位置的值；
例如：
[1,2,3,4,5,6].slice(1,4)//[2, 3, 4];
[1,2,3,4,5,6].slice(-1,-3)//[]  起始位置6+（-1）=5  结束位置：6+（-3）=3；起始位置比结束位置索引值都大，故返回[];


[1,2,3,4,5,6].slice(-3,-1)//[4,5]  起始位置6+（-3）=3  结束位置：6+（-1)=5，返回[4,5];
22.Array.prototype.some()方法：
该方法验证数组的每一项中是否满足callback函数的条件，只要有一个满足，就返回true，否则返回false;
arr.some(callback[, thisArg])
参数：
callback：数组每一项回调的函数；
value：每一次调用函数的当前值；
index:当前值的索引；
array:当前值所在数组；


function isBiggerThan10(value, index, array) {
  return value > 10;
}

[2, 5, 8, 1, 4].some(isBiggerThan10);  // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true


 


var fruits = ['apple', 'banana', 'mango', 'guava'];

function checkAvailability(arr, val) {
  return arr.some(function(arrVal) {
    return val === arrVal;
  });
}
checkAvailability(fruits, 'kela');   // false
checkAvailability(fruits, 'banana'); // true
23.Array.prototype.sort()方法：
该方法对数组进行排序，默认按照转化为Unicode码之后的大小进行排序；
参数：可以包含一个callback；


var fruit = ['cherries', 'apples', 'bananas'];
fruit.sort(); // ['apples', 'bananas', 'cherries']

var scores = [1, 10, 21, 2]; 
scores.sort(); // [1, 10, 2, 21]
// Note that 10 comes before 2,
// because '10' comes before '2' in Unicode code point order.

var things = ['word', 'Word', '1 Word', '2 Words'];
things.sort(); // ['1 Word', '2 Words', 'Word', 'word']
// In Unicode, numbers come before upper case letters,
// which come before lower case letters.



function compareNumbers(a, b) {
  return a - b;
}



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 = ['réservé', 'premier', 'cliché', 'communiqué', 'café', 'adieu'];
items.sort(function (a, b) {
  return a.localeCompare(b);
});

// items is ['adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé']


24.Array.prototype.splice()方法：
splice方法，根据传入的参数不同，可以实现多个功能，其基本功能就是用新的元素替换已存在的数组元素；
有三个参数：


array.splice(start)
array.splice(start, deleteCount)；
array.splice(start, deleteCount, item1, item2, ...)
start：表示替换的起点元素index值；必须；
deletecount:删除的个数，如果是0 ，则不删除，将需要替换的元素追加到start参数后面；
item1，item2..:表示需要替换的新元素
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];

myFish.splice(2, 0, 'drum'); 
// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"]

myFish.splice(2, 1); 
// myFish is ["angel", "clown", "mandarin", "sturgeon"]


var myFish = ['angel', 'clown', 'trumpet', 'sturgeon'];
var removed = myFish.splice(0, 2, 'parrot', 'anemone', 'blue');

// myFish is ["parrot", "anemone", "blue", "trumpet", "sturgeon"] 
// removed is ["angel", "clown"]
25.Array.prototype.toLocaleString()方法：
作用：把数组转换为本地字符串。
说明：首先调用每个数组元素的 toLocaleString() 方法，然后使用地区特定的分隔符把生成的字符串连接起来，形成一个字符串。


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

document.write(arr.toLocaleString())；


var number = 1337;
var date = new Date();
var myArr = [number, date, 'foo'];

var str = myArr.toLocaleString(); 

console.log(str); 
// logs '1337,6.12.2013 19:37:35,foo'


26.Array.prototype.toString()方法：


作用：把数组转换为字符串。




var months = ['Jan', 'Feb', 'Mar', 'Apr'];
months.toString(); // "Jan,Feb,Mar,Apr"


27.Array.prototype.unshift()方法：
作用：给数组的开始添加元素；
参数：需要添加的值；，返回新数组的长度；


var a = [1, 2, 3];
a.unshift(4, 5);

console.log(a); // [4, 5, 1, 2, 3]


var arr = [1, 2];

arr.unshift(0); // result of call is 3, the new array length
// arr is [0, 1, 2]

arr.unshift(-2, -1); // = 5
// arr is [-2, -1, 0, 1, 2]

arr.unshift([-3]);
// arr is [[-3], -2, -1, 0, 1, 2]


　　28.Array.prototype.copyWithin（）方法：


　　　　数组实例的copyWithin方法，在当前数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组。也就是说，使用这个方法，会修改当前数组。


　　　　它接受三个参数。

　　　　target （必需）：从该位置开始替换数据。

　　　　start （可选）：从该位置开始读取数据，默认为 0 。如果为负值，表示倒数。

　　　　end （可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示倒数。
这三个参数都应该是数值，如果不是，会自动转为数值(当前值减一的位置，不包含该位置的值)


　　　　


　　　　var ary=[1,2,3,4,5,6];
　　　　var ary2=ary.copyWithin(0,3,5);
　　　　console.log(ary);//[4, 5, 3, 4, 5, 6]
　　　　console.log(ary2);//[4, 5, 3, 4, 5, 6]


　　　　var ary=[1,2,3,4,5,6];
　　　　var ary2=ary.copyWithin(0,-3,-1);  // -3起始位置，-1终点位置，截取为4,5,然后替换的位置从0开始，替换了1,2
　　　　console.log(ary);[4, 5, 3, 4, 5, 6]
　　　　console.log(ary2);[4, 5, 3, 4, 5, 6]


　　　　


　　29.Array.prototype.join()方法：


　　　　join() 方法用于把数组中的所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的。如果什么都不写，默认是按照逗号分隔；


　　　　var  b=[4,5,6];


　　　　str=b.join()//4,5,6


　　　　str=b.join("")//456


　　　　str=b.join(" ")//4 5 6


　　　　str=b.join("-")//4-5-6


　　　　这个方法和String的split()对应


　　　　“4-5-6”.split("-")//[4,5,6]



30.Array.prototype.values()方法：
作用：将数组切割为一个新得对象，对象每一项是个数组，包含数组的每一项；
var a = ['w', 'y', 'k', 'o', 'p']; 
var iterator = a.values(); 
console.log(iterator.next().value); // w 
console.log(iterator.next().value); // y 
console.log(iterator.next().value); // k 
console.log(iterator.next().value); // o 
console.log(iterator.next().value); // p


var arr = ['w', 'y', 'k', 'o', 'p'];
var iterator = arr.values();

for (let letter of iterator) {
  console.log(letter);
}
31.Array.prototype[@@iterator]()方法：
使用语法：arr[Symbol.iterator]()；
作用和value一样：例如：


var arr = ['w', 'y', 'k', 'o', 'p'];
var eArr = arr[Symbol.iterator]();
console.log(eArr.next().value); // w
console.log(eArr.next().value); // y
console.log(eArr.next().value); // k
console.log(eArr.next().value); // o
console.log(eArr.next().value); // p


32.get Array[@@species]方法：
作用：返回数组的constructor:
使用方法：Array[Symbol.species]
例如：Array[Symbol.species]; // function Array()；



        

	      

	    

	  

	  

	    
      
        【推广】
        免费学中医，健康全家人
      
	  

    

    

          原文地址：https://www.cnblogs.com/-youth/p/6514431.html