Array方法、String方法

Array

Array.from()

1. 语法：Array.from(arrayLike[, mapFn[, thisArg]])
2. 参数：
   （1）arrayLike：想要转换成数组的伪数组对象或可迭代对象
   （2）mapFn：可选 函数 如果指定了该参数，新数组中的每个元素会执行该回调函数。
   （3）thisArg：可选 执行函数时this指向thisArg
3. 返回值：arrayLike转换为新数组后 新数组中的每个元素依次执行mapFn函数 得到的结果组成的新新数组 返回新新数组。
   let dp = Array.from(new Array(m),() => new Array(n).fill(0));//创建m行n列的dp[0][0]二维数组

Array.of()

1. 语法：Array.of(element0[, element1[, ...[, elementN]]])
2. 参数：
   elementN：任意个参数，将按顺序成为返回数组中的元素。
3. 返回值：[element0, element1, ... , elementN]

Array.isArray()

1. 语法：Array.isArray(obj)
2. 检测obj是不是数组Array 是的话返回true 否则返回false

Array.prototype.fill()

1. 语法：arr.fill(value[, start[, end]])
2. 参数：
   （1）value：用来填充数组元素的值。
   （2）start：可选 起始索引，默认值为0 如果start是个负数, 则开始索引为 length+start。
   （3）end：可选 终止索引，默认值为this.length。
3. fill()方法用一个固定值value填充一个数组中从起始索引start到终止索引end内的全部元素 不包括终止索引 即范围为[start, end) 默认忽略超出数组边界、零长度及方向相反的索引范围
4. Array.of()和Array构造函数之间的区别在于处理整数参数：Array.of(7)创建一个具有单个元素7的数组，而Array(7)创建一个长度为7的空数组（指一个有7个空位(empty)的数组，而不是由7个undefined组成的数组）。

Array.of(7);       // [7]
Array.of(1, 2, 3); // [1, 2, 3]

Array(7);          // [ , , , , , , ]
Array(1, 2, 3);    // [1, 2, 3]

Array.prototype.copyWithin()

1. 语法：arr.copyWithin(target[, start[, end]])
2. 参数：
   （1）target：0为基底的索引，复制序列到该位置。如果是负数，target将从末尾开始计算。如果target大于等于arr.length，将不拷贝。如果target在start之后，复制的序列将被修改以符合arr.length。
   （2）start：0为基底的索引，开始复制元素的起始位置。如果是负数，将从length+start开始计算。如果被省略，默认为0。
   （3）end：0为基底的索引，开始复制元素的结束位置。copyWithin将会拷贝到该位置，但不包括end这个位置的元素。如果是负数，将从length+end开始计算。如果被省略，默认为arr.length
3. 返回值：copyWithin()方法浅复制数组的一部分到本数组中的另一个位置，并返回改变后的数组，不会改变原数组的长度。
4. 默认忽略超出数组边界、零长度及方向相反的索引范围

Array.prototype.filter()

1. 语法：var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
2. 参数：
   （1）callback：用来测试数组的每个元素的函数。返回 true 表示该元素通过测试，保留该元素，false 则不保留。它接受以下三个参数：

element：数组中当前正在处理的元素。
index：可选 正在处理的元素在数组中的索引。
array：可选 调用 filter 的数组。

（2）thisArg：可选 执行 callback 时，用于 this 的值。如果没传，非严格模式下将是全局对象，严格模式下为 undefined

3. filter为数组中的每个元素调用一次callback函数，并利用所有使得callback返回true的元素创建一个新数组并返回。

Array.prototype.find()

1. 语法：arr.find(callback[, thisArg])
2. 参数：
   （1）callback：在数组每一项上执行的函数，接收 3 个参数：

element：当前遍历到的元素。
index：可选 当前遍历到的索引。
array：可选 数组本身。

（2）thisArg：可选 执行回调时用作this的对象。

3. find()方法对数组中的每一项元素执行一次callback函数，直至有一个callback返回 true。当找到了这样一个元素后，该方法会立即返回这个元素的值，否则返回undefined。
4. 注意：callback函数会为数组中的每个索引调用即从0到 length - 1，而不仅仅是那些被赋值的索引

Array.prototype.findIndex()

1. 语法：arr.findIndex(callback[, thisArg])
2. 参数：
   （1）callback：针对数组中的每个元素, 都会执行该回调函数, 执行时会自动传入下面三个参数:

element：当前元素。
index：当前元素的索引。
array：调用findIndex的数组。

（2）thisArg：可选。执行callback时 作为this对象的值

3. findIndex()方法对数组中的每一项元素执行一次callback函数，直至有一个callback返回 true。当找到了这样一个元素后，该方法会立即返回这个元素的值，如果回调从不返回真值，或者数组的length为0，则findIndex返回-1。
4. 注意：callback函数会为数组中的每个索引调用即从0到 length - 1，而不仅仅是那些被赋值的索引

Array.prototype.some()

1. 语法：arr.some(callback(element[, index[, array]])[, thisArg])
2. 参数：
   （1）callback：用来测试每个元素的函数，接受三个参数：

element：数组中正在处理的元素。
index：可选 数组中正在处理的元素的索引值。
array：可选 some()被调用的数组。

（2）thisArg：可选 执行 callback 时使用的 this 值。

3. 数组中有至少一个元素通过回调函数的测试就会返回true；所有元素都没有通过回调函数的测试返回值才会为false。

Array.prototype.sort()

1. 语法：arr.sort([compareFunction])
2. 参数：
   compareFunction：函数 可选 用来指定按某种顺序进行排列的函数。如果省略，则按照默认方法排序：将元素转换为字符串，然后比较它们的Unicode 升序排序。
3. 返回值：排序后的数组。
4. compareFunction(a, b) 返回值>0表示a,b交换位置 具体如下：
   如果 compareFunction(a, b) 小于 0 ，那么 a 会被排列到 b 之前；
   如果 compareFunction(a, b) 等于 0 ， a 和 b 的相对位置不变。
   如果 compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前。
   比较函数格式如下：

function compare(a, b) {
  if (a < b ) {           // 按某种排序标准进行比较, a 小于 b
    return -1;
  }
  if (a > b ) {
    return 1;
  }
  // a must be equal to b
  return 0;
}

5.要比较数字而非字符串，比较函数可以简单的以 a 减 b，如下的函数将会将数组升序排列

arr.sort((a, b) => a - b)

Array.prototype.slice()

1.语法：var newArray = arr.slice([begin[, end]])
2.参数：
（1）begin：可选 默认值0 从该索引开始提取原数组元素。如果该参数为负数，则表示从arr.length+begin处开始提取，如果begin超出原数组的索引范围，则会返回空数组。
（2）end：可选 默认值为arr.length 在该索引处结束提取原数组元素（该索引处的元素取不到）。如果该参数为负数， 则它表示在arr.length+end处结束抽取。如果end大于数组的长度，slice()也会一直提取到原数组末尾。
3.slice() 方法浅拷贝原数组[begin,end)范围内的元素到一个新数组中 返回新数组。原始数组不会被改变。

Array.prototype.forEach()

1.语法：arr.forEach(callback(currentValue [, index [, array]])[, thisArg])
2.参数：
（1）callback：为数组中每个元素执行的函数，该函数接收一至三个参数：

1. currentValue：数组中正在处理的当前元素。
2. index：可选 当前元素的索引。
3. array：可选 正在操作的数组。

（2）thisArg 可选 当执行回调函数 callback 时，用作 this 的值。如果省略了 thisArg 参数，或者其值为 null 或 undefined，this 则指向全局对象。
3.forEach() 方法为数组中含有效值的每一项执行一次 callback 函数，那些已删除或者未初始化的项将被跳过（例如在稀疏数组上）。
5.forEach() 与 map() 或者 reduce() 不同的是，它总是返回 undefined 值，并且不可链式调用。
6.除了抛出异常以外，没有办法中止或跳出 forEach() 循环。

Array.prototype.map()

1.语法：

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

2.参数：
（1）callback：生成新数组元素的函数，使用三个参数：

1. currentValue：数组中正在处理的当前元素。
2. index：可选 数组中正在处理的当前元素的索引。
3. array：可选 map 方法调用的数组。

（2）thisArg可选：执行 callback 函数时值被用作this。
3.map 方法会给原数组中的每个元素都按顺序调用一次 callback 函数。callback 每次执行后的返回值（包括 undefined）组合起来形成一个新数组，并返回该数组。 callback 函数只会在有值的索引上被调用；那些从来没被赋过值或者使用 delete 删除的索引则不会被调用。
5.如果被map调用的数组是离散的，新数组将也是离散的保持相同的索引为空。

map和foreach的区别：
相同点：
（1）都是循环遍历数组中的每一项
（2）每次执行匿名函数都支持三个参数，参数分别为item（当前每一项），index（索引值），arr（原数组）
（3）匿名函数中的this都是指向window
（4）只能遍历数组
不同点：forEach更改原始数组的元素。map()返回新的数组。

Array.prototype.join()

1.语法：arr.join([separator])
2.参数：separator 可选 指定一个字符串用来分隔数组的每个元素。默认值为【，】。如果separator是空字符串("")，则所有元素之间都没有任何字符。
3.所有的数组元素被转换成字符串，再用separator将这些字符串连接起来。

Array.prototype.concat()

1. 语法：var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
2. 参数：valueN：可选 数组或值，valueN将被合并到一个新的数组中。若valueN是一个或多个数组 则concat()会把这些数组的每一项都添加到副本中 若不是数组 则直接把他们添加到副本末尾
3. 合并多个数组
4. 首先创建当前数组的副本 然后把参数添加到副本末尾 最后返回副本
5. 在参数数组上指定一个特殊的符号Symbol.isConcatSpreadable 这个符号能够阻止concat()打平参数数组

let colors = ['red','blue','green']
let newColors = ['black','brown']
let moreNewColors= {
    [Symbol.isConcatSpreadable]: true,// 打平数组
    length: 2,
    0: "pink",
    1: "cyan"
};
newColors[Symbol.isConcatSpreadable] = false// 不打平数组
let colors2 = colors.concat("yellow", newColors)
let colors3 = colors.concat(moreNewColors)
console.log(colors2)// ['red', 'blue', 'green', 'yellow',[ 'black', 'brown']]
console.log(colors3)// [ 'red', 'blue', 'green', 'pink', 'cyan' ]

Array.prototype.unshift()

1.语法：arr.unshift(element1, ..., elementN)
2.参数：elementN：要添加到数组开头的元素或多个元素。如果传入多个参数，它们会以块的形式插入到对象的开始位置，它们的顺序和被作为参数传入时的顺序一致。 于是传入多个参数调用一次 unshift ，和传入一个参数调用多次 unshift (例如，循环调用)，它们将得到不同的结果。
3.将一个或多个元素添加到数组的开头，并返回该数组的新长度。

Array.prototype.shift()

1.语法：arr.shift()
2.shift 方法移除索引为 0 的元素(即第一个元素)，并返回被移除的元素，其他元素的索引值随之减 1。如果 length 属性的值为 0 (长度为 0)，则返回 undefined。

Array.prototype.push()

1.语法：arr.push(element1, ..., elementN)
2.参数：elementN 被添加到数组末尾的元素。
3.push() 方法将一个或多个元素添加到数组的末尾，并返回该数组的新长度。

Array.prototype.pop()

1.语法：arr.pop()
2.pop 方法从一个数组中删除并返回最后一个元素。如果你在一个空数组上调用 pop()，它返回 undefined。

Array.prototype.indexOf()

1. 语法：arr.indexOf(searchElement[, fromIndex])
2. 参数：
   （1）searchElement：必须 要查找的元素
   （2）fromIndex：可选 开始查找的位置。如果该索引值大于或等于数组长度，意味着不会在数组里查找，返回-1。如果是一个负值，则从arr.length+fromIndex处开始查找。注意：如果参数中提供的索引值是一个负值，并不改变其查找顺序，查找顺序仍然是从前向后查询数组。如果抵消后的索引值仍小于0，则整个数组都将会被查询。其默认值为0
3. 找到指定元素searchElement在数组中的位置，返回首个被找到的元素在数组中的索引位置; 若没有找到则返回 -1

let person = {name: "cara"}
let people = [{name: "cara"}]
let morePeople = [person]
console.log(people.indexOf(person))// -1
console.log(morePeople.indexOf(person))// 0

Array.prototype.lastIndexOf()

1. 语法：arr.lastIndexOf(searchElement[, fromIndex])
2. 参数：
   （1）searchElement：被查找的元素。
   （2）fromIndex：可选 从此位置开始逆向查找。默认为arr.length - 1，即整个数组都被查找。如果该值大于或等于数组的长度，则整个数组会被查找。如果为负值，将其视为从arr.length - fromIndex开始查找。即使该值为负，数组仍然会被从后向前查找。如果该值为负时，其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。
3. 返回值：数组中该元素最后一次出现的索引，如未找到返回-1。

Array.prototype.includes()

1. 语法：arr.includes(valueToFind[, fromIndex])
2. 参数
   （1）valueToFind：需要查找的元素值。
   （2）fromIndex：可选 开始查找的位置。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜 （即使从末尾开始往前跳 fromIndex 的绝对值个索引，然后往后搜寻）。默认为 0。
3. includes() 方法用来判断一个数组是否包含一个指定的值（区分大小写），如果包含则返回 true，否则返回false。
4. 使用全等比较===

let person = {name: "cara"}
let people = [{name: "cara"}]
let morePeople = [person]
console.log(people.includes(person))// false
console.log(morePeople.includes(person))// true

Array.prototype.splice()

1. 语法：array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
2. 参数：
   （1）start：开始位置（从0计数）。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从arr.length+start开始添加。如果负数的绝对值大于数组的长度，则表示开始位置为第0位。
   （2）deleteCount：可选 整数，表示要移除的数组元素的个数。如果省略该参数，或者它的值大于等于start之后的所有元素的数量，那么start之后数组的所有元素都会被删除。
   （3）item1, item2, … ：可选 要添加进数组的元素。如果不指定，则 splice() 将只删除数组元素。
   （4）如果第二个参数没传 只传了第一个参数start 那么就会把start后面的所有内容全部删掉
   （5）如果第二个参数传了非0数字second 但是没有传第三个参数 那么就会删除start后面的second个内容删掉
   （6）如果第二个参数传入非0数字 第三个参数传入字符串 并且第二个参数后面可以传多个字符串 就会把start后面的second个元素替换成第二个参数后面的字符串
   （7）如果第二个参数传入0 第三个参数传入字符串 并且第二个参数后面可以传多个字符串 就会在start后面追加第二个参数后面的字符串
3. 返回值：由被删除的元素组成的一个数组。如果没有删除元素，则返回空数组。

Array.prototype.reduce()

1. 语法：arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])
2. 参数：
   （1）callback：数组中每个值都会执行该回调函数，包含四个参数：

accumulator：上一次调用回调时返回的累积值
currentValue：数组中正在处理的元素的值。
index：可选 数组中正在处理的元素的索引。 如果提供了initialValue，则起始索引号为0，否则从索引1起始。
array：可选 调用reduce()的数组

（2）initialValue：可选 第一次调用callback函数时的第一个参数的值。如果没有提供初始值，则使用数组中的第一个元素。在空数组上调用 reduce 将报错。

3. 回调函数第一次执行时，accumulator 和currentValue的取值有两种情况：如果调用reduce()时提供了initialValue，accumulator取值为initialValue，currentValue取数组中的第一个值；如果没有提供 initialValue，那么accumulator取数组中的第一个值，currentValue取数组中的第二个值。
4. 返回函数累计处理的结果

Array.prototype.reduceRight()

1. 语法：arr.reduceRight(callback(accumulator, currentValue[, index[, array]])[, initialValue])
2. 参数：
   （1）callback：回调函数，用于操作数组中的每个元素，它可接受四个参数：

accumulator：累加器 上一次调用回调函数时，回调函数返回的值。首次调用回调函数时，如果 initialValue 存在，累加器即为 initialValue，否则须为数组中的最后一个元素
currentValue：当前被处理的元素。
index：可选 当前被处理的元素的索引。
array：可选 当前被处理的数组

（2）initialValue：可选 首次调用callback函数时，累加器accumulator的值。如果未提供该初始值，则将使用数组中的最后一个元素，并跳过该元素。如果不给出初始值，则需保证数组不为空。否则，在空数组上调用reduce或reduceRight且未提供初始值（例如 [].reduce( (acc, cur, idx, arr) => {} ) ）的话，会导致类型错误：TypeError: reduce of empty array with no initial value。

String

反转字符串

function reverseString(str) {
    return str.split('').reverse().join('');
}

split()方法

字符串转数组