最近的工作让我认识到js基础是很重要的，所以这两天抽时间总结一下！因为方法众多，很多时候都会忘记，我也会分享自己记忆的一些方法，帮助大家烂熟于心，也不用每次用到的时候都上网查，让我们开始
一、数组（array）（数组的遍历方法，请看另一篇文章 juejin.cn/post/684490…
1.1 arr.push()
方法：arr.push();
作用：向数组的最后面添加元素
参数：一个或多个元素
返回值：新数组的长度
let arr = [1,2,3]
let arr1 = arr.push('a',['b','c'])
console.log(arr1) // 5
console.log(arr) // [1,2,3,'a',['b','c']]
1.2 arr.pop()
方法：arr.pop()
作用：把数组的最后一个元素删除
参数：没有参数
返回值：删除的那个元素
let arr = [1,2,'3']
let arr1 = arr.pop()
console.log(arr1) // '3'
console.log(arr) // [1,2]
1.3 arr.unshift()
方法：arr.unshift()
作用：向数组的最前面添加元素
参数：一个或多个元素
返回值：新数组的长度
ps：跟push的方法类似
1.4 arr.shift()
方法：arr.shift()
参数：没有参数
作用：把数组的第一个元素删除
返回值：删除的那个元素
ps:跟pop方法类似
上面四种方法就是数组的删除和增加，长的是增，短的是删，主要的记忆在返回值，这里我跟大家说一下我的理解，增加的方法： 因为增加后的数组我可以看到所以返回数组长度，删除的方法： 因为删除是危险的操作，而且删除的那一项已经从本来的数组丢失，所以可能找不到了，所以返回值是删除的那一项
1.5 arr.join()
作用：把数组arr的值按照参数（）中的字符拼接成字符串
参数：','，'-'，'|'等（默认是','）
返回值：拼接成的字符串
let arr = [1,'1','a',3]
let str = arr.join("-")
console.log(str) // '1-1-a-3'
let str1 = arr.join()
console.log(str1) // '1,1,a,3'
let str2 = arr.join('')
console.log(str2) // '11a3'
1.6 arr.concat(arr2)
作用：将两个或多个数组合并（不会改变原数组）
参数：一个或多个数组
返回值：合并后新的数组
let arr1 = [1,2,3]
let arr2 = ['a','b','c']
let arr = arr1.concat(arr2)
console.log(arr)
1.7 arr.slice(begin,end)（摘抄来源mdn developer.mozilla.org/zh-CN/docs/…
作用：返回一个新的数组对象，这一对象是一个由 begin和 end（不包括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 也会一直提取到原数组末尾。
返回值：一个含有提取元素的新数组
let arr = [1,2,3]
let a1 = arr.slice(1,2)
console.log(a1) // [2] 包含start，不包含end
1.8 arr.splice(start,deleteCount,items)
作用： 方法通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组
参数： start 表示指定修改（删除，替换）的下标，如果是负数，则表示从数组末位开始的第几位；如果负数的绝对值大于数组的长度，则表示开始位置为第0位；deleteCount 表示需要移除元素的个数（可选，整数）;item1,item2 要添加进数组的元素,从start 位置开始。如果不指定，则 splice() 将只删除数组元素
返回值： 由被删除的元素组成的一个数组
// ===================start=====================
let arr = [1,2,3,4,5]
let a1 = arr.splice(0)
console.log(a1,arr) // [1,2,3,4,5],[]改变了原数组
arr = [...a1]
let a2 = arr.splice(10)
console.log(a2) // []超过了数组长度从数组末尾开始添加内容
let a3 = arr.splice(-2)
console.log(a3) // [4,5] 从数组倒数第一个开始截取到结束
arr = [...a1]
let a4 = arr.splice(-10)
console.log(a4) // [1,2,3,4,5]如果负数绝对值大于数组长度则从数组第0位开始截取，到结束
// ===================start=====================
// ===================deleteCount=====================
// 上面的例子都么有写第二个参数，所以如果deleteCount如果省略代表start之后的所有元素都被删除（包含start）
let arr2 = [1,2,3,4,5,6]
let a5 = arr2.splice(1,2)
console.log(a5) // [2,3]
// ===================deleteCount=====================
// ===================item=====================
let arr3 = [1,2,3,4,5,6,7]
let a6 = arr3.splice(2,3,{name:'zs',age:18})
console.log(a6) // [2,3,4]
console.log(arr3) // [1,{name:'zs',age:18},5,6,7]
// ===================item=====================
1.9 arr.indexOf(searchElement,fromIndex)
作用： 返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1
参数： searchElement：要查找的元素，fromIndex：数组开始查找的位置,如果参数中提供的索引值是一个负值,-1表示从最后一个元素开始查找，-2表示从倒数第二个元素开始查找 ，以此类推
返回值： 首个被找到的元素在数组中的索引位置; 若没有找到则返回 -1
let arr = [1,'zs','ls',2,true,false,'zs']
let index = arr.indexOf('zs')
console.log(index) // 1
let index1 = arr.indexOf('zs',-2)
console.log(index1) // 6
1.10 arr.lastIndexOf(searchElement,fromIndex)
作用： 返回指定元素在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从 fromIndex 处开始
参数： 同indexOf
返回值： 同indexOf
let arr = [1,'zs','ls',2,true,false,'zs']
let index = arr.lastIndexOf('zs')
console.log(index) // 6
index = arr.lastIndexOf('zs',1)
console.log(index) // 1
1.11 arr.reverse()
作用： 方法将数组中元素的位置颠倒,并返回该数组。该方法会改变原数组
参数： 无
返回值： 该数组
let arr = ['one','two','three']
arr.reverse()
console.log(arr) //["three", "two", "one"]
1.12 arr.toString()
作用： 返回一个字符串，表示指定的数组及其元素
参数： 无
返回值： 用","隔开的数组的字符串
let arr = [1,'a',2,'b']
let str = arr.toString()
console.log(str) // "1,a,2,b"
str = arr.join(',')
console.log(str) // '1,a,2,b'
1.13 arr.sort(compareFunction)
作用： 对数组里的元素进行排序，并返回数组，默认排序顺序是在将元素转换为字符串
参数： 函数（可以省略）
返回值： 排序后的数组，改变了原数组
let arr = [2,1,4,2,46,7,8]
let a1 = arr.sort(function (a,b) { return a-b})
console.log(a1,arr) // [1, 2, 2, 4, 7, 8, 46]
扩展： 我还写了一个数组里有对象，根据数组对象的属性进行排序的方式，附上链接： juejin.cn/post/684490…
1.14 arr.reduce()
作用： reduce() 方法对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。
参数：
一、函数： reducer 函数接收4个参数:
- Accumulator (acc) (累计器)
- Current Value (cur) (当前值)
- Current Index (idx) (当前索引)
- Source Array (src) (源数组)
- 数组遍历的时候是三个参数item(current value)，index，arr）这里增加了一个accumulator
二、 initialValue作为第一次调用 callback函数时的第一个参数的值。 如果没有提供初始值，则将使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错。（可选，就是给accumulate附一个初始值，如果不写默认item的第一个值赋给accumulate）
返回值： 函数累计处理的结果
let arr = [1, 2, 3, 4, 5]
// 数组的reduce这个函数有两种用法
// 1. 传初始化 reduce需要传两个参数，参数1： 函数 参数2：初始值
// 2. 不传初始化， reduce只需要一个参数，，参数：函数
let result = arr.reduce(function(total, item) {
console.log(item)
return total + item
}, 0)
console.log(result)
扩展： 我还写了一个数组里有对象，根据数组对象的属性进行排序的方式，附上链接： juejin.cn/post/684490…
二、字符串（string，字符串的方法都不会操作原字符串）
2.1 str.split(separator,limit)
作用： 分割字符串为数组（方法使用指定的分隔符字符串将一个String对象分割成字符串数组，以将字符串分隔为子字符串，以确定每个拆分的位置。）
参数： 没有参数的情况会把字符串变成一个整体的数组， separator 指定表示每个拆分应发生的点的字符串。separator 可以是一个字符串或正则表达式。如果不存在，分割为一个整体的数组 limit 一个整数，限定返回的分割片段数量。
返回值： 返回源字符串分割后的一个数组
let str = 'hello word!!! I am Chinese'
let a1 = str.split()
console.log(a1) // ["hello word!!! I am Chinese"]
let a2 = str.split('')
console.log(a2) // ["h", "e", "l", "l", "o", " ", "w", "o", "r", "d", "!", "!", "!", " ", "I", " ", "a", "m", " ", "C", "h", "i", "n", "e", "s", "e"]
let a3 = str.split(' ')
console.log(a3) // ["hello", "word!!!", "I", "am", "Chinese"]
let a4 = str.split(',')
console.log(a4) // ["hello word!!! I am Chinese"]
=========还有一个有趣的例子=========
let replace = str.split('word').join('USA')
console.log(replace) // 'hello USA!!! I am Chinese'
// 这个起到了replace的作用，下面也会讲到replace
2.2 str.substring(indexStart，indexEnd) // substr MDN已经不推荐使用
作用： 截取字符串（字符串在开始索引到结束索引之间的一个子集）
参数： indexStart 截取的第一个字符的索引，indexEnd 截取的最后一个字符的索引（不包含本身）
返回值： 根据条件截取后的字符串
let str = 'hello word!!! I am Chinese'
let s1 = str.substring() // "hello word!!! I am Chinese"
let s2 = str.substring(2,2) // "" 如果 indexStart 等于 indexEnd，substring 返回一个空字符串
let s3 = str.substring(-1,5) // 'hello'
s3 = str.substring(5,-1) // 'hello' 如果任一参数小于 0 或为 NaN，则被当作 0,如果 indexStart 大于 indexEnd，则 substring的执行效果就像两个参数调换了一样
let s4 = str.substring(2,1) //
2.3 str.indexOf(searchValue,fromIndex)
作用： 方法返回调用它的 String 对象中第一次出现的指定值的索引，从 fromIndex 处进行搜索。如果未找到该值，则返回 -1
参数： searchElement：要查找的元素字符串 fromIndex 表示开始查找的位置，默认为0，如果小于0（当做0），如果大于等于数组长度，返回-1
返回值： 第一次出现的索引，如果没找到，返回-1，
let str = 'hello word!!! I am Chinese'
let s1 = str.indexOf('e')
console.log(s1) // 1
let s2 = str.indexOf('e',1)
console.log(s2) // 1
let s3 = str.indexOf('e',2)
console.log(s3) // 23
let s4 = str.indexOf('e',-7)
console.log(s4) // 1
let s5 = str.indexOf('e',100)
console.log(s5) // -1
let s6 = str.indexOf('ab')
console.log(s6) // -1
2.4 str.slice(begin,end)
作用： 截取字符串的一部分
详情请看上面1.7数组的slice的方法
let str = 'hello word!!! I am Chinese'
let s1 = str.slice()
console.log(s1) // 'hello word!!! I am Chinese' 默认参数是begin 是0
let s2 = str.slice(6)
console.log(s2) // 'word!!! I am Chinese'
let s3 = str.slice(6,13)
console.log(s3)
let s4 = str.slice(-7)
console.log(s4) // 'Chinese'
let s5 = str.slice(-7,-2)
console.log(s5) //'Chine'
let s6 = str.slice(-7,-8)
console.log(s6) // ''
2.5 str.trim()
作用： 去除字符串两边的空格（中间的空格不去除）
let str = ' hello word!!! I am Chinese '
let s1 = str.trim() // hello word!!! I am Chinese
2.6 str.replace(pattern,replacement)
作用： 由替换值（replacement）替换一些或所有匹配的模式（pattern）后的新字符串。模式可以是一个字符串或者一个正则表达式，替换值可以是一个字符串或者一个每次匹配都要调用的回调函数
参数： pattern可以是一个正则表达式（正则所匹配到的内容都会被替代），也可以是一个字符串（只有第一个匹配到的字符串被替换），replacement用于替换原字符串中匹配的字符串
返回值： 一个替换了部分匹配或者全部匹配后的新的字符串
let str = 'hello word!!! I am Chinese'
let s1 = str.replace('o', 'a') // 'hella word!!! I am Chinese' 只替换了第一个
let regex = /o/gi
let s2 = str.replace(regex,'a') //"hella ward!!! I am Chinese" 替换了所有的'o'
2.7 str.charAt(index)
作用： 取字符串下标为index的那一项字符
let str = 'hello word!!! I am Chinese'
let s1 = str.charAt(2) // 'l'
2.8 str.toUpperCase()
作用： 字符串值转换为大写形式
console.log('abCDe'.toUpperCase()) // 'ABCDE'
2.9 str.str.toLowerCase()
作用： 字符串值转换为小写形式
console.log('abCDe'.toLowerCase()) // 'abcde'
三、set（可以看做数组，但是不能重复的数组（let list = new Set()））
3.1 追加元素list.add(element)
参数：添加的元素
作用：添加元素
返回值：追加后新的set数据结构
其它：一次只能追加一个
3.2 删除元素list.add('add')
参数：删除的元素
作用：删除元素
返回值：成功返回true，失败返回false
3.3 清理元素list.clear()
参数：no
作用：清空set数据结构
返回值：没有返回值
3.4 判断是否存在list.has(element)
参数：判断是否存在的元素
作用：判断set数据结构中是否存在参数
返回值：存在返回true，不存在返回false
3.5 Set的长度list.size
参数：no
作用：set的长度，没有括号
返回值：返回list数据结构的长度
