数组（Array）的常规操作2

数组的常规操作2

常用属性

length属性：数组的长度；
prototype：原型

常用数组（Array）操作方法

form 在一个类数组中创建一个新的数组实列
isArry is就是判断是否为Array，isArray用于确认传递的值是否为数组（Array）

Array.isArray([1,2,3,]);//ture 括号里传递的值是否为数组。
//通常用于判断

concat：合并数组并且返回新数组，不改变原数组。

demo：

var a = ["n","s","s","b"];//声明一个数组
var a2 = ["l","z","s"."b"];//第二个数组
console.log(a.concat(a2));
//通过concat将两个数组相连

every：

翻译成中文就是每一个的意思。测试数组里的所有元素都通过了函数测试。

arr.every(callback[,thisArg]);
//测试数组里是否所有的元素都通过了，回调函数的测试。

demo:

function isBelowThreshold(currentValue) {
  return currentValue < 40;
}

var array1 = [1, 30, 39, 29, 10, 13];

console.log(array1.every(isBelowThreshold));
// expected output: true-预期输出是t

fill

用一个固定值填充一个数组内索引值从0到最后的全部元素，但不包括最后一个索引。
语法：

arr.fill(数值[,start[,end]]);

参数:

value
用来填充数组元素的值。
start 可选
起始索引，默认值为0。
end 可选
终止索引，默认值为 this.length。
返回的是修改以后的数组

felter

创建一个新的数组，包含所提供函数通过测试的所有函数。

var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])

参数
callback
回调函数，用来测试数组每个元素的函数，返回true表示通过filter测试，保留该元素
如果不通过返回false
可接收参数
element
数组中当前正在处理的元素。
index可选
正在处理的元素在数组中的索引。
array可选
调用了 filter 的数组本身。
thisArg可选
执行 callback 时，用于 this 的值。
demo：

var words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(word => word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

find

中文翻译寻找的意思，用来返回数组中满足回调函数条件的第一个元素的值，如果一个都没有返回undefined。
语法：

arr.find(callback[,thisArg]);

参数

callback
在数组每一项上执行的函数，接收 3 个参数：
element
当前遍历到的元素。
index可选
当前遍历到的索引。
array可选
数组本身。
thisArg可选
执行回调时用作this 的对象。
demo:

var a = [5,12,8,130,44];
var f = a.find(function(element){
return element>10;//变量a数组里面找到第一个比10大的数
})
console.log(f)

forEach

对数组的每一个元素执行一次所提供的函数。
语法：

arr.forEach(callback[, thisArg]);

参数:

callback
为数组中每个元素执行的函数，该函数接收三个参数：
currentValue
数组中正在处理的当前元素。
index可选
数组中正在处理的当前元素的索引。
array可选
forEach() 方法正在操作的数组。
thisArg可选
可选参数。当执行回调函数时用作 this 的值(参考对象)。
demo:

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

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

// expected output: "a"
// expected output: "b"
// expected output: "c"

indexOf

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

arr.indexOf(searchElement)
arr.indexOf(searchElement[, fromIndex = 0])

参数：
searchElement
要查找的元素
fromIndex
开始查找的位置。如果该索引值大于或等于数组长度，意味着不会在数组里查找，返回-1。如果参数中提供的索引值是一个负值，则将其作为数组末尾的一个抵消，即-1表示从最后一个元素开始查找，-2表示从倒数第二个元素开始查找，以此类推。注意：如果参数中提供的索引值是一个负值，并不改变其查找顺序，查找顺序仍然是从前向后查询数组。如果抵消后的索引值仍小于0，则整个数组都将会被查询。其默认值为0.
返回值:第一个被找到的元素在索引中的位置，如果找不到该元素，返回-1
demo：

var beasts = ['ant', 'bison', 'camel', 'duck', 'bison'];

console.log(beasts.indexOf('bison'));
// expected output: 1

// start from index 2
console.log(beasts.indexOf('bison', 2));
// expected output: 4

console.log(beasts.indexOf('giraffe'));
// expected output: -1

join

将一个数组的所有元素连接成一个祖父因此高压包并返回这个字符串。
如果数组只有一个项目，那么返回该项目而不是用分隔符。
语法:

arr.join([separator])

参数
separator
指定一个字符串来分隔数组的每个元素。如果需要，将分隔符转换为字符串。如果省略()，数组元素用逗号分隔。默认为 ","。如果separator是空字符串("")，则所有元素之间都没有任何字符。
demo:

var elements = ['Fire', 'Air', 'Water'];

console.log(elements.join());
// expected output: "Fire,Air,Water"

console.log(elements.join(''));
// expected output: "FireAirWater"

console.log(elements.join('-'));
// expected output: "Fire-Air-Water"

keys

返回一个包含数组中每个索隐建的Array Iterator
语法:

arr.keys()

返回值:
一个新的数组迭代器对象。
demo:

var array1 = ['a', 'b', 'c'];
var iterator = array1.keys(); 
  
for (let key of iterator) {
  console.log(key); // expected output: 0 1 2
}

map

创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。
语法:

var new_array = arr.map(function callback(currentValue[, index[, array]]) {
 // Return element for new_array 
}[, thisArg])

参数：
callback
生成新数组元素的函数，使用三个参数：
currentValue
callback 数组中正在处理的当前元素。
index可选
callback 数组中正在处理的当前元素的索引。
array可选
callback map 方法被调用的数组。
thisArg可选
执行 callback 函数时使用的this 值。
返回值:
一个新数组，每个元素都是回调函数的结果。
demo：

var array1 = [1, 4, 9, 16];

// pass a function to map
const map1 = array1.map(x => x * 2);

console.log(map1);
// expected output: Array [2, 8, 18, 32]

pop

从数组中删除最后一个元素，并返回所删除元素的值，可以改变数组的长度

语法：

arr.pop()

返回值：
从数组中所删除的元素。
demo:

var plants = ['broccoli', 'cauliflower', 'cabbage', 'kale', 'tomato'];

console.log(plants.pop());
// expected output: "tomato"

console.log(plants);
// expected output: Array ["broccoli", "cauliflower", "cabbage", "kale"]

plants.pop();

console.log(plants);
// expected output: Array ["broccoli", "cauliflower", "cabbage"]

reduce

对数组中的每个元素只能给一个自定义的reducer函数，并将其结果汇总为单个返回值。

语法:

  arr.reduce(callback[,initialvalue])

参数:
callback
执行数组中每个值的函数，包含四个参数：
accumulator
累计器累计回调的返回值; 它是上一次调用回调时返回的累积值，或initialValue（见于下方）。
currentValue

数组中正在处理的元素。

currentIndex可选

数组中正在处理的当前元素的索引。如果提供了initialValue，则起始索引号为0，否则为1。

array可选

调用reduce()的数组

initialValue可选

作为第一次调用 callback函数时的第一个参数的值。如果没有提供初始值，则将使用数组中的第一个元素。在没有初始值的空数组上调用 reduce 将报错。
返回值：
函数累计的处理结果
demo：

const array1 = [1, 2, 3, 4];
const reducer = (accumulator, currentValue) => accumulator + currentValue;

// 1 + 2 + 3 + 4
console.log(array1.reduce(reducer));
// expected output: 10

// 5 + 1 + 2 + 3 + 4
console.log(array1.reduce(reducer, 5));
// expected output: 15

reverse

将数组中的元素位置颠倒，并且返回该数组，此方法会对原数组内容进行修改。
语法：

arr. reverse()

demo:

var array1 = ['one', 'two', 'three'];
console.log('array1: ', array1);
// expected output: Array ['one', 'two', 'three']

var reversed = array1.reverse(); 
console.log('reversed: ', reversed);
// expected output: Array ['three', 'two', 'one']

/* Careful: reverse is destructive. It also changes
the original array */ 
console.log('array1: ', array1);
// expected output: Array ['three', 'two', 'one']

slice

返回一个性的数组对象，这个对象是由begin和end（不包括end）决定的原数组浅拷贝，原数组内容不变
语法：

 arr.slice();
    // [0, end]
    
    arr.slice(begin);
    // [begin, end]
    
    arr.slice(begin, end);
    // [begin, end)

参数:
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 会一直提取到原数组末尾。
如果 end 大于数组长度，slice 也会一直提取到原数组末尾。
返回值：
一个含有提取元素的新数组
demo：

var animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];

console.log(animals.slice(2));
// expected output: Array ["camel", "duck", "elephant"]

console.log(animals.slice(2, 4));
// expected output: Array ["camel", "duck"]

console.log(animals.slice(1, 5));
// expected output: Array ["bison", "camel", "duck", "elephant"]

some

至少有一个元素通过了所提供的函数实现测试。
语法：
arr.some(callback(element[, index[, array]])[, thisArg])
参数
callback
用来测试每个元素的函数，接受三个参数：
element
数组中正在处理的元素。
index 可选
数组中正在处理的元素的索引值。
array可选
some()被调用的数组。
thisArg可选
执行 callback 时使用的 this 值。
返回值：
如果回调函数返回任何数组元素的truthy值，则返回true；否则为false。
demo:

var array = [1, 2, 3, 4, 5];

var even = function(element) {
  // checks whether an element is even
  return element % 2 === 0;
};

console.log(array.some(even));
// expected output: true

sort

永远地算法对数组的元素惊醒排序，并返回数组。排序算法现在是稳定的。默认排序是按照unicode的顺序
即所谓（1，2，3，4，5）（a,b,c,d,e）顺序
语法：

arr.sort([compareFunction])

参数：
compareFunction 可选
用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。
返回值：
排序后的数组。请注意，数组已原地排序，并且不进行复制。
demo：

var months = ['March', 'Jan', 'Feb', 'Dec'];
months.sort();
console.log(months);
// expected output: Array ["Dec", "Feb", "Jan", "March"]

var array1 = [1, 30, 4, 21, 100000];
array1.sort();
console.log(array1);
// expected output: Array [1, 100000, 21, 30, 4]

splice

通过删除或替换现有元素或者原地添加新的元素来修改数组，全能型的方法。并以数组的星师返回被修改的内容，此方法会修改元素组的值
语法：

array.splice(start[, deleteCount[, item1[, item2[, ...]]]])

参数：
start
指定修改的开始位置（从0计数）。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始的第几位（从-1计数，这意味着-n是倒数第n个元素并且等价于array.length-n）；如果负数的绝对值大于数组的长度，则表示开始位置为第0位。

deleteCount 可选
整数，表示要移除的数组元素的个数。
如果 deleteCount 大于 start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。
如果 deleteCount 被省略了，或者它的值大于等于array.length - start(也就是说，如果它大于或者等于start之后的所有元素的数量)，那么start之后数组的所有元素都会被删除。
如果 deleteCount 是 0 或者负数，则不移除元素。这种情况下，至少应添加一个新元素。

item1, item2, ... 可选
要添加进数组的元素,从start 位置开始。如果不指定，则 splice() 将只删除数组元素。
返回值;
有被删除的元素组成的数组，如果只删除了一个元素。则返回只包含一个元素的数组，如果没有删除数组，则返回一个空的数组
demo：

var months = ['Jan', 'March', 'April', 'June'];
months.splice(1, 0, 'Feb');
// inserts at index 1
console.log(months);
// expected output: Array ['Jan', 'Feb', 'March', 'April', 'June']

months.splice(4, 1, 'May');
// replaces 1 element at index 4
console.log(months);
// expected output: Array ['Jan', 'Feb', 'March', 'April', 'May']