concat
concat() 方法用于连接两个或多个数组。该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。
//把 concat() 中的参数连接到数组 a
var a = [1,2,3]
a // [1, 2, 3]
a.concat(4,5) //[1, 2, 3, 4, 5] 返回被连接数组的一个副本
a // [1, 2, 3] 该方法不会改变现有的数组
------------------------------------------------------
//使用 concat()连接两个数组
var arr1 = ["George","John","Thomas"]
var arr2 = ["James","Adrew","Martin"]
arr1.concat(arr2) // ["George", "John", "Thomas", "James", "Adrew", "Martin"]
//返回被连接数组的一个副本
arr1 // ["George", "John", "Thomas"] 不会改变现有的数组
---------------------------------------------------------------------------
//如果连接3个数组
arr1.concat(arr2,arr3)
constructor
constructor n.构造器
返回对创建此对象的数组函数的引用
按照自己的理解的话，就是指向了是谁构造了自己。。
//判断自己的类型
var test=new Array();
if (test.constructor==Array){
document.write("This is an Array");
}
if (test.constructor==Boolean){
document.write("This is a Boolean");
}
if (test.constructor==Date){
document.write("This is a Date");
}
if (test.constructor==String){
document.write("This is a String");
}
//This is an Array
这样看起来好像和instanceof很像啊。疑问：constructor和instanceof有什么区别？
--------------------------------------------------------------------------
function employee(name,job,born){
this.name=name;
this.job=job;
this.born=born;
}
var bill=new employee("Bill Gates","Engineer",1985);
bill.constructor //bill的由谁构造的
//function employee(name, job, born){
// this.name = name;
// this.job = job;
// this.born = born
//;}
copyWithin
copyWithin() 方法浅复制数组的一部分到同一数组中的另一个位置，并返回它，而不修改其大小。会改变原数组。
arr.copyWithin(target[, start[, end]])
target //从哪个地方修改，从0开始计算
start //从哪里开始复制，从0开始计算
end //从哪里结束复制，从0开始计算，不包括这个下标值
a = [0,1,2,3,4,5]
a.copyWithin(3,0,2) // [0, 1, 2, 0, 1, 5] 从第三个位置修改0~2(0,1)。
a //[0, 1, 2, 0, 1, 5] 改变原数组
entries
entries() 方法返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对。
Array Iterator是对象，它的原型（__proto__:Array Iterator）上有一个next方法，可用用于遍历迭代器取得原数组的[key,value]。
var a = [1,2,3]
var aa = a.entries()
aa //Array Iterator {} 返回一个新的Array Iterator对象
aa.next() //{value: Array(2), done:false, value: (2) [0, 1], __proto__: Object}
aa.next() //{value: Array(2), done:false, value: (2) [1, 2], __proto__: Object}
aa.next() //{value: Array(2), done:false, value: (2) [2, 3], __proto__: Object}
aa.next() //{value: undefined, done: true} 找不到
aa.next() //{value: undefined, done: true} 找不到
aa.next() //{value: undefined, done: true} 找不到
aa.next()返回值
/*{value: Array(2), done: false}
done:false
value:(2) [0, "a"]
__proto__: Object
*/
// iterator.next()返回一个对象，对于有元素的数组，
// 是next{ value: Array(2), done: false }；
// next.done 用于指示迭代器是否完成：在每次迭代时进行更新而且都是false，
// 直到迭代器结束done才是true。
// next.value是一个["key":"value"]的数组，是返回的迭代器中的元素值。
every
every() 方法测试数组的所有元素是否都通过了指定函数的测试。
arr.every(callback[, thisArg])
// callback 用来测试每个元素的函数。
// thisArg 执行 callback 时使用的 this 值。
every 方法为数组中的每个元素执行一次 callback 函数，直到它找到一个使 callback 返回 false（表示可转换为布尔值 false 的值）的元素。如果发现了一个这样的元素，every 方法将会立即返回 false。否则，callback 为每一个元素返回 true，every 就会返回 true。
callback 只会为那些已经被赋值的索引调用。不会为那些被删除或从来没被赋值的索引调用。
callback 被调用时传入三个参数：元素值，元素的索引，原数组。
every 遍历的元素范围在第一次调用 callback 之前就已确定了。在调用 every 之后添加到数组中的元素不会被 callback 访问到。
every 和数学中的"所有"类似，当所有的元素都符合条件才返回true。另外，空数组也是返回true。
function callback(a){
return(a>=8)
}
var passed1 = [8,9,10,12]
passed1.every(callback) //true
var passed2= [8,9,1,10]
passed2.every(callback) //false
fill
fill() 方法用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。
fill和copyWithin用法很像，fill是自定义修改数组，改变原数组；copyWithin是复制数组元素到指定位置，改变原数组。
arr.fill(value[, start[, end]])
//value 用来填充数组元素的值。
//start 起始索引，默认值为0。
//end 终止索引，默认值为 this.length。
[1, 2, 3].fill(4); // [4, 4, 4] 替换值为4
[1, 2, 3].fill(4, 1); // [1, 4, 4] 替换值为4，位置从1~3(不包括)
[1, 2, 3].fill(4, 1, 2); // [1, 4, 3] 替换值为4，位置从1~2(不包括)
[1, 2, 3].fill(4, 1, 1); // [1, 2, 3] 替换值为4，位置从1~1(不包括)
[1, 2, 3].fill(4, 3, 3); // [1, 2, 3] 替换值为4，位置从3~3(不包括)
[1, 2, 3].fill(4, -3, -2); // [4, 2, 3] 位置从(3+-3)~(3+-2)=>0~1(不包括)
[1, 2, 3].fill(4, NaN, NaN); // [1, 2, 3] 替换值4,
[1, 2, 3].fill(4, 3, 5); // [1, 2, 3] 替换值为4 从4~5(不包括)
\Array(3).fill(4); // [4, 4, 4] 新数组，替换值为4
\[].fill.call({ length: 3 }, 4); // {0: 4, 1: 4, 2: 4, length: 3}
\//绑定this，使用this的length，把4填充到this数组里面
\// Objects by reference.
var arr = Array(3).fill({}) // [{}, {}, {}];
arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }]
filter
filter() 方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。
find
findIndex
forEach
includes
indexOf
join
keys
lastIndexOf
length
map
pop
push
reduce
reduceRight
reverse
shift
slice
some
sort
splice
toLocaleString
toString
unshift
