对数组的一些Api和字符串Api的总结

数组Api

改变原数组：

1. fill(value,start,end) 替换数组得某一些元素
   value 替换值 start开始下标，end结束下标
2. pop() 删除数组最后一个元素，并返回删除元素
3. push() 末尾增加一个或多个元素，并返回数组的新长度
4. reverse() 颠倒数组中元素的排列顺序
5. shift() 删除第一个元素，并返回删除元素
6. unshift() 在首位增加一个元素，并返回数组得长度
7. sort() 对数组进行排序，并返回当前数组
8. splice(ind,del,value) 在任意的位置给数组添加或删除任意个元素
   ind 插入索引或者删除得索引，del 删除几个元素， value，增加元素得值

使用的方法就不一一描述了，也可以去MDN上查询，这只是我总结的一小部分，有不对的请多多指教

不改变原数组：

9. concat 连接当前数组和其他数组或者非数组值组合成新数组
10. includes 判断当前数组是否包含某个值，有返回true，没有则返回false
11. join 把数组转成字符串，并可指定某个字符连接
12. slice(start,end) 截取，截取当前数组得某一段元素组合成新数组
    start，起始值，end-终止值，取头不去尾、
13. toString 把数组转化成字符串
14. indexOf 返回数组第一个与指定值相同得元素得索引
15. lastIndexOf 返回数组最后一个与指定元素相同得元素的索引

数组的迭代方法

entries()
	const array1 = ['a', 'b', 'c'];
	const iterator1 = array1.entries();
	console.log(iterator1.next().value);  [0,'a']
filter()  //将所有在过滤函数中返回 true 的数组元素放进一个新数组中并返回
find()    //找到第一个满足条件的元素，并返回那个元素的值
findIndex()   //找到第一个满足条件的元素，并返回元素的索引
keys()  //返回一个数组迭代器对象，该迭代器会包含所有数组元素的键
	const array2 = ['a','b','c']
    const iter = array2.keys()
    for(let key of iter) {
		consolo.log(key)   0,1,2
    }
values()  //返回包含数组元素得值

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

const array1 = ['a', 'b', 'c'];
const array2 = ['d', 'e', 'f'];
const array3 = array1.concat(array2);

2、copyWithin()
浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度。修改原数组
语法：arr.copyWithin(target, start, end)

const array1 = ['a', 'b', 'c', 'd', 'e'];
console.log(array1.copyWithin(0, 3, 4));
//["d", "b", "c", "d", "e"]

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

const array1 = ['a', 'b', 'c'];
const iterator1 = array1.entries();
console.log(iterator1.next().value);//[0, "a"]
console.log(iterator1.next().value);//[1, "b"]
console.log(iterator1.next().value);//[2, "c"]

4、every()
测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。

语法：arr.every(element, index, array)
element：用于测试的当前值。
[12, 54, 18, 130, 44].every(x => x >= 10); // true
//和下面同等结果
function isBigEnough(element, index, array) {
  return element >= 10;
}
[12, 54, 18, 130, 44].every(isBigEnough); // true

注意：只要在遍历过程中，遇到一个不满足条件的就停止遍历，就返回false

5、fill()

用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引。修改原数组
语法：arr.fill(value, start, end)
value：用来填充数组元素的值。
const array1 = [1, 2, 3, 4];
console.log(array1.fill(0, 2, 4));// [1, 2, 0, 0]

6、filter()

创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。 返回一个新数组
[12, 5, 8, 130, 44].filter(x => x >= 10); // [12, 130, 44]

7、find()

返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。
[5, 12, 8, 130, 44].find(element => element > 10);//12

8、findIndex()

返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回-1。
[5, 12, 8, 130, 44].find(element => element > 13);//3

9、flat()

按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。返回一个新数组
语法：arr.flat(depth)
depth：指定要提取嵌套数组的结构深度，默认值为 1。
const arr1 = [0, 1, 2, [3, 4]];
console.log(arr1.flat());//[0, 1, 2, 3, 4]
const arr2 = [0, 1, 2, [[[3, 4]]]];
console.log(arr2.flat(2));//[0, 1, 2, [3, 4]]
console.log(arr2.flat(3));//[0, 1, 2, 3, 4]

10、flatMap()

首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。返回一个新数组
var arr1 = [1, 2, 3, 4]
arr1.map(x => [x * 2]);//[[2], [4], [6], [8]]
arr1.flatMap(x => [x * 2]);//[2, 4, 6, 8]
arr1.flatMap(x => [[x * 2]]);//[[2], [4], [6], [8]]

11、forEach()

对数组的每个元素执行一次给定的函数。特殊情况会改变原数组
['a', 'b', 'c'].forEach(
    element => console.log(element)
);//分三次打印"a""b""c"
注意：forEach 在对 item 进行修改的时候，如果 item 是原始类型的值，item 对应的 的内存地址实际并没有变化，如果 item 是 引用类型的值，item 对应多的内存地址也没有变化，但是对应的值，已经重写了
var arr1 = [1,2,3,4];
var arr2 = [{a:1},{a:2},{a:3}];
arr1.forEach(item =>{
    item = item * item;
});
arr2.forEach(item =>{
    item.a = item.a * item.a;
});
console.log(arr1); // [1,2,3,4]
console.log(arr2); // [{a:1},{a:4},{a:9}]

12、includes()

用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false。
[1, 2, 3].includes(2)//true

13、indexOf()

返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。
语法：arr.indexOf(searchElement, fromIndex)
fromIndex：开始查找的位置
var array = [2, 5, 9];
array.indexOf(2);// 0
array.indexOf(7);// -1
array.indexOf(2, -1); // -1

14、lastIndexOf()

返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从 fromIndex 处开始。
const animals = ['Dodo', 'Tiger', 'Penguin', 'Dodo'];
console.log(animals.lastIndexOf('Dodo'));//3

15、join()

将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。不改变原数组
const elements = ['Fire', 'Air', 'Water'];
console.log(elements.join(''));//"FireAirWater"

16、keys()

返回一个包含数组中每个索引键的Array Iterator对象。
const array1 = ['a', 'b', 'c'];
const iterator = array1.keys();
for (const key of iterator) {
  console.log(key);
}//分三次打印 0,1,2

17、map()

创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值。返回新数组
const array1 = [1, 4, 9, 16];
const map1 = array1.map(x => x * 2);
console.log(map1);//[2, 8, 18, 32]

注意：map 不修改调用它的原数组本身，当然可以在 callback 执行时改变原数组
var arr2 = [{a:1},{a:2},{a:3}];
const map2 = arr2.map(item =>{
    item.a = item.a * item.a;
});
console.log(map2);//[undefined, undefined, undefined]
console.log(arr2);//[Object { a: 1 }, Object { a: 4 }, Object { a: 9 }]

return如果是判断条件，不满足条件的返回undefined

18、pop()

从数组中删除最后一个元素，并返回该元素的值。此方法更改数组的长度。修改原数组
const plants = ['broccoli', 'cauliflower', 'cabbage', 'kale', 'tomato'];
console.log(plants.pop());//"tomato"
console.log(plants);//["broccoli", "cauliflower", "cabbage", "kale"]

19、push()

将一个或多个元素添加到数组的末尾，并返回该数组的新长度。修改原数组
const animals = ['pigs', 'goats', 'sheep'];
const count = animals.push('cows') //4
console.log(animals);//["pigs", "goats", "sheep", "cows"]

20、reduce()

对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。
reducer 函数接收4个参数：
1、Accumulator (acc) (累计器 )        2、Current Value (cur) (当前值)
3、Current Index (idx) (当前索引)     4、Source Array (src) (源数组)
var arr=[5,2,3,4,2]
var sum=arr.reduce (function(res,item) {
    return res+item
},0)
console.log(sum)//16

注意：他可以用来归并二维数组

21、reduceRight()

接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值。
var arr=[5,2,3,4,2]
var sum=arr.reduceRight (function(res,item) {
    return res+item
},0)
console.log(sum)//16

22、reverse()

将数组中元素的位置颠倒，并返回该数组。改变原数组
const a = [1, 2, 3];
a.reverse(); 
console.log(a); // [3, 2, 1]

23、shift()

从数组中删除第一个元素，并返回该元素的值。如果数组为空则返回undefined 。改变原数组
const a = [1, 2, 3];
const b = a.shift() //1
console.log(a); // [2,3]

24、slice()

slice() 方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。不改变原数组
const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];
console.log(animals.slice(2));//["camel", "duck", "elephant"]
console.log(animals.slice(2, 4));//["camel", "duck"]

25、some()

只要这些数组元素有任意一个满足条件，就得到true，就停止遍历，类似于逻辑短路，是some封装本身含有的特点
[12, 5, 8, 1, 4].some(x => x > 10); // true

26、sort()

用原地算法对数组的元素进行排序，并返回数组，比较它们的UTF-16代码单元值序列时构建的
const array1 = [1, 30, 4, 21, 100000];
array1.sort();
console.log(array1);//[1, 100000, 21, 30, 4]

27、splice()

通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。改变原数组
const months = ['Jan', 'March', 'April', 'June'];
months.splice(1, 0, 'Feb');//从第一位删除0个元素，添加'Feb'
console.log(months);//["Jan", "Feb", "March", "April", "June"]

28、toLocaleString()

不改变原数组
var prices = ['￥7', 500, 8123, 12];
prices.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' });
// "￥7,￥500,￥8,123,￥12"

29、toString()

不改变原数组
const array1 = [1, 2, 'a', '1a'];
console.log(array1.toString());//"1,2,a,1a"

30、unshift()

将一个或多个元素添加到数组的开头，改变原数组
const array1 = [1, 2, 3];
console.log(array1.unshift(4, 5));// 5
console.log(array1);//[4, 5, 1, 2, 3]

31、values()

返回一个新的 Array Iterator 对象，该对象包含数组每个索引的值
const array1 = ['a', 'b', 'c'];
const iterator = array1.values();
for (const value of iterator) {
  console.log(value);
}
// "a"，"b"，"c"

字符串Api

charAt()  		//指定返回特定位置的字符
concat()  		//连接两个字符串，并返回一个新的字符串
includes()  	//判断一个字符串里是否包含其他字符串--区分大小写
indexOf()   	//从字符串对象中返回首个被发现的给定值的索引值
lastIndexOf()   //从字符串对象中返回最后一个被发现的给定值的索引值
slice()   		//截取字符串区域，返回一个新的字符串
split()         //把字符串转成数组，指定字符
substr(start,length)		//返回一个字符串中从指定位置开始到指定字符数的字符
	start:开始提取字符串位置， length: 提取的字符数,如果不填，则提取到末尾，如果为0或者负，则提取为''
substring(start,end)		//一个字符串在开始索引到结束索引之间的一个子集
	start：截取第一个字符的索引，该索引作为返回字符的首字母
	end：可选，截取最后一位索引，该索引不作为返回字符
	start，end，谁的数组大 谁就为end
toLocaleLowerCase()		//转换成小写字母
toLocaleUpperCase()		//转换成大写字母
trim()		//去掉开始或者结尾的空格

总结的有问题的，有错误的请多指教指教，新人小白