目录
.copyWithin(target，start，end) ES6
.splice(startIndex，number，value)
.forEach(function(element, index, array))
.find(当前的值，当前的位置，原数组)，findIndex()，findLast()，findLastIndex() ES6
.filter(function(element, index, array))
.map(function(element, index, array))
.reduce(function(element, index, array)，origin)
.toReversed()，.toSorted()，.toSpliced()，.with()
.group(数组的当前成员，该成员的位置序号，原数组)，groupToMap(数组的当前成员，该成员的位置序号，原数组)
str.includes(查询的子串，startIndex) ES6
str.indexOf()、str.lastIndexOf()
str.startsWith(查询的子串，startIndex) ES6
str.endsWith(查询的子串，startIndex) ES6
str.slice(startIndex，endIndex)
str.substring(startIndex，endIndex)
一、简介
1、什么是数组？
- 数组是一种复合数据类型，在数组可以存储多个不同类型的数据。
- 数组中存储的是有序的数据，数组中的每个数据都有一个唯一的索引。
- 数组可以通过索引来操作获取数据。
- 数组中存储的数据叫做元素。
- 数组的索引（index）是一组大于0的整数。
2、创建数组
方式一：通过Array()来创建数组
const arr = new Array()方式二：通过[]来创建数组
const arr = []3、数组的数据类型
数组的数据类型是对象
const arr = [1, 2, 3, 4, 5]
console.log(typeof arr) // object4、向数组中添加元素
语法：数组[索引] = 元素
5、读取数组中的元素
语法：数组[索引]
PS：如果读取了一个不存在的元素，不会报错而是返回undefined
6、实例属性：length
作用：获取数组的长度。获取的实际值就是数组的最大索引 + 1
向数组最后添加元素：数组[数组.length] = 元素
const arr = [1, 2, 3, 4, 5]
arr[arr.length] = 6
console.log(arr) // [1, 2, 3, 4, 5, 6]数组的length是可以修改的：
const arr = [1, 2, 3, 4, 5, 6, 7]
arr.length = 5
console.log(arr) // [1, 2, 3, 4, 5]
arr.length = 10
console.log(arr) // [1, 2, 3, 4, 5, 6, 7, empty*3]二、遍历数组
简单理解，就是获取到数组中的每一个元素
方式一：for循环
arr = ["孙悟空", "猪八戒", "沙和尚", "唐僧", "白骨精"]
// 正序遍历
for(let i=0; i<arr.length; i++){
console.log(arr[i])
}
// 倒序遍历
for (let i = arr.length - 1; i >= 0; i--) {
console.log(arr[i])
}方式二：for...of
语法：
for(变量 of 可迭代的对象){
语句...
}执行流程： for-of的循环体会执行多次，数组中有几个元素就会执行几次，每次执行时都会将一个元素赋值给变量value。value可以替换成其他单词。
const arr = ["孙悟空", "猪八戒", "沙和尚", "唐僧"]
for(let value of arr){
console.log(value)
}
// 孙悟空
// 猪八戒
// 沙和尚
// 唐僧三、数组方法（常用）
方法查询地址：Array - JavaScript | MDN (mozilla.org)
------------------------------------------ 静态方法----------------------------------------------
Array.isArray()
作用：用来检查一个对象是否是数组。静态方法。
console.log(Array.isArray({ name: "孙悟空" })) // false
console.log(Array.isArray([1, 2, 3])) // trueArray.from() ES6
将两类对象转为真正的数组：类似数组的对象（array-like object）和可遍历（iterable）的对象（包括 ES6 新增的数据结构 Set 和 Map）
Array.from('hello')
// ['h', 'e', 'l', 'l', 'o']
let namesSet = new Set(['a', 'b'])
Array.from(namesSet) // ['a', 'b']还可以接受一个函数作为第二个参数，作用类似于数组的map()方法，用来对每个元素进行处理，将处理后的值放入返回的数组。
Array.from(arrayLike, x => x * x);
// 等同于
Array.from(arrayLike).map(x => x * x);
Array.from([1, 2, 3], (x) => x * x)
// [1, 4, 9]如果参数是一个真正的数组，Array.from()会返回一个一模一样的新数组
Array.from([1, 2, 3])
// [1, 2, 3]将字符串转为数组，然后返回字符串的长度
Array.of() ES6
用于将一组值，转换为数组。弥补数组构造函数Array()的不足
Array.of(3, 11, 8) // [3,11,8]
Array.of(3) // [3]
Array.of(3).length // 1------------------------------------------ 实例方法（破坏性方法）----------------------------------------------
【破坏性方法，会影响原数组，在原数组上修改】
.copyWithin(target，start，end) ES6
target=要替换的数据（必选），start=开始读取数据的位置，默认0，为负值，表示从末尾开始计算（可选），end=定制读取数据的位置，默认数组长度，为负值，表示从末尾开始计算（可选）
[1, 2, 3, 4, 5].copyWithin(0, 3)
// [4, 5, 3, 4, 5].fill() ES6
用于空数组的初始化非常方便。数组中已有的元素，会被全部抹去。
接受第二个和第三个参数，用于指定填充的起始位置和结束位置
['a', 'b', 'c'].fill(7)
// [7, 7, 7]
new Array(3).fill(7)
// [7, 7, 7].push(value1，value2...)
作用：向数组的末尾添加一个或多个元素，并返回新的长度
参数：value=添加的元素
返回值：新的数组，新的长度
let arr = ["孙悟空", "猪八戒", "沙和尚"]
let result = arr.push("唐僧", "白骨精")
console.log(arr) // ["孙悟空", "猪八戒", "沙和尚", "唐僧", "白骨精"]
console.log(result) // 5 .pop()
作用：删除并返回数组的最后一个元素
参数：无
返回值：数组的最后一个元素
let arr = ["孙悟空", "猪八戒", "沙和尚", "唐僧", "白骨精"]
let result = arr.pop()
console.log(arr) // ["孙悟空", "猪八戒", "沙和尚", "唐僧"]
console.log(result) // 白骨精.unshift(value1，value2...)
作用：向数组的开头添加一个或多个元素，并返回新的长度
参数：value=添加的元素
返回值：新的数组，新的长度
let arr = ["孙悟空", "猪八戒", "沙和尚"]
result = arr.unshift("牛魔王")
console.log(arr) // ["牛魔王","孙悟空", "猪八戒", "沙和尚"]
console.log(result) // 4.shift()
作用：删除并返回数组的第一个元素
参数：无
返回值：数组的第一一个元素
let arr = ["孙悟空", "猪八戒", "沙和尚", "唐僧"]
result = arr.shift()
console.log(arr) // ["猪八戒", "沙和尚", "唐僧"]
console.log(result) // 孙悟空.splice(startIndex，number，value)
作用：可以删除、插入、替换数组中的元素
参数：startIndex=删除的起始位置， number=删除的元素数量，value=要插入的元素（插在被删除的元素原来的地方）。当number=0时，表示在startIndex之前插入value，且若startIndex>=arr.length，value都会在数组最后插入，不会补充empty占位
返回值：返回被删除的元素
let arr = ["孙悟空", "猪八戒", "沙和尚", "唐僧"]
let result = arr.splice(1, 3)
console.log(result) // ["猪八戒", "沙和尚", "唐僧"]
console.log(arr) // ["孙悟空"]
result = arr.splice(1, 1, "牛魔王", "铁扇公主", "红孩儿")
console.log(result) // 猪八戒
console.log(arr) // ["孙悟空", "牛魔王", "铁扇公主", "红孩儿", "沙和尚", "唐僧"]
result = arr.splice(1, 0, "牛魔王", "铁扇公主", "红孩儿")
console.log(arr) // ["孙悟空", "猪八戒", "牛魔王", "铁扇公主", "红孩儿", "沙和尚", "唐僧"].reverse()
作用：反转数组
参数：无
返回值：新数组
let arr = ["a", "b", "c", "d"]
arr.reverse()
console.log(arr) // ["d", "c", "b", "a"].sort()
作用：sort用来对数组进行排序（会对改变原数组）。sort默认会将数组升序排列。sort默认会按照Unicode编码进行排序，所以如果直接通过sort对数字进行排序可能会得到一个不正确的结果。
参数：可以传递一个回调函数作为参数，通过回调函数来指定排序规则。(a, b) => a - b 升序排列。(a, b) => b - a 降序排列。（a表示相邻两个元素的前一个元素，b表示相邻两个元素的后一个元素）
let arr = [2, 3, 1, 9, 0, 4, 5, 7, 8, 6, 10]
console.log(arr) // [0,1,10,2,3,4,5,6,7,8,9]
arr.sort((a, b) => a - b)
console.log(arr) // [0,1,2,3,4,5,6,7,8,9,10]
arr.sort((a, b) => b - a)
console.log(arr) // [10,9,8,7,6,5,4,3,2,1,0].forEach(function(element, index, array))
作用：用来遍历数组
参数：function=回调函数。这个回调函数会被调用多次，数组中有几个元素，回调函数就会调用几次，每次调用，都会将数组中的元素作为参数传递。
回调函数的参数：element=当前的元素，index=当前元素的索引，array=被遍历的数组（可省）。
let arr = ["孙悟空", "猪八戒", "沙和尚", "唐僧"]
arr.forEach((element, index, array) => {
console.log(array) // ["孙悟空", "猪八戒", "沙和尚", "唐僧"]
})
arr.forEach((element, index) => console.log(index, element))
// 0 孙悟空
// 1 猪八戒
// 2 沙和尚
// 3 唐僧数组去重方法
方法一：（在原数组操作）将第一个元素取出，从第二个位置开始依次向后比，不一样的元素留下，一样的元素删掉；将第二个元素取出，从第三个位置开始依次向后比，不一样的元素留下，一样的元素删掉.....重复以上操作
const arr = [1, 2, 1, 3, 2, 2, 4, 5, 5, 6, 7]
// 版本一
// 分别获取数组中的元素
for (let i = 0; i < arr.length; i++) {
// 获取当前值后边的所有值
for (let j = i + 1; j < arr.length; j++) {
// 判断两个数是否相等
if (arr[i] === arr[j]) {
// 出现了重复元素，删除后边的元素
arr.splice(j, 1);
j--; // **重要**
//当arr[i] 和 arr[j]相同时，它会自动的删除j位置的元素，
//然后j+1位置的元素，会变成j位置的元素,而j位置已经比较过了，
//不会重复比较，所以会出现漏比较的情况.
//解决办法，当删除一个元素后，需要将该位置的元素在比较一遍
}
}
}
console.log(arr)
// 版本二
// 获取数组中的元素
for(let i=0; i<arr.length; i++){
const index = arr.indexOf(arr[i], i+1)
if(index !== -1){
// 出现重复内容
arr.splice(index, 1)
i--
}
}
console.log(arr)
方法二：（在新数组操作）
const newArr = []
for(let ele of arr){
if(newArr.indexOf(ele) === -1){
newArr.push(ele)
}
}
console.log(newArr)方法三：使用Set
const arr2 = [1,2,3,2,1,3,4,5,4,6,7,7,8,9,10]
const set2 = new Set(arr2)
console.log([...set2])查找数组重复元素方法
方法一： indeOf(元素第一次出现的索引) 与 lastIndexOf (元素最后一次出现的索引) 的返回值不一致，判断重复出现过
function duplicates(arr) {
let res = [];
arr.forEach((element, index)=>{
if (res.indexOf(element)===-1 && arr.indexOf(element) !== arr.lastIndexOf(element)){
res.push(element)
}
})
return res;
}方法二：sort，某元素前一个不相同但和后一个相同，该元素就是重复元素
function duplicates(arr) {
let newArr = arr.sort();
return newArr.filter((el, index)=> el == newArr[index+1] && el != newArr[index-1])
}方法三：filter + index + lastIndexOf
function duplicates(arr) {
return arr.filter((el, i)=>arr.lastIndexOf(el) != i && i == arr.indexOf(el))
}------------------------------------------ 实例方法（非破坏性方法）----------------------------------------------
【非破坏性方法，不会影响原数组。】
.at(index)
作用：可以根据索引获取数组中的指定元素。可以接收负索引作为参数，表示从数组尾部开始获取。
参数：需要获取的元素的索引
返回值：需要获取的元素
const arr = ["孙悟空", "猪八戒", "沙和尚", "唐僧"]
console.log(arr.at(-2)) // 沙和尚
console.log(arr[arr.length - 2]) // 沙和尚.concat(arr1, arr2, ...)
作用：用来连接两个或多个数组。
参数：需要拼接的数组
返回值：连接的新数组
const arr2 = ["白骨精", "蜘蛛精", "玉兔精"]
let result = arr.concat(arr2, ["牛魔王","铁扇公主"])
console.log(result) // ["白骨精", "蜘蛛精", "玉兔精", "牛魔王","铁扇公主"].indexOf(value, index)
作用：获取元素在数组中第一次出现的索引
参数：value=要查询的元素，index=查询的起始位置
返回值：找到了则返回元素的索引
let arr = ["孙悟空", "猪八戒", "沙和尚", "唐僧", "沙和尚"]
let result = arr.indexOf("沙和尚", 3)
console.log(result) // 2.lastIndexOf(value, index)
作用：获取元素在数组中最后一次出现的位置
参数：value=要查询的元素，index=查询的起始位置（从数组尾部向前查询）
返回值：找到了则返回元素的索引，没有找到返回-1
let arr = ["孙悟空", "猪八戒", "沙和尚", "唐僧", "沙和尚"]
let result = arr.lastIndexOf("沙和尚", 3)
console.log(result) // 2.find(当前的值，当前的位置，原数组)，findIndex()，findLast()，findLastIndex() ES6
找出第一个符合条件的数组成员，如果所有成员都不符合条件，则返回-1。
[1, 4, -5, 10].find((n) => n < 0)
// -5indexOf()方法无法识别数组的NaN成员，但是findIndex()方法可以借助Object.is()方法做到
[NaN].indexOf(NaN)
// -1
[NaN].findIndex(y => Object.is(NaN, y))
// 0.join(str)
作用：将一个数组中的元素连接为一个字符串
参数：str=数组元素间进行连接的字符，如果不需要字符连接，str则为空串""
返回值：连接后的字符串
let arr = ["孙悟空", "猪八戒", "沙和尚", "唐僧", "沙和尚"]
result = arr.join("@-@")
console.log(result) // 孙悟空@-@猪八戒@-@沙和尚@-@唐僧@-@沙和尚@-@
result = arr.join("")
console.log(result) // 孙悟空猪八戒沙和尚唐僧沙和尚.slice(startIndex，endIndex)
作用：用来截取数组。
参数：startIndex=截取的起始位置（包括该位置），endIndex=截取的结束位置（不包括该位置）。第二个参数可以省略不写，如果省略则会一直截取到最后。索引可以是负值。如果将两个参数全都省略，则可以对数组进行浅拷贝（也称为浅复制，对象的复制见数组和对象的拷贝（复制）_Kw_Chng的博客-CSDN博客）
返回值：截取后的数组
arr = ["孙悟空", "猪八戒", "沙和尚", "唐僧"]
result = arr.slice(0, 2)
console.log(result) // ["孙悟空", "猪八戒"]
result = arr.slice(1, 3)
console.log(result) // ["孙悟空", "猪八戒", "沙和尚"]
result = arr.slice(1, -1)
console.log(result) // ["孙悟空", "猪八戒", "沙和尚"].filter(function(element, index, array))
作用：将数组中符合条件的元素保存到一个新数组中返回
参数：function=回调函数。会为每一个元素去调用回调函数，并根据返回值来决定是否将元素添加到新数组中。
回调函数的参数：element=当前的元素，index=当前元素的索引，array=被遍历的数组。
返回值：每次回调函数都会返回数组中的一个元素
let arr = [1, 2, 3, 4, 5, 6, 7, 8]
// 获取数组中的所有偶数
let result = arr.filter((element) => ele % 2 === 0)
console.log(result) // [0,2,4,6,8]
let result = arr.filter((element) => true)
console.log(result) // [1, 2, 3, 4, 5, 6, 7, 8]
let result = arr.filter((element) => false)
console.log(result) // [].map(function(element, index, array))
作用：根据当前数组生成一个新数组。
参数：function=回调函数。回调函数的返回值会成为新数组中的元素。
回调函数的参数：element=当前的元素，index=当前元素的索引，array=被遍历的数组。
返回值：每次回调函数都会返回数组中的一个元素
let arr = [1, 2, 3, 4, 5, 6, 7, 8]
let result = arr.map((element) => 123) // arr有8个元素，每次执行都会将123加入新数组
console.log(result) // [123, 123, 123, 123, 123, 123, 123, 123]
result = arr.map((ele) => ele * 2)
console.log(result) // [2, 4, 6, 8, 10, 12, 14, 16].reduce(function(element, index, array)，origin)
作用：用来将一个数组中的所有元素整合为一个值
参数：function=回调函数，通过回调函数来指定合并的规则。origin=初始值（可选参数）。
let arr = [1, 2, 3]
result = arr.reduce((a, b) => {
console.log(a, b) // 第1次：1,2 第2次：3,3 （都是将新的结果作为前一个元素）
return a + b // 第1次：1+2=3，第2次：3+3=6
})
console.log(result) // 3+6=9
// 实际上求数组的和
.entries()，.keys()，.values()
用于遍历数组。它们都返回一个遍历器对象。可以用for...of循环进行遍历，唯一的区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历。
for (let index of ['a', 'b'].keys()) {
console.log(index);
}
// 0
// 1
for (let elem of ['a', 'b'].values()) {
console.log(elem);
}
// 'a'
// 'b'
for (let [index, elem] of ['a', 'b'].entries()) {
console.log(index, elem);
}
// 0 "a"
// 1 "b".includes()
返回一个布尔值，表示某个数组是否包含给定的值，与字符串的includes方法类似
[1, 2, 3].includes(2) // true
[1, 2, 3].includes(4) // false
[1, 2, NaN].includes(NaN) // true.flat()，flatMap()
flat()方法将子数组的成员取出来，添加在原来的位置。
flat()默认只会“拉平”一层，如果想要“拉平”多层的嵌套数组，可以将flat()方法的参数写成一个整数，表示想要拉平的层数，默认为1
flatMap()方法对原数组的每个成员执行一个函数（相当于执行Array.prototype.map()），然后对返回值组成的数组执行flat()方法。只能展开一层数组
.toReversed()，.toSorted()，.toSpliced()，.with()
许对数组进行操作时，不改变原数组，而返回一个原数组的拷贝
toReversed()对应reverse()，用来颠倒数组成员的位置。toSorted()对应sort()，用来对数组成员排序。toSpliced()对应splice()，用来在指定位置，删除指定数量的成员，并插入新成员。with(index, value)对应splice(index, 1, value)，用来将指定位置的成员替换为新的值。
const sequence = [1, 2, 3];
sequence.toReversed() // [3, 2, 1]
sequence // [1, 2, 3]
const outOfOrder = [3, 1, 2];
outOfOrder.toSorted() // [1, 2, 3]
outOfOrder // [3, 1, 2]
const array = [1, 2, 3, 4];
array.toSpliced(1, 2, 5, 6, 7) // [1, 5, 6, 7, 4]
array // [1, 2, 3, 4]
const correctionNeeded = [1, 1, 3];
correctionNeeded.with(1, 2) // [1, 2, 3]
correctionNeeded // [1, 1, 3].group(数组的当前成员，该成员的位置序号，原数组)，groupToMap(数组的当前成员，该成员的位置序号，原数组)
group()根据分组函数的运行结果，将数组成员分组
groupToMap()的作用和用法与group()完全一致，唯一的区别是返回值是一个 Map 结构，而不是对象。
四、字符串
字符串其本质就是一个字符数组
"hello" --> ["h", "e", "l", "l", "o"]字符串的很多方法都和数组是非常类似的。
属性：
.length 获取字符串的长度
字符串[索引] 获取指定位置的字符
原生方法：
String.fromCodePoint() （ES6）
-从 Unicode 码点返回对应字符，与ES5的String.fromCharCode()相比，识别大于0xFFFF的字符
String.raw() （ES6）
- 返回一个斜杠都被转义（即斜杠前面再加一个斜杠）的字符串，往往用于模板字符串的处理方法
String.raw({ raw: ['foo', 'bar'] }, 1 + 2) // "foo3bar"实例方法：
str.at() （实验方法）
- 根据索引获取字符，可以接受负索引
str.charAt()
- 根据索引获取字符
str.concat()
- 用来连接两个或多个字符串
str.includes(查询的子串，startIndex) ES6
- 用来检查字符串中是否包含某个内容，有返回true，没有返回false
str.indexOf()、str.lastIndexOf()
- 查询字符串中是否包含某个内容，有则返回第一次出现的索引
str.startsWith(查询的子串，startIndex) ES6
- 检查一个字符串是否以指定内容开头
str.endsWith(查询的子串，startIndex) ES6
- 检查一个字符串是否以指定内容结尾
str.padStart(保持的长度，添加的内容) ES6
- 通过在字符串前添加指定的内容，使字符串保持某个长度，不写添加的内容补充空格
str = "100"
console.log(str.padStart(7, "0")) // 0000100str.padEnd(保持的长度，添加的内容) ES6
- 通过在字符串后添加指定的内容，使字符串保持某个长度，不写添加的内容补充空格
str = "100"
console.log(str.padEnd(7, "0")) // 1000000str.replace()
- 使用一个新字符串替换一个指定内容
str = "hello hello how are you"
result = str.replace("hello", "abc")
console.log(result) // abc hello how are youstr.replaceAll()
- 使用一个新字符串替换所有指定内容
// $& 表示匹配的字符串，即`b`本身
// 所以返回结果与原字符串一致
'abbc'.replaceAll('b', '$&')
// 'abbc'
// $` 表示匹配结果之前的字符串
// 对于第一个`b`，$` 指代`a`
// 对于第二个`b`，$` 指代`ab`
'abbc'.replaceAll('b', '$`')
// 'aaabc'
// $' 表示匹配结果之后的字符串
// 对于第一个`b`，$' 指代`bc`
// 对于第二个`b`，$' 指代`c`
'abbc'.replaceAll('b', `$'`)
// 'abccc'
// $1 表示正则表达式的第一个组匹配，指代`ab`
// $2 表示正则表达式的第二个组匹配，指代`bc`
'abbc'.replaceAll(/(ab)(bc)/g, '$2$1')
// 'bcab'
// $$ 指代 $
'abc'.replaceAll('b', '$$')
// 'a$c'str = "hello hello how are you"
result = str.replaceAll("hello", "abc")
console.log(result) // abc abc how are youstr.slice(startIndex，endIndex)
- 对字符串进行切片，区间左闭右开
str.substring(startIndex，endIndex)
- 截取字符串，区间左闭右开
str = "hello hello how are you"
result = str.slice(12, 15)
console.log(result) // how
result = str.slice(15, 12)
console.log(result) //
result = str.substring(12, 15)
console.log(result) // how
result = str.substring(15, 12) // 自动交换前后位置
console.log(result) // howstr.split(str1)
- 用来将一个字符串拆分为一个数组
str = "abc@bcd@efg@jqk"
result = str.split("@")
console.log(result) // ["abc", "bcd", "efg", "jqk"]str.toLowerCase()
- 将字符串转换为小写
str = "abcdABCD"
result = str.toLowerCase()
console.log(result) // abcdabcdstr.toUpperCase()
- 将字符串转换为大写
str.trim()
- 去除前后空格
str = " ab c "
result = str.trim()
console.log(result) // ab cstr.trimStart() ES6
- 去除开始空格
str = " ab c "
result = str.trimStart()
console.log(result) // “ab c ”str.trimEnd() ES6
- 去除结束空格
str = " ab c "
result = str.trimEnd()
console.log(result) // “ ab c”Unicode 表示法 （ES6）
-采用\uxxxx形式表示一个字符，其中xxxx表示字符的 Unicode 码点
str.codePointAt() ES6
-处理 4 个字节储存的字符，返回一个字符的码点
let s = '𠮷a';
s.codePointAt(0) // 134071
s.codePointAt(1) // 57271
s.codePointAt(2) // 97-测试一个字符由两个字节还是由四个字节组成
is32Bit("𠮷") // true
is32Bit("a") // falsestr.normalize() ES6
-将字符的不同表示方法统一为同样的形式，这称为 Unicode 正规化
str.repeat(重复次数n) ES6
-返回一个新字符串，表示将原字符 串重复n次。
n为小数会取整，负数或者Infinity，会报错，为NaN等同于 0，是字符串，则会先转换成数字
'x'.repeat(3) // "xxx"
'hello'.repeat(2) // "hellohello"
'na'.repeat(0) // ""
'na'.repeat('na') // ""
'na'.repeat('3') // "nanana"str.matchAll(正则表达式) ES6
返回一个包含所有匹配正则表达式的结果及其分组捕获组的迭代器
str.match(正则表达式) ES6
返回正则表达式的搜索结果，结果以数组形式呈现，找不到就undefined
要查询一个字符串中子字符串出现的次数，可以直接找str.match(子字符串).length
遍历字符串
for...of
for (let i of text) {
console.log(i);
}模板字符串
反引号包裹，如果在模板字符串中需要使用反引号，则前面要用反斜杠转义。
let greeting = `\`Yo\` World!`;如果使用模板字符串表示多行字符串，所有的空格和缩进都会被保留在输出之中
模板字符串中嵌入变量，需要将变量名写在${}之中
`User ${user.name} is not authorized to do ${action}.`)模板字符串之中还能调用函数
function fn() {
return "Hello World";
}
`foo ${fn()} bar`
// foo Hello World bar模板字符串还能嵌套
const tmpl = addrs => `
<table>
${addrs.map(addr => `
<tr><td>${addr.first}</td></tr>
<tr><td>${addr.last}</td></tr>
`).join('')}
</table>
`;标签模版
模板字符串可以紧跟在一个函数名后面，该函数将被调用来处理这个模板字符串。这被称为“标签模板”功能。标签模板其实不是模板，而是函数调用的一种特殊形式。“标签”指的就是函数，紧跟在后面的模板字符串就是它的参数。
作用：
过滤 HTML 字符串，防止用户输入恶意内容
多语言转换（国际化处理）
945
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
