recursal/MDN huggingface dataset:
String.prototype.slice()
========================

**`slice()`** 方法提取字符串的一部分，并将其作为新字符串返回，而不修改原始字符串。

尝试一下
----

语法
--


```js
slice(indexStart)
slice(indexStart, indexEnd)
```

### 参数

`indexStart`

要返回的子字符串中包含的第一个字符的索引。

`indexEnd` 可选

要返回的子字符串中排除的第一个字符的索引。

### 返回值

一个包含提取的字符串片段的新字符串。

描述
--

`slice()` 方法从一个字符串中提取文本并返回一个新的字符串。对它们中的一个的文本进行的更改不会影响另一个字符串。

`slice()` 方法提取直到但不包括 `indexEnd` 的文本。例如，`str.slice(1, 4)` 提取的是第二个字符到第四个字符（字符的索引为 `1`、`2` 和 `3`）。

* 如果 `indexStart >= str.length`，则返回一个空字符串。
* 如果 `indexStart < 0`，则索引从字符串末尾开始计数。更正式地说，在这种情况下，子字符串从 `max(indexStart + str.length, 0)` 开始。
* 如果 `indexStart` 被省略、为 undefined，或无法转换为数字（使用 `Number(indexStart)`），则将其视为 `0`。
* 如果 `indexEnd` 被省略、为 undefined，或无法转换为数字（使用 `Number(indexEnd)`），或者 `indexEnd >= str.length`，则 `slice()` 提取到字符串的末尾。
* 如果 `indexEnd < 0`，则索引从字符串末尾开始计数。更正式地说，在这种情况下，子字符串在 `max(indexEnd + str.length, 0)` 处结束。
* 在标准化负值后，如果 `indexEnd <= indexStart`（即 `indexEnd` 表示位于 `indexStart` 之前的字符），则返回一个空字符串。
示例
--

### 使用 slice() 创建一个新的字符串

以下示例使用 `slice()` 创建了一个新字符串。


```js
const str1 = "The morning is upon us."; // str1 的长度是 23。
const str2 = str1.slice(1, 8);
const str3 = str1.slice(4, -2);
const str4 = str1.slice(12);
const str5 = str1.slice(30);
console.log(str2); // he morn
console.log(str3); // morning is upon u
console.log(str4); // is upon us.
console.log(str5); // ""
```

### 使用负值索引调用 slice()

下面的例子在使用 `slice()` 时传入了负值作为索引。


```js
const str = "The morning is upon us.";
str.slice(-3); // 'us.'
str.slice(-3, -1); // 'us'
str.slice(0, -1); // 'The morning is upon us'
str.slice(4, -1); // 'morning is upon us'
```


这个例子通过从字符串末尾倒数 `11` 个字符来找到起始索引，并通过从字符串开头正数 `16` 个字符来找到结束索引。


```js
console.log(str.slice(-11, 16)); // "is u"
```


在这个例子中，它通过从字符串开头正数 `11` 个字符来找到起始索引，并通过从字符串末尾倒数 `7` 个字符来找到结束索引。


```js
console.log(str.slice(11, -7)); // " is u"
```


这些参数通过从字符串末尾倒数 `5` 个字符来找到起始索引，并通过从字符串末尾倒数 `1` 个字符来找到结束索引。


```js
console.log(str.slice(-5, -1)); // "n us"
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.slice |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `String.prototype.substr()`
* `String.prototype.substring()`
* `Array.prototype.slice()`
String.fromCharCode()
=====================

**`String.fromCharCode()`** 静态方法返回由指定的 UTF-16 码元序列创建的字符串。

尝试一下
----

语法
--


```js
String.fromCharCode(num1)
String.fromCharCode(num1, num2)
String.fromCharCode(num1, num2, /\* …, \*/ numN)
```

### 参数

`numN`

一个介于 `0` 和 `65535`（`0xFFFF`）之间的数字，表示一个 UTF-16 码元。大于 `0xFFFF` 的数字会被截断为最后的 16 位。不进行有效性检查。

### 返回值

一个长度为 `N` 的字符串，由 `N` 个指定的 UTF-16 码元组成。

描述
--

因为 `fromCharCode()` 是 `String` 的静态方法，所以始终使用 `String.fromCharCode()` 来调用它，而不是作为你创建的 `String` 值的方法。

Unicode 码位的范围是从 `0` 到 `1114111`（`0x10FFFF`）。`charCodeAt()` 总是返回一个小于 `65536` 的值，因为较高的码位由*一对* 16 位代理伪字符组成。因此，为了生成一个值大于 `65535` 的完整字符，需要提供两个码元（就好像操作一个包含两个字符的字符串）。有关 Unicode 的信息，请参阅 UTF-16 字符、Unicode 码位和字素簇。

由于 `fromCharCode()` 仅适用于 16 位的值（与 `\u` 转义序列相同），因此需要使用代理对来返回补充字符。例如，`String.fromCharCode(0xd83c, 0xdf03)` 和 `"\ud83c\udf03"` 都返回码位 `U+1F303` "Night with Stars"。虽然补充码位值（例如 `0x1f303`）与表示它的两个代理值（例如 `0xd83c` 和 `0xdf03`）之间存在数学关系，但每次使用补充码位时都需要额外的步骤来计算或查找代理对值。出于这个原因，使用 `String.fromCodePoint()` 更方便，它可以根据实际的码位值返回补充字符。例如，`String.fromCodePoint(0x1f303)` 返回码位 `U+1F303` "Night with Stars"。

示例
--

### 使用 fromCharCode()

在 UTF-16 中，BMP 字符使用单个码元：


```js
String.fromCharCode(65, 66, 67); // 返回 "ABC"
String.fromCharCode(0x2014); // 返回 "—"
String.fromCharCode(0x12014); // 也返回 "—"；数字 1 被截断并忽略
String.fromCharCode(8212); // 也返回 "—"；8212 是 0x2014 的十进制表示
```


在 UTF-16 中，补充字符需要两个码元（即一个代理对）：


```js
String.fromCharCode(0xd83c, 0xdf03); // 码位 U+1F303 "Night with
String.fromCharCode(55356, 57091); // Stars" == "\uD83C\uDF03"

String.fromCharCode(0xd834, 0xdf06, 0x61, 0xd834, 0xdf07); // "\uD834\uDF06a\uD834\uDF07"
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.fromcharcode |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `String.fromCodePoint()`
* `String.prototype.charAt()`
* `String.prototype.charCodeAt()`
* `String.prototype.codePointAt()`
String.fromCodePoint()
======================

**`String.fromCodePoint()`** 静态方法将根据指定的码位序列返回一个字符串。

尝试一下
----

语法
--


```js
String.fromCodePoint(num1)
String.fromCodePoint(num1, num2)
String.fromCodePoint(num1, num2, /\* …, \*/ numN)
```

### 参数

`numN`

一个介于 `0` 和 `0x10FFFF`（包括两者）之间的整数，表示一个 Unicode 码位。

### 返回值

通过使用指定的码位序列创建的字符串。

### 异常

`RangeError`

如果 `numN` 不是整数、小于 `0` 或者在转换为数字后大于 `0x10FFFF`，则会抛出该异常。

说明
--

`fromCodePoint()` 是 `String` 的静态方法，因此始终使用 `String.fromCodePoint()` 调用它，而不是作为你创建的 `String` 值的方法。

Unicode 码位范围从 `0` 到 `1114111`（`0x10FFFF`）。在 UTF-16 中，每个字符串索引是一个取值范围为 `0` 到 `65535` 的码元。较高的码位由一对 16 位代理伪字符表示。因此，`fromCodePoint()` 可能返回一个字符串，其在 UTF-16 码元中的 `length` 大于传递的参数个数。有关 Unicode 的更多信息，请参阅 UTF-16 字符、Unicode 码位和字素簇。

示例
--

### 使用 fromCodePoint()

有效输入：


```js
String.fromCodePoint(42); // "\*"
String.fromCodePoint(65, 90); // "AZ"
String.fromCodePoint(0x404); // "\u0404" === "Є"
String.fromCodePoint(0x2f804); // "\uD87E\uDC04"
String.fromCodePoint(194564); // "\uD87E\uDC04"
String.fromCodePoint(0x1d306, 0x61, 0x1d307); // "\uD834\uDF06a\uD834\uDF07"
```


无效输入：


```js
String.fromCodePoint("\_"); // RangeError
String.fromCodePoint(Infinity); // RangeError
String.fromCodePoint(-1); // RangeError
String.fromCodePoint(3.14); // RangeError
String.fromCodePoint(3e-2); // RangeError
String.fromCodePoint(NaN); // RangeError
```

### 与 fromCharCode() 的比较

`String.fromCharCode()` 方法无法通过指定其码位来返回补充字符（即码位 `0x010000` 至 `0x10FFFF`）。相反，它需要使用 UTF-16 代理对来返回补充字符：


```js
String.fromCharCode(0xd83c, 0xdf03); // 码位 U+1F303（夜晚与星星）=== "\uD83C\uDF03"
String.fromCharCode(55356, 57091);
```


另一方面，`String.fromCodePoint()` 可以通过指定其码位（相当于 UTF-32 码元）返回 4 个字节的补充字符，以及更常见的 2 个字节的 BMP 字符：


```js
String.fromCodePoint(0x1f303); // 或十进制数 127747
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.fromcodepoint |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `String.fromCodePoint` 的 polyfill
* `String.fromCharCode()`
* `String.prototype.charAt()`
* `String.prototype.codePointAt()`
* `String.prototype.charCodeAt()`
String.prototype.fontcolor()
============================

**已弃用:** 不再推荐使用该特性。虽然一些浏览器仍然支持它，但也许已从相关的 web 标准中移除，也许正准备移除或出于兼容性而保留。请尽量不要使用该特性，并更新现有的代码；参见本页面底部的兼容性表格以指导你作出决定。请注意，该特性随时可能无法正常工作。

`String` 值的 **`fontcolor()`** 方法会创建一个 `<font>` 元素字符串，其中嵌入了调用字符串（`<font color="...">str</font>`），从而导致该字符串以指定的字体颜色显示。

**备注：** 所有的 HTML 包装方法都已经被弃用，并且仅为了兼容性而标准化。对于 `fontcolor()` 方法来说，`<font>` 元素本身在 HTML5 中已被移除，不应再使用。Web 开发者应该使用 CSS 属性来代替。

语法
--


```js
fontcolor(color)
```

### 参数

`color`

该参数可以接受十六进制 RGB 三元组或字符串字面量来表示颜色。颜色名称的字符串字面量可以参考 CSS 颜色参考。

### 返回值

一个以 `<font color="color">` 开头的字符串（`color` 中的双引号被替换为 `&quot;`），然后是文本 `str`，最后以 `</font>` 结束标记。

描述
--

`fontcolor()` 方法本身只是简单地将字符串部分连接在一起，没有进行任何验证或规范化。然而，为了创建有效的 `<font>` 元素，如果你将颜色表示为十六进制 RGB 三元组，你必须使用格式 `rrggbb`。例如，salmon（鲑鱼色）的十六进制 RGB 值为红色 = FA，绿色=80，蓝色=72，因此 salmon 的 RGB 三元组为 `"FA8072"`。

示例
--

### 使用 fontcolor()

下面的示例使用 `fontcolor()` 方法通过生成一个带有 HTML `<font>` 元素的字符串来改变字符串的颜色。


```js
const worldString = "Hello, world";

console.log(`${worldString.fontcolor("red")} is red in this line`);
// '<font color="red">Hello, world</font> is red in this line'

console.log(
  `${worldString.fontcolor("FF00")} is red in hexadecimal in this line`,
);
// '<font color="FF00">Hello, world</font> is red in hexadecimal in this line'
```


使用 `element.style` 对象，你可以获取元素的 `style` 属性并进行更通用的操作，例如：


```js
document.getElementById("yourElemId").style.color = "red";
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.fontcolor |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 的 `String.prototype.fontcolor` 的 polyfill
* `String.prototype.fontsize()`
String.prototype.toLocaleLowerCase()
====================================

`String` 的 **`toLocaleLowerCase()`** 方法会根据特定区域设置的大小写映射规则，将字符串转换为小写形式并返回。

尝试一下
----

语法
--


```js
toLocaleLowerCase()
toLocaleLowerCase(locales)
```

### 参数

`locales` 可选

一个带有 BCP 47 语言标签的字符串，或者是这种字符串的数组。指示要根据特定区域设置的大小写映射规则进行转换的区域设置。有关 `locales` 参数的一般形式和解释，请参阅 `Intl` 主页上的参数描述。

与使用 `locales` 参数的其他方法不同，`toLocaleLowerCase()` 不允许进行区域设置匹配。因此，在检查 `locales` 参数的有效性之后，`toLocaleLowerCase()` 始终使用列表中的第一个区域设置（如果列表为空，则使用默认区域设置），即使该区域设置在实现中不受支持。

### 返回值

一个新的字符串，表示调用字符串根据特定区域设置的大小写映射规则转换得到的小写形式。

描述
--

`toLocaleLowerCase()` 方法返回根据特定区域设置的大小写映射规则将字符串转换为小写形式的值。`toLocaleLowerCase()` 不会影响字符串本身的值。在大多数情况下，这将产生与 `toLowerCase()` 相同的结果，但对于某些区域设置（例如土耳其语），它们的大小写映射与 Unicode 的默认映射不同，可能会得到不同的结果。

示例
--

### 使用 toLocaleLowerCase()


```js
"ALPHABET".toLocaleLowerCase(); // 'alphabet'

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

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

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.tolocalelowercase |
| ECMAScript Internationalization API Specification # sup-string.prototype.tolocalelowercase |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `String.prototype.toLocaleUpperCase()`
* `String.prototype.toLowerCase()`
* `String.prototype.toUpperCase()`
String.prototype.italics()
==========================

**已弃用:** 不再推荐使用该特性。虽然一些浏览器仍然支持它，但也许已从相关的 web 标准中移除，也许正准备移除或出于兼容性而保留。请尽量不要使用该特性，并更新现有的代码；参见本页面底部的兼容性表格以指导你作出决定。请注意，该特性随时可能无法正常工作。

`String` 值的 **`italics()`** 方法会创建一个 `<i>` 元素字符串，其中嵌入了调用的字符串（`<i>str</i>`），从而使该字符串以斜体显示。

**备注：** 所有 HTML 包装方法都已被弃用，并且仅为了兼容性而标准化。请使用 DOM API（例如 `document.createElement()`）代替。

语法
--


```js
italics()
```

### 参数

无。

### 返回值

一个以 `<i>` 开始标签，然后是文本 `str`，最后是 `</i>` 结束标签的字符串。

示例
--

### 使用 italics()

下面的示例使用已弃用的字符串方法来更改字符串的格式：


```js
const worldString = "Hello, world";
console.log(worldString.blink()); // <blink>Hello, world</blink>
console.log(worldString.bold()); // <b>Hello, world</b>
console.log(worldString.italics()); // <i>Hello, world</i>
console.log(worldString.strike()); // <strike>Hello, world</strike>
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.italics |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js 中` String.prototype.italics `的 polyfill`
* `String.prototype.blink()`
* `String.prototype.bold()`
* `String.prototype.strike()`
String.prototype.charAt()
=========================

`String` 的 **`charAt()`** 方法返回一个由给定索引处的单个 UTF-16 码元构成的新字符串。

`charAt()` 方法总是将字符串作为 UTF-16 码元序列进行索引，因此它可能会返回孤项代理。要获取给定索引处的完整 Unicode 码位，请使用 `String.prototype.codePointAt()` 和 `String.fromCodePoint()`。

尝试一下
----

语法
--


```js
charAt(index)
```

### 参数

`index`

要返回的字符的索引，从零开始。会被转换为整数——`undefined` 会被转换为 0。

### 返回值

返回一个字符串，该字符串表示指定 `index` 处的字符（恰好是一个 UTF-16 码元）。如果 `index` 超出了 `0` – `str.length - 1` 的范围，`charAt()` 将返回一个空字符串。

描述
--

字符串中的字符从左到右进行索引。第一个字符的索引为 `0`，字符串中最后一个字符的索引为 `str.length - 1`。

Unicode 码位的范围从 `0` 到 `1114111` (`0x10FFFF`)。`charAt()` 方法总是返回一个其值小于 `65536` 的字符，因为更高的码位是由*一对* 16 位代理伪字符表示的。因此，为了获取值大于 `65535` 的完整字符，需要检索不仅是 `charAt(i)`，还要检索 `charAt(i + 1)`（就像操作一个由两个字符组成的字符串一样），或者使用 `codePointAt(i)` 和 `String.fromCodePoint()` 代替。有关 Unicode 的信息，请参阅 UTF-16 字符、Unicode 码位和字素簇。

`charAt()` 和使用方括号表示法访问指定索引处的字符非常相似。它们的主要区别在于：

* `charAt()` 尝试将 `index` 转换为整数，而方括号表示法不会，直接使用 `index` 作为属性名。
* 如果 `index` 超出范围，`charAt()` 返回一个空字符串，而方括号表示法返回 `undefined`。
示例
--

### 使用 charAt()

下例输出字符串 `"Brave new world"` 不同位置处的字符：


```js
const anyString = "Brave new world";
console.log(`在索引 0 处的字符为 '${anyString.charAt()}'`);
// 没有提供索引，使用 0 作为默认值

console.log(`在索引 0 处的字符为 '${anyString.charAt(0)}'`);
console.log(`在索引 1 处的字符为 '${anyString.charAt(1)}'`);
console.log(`在索引 2 处的字符为 '${anyString.charAt(2)}'`);
console.log(`在索引 3 处的字符为 '${anyString.charAt(3)}'`);
console.log(`在索引 4 处的字符为 '${anyString.charAt(4)}'`);
console.log(`在索引 999 处的字符为 '${anyString.charAt(999)}'`);
```


上面代码的输出为：
```

在索引 0 处的字符为 'B'

在索引 0 处的字符为 'B'
在索引 1 处的字符为 'r'
在索引 2 处的字符为 'a'
在索引 3 处的字符为 'v'
在索引 4 处的字符为 'e'
在索引 999 处的字符为 ''
```


`charAt()` 可能会返回孤项代理，这些代理项不是有效的 Unicode 字符。


```js
const str = "𠮷𠮾";
console.log(str.charAt(0)); // "\ud842"，这不是有效的 Unicode 字符
console.log(str.charAt(1)); // "\udfb7"，这不是有效的 Unicode 字符
```


要获取给定索引处的完整 Unicode 码位，请使用按 Unicode 码位拆分的索引方法，例如 `String.prototype.codePointAt()` 和将字符串展开为 Unicode 码位数组。


```js
const str = "𠮷𠮾";
console.log(String.fromCodePoint(str.codePointAt(0))); // "𠮷"
console.log([...str][0]); // "𠮷"
```


**备注：** 避免使用 `charAt()` 重新实现上述解决方案。检测孤项代理及其配对很复杂，而内置 API 可能更高效，因为它们直接使用字符串的内部表示形式。如有必要，请安装上述 API 的 polyfill。

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.charat |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* `String.prototype.charCodeAt()`
* `String.prototype.codePointAt()`
* `String.prototype.split()`
* `String.fromCodePoint()`
* JavaScript 有一个关于 Unicode 的问题——Mathias Bynens
String.prototype.strike()
=========================

**已弃用:** 不再推荐使用该特性。虽然一些浏览器仍然支持它，但也许已从相关的 web 标准中移除，也许正准备移除或出于兼容性而保留。请尽量不要使用该特性，并更新现有的代码；参见本页面底部的兼容性表格以指导你作出决定。请注意，该特性随时可能无法正常工作。

`String` 值的 **`strike()`** 方法创建一个 `<strike>` 元素字符串，其中嵌入了调用的字符串（`<strike>str</strike>`），从而使该字符串以删除线的形式显示。

**备注：** 所有 HTML 包装方法都已被弃用，并且仅为了兼容性而标准化。请使用 DOM API（例如 `document.createElement()`）代替。

语法
--


```js
strike()
```

### 参数

无。

### 返回值

一个以 `<strike>` 开始标签开头的字符串，接着是文本 `str`，最后是 `</strike>` 结束标签。

示例
--

### 使用 strike()

下面的示例使用了已弃用的字符串方法来更改字符串的格式：


```js
const worldString = "Hello, world";

console.log(worldString.blink()); // <blink>Hello, world</blink>
console.log(worldString.bold()); // <b>Hello, world</b>
console.log(worldString.italics()); // <i>Hello, world</i>
console.log(worldString.strike()); // <strike>Hello, world</strike>
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.strike |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `String.prototype.strike` 的 polyfill
* `String.prototype.blink()`
* `String.prototype.bold()`
* `String.prototype.italics()`
String.prototype.blink()
========================

**已弃用:** 不再推荐使用该特性。虽然一些浏览器仍然支持它，但也许已从相关的 web 标准中移除，也许正准备移除或出于兼容性而保留。请尽量不要使用该特性，并更新现有的代码；参见本页面底部的兼容性表格以指导你作出决定。请注意，该特性随时可能无法正常工作。

`String` 值的 **`blink()`** 方法创建一个字符串，其在 `<blink>str</blink>` 中嵌入字符串，这使得字符串在旧版浏览器中闪烁。

**备注：** 所有 HTML 包装方法都已被弃用，并且仅为了兼容性而标准化。对于 `blink()` 方法，`<blink>` 元素本身已在现代浏览器中移除，并且闪烁文本违反了多个无障碍标准。请避免以任何方式使用该元素。

语法
--


```js
blink()
```

### 参数

无。

### 返回值

一个以 `<blink>` 开始标签开头的字符串，接着是文本 `str`，然后是 `</blink>` 结束标签。

示例
--

### 使用 blink()

以下示例使用已弃用的字符串方法来更改字符串的格式：


```js
const worldString = "Hello, world";

console.log(worldString.blink()); // <blink>Hello, world</blink>
console.log(worldString.bold()); // <b>Hello, world</b>
console.log(worldString.italics()); // <i>Hello, world</i>
console.log(worldString.strike()); // <strike>Hello, world</strike>
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.blink |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `String.prototype.blink` 的 polyfill
* `String.prototype.bold()`
* `String.prototype.italics()`
* `String.prototype.strike()`
String.prototype.small()
========================

**已弃用:** 不再推荐使用该特性。虽然一些浏览器仍然支持它，但也许已从相关的 web 标准中移除，也许正准备移除或出于兼容性而保留。请尽量不要使用该特性，并更新现有的代码；参见本页面底部的兼容性表格以指导你作出决定。请注意，该特性随时可能无法正常工作。

`String` 值的 **`small()`** 方法创建一个 `<small>` 元素字符串，其中嵌入了调用的字符串（`<small>str</small>`），从而使该字符串以小号字体显示。

**备注：** 所有 HTML 包装方法都已被弃用，并且仅为了兼容性而标准化。请使用 DOM API（例如 `document.createElement()`）代替。

语法
--


```js
small()
```

### 参数

无。

### 返回值

一个以 `<small>` 开始标签开头的字符串，接着是文本 `str`，最后是 `</small>` 结束标签。

示例
--

### 使用 small()

以下示例使用字符串方法更改字符串的大小：


```js
const worldString = "Hello, world";

console.log(worldString.small()); // <small>Hello, world</small>
console.log(worldString.big()); // <big>Hello, world</big>
console.log(worldString.fontsize(7)); // <font size="7">Hello, world</fontsize>
```


使用 `element.style` 对象，你可以获取元素的 `style` 属性并以更通用的方式进行操作，例如：


```js
document.getElementById("yourElemId").style.fontSize = "0.7em";
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.small |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `String.prototype.small` 的 polyfill
* `String.prototype.fontsize()`
* `String.prototype.big()`
String.prototype.toLowerCase()
==============================

`String` 的 **`toLowerCase()`** 方法将该字符串转换为小写形式。

尝试一下
----

语法
--


```js
toLowerCase()
```

### 返回值

一个新的字符串，表示转换为小写的调用字符串。

描述
--

`toLowerCase()` 方法返回将字符串转换为小写形式后的值。`toLowerCase()` 不会影响字符串 `str` 本身的值。

示例
--

### 使用 `toLowerCase()`


```js
console.log("ALPHABET".toLowerCase()); // 'alphabet'
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.tolowercase |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `String.prototype.toLocaleLowerCase()`
* `String.prototype.toLocaleUpperCase()`
* `String.prototype.toUpperCase()`
String.prototype.at()
=====================

**`at()`** 方法接受一个整数值，并返回一个新的 `String`，该字符串由位于指定偏移量处的单个 UTF-16 码元组成。该方法允许正整数和负整数。负整数从字符串中的最后一个字符开始倒数。

尝试一下
----

语法
--


```js
at(index)
```

### 参数

`index`

要返回的字符串字符的索引（位置）。当传递负数时，支持从字符串末端开始的相对索引；也就是说，如果使用负数，返回的字符将从字符串的末端开始倒数。

### 返回值

由位于指定位置的单个 UTF-16 码元组成的 `String`。如果找不到指定的索引，则返回 `undefined` 。

示例
--

### 返回字符串的最后一个字符

以下示例提供了一个函数，该函数返回指定字符串中的最后一个字符。


```js
// 返回给定字符串的最后一个字符的函数
function returnLast(arr) {
  return arr.at(-1);
}

let invoiceRef = "myinvoice01";

console.log(returnLast(invoiceRef));
// Logs: '1'

invoiceRef = "myinvoice02";

console.log(returnLast(invoiceRef));
// Logs: '2'
```

### 方法对比

下面我们通过比较不同的方法来实现选择 `String` 的倒数第二个字符。尽管以下所有方法都是有效的，但它们凸显了 `at()` 方法的简洁性和可读性。


```js
const myString = "Every green bus drives fast.";

// 使用 length 属性和 charAt() 方法
const lengthWay = myString.charAt(myString.length - 2);
console.log(lengthWay); // 't'

// 使用 slice() 方法
const sliceWay = myString.slice(-2, -1);
console.log(sliceWay); // 't'

// 使用 at() 方法
const atWay = myString.at(-2);
console.log(atWay); // 't'
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.at |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中的 `String.prototype.at` 的 polyfill
* at() 方法的 polyfill.
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* `String.prototype.charCodeAt()`
* `String.prototype.codePointAt()`
* `String.prototype.split()`
String.prototype.lastIndexOf()
==============================

`String` 的 **`lastIndexOf()`** 方法搜索该字符串并返回指定子字符串最后一次出现的索引。它可以接受一个可选的起始位置参数，并返回指定子字符串在小于或等于指定数字的索引中的最后一次出现的位置。

尝试一下
----

语法
--


```js
lastIndexOf(searchString)
lastIndexOf(searchString, position)
```

### 参数

`searchString`

要搜索的子字符串。所有值都会强制转换为字符串，因此如果该参数被省略或传入 `undefined`，`lastIndexOf()` 方法会在字符串中搜索 `"undefined"`，这通常不是你想要的。

`position` 可选

该方法返回指定子字符串在小于或等于 `position` 的位置中的最后一次出现的索引，默认为 `+Infinity`。如果 `position` 大于调用字符串的长度，则该方法将搜索整个字符串。如果 `position` 小于 `0`，则行为与 `0` 相同，即该方法只在索引 `0` 处查找指定的子字符串。

* `'hello world hello'.lastIndexOf('world', 4)` 返回 `-1`——因为虽然子字符串 `world` 在索引 `6` 处出现，但该位置不小于或等于 `4`。
* `'hello world hello'.lastIndexOf('hello', 99)` 返回 `12`——因为小于或等于 `99` 的位置中，最后一次出现 `hello` 的位置是索引 `12`。
* `'hello world hello'.lastIndexOf('hello', 0)` 和 `'hello world hello'.lastIndexOf('hello', -5)` 都返回 `0`——因为两者都导致该方法只在索引 `0` 处查找 `hello`。

### 返回值

如果找到了 `searchString`，则返回最后一次出现的索引，否则返回 `-1`。

描述
--

字符串的索引从 0 开始：字符串第一个字符的索引为 `0`，字符串最后一个字符的索引为字符串长度减 1。


```js
"canal".lastIndexOf("a"); // 返回 3
"canal".lastIndexOf("a", 2); // 返回 1
"canal".lastIndexOf("a", 0); // 返回 -1
"canal".lastIndexOf("x"); // 返回 -1
"canal".lastIndexOf("c", -5); // 返回 0
"canal".lastIndexOf("c", 0); // 返回 0
"canal".lastIndexOf(""); // 返回 5
"canal".lastIndexOf("", 2); // 返回 2
```

### 区分大小写

`lastIndexOf()` 方法区分大小写。例如，以下表达式返回 `-1`：


```js
"Blue Whale, Killer Whale".lastIndexOf("blue"); // 返回 -1
```

示例
--

### 使用 indexOf() 和 lastIndexOf()

以下示例使用 `indexOf()` 和 `lastIndexOf()` 在字符串 `"Brave, Brave New World"` 中查找值。


```js
const anyString = "Brave, Brave New World";

console.log(anyString.indexOf("Brave")); // 0
console.log(anyString.lastIndexOf("Brave")); // 7
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.lastindexof |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `String.prototype.charAt()`
* `String.prototype.indexOf()`
* `String.prototype.split()`
* `Array.prototype.indexOf()`
* `Array.prototype.lastIndexOf()`
String.prototype.padStart()
===========================

**`padStart()`** 方法用另一个字符串填充当前字符串（如果需要会重复填充），直到达到给定的长度。填充是从当前字符串的开头开始的。

尝试一下
----

语法
--


```js
padStart(targetLength)
padStart(targetLength, padString)
```

### 参数

`targetLength`

当前 `str` 填充后的长度。如果该值小于或等于 `str.length`，则会直接返回当前 `str`。

`padString` 可选

用于填充当前 `str` 的字符串。如果 `padString` 太长，无法适应 `targetLength`，则会从末尾被截断。默认值为 Unicode“空格”字符（U+0020）。

### 返回值

在开头填充 `padString` 直到达到给定的 `targetLength` 所形成的 `String`。

示例
--

### 简单示例


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

### 将数字转换为固定长度的字符串


```js
// JavaScript version of: (unsigned)
// printf "%0\*d" width num
function leftFillNum(num, targetLength) {
  return num.toString().padStart(targetLength, "0");
}

const num = 123;
console.log(leftFillNum(num, 5)); // "00123"
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.padstart |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `String.prototype.padStart` 的 polyfill
* `String.prototype.padEnd()`
String.prototype.big()
======================

**已弃用:** 不再推荐使用该特性。虽然一些浏览器仍然支持它，但也许已从相关的 web 标准中移除，也许正准备移除或出于兼容性而保留。请尽量不要使用该特性，并更新现有的代码；参见本页面底部的兼容性表格以指导你作出决定。请注意，该特性随时可能无法正常工作。

`String` 值的 **`big()`** 方法创建一个 `<big>` 元素字符串，其中嵌入了调用的字符串（`<big>str</big>`），从而使该字符串以大字体显示。

**备注：** 所有的 HTML 包装方法都已被弃用，并且仅为了兼容性而标准化。对于 `big()` 方法来说，在 HTML5 中已经移除了 `<big>` 元素，不应再使用它。Web 开发者应该使用 CSS 属性来实现相应的效果。

语法
--


```js
big()
```

### 参数

无。

### 返回值

一个以 `<big>` 开始标签开头的字符串，然后是文本 `str`，最后是 `</big>` 结束标签。

示例
--

### 使用 big()

下面的例子使用了字符串方法来改变一个字符串的字体大小：


```js
const worldString = "Hello, world";

console.log(worldString.small()); // <small>Hello, world</small>
console.log(worldString.big()); // <big>Hello, world</big>
console.log(worldString.fontsize(7)); // <font size="7">Hello, world</font>
```


使用 `element.style` 对象，你能更通用地获得和操作该元素的 `style` 属性，例如：


```js
document.getElementById("yourElemId").style.fontSize = "2em";
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.big |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `String.prototype.big` 的 polyfill
* `String.prototype.fontsize()`
* `String.prototype.small()`