String相关的方法 | OneYoung's Blog

本章记录了字符串常用的一些方法。

1.字节相关

这部分主要与字符串的字节相关。

1-1.str.charAt()

语法：str.charAt(index)。

含义：返回字符串中的指定索引处的字符。

参数：

index: 一个介于 0 和字符串长度减 1 之间的整数。 (0~length-1)如果没有提供索引，charAt() 将使用 0。如果大于 length - 1，返回会是空字符串 ''。

var str = 'Hello'
console.log(str.charAt(0)) // H
console.log(str.charAt(1)) // e
console.log(str.charAt(5)) // ''

1-2.str.charCodeAt()

语法：str.charCodeAt(index)

含义：返回 0 到 65535 之间的整数，表示给定索引处的 UTF-16 代码单元。

参数：

index: 一个大于等于 0，小于字符串长度的整数。如果不是一个数值，则默认为 0。

返回值：指定 index 处字符的 UTF-16 代码单元值的一个数字；如果 index 超出范围，charCodeAt() 返回 NaN。

var str = "aBC"
console.log(str.charCodeAt(0)) // 97
console.log(str.charCodeAt(1)) // 66
console.log(str.charCodeAt(2)) // 67
var emoji = '😂'
console.log(str.charCodeAt(0)) // 55357
console.log(str.charCodeAt(1)) // 56834

1-3.str.codePointAt()

语法：str.codePointAt(index)

含义：返回一个 Unicode 编码点值的十进制非负整数。该方法返回是 Unicode，注意与 charCodeAt() 方法的区别。

参数：

index: 一个大于等于 0，小于字符串长度的整数。如果不是一个数值，则默认为 0。

返回值：是在字符串中的给定索引的编码单元体现的数字，如果在索引处没找到元素则返回 undefined。

var emoji = '😂'
console.log(emoji.length) // 2
console.log(emoji.charAt(0)) // �
console.log(emoji.charAt(1)) // �
console.log(emoji.charCodeAt(0)) // 55357
console.log(emoji.charCodeAt(1)) // 56834
console.log(emoji.codePointAt(0)) // 128514
console.log(emoji.codePointAt(1)) // 56834
console.log(Array.from(emoji).length) // 1

可以看到，codePointAt 会将 😂 看做两个字符，codePointAt(0) 会返回 😂 对应的正确十进制数字，但 codePointAt(1) 与 charCodeAt(1) 的返回结果一致，这很明显是一个问题。

解决此问题的根本在于需要正确的判定字符串长度，方案有三：

var emoji = '😂'
// 1.利用Array.from
Array.from(emoji).forEach(item => console.log(item.codePointAt())) // 128514
// 2.利用展开运算符
[...emoji].forEach(item => console.log(item.codePointAt())) // 128514
// 3.利用for...of
for (var item of emoji) {
  console.log(item.codePointAt()) // 128514
}

1-4.String.fromCharCode()

语法：String.fromCharCode(charCode, ..., charCode)

含义：找出由指定的 UTF-16 代码单元序列创建的字符串。该方法与 charCodeAt() 对应。

参数：charCode，在 [0, 2^16) 之间的数字。最大值为 65535。

console.log(String.fromCharCode(65, 66, 67)) // ABC
console.log(String.fromCharCode(520)) // Ȉ

1-5.String.fromCodePoint()

语法：String.fromCodePoint(codePoint, ..., codePoint)

含义：找出指定的 Unicode 创建的字符串。该方法与 codePointAt() 对应。

参数：codePoint 码点，即 Unicode 码。如果传入无效的 Unicode 编码，将会抛出一个 RangeError。

// 可以是十进制
console.log(String.fromCodePoint(128514))
// 也可以是十六进制
console.log(String.fromCodePoint(0x1f602))

2.操作相关

str.concat()

concat() 方法将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回。

concat 方法并不影响原字符串。

str.concat(str2, [, ...strN])

TIP

由于性能原因，强烈建议使用赋值操作符（+, +=）代替 concat 方法。

let hello = 'Hello'
console.log(hello.concat(' ', 'world')) // 'Hello world'

let greetList = ['Hello', ' ', 'world']
"".concat(...greetList)  // "Hello world"

"".concat({})    // [object Object]
"".concat([])    // ""
"".concat(null)  // "null"
"".concat(true)  // "true"
"".concat(4, 5)  // "45"

str.slice()

slice() 方法提取某个字符串的一部分，并返回一个新的字符串，且不会改动原字符串。

str.slice(beginIndex[, endIndex])

beginIndex: 从该索引（以 0 为基数）处开始提取原字符串中的字符。如果值为负数，会被当做 strLength + beginIndex 看待，这里的strLength 是字符串的长度。
endIndex: 可选。在该索引处结束提取字符串。如果省略该参数，slice() 会一直提取到字符串末尾。

var str = 'Hello world'
console.log(str.slice(0))     // 'Hello world'
console.log(str.slice(0, 6))  // 'Hello'
console.log(str.slice(-5))    // 'world'

str.split()

split() 方法使用指定的分隔符字符串将一个 String 对象分割成子字符串数组，以一个指定的分割字串来决定每个拆分的位置。

str.split([separator[, limit]])

separator: 指定表示每个拆分应发生的点的字符串。separator 可以是一个字符串或正则表达式。
limit: 一个整数，限定返回的分割片段数量。

var myString = "Hello World. How are you doing?"
var splits = myString.split(" ", 3)

console.log(splits) // ["Hello", "World.", "How"]

// 依靠正则进行分割
// 该例会以数字进行分割
var myString = "Hello 1 word. Sentence number 2."
var splits = myString.split(/(\d)/)

console.log(splits) // [ "Hello ", "1", " word. Sentence number ", "2", "." ]

// 如果分割符不是字符串类型或者正则类型的话 会默认将分割符转化为字符串类型 再进行分割
const myString = 'ca,bc,a,bca,bca,bc'

const splits = myString.split(['a','b'])
// myString.split(String(['a','b']))

console.log(splits)  //["c", "c,", "c", "c", "c"]

str.substring()

substring() 方法返回一个字符串在开始索引到结束索引之间的一个子集, 或从开始索引直到字符串的末尾的一个子集。

str.substring(indexStart[, indexEnd])

indexStart: 需要截取的第一个字符的索引，该索引位置的字符作为返回的字符串的首字母。
indexEnd: 可选。一个 0 到字符串长度之间的整数，以该数字为索引的字符不包含在截取的字符串内。

var str = 'Hello world'
console.log(str.substring(0))     // 'Hello world'
console.log(str.substring(0, 6))  // 'Hello'
console.log(str.substring(-5))    // 'Hello world'

TIP

其实，substring 与 slice 的用法基本完全一致。

两者唯一的区别在于对可选参数的负值处理。

详见：slice()、 substring()和substr()的区别

str.substr()

TIP

虽然 substr() 方法没有严格的被废弃，但该方法并非 JavaScript 核心语言的一部分，未来将可能会被移除掉。

所以尽量使用 slice() 或者 substring() 方法来替代。

substr() 方法返回一个字符串中从指定位置开始到指定字符数的字符。

str.substr(start[, length])

start: 开始提取字符的位置。如果为负值，则被看作 strLength + start，其中 strLength 为字符串的长度。
length: 可选。提取的字符数。如果 length 为 0 或 负值，则统一看做 0。如果未指定，则读取剩余的所有字符串长度。

var str = 'Hello world'
console.log(str.substr(0))      // 'Hello world'
console.log(str.substr(0, 6))   // 'Hello'
console.log(str.substr(0, -6))  // ''
console.log(str.substr(-5))     // 'world'

str.toString()

toString() 方法返回指定对象的字符串形式。

str.toString()

String 对象覆盖了 Object 对象的 toString 方法，并没有继承 Object.toString()。

对于 String 对象，toString 方法返回该对象的字符串形式，和 String.prototype.valueOf() 方法返回值一样。

var x = new String('Hello world')

console.log(x.toString())  // 'Hello world'

str.valueOf()

valueOf() 方法返回 String 对象的原始值。

str.valueOf()

TIP

该 valueOf() 方法等同于 toString() 方法。

此方法通常由 JavaScript 在内部调用，而不是在代码中显式调用。

var x = new String('Hello world')
console.log(x.valueOf()) // 'Hello world'

str.repeat()

repeat() 构造并返回一个新字符串，该字符串包含被连接在一起的指定数量的字符串的副本。

str.repeat(count)

count: 介于 0 和 +Infinity 之间的整数。表示在新构造的字符串中重复了多少遍原字符串。

"abc".repeat(-1)     // RangeError: repeat count must be positive and less than inifinity
"abc".repeat(0)      // ""
"abc".repeat(1)      // "abc"
"abc".repeat(2)      // "abcabc"
"abc".repeat(3.5)    // "abcabcabc" 参数count将会被自动转换成整数.
"abc".repeat(1/0)    // RangeError: repeat count must be positive and less than inifinity

3.遍历相关

str.startsWith()

startsWith() 方法用来判断当前字符串是否以另外一个给定的子字符串开头，并根据判断结果返回 true 或 false。

str.startsWith(searchString[, position])

searchString: 要搜索的子字符串。
position: 在 str 中搜索 searchString 的开始位置，默认值为 0。

var str = "To be, or not to be, that is the question."

alert(str.startsWith("To be"))         // true
alert(str.startsWith("not to be"))     // false
alert(str.startsWith("not to be", 10)) // true

str.endsWith()

endsWith() 方法用来判断当前字符串是否是以另外一个给定的子字符串“结尾”的，根据判断结果返回 true 或 false。

str.endsWith(searchString[, length])

searchString: 要搜索的子字符串。
length: 作为 str 的长度。默认值为 str.length。

var str = 'Hello world!'
console.log(str.endsWith('!')) // true
console.log(str.endsWith('!', 3)) // false

str.indexOf()

indexOf() 方法返回调用它的 String 对象中第一次出现的指定值的索引，从 fromIndex 处进行搜索。如果未找到该值，则返回 -1。

str.indexOf(searchValue [, fromIndex])

searchValue: 要被查找的字符串值。
fromIndex: 数字表示开始查找的位置。可以是任意整数，默认值为 0。

var str = 'Hello world'
console.log(str.indexOf('world')) // 6

str.lastIndexOf()

lastIndexOf() 方法返回调用 String 对象的指定值最后一次出现的索引，在一个字符串中的指定位置 fromIndex 处从后向前搜索。如果没找到这个特定值则返回 -1。

str.lastIndexOf(searchValue[, fromIndex])

searchValue: 一个字符串，表示被查找的值。如果 searchValue 是空字符串，则返回 fromIndex。
fromIndex: 待匹配字符串 searchValue 的开头一位字符从 str 的第 fromIndex 位开始向左回向查找。fromIndex 默认值是 +Infinity。

var str = 'Hello world'
console.log(str.lastIndexOf('world')) // 6

str.includes()

includes() 方法用于判断一个字符串是否包含在另一个字符串中，根据情况返回 true 或 false。

str.includes(searchString[, position])

searchString: 要在此字符串中搜索的字符串。
position: 从当前字符串的哪个索引位置开始搜寻子字符串，默认值为 0。

var str = 'Hello world'
console.log(str.includes('Hello')) // true
console.log(str.includes('Hello', 6)) // false

str.search()

search() 方法执行正则表达式和 String 对象之间的一个搜索匹配。

str.search(regexp)

regexp: 一个正则表达式（regular expression）对象。如果传入一个非正则表达式对象 regexp，则会使用 new RegExp(regexp) 隐式地将其转换为正则表达式对象。

如果匹配成功，则 search() 返回正则表达式在字符串中首次匹配项的索引;否则，返回 -1。

TIP

当你想要知道字符串中是否存在某个模式（pattern）时可使用 search()，类似于正则表达式的 test() 方法。

var str = 'HELLO world'
var reg1 = /[a-z]/
var reg2 = /[.]/
console.log(str.search(reg1)) // 6 第一位小写字母的索引为6
console.log(str.search(reg2)) // -1 字符串中不存在'.'符号

4.正则相关

str.replace()

replace() 方法返回一个由替换值（replacement）替换部分或所有的模式（pattern）匹配项后的新字符串。

str.replace(regexp|substr, newSubStr|function)

regexp: 一个 RegExp 对象或者其字面量。该正则所匹配的内容会被第二个参数的返回值替换掉。
substr: 一个将被 newSubStr 替换的字符串。其被视为一整个字符串，而不是一个正则表达式。仅第一个匹配项会被替换。
newSubStr: 用于替换掉第一个参数在原字符串中的匹配部分的字符串。
function: 一个用来创建新子字符串的函数，该函数的返回值将替换掉第一个参数匹配到的结果。

let str = 'JS will, JS will rock you!'
let newStr = str.replace('JS', 'JavaScript')

console.log(newStr) // 'JavaScript will, JS will rock you!'

可以看出，字符串替换的情况下，只有第一次出现的 substr JS被替换为新的 newSubStr JavaScript。

要将字符串中出现的所有子字符串替换为新的，必须使用正则表达式。

let str = 'JS will, JS will rock you!'
let newStr = str.replace(/JS/g, 'JavaScript')

console.log(newStr) // 'JavaScript will, JavaScript will rock you!'

第二个参数也可以是一个回调函数 replacer，而不是一个固定字符串：

function replacer(match, p1, p2, ..., offset, string)

以下是各个参数的含义：

match: 是匹配的子字符串。
p1, p2, ...pn: 是由正则表达式提供的带括号的捕获组找到的第 n 个字符串。
offset: 是被搜索的整个字符串中匹配的子字符串的偏移量。
string: 是被检查的整个字符串。

let str = "I like to eat, eat, eat apples and bananas";
let re = /apples|bananas/gi

let newStr = str.replace(re, (match, a, b, c) => { 
    console.log(match, '---', a, '---', b, '---', c) 
    return match.toUpperCase()
})
/*
apples---24---I like to eat, eat, eat apples and bananas---undefined
bananas---35---I like to eat, eat, eat apples and bananas---undefined
*/
console.log(newStr)

因为上例中的正则表达式并没有使用捕获组，所以打印的参数并不会有 p1 p2 等。

参考链接

str.match()

match() 方法检索返回一个字符串匹配正则表达式的结果。

str.match(regexp)

regexp: 一个正则表达式对象。如果传入一个非正则表达式对象，则会隐式地使用 new RegExp(obj) 将其转换为一个 RegExp 。如果你没有给出任何参数并直接使用 match() 方法，你将会得到一个包含空字符串的 Array ：[""] 。

TIP

如果使用 g 标志，则将返回与完整正则表达式匹配的所有结果，但不会返回捕获组。

如果未使用 g 标志，则仅返回第一个完整匹配及其相关的捕获组（Array）。在这种情况下，返回的项目将具有如下所述的其他属性。

groups: 一个捕获组数组或 undefined（如果没有定义命名捕获组）。
index: 匹配的结果的开始位置
input: 搜索的字符串.

如果正则表达式不包含 g 标志，str.match() 将返回与 RegExp.exec() 相同的结果。

不使用 g 标志：

var str = 'For more information, see Chapter 3.4.5.1'
var re = /see (chapter \d+(\.\d)*)/i
var found = str.match(re)
console.log(found)
/*
[ 
  'see Chapter 3.4.5.1',
  'Chapter 3.4.5.1',
  '.1',
  index: 22,
  input: 'For more information, see Chapter 3.4.5.1' 
  groups: undefined
]
*/
// 'see Chapter 3.4.5.1' 是整个匹配。
// 'Chapter 3.4.5.1' 被'(chapter \d+(\.\d)*)'捕获。
// '.1' 是被'(\.\d)'捕获的最后一个值。
// 'index' 属性(22) 是整个匹配从零开始的索引。
// 'input' 属性是被解析的原始字符串。

// 命名捕获组 使用 ?<name>
var str = 'For more information, see Chapter 3.4.5.1'
var re = /see (?<first>chapter \d+(?<second>\.\d)*)/i
var found = str.match(re)
console.log(found)
/*
[
  'see Chapter 3.4.5.1',
  'Chapter 3.4.5.1',
  '.1',
  index: 22,
  input: 'For more information, see Chapter 3.4.5.1',
  groups: {first: 'Chapter 3.4.5.1', second: '.1'}
]
*/

使用 g 标志：

var str = 'For more information, see Chapter 3.4.5.1';
var re = /see (chapter \d+(\.\d)*)/ig;
var found = str.match(re);
console.log(found);
// ['see Chapter 3.4.5.1']

var str = 'I Promise You!'
var reg = /[a-m]/ig
var result = str.match(reg)
console.log(result)
// ['I', 'm', 'i', 'e']

一个非正则表达式对象作为参数：

var str1 = "NaN means not a number. Infinity contains -Infinity and +Infinity in JavaScript.",
    str2 = "My grandfather is 65 years old and My grandmother is 63 years old.",
    str3 = "The contract was declared null and void.";
str1.match("number");   // "number" 是字符串。返回["number"]
str1.match(NaN);        // NaN的类型是number。返回["NaN"]
str1.match(Infinity);   // Infinity的类型是number。返回["Infinity"]
str1.match(+Infinity);  // 返回["Infinity"]
str1.match(-Infinity);  // 返回["-Infinity"]
str2.match(65);         // 返回["65"]
str2.match(+65);        // 有正号的number。返回["65"]
str3.match(null);       // 返回["null"]

本节参考至MDN

str.matchAll()

matchAll() 方法返回一个包含所有匹配正则表达式的结果及分组捕获组的可迭代对象。

可以配合 for..of Array.from 以及展开运算符 ... 使用。

str.matchAll(regexp)

regexp: 正则表达式对象。如果所传参数不是一个正则表达式对象，则会隐式地使用 new RegExp(obj) 将其转换为一个 RegExp 。

TIP

RegExp 必须是设置了全局模式 g 的形式，否则会抛出异常 TypeError。

matchAll() 与 match() 方法相比，就是能够获取捕获组数据。

而 match() 方法在声明正则表达式的 g 模式下，会忽略捕获组。

var str = 'love you,love me'
var reg = /love ([a-z]*)/g
console.log(str.match(reg))
/*
[
  'love you',
  'love me'
]
*/
console.log([...str.matchAll(reg)])
/*
[
  [
    'love you',
    'you',
    index: 0,
    input: "love you,love me",
    groups: undefined
  ],
  [
    'love me',
    'me',
    index: 9,
    input: "love you,love me",
    groups: undefined
  ]
]
*/

5.大小写相关

str.toLocaleLowerCase()

toLocaleLowerCase() 方法根据任何指定区域语言环境设置的大小写映射，返回调用字符串被转换为小写的格式。

str.toLocaleLowerCase() str.toLocaleLowerCase(locale) str.toLocaleLowerCase([locale, locale, ...])

locale: 参数 locale 指明要转换成小写格式的特定语言区域。如果以一个数组 Array 形式给出多个 locales, 最合适的地区将被选出来应用。默认的 locale 是主机环境的当前区域( locale )设置。

TIP

toLocaleLowerCase() 方法返回根据任意区域语言大小写映射集而转换成小写格式的字符串。

toLocaleLowerCase() 并不会影响字符串原本的值。在大多数情况下，该方法和调用 toLowerCase() 的结果相同。

但是在某些区域环境中，比如土耳其语，它的大小写映射并不遵循在 Unicode 中的默认的大小写映射，因此会有一个不同的结果。

'ALPHABET'.toLocaleLowerCase(); // 'alphabet'

'\u0130'.toLocaleLowerCase('tr') === 'i'    // true
'\u0130'.toLocaleLowerCase('en-US') === 'i' // false

let locales = ['tr', 'TR', 'tr-TR', 'tr-u-co-search', 'tr-x-turkish'];
'\u0130'.toLocaleLowerCase(locales) === 'i' // true

str.toLocaleUpperCase()

toLocaleUpperCase() 方法根据本地主机语言环境把字符串转换为大写格式，并返回转换后的字符串。

str.toLocaleUpperCase() str.toLocaleUpperCase(locale) str.toLocaleUpperCase([locale, locale, ...])

与 toLocaleLowerCase() 方法类似。

str.toLowerCase()

toLowerCase() 会将调用该方法的字符串值转为小写形式，并返回。

str.toLowerCase()

console.log('中文简体 zh-CN || zh-Hans'.toLowerCase())
// 中文简体 zh-cn || zh-hans

console.log("ALPHABET".toLowerCase())
// alphabet

str.toUpperCase()

toUpperCase() 方法将调用该方法的字符串转为大写形式并返回。

str.toUpperCase()

TIP

如果调用该方法的值不是字符串类型，会调用该值的 toString() 方法，进行强制转换。

const a = String.prototype.toUpperCase.call({
  toString() {
    return 'abcdef'
  }
})

const b = String.prototype.toUpperCase.call(true);

// 输出 'ABCDEF TRUE'
console.log(a, b)

str.localeCompare()

localeCompare() 方法返回一个数字来指示一个参考字符串是否在排序顺序前面或之后或与给定字符串相同。

如果引用字符存在于比较字符之前则为负数; 如果引用字符存在于比较字符之后则为正数; 相等的时候返回 0 。

str.localeCompare(compareString[, locales[, options]])

compareString: 用来比较的字符串。

// a在b之前 所以返回负数
console.log('a'.localeCompare('b')) // -1 or -2
// check在arguments之后 因为c在a之后 所以返回正数
console.log('check'.localeCompare('arguments')) // 1 or 2
// a与a相等
console.log('a'.localeCompare('a')) // 0

6.空白符相关

str.trim()

trim() 方法会从一个字符串的两端删除空白字符。

这里的空白字符是所有的空白字符 (space, tab, no-break, space 等) 以及所有行终止符字符（如 LF，CR 等）。

str.trim()

var str = '   Hello world  '
console.log(str.trim()) // 'Hello world'

var str = '   Hello world'
console.log(str.trim()) // 'Hello world'

var str = 'Hello world    '
console.log(str.trim()) // 'Hello world'

str.trimStart()

trimStart() 方法从字符串的开头删除空白字符。

trimLeft() 是此方法的别名。

str.trimStart()

var str = '   Hello world  '
console.log(str.trimStart()) // 'Hello world  '

var str = '   Hello world'
console.log(str.trimStart()) // 'Hello world'

var str = 'Hello world    '
console.log(str.trimStart()) // 'Hello world    '

str.trimEnd()

trimEnd() 方法从一个字符串的末端移除空白字符。

trimRight() 是这个方法的别名。

str.trimEnd()

var str = '   Hello world  '
console.log(str.trimEnd()) // '   Hello world'

var str = '   Hello world'
console.log(str.trimEnd()) // '   Hello world'

var str = 'Hello world    '
console.log(str.trimEnd()) // 'Hello world'

str.padStart()

padStart() 方法用另一个字符串填充当前字符串(如果需要的话，会重复多次)，以便产生的字符串达到给定的长度。从当前字符串的左侧开始填充。

str.padStart(targetLength [, padString])

targetLength: 当前字符串需要填充到的目标长度。如果这个数值小于当前字符串的长度，则返回当前字符串本身。
padString: 填充字符串。如果字符串太长，使填充后的字符串长度超过了目标长度，则只保留最左侧的部分，其他部分会被截断。

'abc'.padStart(10)         // "       abc"
'abc'.padStart(10, "foo")  // "foofoofabc"
'abc'.padStart(6,"123465") // "123abc"
'abc'.padStart(8, "0")     // "00000abc"
'abc'.padStart(1)          // "abc"

str.padEnd()

padEnd() 方法会用一个字符串填充当前字符串（如果需要的话则重复填充），返回填充后达到指定长度的字符串。从当前字符串的末尾（右侧）开始填充。

str.padEnd(targetLength [, padString])

targetLength: 当前字符串需要填充到的目标长度。如果这个数值小于当前字符串的长度，则返回当前字符串本身。
padString: 填充字符串。如果字符串太长，使填充后的字符串长度超过了目标长度，则只保留最左侧的部分，其他部分会被截断。

'abc'.padEnd(10)          // "abc       "
'abc'.padEnd(10, "foo")   // "abcfoofoof"
'abc'.padEnd(6, "123456") // "abc123"
'abc'.padEnd(1)           // "abc"

7.转码相关

eval

eval() 函数会将传入的字符串当做 JavaScript 代码进行执行。

如果 eval() 的参数不是字符串， eval() 会将参数原封不动地返回。

console.log(eval('2 + 2')) // 4
console.log(eval(new String('2 + 2'))) // String {'2 + 2'}

escape

废弃的 escape() 方法生成新的由十六进制转义序列替换的字符串。

推荐使用 encodeURI 或 encodeURIComponent 代替。

escape(str)

TIP

escape 函数是全局对象的属性。特色字符如: @*_+-./ 被排除在外。

字符的 16 进制格式值,当该值小于等于 0xFF 时,用一个 2 位转义序列: %xx 表示，大于的话则使用 4 位序列: %uxxxx 表示。

escape("abc123")     // "abc123"
escape("äöü")        // "%E4%F6%FC"
escape("ć")          // "%u0107"

// special characters
escape("@*_+-./")    // "@*_+-./"

unescape

已废弃的 unescape() 方法计算生成一个新的字符串，其中的十六进制转义序列将被其表示的字符替换。上述的转义序列就像 escape 里介绍的一样。

因为 unescape 已经废弃，建议使用 decodeURI 或者 decodeURIComponent 替代本方法。

unescape(str)

encodeURI

encodeURI 会替换所有的字符，但不包括以下字符：

类型	包含
保留字符	`;` `,` `/` `?` `:` `@` `&` `=` `+` `$`
非转义字符	字母数字 `-` `_` `.` `!` `~` `*` `'` `(` `)`
数字符号	`#`

TIP

encodeURI 方法不适用于 HTTP 请求的 URI, 例如对于 XMLHTTPRequests, 因为 &, +, 和 = 不会被编码，然而在 GET 和 POST 请求中它们是特殊字符。

然而encodeURIComponent这个方法会对这些字符编码。

decodeURI

decodeURI() 函数能解码由encodeURI 创建或其它流程得到的统一资源标识符（URI）。

将已编码 URI 中所有能识别的转义序列转换成原字符，但不能解码那些不会被 encodeURI 编码的内容（例如 #）。

encodeURIComponent

在实际编码中，如果要对参数进行转码，一般使用 encodeURIComponent。

它相比 encodeURI 来说，可转码范围更广一些。

它的不转义的字符如下：

A-Z a-z 0-9 - _ . ! ~ * ' ( )

decodeURIComponent

decodeURIComponent() 方法用于解码由 encodeURIComponent 方法或者其它类似方法编码的部分统一资源标识符（URI）。

1.字节相关 ​

1-1.str.charAt() ​

1-2.str.charCodeAt() ​

1-3.str.codePointAt() ​

1-4.String.fromCharCode() ​

1-5.String.fromCodePoint() ​

2.操作相关 ​

str.concat() ​

str.slice() ​

str.split() ​

str.substring() ​

str.substr() ​

str.toString() ​

str.valueOf() ​

str.repeat() ​

3.遍历相关 ​

str.startsWith() ​

str.endsWith() ​

str.indexOf() ​

str.lastIndexOf() ​

str.includes() ​

str.search() ​

4.正则相关 ​

str.replace() ​

str.match() ​

str.matchAll() ​

5.大小写相关 ​

str.toLocaleLowerCase() ​

str.toLocaleUpperCase() ​

str.toLowerCase() ​

str.toUpperCase() ​

str.localeCompare() ​

6.空白符相关 ​

str.trim() ​

str.trimStart() ​

str.trimEnd() ​

str.padStart() ​

str.padEnd() ​

7.转码相关 ​

eval ​

escape ​

unescape ​

encodeURI ​

decodeURI ​

encodeURIComponent ​

decodeURIComponent ​

1.字节相关

1-1.str.charAt()

1-2.str.charCodeAt()

1-3.str.codePointAt()

1-4.String.fromCharCode()

1-5.String.fromCodePoint()

2.操作相关

str.concat()

str.slice()

str.split()

str.substring()

str.substr()

str.toString()

str.valueOf()

str.repeat()

3.遍历相关

str.startsWith()

str.endsWith()

str.indexOf()

str.lastIndexOf()

str.includes()

str.search()

4.正则相关

str.replace()

str.match()

str.matchAll()

5.大小写相关

str.toLocaleLowerCase()

str.toLocaleUpperCase()

str.toLowerCase()

str.toUpperCase()

str.localeCompare()

6.空白符相关

str.trim()

str.trimStart()

str.trimEnd()

str.padStart()

str.padEnd()

7.转码相关

eval

escape

unescape

encodeURI

decodeURI

encodeURIComponent

decodeURIComponent