JavaScript------数组、字符串
目录
一、简介
1、什么是数组？
2、创建数组
3、数组的数据类型
4、向数组中添加元素
5、读取数组中的元素
6、实例属性：length
二、遍历数组
方式一：for循环
方式二：for...of
三、数组方法（常用）
Array.isArray()
Array.from() ES6
Array.of() ES6
.copyWithin(target，start，end) ES6
.fill() ES6
.push(value1，value2...)
.pop()
.unshift(value1，value2...)
.shift()
.splice(startIndex，number，value)
.reverse()
.sort()
.forEach(function(element, index, array))
数组去重方法
.at(index)
.concat(arr1, arr2, ...)
.indexOf(value, index)
.lastIndexOf(value, index)
.find(当前的值，当前的位置，原数组)，findIndex()，findLast()，findLastIndex() ES6
.join(str)
.slice(startIndex，endIndex)
.filter(function(element, index, array))
.map(function(element, index, array))
.reduce(function(element, index, array)，origin)
.entries()，.keys()，.values()
.includes()
.flat()，flatMap()
.toReversed()，.toSorted()，.toSpliced()，.with()
.group(数组的当前成员，该成员的位置序号，原数组)，groupToMap(数组的当前成员，该成员的位置序号，原数组)
四、字符串
属性：
原生方法：
String.fromCodePoint() （ES6）
String.raw() （ES6）
实例方法：
str.at() （实验方法）
str.charAt()
str.concat()
str.includes(查询的子串，startIndex) ES6
str.indexOf()、str.lastIndexOf()
str.startsWith(查询的子串，startIndex) ES6
str.endsWith(查询的子串，startIndex) ES6
str.padStart(保持的长度，添加的内容) ES6
str.padEnd(保持的长度，添加的内容) ES6
str.replace()
str.replaceAll()
str.slice(startIndex，endIndex)
str.substring(startIndex，endIndex)
str.split(str1)
str.toLowerCase()
str.toUpperCase()
str.trim()
str.trimStart() ES6
str.trimEnd() ES6
Unicode 表示法 （ES6）
str.codePointAt() ES6
str.normalize() ES6
str.repeat(重复次数n) ES6
str.matchAll(正则表达式) ES6
str.match(正则表达式) ES6
遍历字符串
模板字符串
标签模版
一、简介
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= 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方法二：（在新数组操作）
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 => `
${addrs.map(addr => `
${addr.first} ${addr.last}
`;标签模版
模板字符串可以紧跟在一个函数名后面，该函数将被调用来处理这个模板字符串。这被称为“标签模板”功能。标签模板其实不是模板，而是函数调用的一种特殊形式。“标签”指的就是函数，紧跟在后面的模板字符串就是它的参数。
作用：
过滤 HTML 字符串，防止用户输入恶意内容
多语言转换（国际化处理）