Array
- Array.from()
- Array.of()
- Array.isArray()
- Array.prototype.fill()
- Array.prototype.copyWithin()
- Array.prototype.filter()
- Array.prototype.find()
- Array.prototype.findIndex()
- Array.prototype.some()
- Array.prototype.sort()
- Array.prototype.slice()
- Array.prototype.forEach()
- Array.prototype.map()
- Array.prototype.join()
- Array.prototype.concat()
- Array.prototype.unshift()
- Array.prototype.shift()
- Array.prototype.push()
- Array.prototype.pop()
- Array.prototype.indexOf()
- Array.prototype.lastIndexOf()
- Array.prototype.includes()
- Array.prototype.splice()
- Array.prototype.reduce()
- Array.prototype.reduceRight()
String
- 反转字符串
- split()方法

Array

Array.from()

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

Array.of()

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

Array.isArray()

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

Array.prototype.fill()

语法：arr.fill(value[, start[, end]])
参数：
（1）value：用来填充数组元素的值。
（2）start：可选起始索引，默认值为0 如果start是个负数, 则开始索引为 length+start。
（3）end：可选终止索引，默认值为this.length。
fill()方法用一个固定值value填充一个数组中从起始索引start到终止索引end内的全部元素不包括终止索引即范围为[start, end) 默认忽略超出数组边界、零长度及方向相反的索引范围
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()

语法：arr.copyWithin(target[, start[, end]])
参数：
（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
返回值：copyWithin()方法浅复制数组的一部分到本数组中的另一个位置，并返回改变后的数组，不会改变原数组的长度。
默认忽略超出数组边界、零长度及方向相反的索引范围

Array.prototype.filter()

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

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

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

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

Array.prototype.find()

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

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

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

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

Array.prototype.findIndex()

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

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

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

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

Array.prototype.some()

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

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

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

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

Array.prototype.sort()

语法：arr.sort([compareFunction])
参数：
compareFunction：函数可选用来指定按某种顺序进行排列的函数。如果省略，则按照默认方法排序：将元素转换为字符串，然后比较它们的Unicode 升序排序。
返回值：排序后的数组。
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 小于 breturn -1;}if (a > b ) {return 1;}// a must be equal to breturn 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：为数组中每个元素执行的函数，该函数接收一至三个参数：

currentValue：数组中正在处理的当前元素。
index：可选当前元素的索引。
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：生成新数组元素的函数，使用三个参数：

currentValue：数组中正在处理的当前元素。
index：可选数组中正在处理的当前元素的索引。
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()

语法：var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
参数：valueN：可选数组或值，valueN将被合并到一个新的数组中。若valueN是一个或多个数组则concat()会把这些数组的每一项都添加到副本中若不是数组则直接把他们添加到副本末尾
合并多个数组
首先创建当前数组的副本然后把参数添加到副本末尾最后返回副本
在参数数组上指定一个特殊的符号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()

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

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

Array.prototype.includes()

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

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()

语法：array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
参数：
（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后面追加第二个参数后面的字符串
返回值：由被删除的元素组成的一个数组。如果没有删除元素，则返回空数组。

Array.prototype.reduce()

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

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

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

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

Array.prototype.reduceRight()

语法：arr.reduceRight(callback(accumulator, currentValue[, index[, array]])[, initialValue])
参数：
（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()方法

字符串转数组

Array方法、String方法相关推荐

JavaScript 常用Array、String方法
1.常用Array方法 concat()连接两个数组 [1, 3, 5, 7, 9].concat([2, 4, 6, 8, 10]) forEach()遍历数组 [1, 2, 3, 4, 5, 6, ...
Array，String 方法
Array 1..slice(start,end)可从已有的数组中返回选定的元素 start 必需.规定从何处开始选取.如果是负数,那么它规定从数组尾部开始算起的位置.也就是说,-1 指最后一个元素, ...
toString方法和String方法
要把一个值转换成字符串有两个方法,toString Sting toString()方法:数值,布尔值,对象和字符串值(没错,每个字符串都有一个toSrting()方法,该方法返回一个字符串副本) ...
php 判断类型array,判断一个变量是数组Array类型的方法_javascript技巧
在很多时候,我们都需要对一个变量进行数组类型的判断.JavaScript中如何判断一个变量是数组Array类型呢?我最近研究了一下,并分享给大家,希望能对大家有所帮助. JavaScript中检测对象 ...
ES6/07/Array的扩展方法，...扩展运算符,Array.from()，（arr.find(),arr.findIndex()和arr.includes()）模板字符串,Set数据结构
ES6扩展的内置对象 1,Array的扩展方法 -扩展运算符(展开语法) 1,扩展运算可以的将数组或者对象转为用逗号分隔的参数序列: let ary =[1,2,3]; //-ary;//" ...
Java String API 常用的String方法详解
标题 String类的特性 Java中String类的构造方法 String类的 intern() 注意还跟jdk有关如何保证变量S指向的是字符串常量池中的数据呢? 关于String中 new St ...
常用String方法
2019独角兽企业重金招聘Python工程师标准>>> 字符串的拼接: 方法一:使用String.format("",--); String name = Str ...
ndarray 与 array 的区别关系,所以ndarray是一个类对象，而array是一个方法
ndarray 与 array 的区别关系置顶 wanglll* 2020-02-06 20:00:37 8455 已收藏 17 分类专栏: 数据分析文章标签: numpy 版权 ndarr ...
java string出现次数_Java String方法获取字符出现次数及字符最大相同部分示例
本文实例讲述了Java String方法获取字符出现次数及字符最大相同部分.分享给大家供大家参考,具体如下: package demo; public class Test { public stat ...
扩展js string 方法
eg : //扩展strWith方法 String.prototype.startWith = function (str) { if (str == null || str == " ...

Array方法、String方法

目录