Js中String对象

String全局对象是一个用于字符串或一个字符序列的构造函数。

描述

创建一个字符串可以通过字面量的方式，通过字面量创建的字符串变量在调用方法的时候能够自动转化为临时的包装对象，从而能够调用其构造函数的原型中的方法，也可以利用String对象生成字符串对象，此外在ES6标准还定义了模板字面量用以生成字符串的方式。

var s = "s";
console.log(typeof(s)); // string

var s = new String("s");
console.log(typeof(s)); // object

var fill = "0";
var s = `1${fill}1`;
console.log(s); // 101

属性

String.prototype.constructor: 用于创造对象的原型对象的构造函数。
String.prototype.length: 返回了字符串的长度。

方法

String.fromCharCode()

String.fromCharCode(num1[, ...[, numN]])
String.fromCharCode()静态方法返回由指定的UTF-16代码单元序列创建的字符串，参数为一系列UTF-16代码单元的数字，范围介于0到65535即0xFFFF之间，大于0xFFFF的数字将被截断，不进行有效性检查。

var s = String.fromCharCode(65, 66, 67);
console.log(s); // ABC

String.fromCodePoint()

String.fromCodePoint(num1[, ...[, numN]])
String.fromCodePoint()静态方法返回使用指定的代码点序列创建的字符串，参数为一串Unicode编码位置，即代码点。

var s = String.fromCharCode(9733, 9733, 9733);
console.log(s); // ★★★

String.prototype.charAt()

str.charAt(index)
charAt()方法从一个字符串中返回指定的字符，参数index是一个介于0和字符串长度减1之间的整数，如果没有提供索引，charAt()将使用0。

var s = "ABC";
console.log(s.charAt(0)); // A

String.prototype.charCodeAt()

str.charCodeAt(index)
charCodeAt()方法返回0到65535之间的整数，表示给定索引处的UTF-16代码单元，参数index是一个介于0和字符串长度减1之间的整数，如果没有提供索引，charCodeAt()将使用0。

var s = "ABC";
console.log(s.charCodeAt(0)); // 65

String.prototype.codePointAt()

str.codePointAt(pos)
codePointAt()方法返回一个Unicode编码点值的非负整数，参数index是一个介于0和字符串长度减1之间的整数，如果没有提供索引，codePointAt()将使用0。

var s = "ABC";
console.log(s.codePointAt(0)); // 65

String.prototype.concat()

str.concat(str2, [, ...strN])
concat()方法将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回，concat方法将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回，concat方法并不影响原字符串，如果参数不是字符串类型，它们在连接之前将会被转换成字符串。事实上，Js中基本数据类型的值不可变，基本类型的值一旦创建就不能被改变，所有操作只能返回一个新的值而不能去改变旧的值。

var s1 = "ABC";
var s2 = "DEF";
console.log(s1.concat(s2)); // ABCDEF

String.prototype.endsWith()

str.endsWith(searchString[, length])
endsWith()方法用来判断当前字符串是否是以另外一个给定的子字符串结尾的，根据判断结果返回true或false，参数searchString是要搜索的子字符串，length可选，是作为str的长度，默认值为str.length。

var s = "ABC";
console.log(s.endsWith("BC")); // true

String.prototype.includes()

str.includes(searchString[, position])
includes()方法用于判断一个字符串是否包含在另一个字符串中，根据情况返回true或false，参数searchString是要在此字符串中搜索的字符串，position可选，是从当前字符串的哪个索引位置开始搜寻子字符串，默认值为0。

var s = "ABC";
console.log(s.includes("BC")); // true

String.prototype.indexOf()

str.indexOf(searchValue [, fromIndex])
indexOf()方法返回调用String对象中第一次出现的指定值的索引，从fromIndex处进行搜索，如果未找到该值，则返回-1，参数searchValue是要被查找的字符串值，如果没有提供确切地提供字符串，searchValue会被强制设置为undefined，然后在当前字符串中查找这个值，fromIndex可选，是数字表示开始查找的位置，可以是任意整数，默认值为0，如果fromIndex的值小于0或者大于str.length，那么查找分别从0和str.length开始查找。

var s = "ABC";
console.log(s.indexOf("BC")); // 1

String.prototype.lastIndexOf()

str.lastIndexOf(searchValue[, fromIndex])
lastIndexOf()方法返回调用String对象的指定值最后一次出现的索引，在一个字符串中的指定位置fromIndex处从后向前搜索，如果没找到这个特定值则返回-1，该方法将从尾到头地检索字符串str，看它是否含有子串searchValue，开始检索的位置在字符串的fromIndex处或字符串的结尾，如果找到一个searchValue，则返回searchValue的第一个字符在str中的位置，参数searchValue是一个字符串，表示被查找的值，如果searchValue是空字符串，则返回fromIndex，fromIndex可选，待匹配字符串searchValue的开头一位字符从 str的第fromIndex位开始向左回向查找，fromIndex默认值是+Infinity，如果fromIndex >= str.length，则会搜索整个字符串，如果fromIndex < 0，则等同于fromIndex === 0。

var s = "ABCABC";
console.log(s.lastIndexOf("BC")); // 4

String.prototype.localeCompare()

referenceStr.localeCompare(compareString)
localeCompare()方法返回一个数字来指示一个参考字符串是否在排序顺序前面或之后或与给定字符串相同，当引用字符串在比较字符串前面时返回-1，当引用字符串在比较字符串后面时返回1，相同位置时返回0。

var s = "ABC";
console.log(s.localeCompare("DEF")); // -1

String.prototype.match()

str.match(regexp)
match()方法检索返回一个字符串匹配正则表达式的结果，如果传入一个非正则表达式对象，则会隐式地使用new RegExp(obj)将其转换为一个RegExp，如果没有给出任何参数并直接使用match()方法，将会得到一个包含空字符串的Array即[""]，如果使用g标志，则将返回与完整正则表达式匹配的所有结果，但不会返回捕获组，如果未使用g标志，则仅返回第一个完整匹配及其相关的捕获组Array。

var regex = /(\d{4})-(\d{2})-(\d{2})/g;
var res = "2020-09-02".match(regex);
console.log(res); // ["2020-09-02"]

String.prototype.matchAll()

str.matchAll(regexp)
matchAll()方法返回一个包含所有匹配正则表达式的结果及分组捕获组的迭代器，如果传入一个非正则表达式对象，则会隐式地使用new RegExp(obj)将其转换为一个RegExp，传入的RegExp必须是设置了全局模式g的形式，否则会抛出异常TypeError，返回一个迭代器，不可重用，结果耗尽需要再次调用方法，获取一个新的迭代器。matchAll内部做了一个regexp的复制，所以不像regexp.exec,lastIndex在字符串扫描时不会改变。

var regex = /(\d{4})-(\d{2})-(\d{2})/g;
var res = "2020-09-02".matchAll(regex);
console.log([...res]); // 使用Spread操作符展开 也可以调用next()方法进行迭代
// [["2020-09-02", "2020", "09", "02", index: 0, input: "2020-09-02", ... ]]

String.prototype.normalize()

str.normalize([form])
normalize()方法会按照指定的一种Unicode正规形式将当前字符串正规化，参数form可选，四种Unicode正规形式Unicode Normalization Form: NFC、NFD、NFKC或NFKD其中的一个, 默认值为NFC。

var s = "\u00F1";
console.log(s.normalize()); // ñ

String.prototype.padEnd()

str.padEnd(targetLength [, padString])
padEnd()方法会用一个字符串填充当前字符串，如果需要的话则重复填充，返回填充后达到指定长度的字符串，从当前字符串的末尾右侧开始填充，参数targetLength当前字符串需要填充到的目标长度，如果这个数值小于当前字符串的长度，则返回当前字符串本身，padString可选，填充字符串，如果字符串太长，使填充后的字符串长度超过了目标长度，则只保留最左侧的部分，其他部分会被截断。

var s = "|";
console.log(s.padEnd(3, ".")); // |..

String.prototype.padStart()

str.padStart(targetLength [, padString]) padStart()方法会用一个字符串填充当前字符串，如果需要的话则重复填充，返回填充后达到指定长度的字符串，从当前字符串的左侧开始填充，参数targetLength当前字符串需要填充到的目标长度，如果这个数值小于当前字符串的长度，则返回当前字符串本身，padString可选，填充字符串，如果字符串太长，使填充后的字符串长度超过了目标长度，则只保留最左侧的部分，其他部分会被截断。

var s = "|";
console.log(s.padStart(3, ".")); // ..|

String.prototype.repeat()

str.repeat(count)
repeat()构造并返回一个新字符串，该字符串包含被连接在一起的指定数量的字符串的副本，参数count表示介于0和+Infinity之间的整数，表示在新构造的字符串中重复了多少遍原字符串。

var s = "ABC";
console.log(s.repeat(2)); // ABCABC

String.prototype.replace()

str.replace(regexp|substr, newSubStr|function)
replace()方法返回一个由替换值replacement替换部分或所有的模式pattern匹配项后的新字符串，模式可以是一个字符串或者一个正则表达式，替换值可以是一个字符串或者一个每次匹配都要调用的回调函数，如果pattern是字符串，则仅替换第一个匹配项，原字符串不会改变。

var regex = /\d+/g;
var res = "s1s11s111".replace(regex, "");
console.log(res); // sss

String.prototype.replaceAll()

str.replaceAll(regexp|substr, newSubstr|function)
replaceAll()方法返回一个新字符串，新字符串所有满足pattern的部分都已被replacement替换，pattern可以是一个字符串或一个RegExp，replacement可以是一个字符串或一个在每次匹配被调用的函数，原始字符串保持不变。当使用一个regex时，必须设置全局g标志，否则将引发TypeError，即必须使用全局RegExp调用replaceAll。

var regex = /\d+/g;
var res = "s1s11s111".replaceAll(regex, "");
console.log(res); // sss

String.prototype.search()

str.search(regexp)
search()方法执行正则表达式和String对象之间的一个搜索匹配，如果传入一个非正则表达式对象regexp，则会使用new RegExp(regexp)隐式地将其转换为正则表达式对象，如果匹配成功，则search()返回正则表达式在字符串中首次匹配项的索引，否则返回-1。

var regex = /[0-9]+/g;
console.log("s123".search(regex)); // 1

String.prototype.slice()

str.slice(beginIndex[, endIndex])
slice()方法提取某个字符串的一部分，并返回一个新的字符串，且不会改动原字符串，参数beginIndex从该索引以0为基数处开始提取原字符串中的字符，如果值为负数，会被当做strLength + beginIndex看待，这里的strLength是字符串的长度，endIndex可选，在该索引以0为基数处结束提取字符串，如果省略该参数，slice()会一直提取到字符串末尾，如果该参数为负数，则被看作是strLength + endIndex。

var s = "[ABC]";
console.log(s.slice(1, -1)); // ABC

String.prototype.split()

str.split([separator[, limit]])
split()方法使用指定的分隔符字符串将一个String对象分割成子字符串数组，以一个指定的分割字串来决定每个拆分的位置，separator指定表示每个拆分应发生的点的字符串，separator可以是一个字符串或正则表达式，limit提供一个整数，限定返回的分割片段数量，返回源字符串以分隔符出现位置分隔而成的一个Array。

var regex = /\d+/g; // 以数字分割
var res = "2020-09-02".split(regex);
console.log(res); // ["", "-", "-", ""]

String.prototype.startsWith()

str.startsWith(searchString[, position])
startsWith()方法用来判断当前字符串是否以另外一个给定的子字符串开头，并根据判断结果返回true或false，参数searchString是要搜索的子字符串，参数position可选，在str中搜索searchString的开始位置，默认值为0。

var s = "ABC";
console.log(s.startsWith("AB")); // true

String.prototype.substring()

str.substring(indexStart[, indexEnd])
substring()方法返回一个字符串在开始索引到结束索引之间的一个子集，或从开始索引直到字符串的末尾的一个子集，参数indexStart需要截取的第一个字符的索引，该索引位置的字符作为返回的字符串的首字母，indexEnd可选，一个0到字符串长度之间的整数，以该数字为索引的字符不包含在截取的字符串内。

var s = "ABC";
console.log(s.substring(1)); // BC

String.prototype.toLocaleLowerCase()

str.toLocaleLowerCase([locale, locale, ...])
toLocaleLowerCase()方法根据任何指定区域语言环境设置的大小写映射，返回调用字符串被转换为小写的格式，参数locale可选，指明要转换成小写格式的特定语言区域，如果以一个数组Array形式给出多个locales, 最合适的地区将被选出来应用，默认的locale是主机环境的当前区域locale设置。

var s = "ABC";
console.log(s.toLocaleLowerCase()); // abc

String.prototype.toLowerCase()

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

var s = "ABC";
console.log(s.toLowerCase()); // abc

String.prototype.toString()

str.toString()
toString()方法返回指定对象的字符串形式，String对象覆盖了Object对象的toString方法,并没有继承Object.toString()，对于String对象，toString方法返回该对象的字符串形式，和String.prototype.valueOf()方法返回值一样。

var s = new String("ABC");
console.log(s); // String {"ABC"}
console.log(s.toString()); // ABC

String.prototype.toUpperCase()

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

var s = "abc";
console.log(s.toUpperCase()); // ABC

String.prototype.trim()

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

var s = " A B C ";
console.log(s.trim()); // A B C

String.prototype.trimEnd()

str.trimEnd()
trimEnd()方法从一个字符串的末端移除空白字符，trimRight()是这个方法的别名。

var s = " A B C ";
console.log(s.trimEnd()); //  A B C

String.prototype.trimStart()

str.trimStart()
trimStart()方法从字符串的开头删除空格，trimLeft()是此方法的别名。

var s = " A B C ";
console.log(s.trimStart()); // A B C

String.prototype.valueOf()

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

var s = new String("ABC");
console.log(s); // String {"ABC"}
console.log(s.valueOf()); // ABC

String.prototype[@@iterator]()

string[Symbol.iterator]
[@@iterator]()方法返回一个新的Iterator对象，它遍历字符串的代码点，返回每一个代码点的字符串值。

var s = "ABC";
var it = s[Symbol.iterator]();
console.log(it.next().value); // A

String.raw()

String.raw(callSite, ...substitutions)
String.raw() 是一个模板字符串的标签函数，是用来获取一个模板字符串的原始字符串的，例如\n转义字符不会被转义，参数callSite是一个模板字符串的调用点对象，类似{ raw: ['foo', 'bar', 'baz'] }，...substitutions是任意个可选的参数，表示任意个内插表达式对应的值，templateString是模板字符串，可包含占位符${...}。

var raw = String.raw `\n`;
console.log(raw); // \n
console.log(raw.length); // 2

每日一题

https://github.com/WindrunnerMax/EveryDay

参考

https://www.runoob.com/jsref/jsref-obj-string.html
https://blog.csdn.net/a153375250/article/details/51013457
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String

Files

Js中String对象.md

Latest commit

History