recursal/MDN huggingface dataset:
Error.prototype.fileName
========================

**非标准:** 该特性是非标准的，请尽量不要在生产环境中使用它！

**`fileName`** 属性包含引发此错误的文件的路径。

描述
--

此非标准属性包含引发此错误的文件的路径。如果从调试器上下文调用，例如 Firefox Developer Tools，将会返回“debugger eval code”.

示例
--

### 使用 `fileName`


```js
var e = new Error("Could not parse input");
throw e;
// e.fileName could look like "file:///C:/example.html"
```

规范
--

#### No specification found

No specification data found for `javascript.builtins.Error.fileName`.  
Check for problems with this page or contribute a missing `spec_url` to mdn/browser-compat-data. Also make sure the specification is included in w3c/browser-specs.

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

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

参见
--

* `Error.prototype.stack` 
非标准
* `Error.prototype.columnNumber` 
非标准
* `Error.prototype.lineNumber` 
非标准
String.prototype.search()
=========================

**`search()`** 方法用于在 `String` 对象中执行正则表达式的搜索，寻找匹配项。

尝试一下
----

语法
--


```js
search(regexp)
```

### 参数

`regexp`

一个正则表达式对象，或者具有 `Symbol.search` 方法的任意对象。

如果 `regexp` 不是 `RegExp` 对象，并且不具有 `Symbol.search` 方法，则会使用 `new RegExp(regexp)` 将其隐式转换为 `RegExp`。

### 返回值

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

描述
--

`String.prototype.search()` 方法的实现非常简单——它只是将该字符串作为调用实参拥有的 `Symbol.search` 方法的第一个参数。实际的实现来自于 `RegExp.prototype[@@search]()`。

`regexp` 的 `g` 标志对 `search()` 方法的结果没有影响，搜索总是以正则表达式的 `lastIndex` 为 0 进行。有关 `search()` 方法行为的更多信息，请参阅 `RegExp.prototype[@@search]()`。

当你想知道字符串中是否存在某个模式，并且*还*想知道它在字符串中的索引时，可以使用 `search()` 方法。

* 如果你只想知道某个模式是否存在，请使用 `RegExp.prototype.test()` 方法，它返回一个布尔值。
* 如果你需要获取匹配文本的内容，请使用 `match()` 或 `RegExp.prototype.exec()`。
示例
--

### 使用 search()

下面的示例中用两个不同的正则表达式对同一个字符串执行搜索匹配，得到一个成功匹配（正数返回值）和一个失败匹配（`-1`）。


```js
const str = "hey JudE";
const re = /[A-Z]/;
const reDot = /[.]/;
console.log(str.search(re)); // 返回 4，这是第一个大写字母“J”的索引
console.log(str.search(reDot)); // 返回 -1，找不到点符号“.”
```

规范
--

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

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

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

参见
--

* `core-js` 中 `String.prototype.search` 的 polyfill，修复并实现了 `Symbol.search` 支持等现代行为
* 在 JavaScript 中使用正则表达式
* `String.prototype.match()`
* `RegExp.prototype.exec()`
* `RegExp.prototype[@@search]()`
String.prototype.fixed()
========================

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

`String` 值的 **`fixed()`** 方法创建一个 `<tt>` 元素字符串，其中嵌入了调用的字符串（`<tt>str</tt>`），这会导致该字符串以等宽字体显示。

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

语法
--


```js
fixed()
```

### 参数

无。

### 返回值

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

示例
--

### 使用 fixed()

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


```js
const worldString = "Hello, world";
console.log(worldString.fixed()); // "<tt>Hello, world</tt>"
```

规范
--

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

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

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

参见
--

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

**`replaceAll()`** 方法返回一个新字符串，其中所有匹配 `pattern` 的部分都被替换为 `replacement`。`pattern` 可以是一个字符串或一个 `RegExp`，`replacement` 可以是一个字符串或一个在每次匹配时调用的函数。原始字符串保持不变。

尝试一下
----

语法
--


```js
replaceAll(pattern, replacement)
```

### 参数

`pattern`

可以是一个字符串或一个具有 `Symbol.replace` 方法的对象，典型的例子是正则表达式。任何没有 `Symbol.replace` 方法的值都将被强制转换为字符串。

如果 `pattern` 是一个正则表达式，则必须设置全局（`g`）标志，否则会抛出 `TypeError`。

`replacement`

可以是一个字符串或一个函数。替换字符串的语义与 `String.prototype.replace()` 相同。

### 返回值

返回一个新字符串，其中所有匹配 `pattern` 的部分都被替换为 `replacement`。

### 异常

`TypeError`

如果 `pattern` 是一个正则表达式，并且没有设置全局（`g`）标志（其 `flags` 属性不包含 `"g"`），则会抛出该异常。

描述
--

该方法不会修改调用它的字符串。它返回一个新字符串。

与 `replace()` 不同，该方法将替换所有匹配的字符串，而不仅仅是第一个。如果字符串不是静态已知的，那么这特别有用，因为调用 `RegExp()` 构造函数而不转义特殊字符可能会意外地改变它的语义。


```js
function unsafeRedactName(text, name) {
  return text.replace(new RegExp(name, "g"), "[REDACTED]");
}
function safeRedactName(text, name) {
  return text.replaceAll(name, "[REDACTED]");
}

const report =
  "A hacker called ha.\*er used special characters in their name to breach the system.";

console.log(unsafeRedactName(report, "ha.\*er")); // "A [REDACTED]s in their name to breach the system."
console.log(safeRedactName(report, "ha.\*er")); // "A hacker called [REDACTED] used special characters in their name to breach the system."
```


如果 `pattern` 是一个具有 `Symbol.replace` 方法的对象（包括 `RegExp` 对象），则该方法将被调用，并以目标字符串和 `replacement` 作为参数。它的返回值成为 `replaceAll()` 的返回值。在这种情况下，`replaceAll()` 的行为完全取决于 `@@replace` 方法，因此除了额外的输入验证（即正则表达式必须是全局的）之外，它将具有与 `replace()` 相同的结果。

如果 `pattern` 是一个空字符串，则替换内容将插入到每个 UTF-16 码元之间，类似于 `split()` 的行为。


```js
"xxx".replaceAll("", "\_"); // "\_x\_x\_x\_"
```


有关正则表达式属性（尤其是 sticky 标志）如何与 `replaceAll()` 交互的更多信息，请参阅 `RegExp.prototype[@@replace]()`。

示例
--

### 使用 replaceAll()


```js
"aabbcc".replaceAll("b", ".");
// 'aa..cc'
```

### 非全局正则表达式抛出错误

使用正则表达式搜索值时，它必须是全局的。下面的代码是不可行的：


```js
"aabbcc".replaceAll(/b/, ".");
// TypeError: replaceAll must be called with a global RegExp
```


下面的代码可以正常运行：


```js
"aabbcc".replaceAll(/b/g, ".");
("aa..cc");
```

规范
--

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

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

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

参见
--

* `core-js` 中 `String.prototype.replaceAll` 的 polyfill
* `String.prototype.replace()`
* `String.prototype.match()`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`
String：length
=============

`String` 类型的 **`length`** 数据属性表示字符串的 UTF-16 码元长度。

尝试一下
----

值
-

一个非负整数。

| `String：length` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 否 |

描述
--

该属性返回字符串中的码元数量。JavaScript 使用 UTF-16 编码，其中每个 Unicode 字符可以编码为一个或两个码元，因此 `length` 返回的值可能与字符串中 Unicode 字符的实际数量不匹配。对于拉丁文、西里尔文、众所周知的 CJK 字符等常见脚本，这应该不是问题，但如果你正在处理某些脚本，例如表情符号、数学符号或生僻字，你可能需要考虑码元和字符之间的差异。

语言规范要求字符串的最大长度为 253 - 1 个元素，这是精确整数的上限。但是，具有此长度的字符串需要 16384TiB 的存储空间，这远远超出了任何合理设备的内存限制，因此实现通常会降低这个阈值，从而允许字符串的长度方便地存储在一个 32 位整数中。

* 在 V8 引擎（Chrome 和 Node 使用）中，最大长度为 229 - 24（约为 1GiB）。在 32 位系统上，最大长度为 228 - 16（约为 512MiB）。
* 在 Firefox 中，最大长度为 230 - 2（约为 2GiB）。在 Firefox 65 之前，最大长度为 228 - 1（约为 512MiB）。
* 在 Safari 中，最大长度为 231 - 1（约为 4GiB）。

对于空字符串，`length` 为 0。

静态属性 `String.length` 与字符串的长度无关。它是 `String` 函数的参数数量（简单地说，就是它有多少个形参），也就是 1。

由于 `length` 统计的是码元而不是字符，如果你想得到字符的数量，你可以首先用它的迭代器分割字符串，它按字符进行迭代：


```js
function getCharacterLength(str) {
  // 这里使用的字符串迭代器遍历的是字符，而不仅仅是码元
  return [...str].length;
}

console.log(getCharacterLength("A\uD87E\uDC04Z")); // 3
```

示例
--

### 基本用法


```js
const x = "Mozilla";
const empty = "";

console.log(`${x} 有 ${x.length} 个码元`);
// Mozilla 有 7 个码元

console.log(`空字符串的 length 为 ${empty.length}`);
// 空字符串的 length 为 0
```

### 长度不等于字符数的字符串


```js
const emoji = "😄";
console.log(emoji.length); // 2
console.log([...emoji].length); // 1
const adlam = "𞤲𞥋𞤣𞤫";
console.log(adlam.length); // 8
console.log([...adlam].length); // 4
const formula = "∀𝑥∈ℝ,𝑥²≥0";
console.log(formula.length); // 11
console.log([...formula].length); // 9
```

### 指定长度

因为字符串是一个基本类型，所以尝试为字符串的 `length` 属性赋值没有可观察到的效果，并且在严格模式下会抛出错误。


```js
const myString = "bluebells";

myString.length = 4;
console.log(myString); // "bluebells"
console.log(myString.length); // 9
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-properties-of-string-instances-length |

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

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

参见
--

* JavaScript 的 `String.length` 属性和国际化 Web 应用
String.prototype.trimEnd()
==========================

`String` 的 **`trimEnd()`** 方法会从字符串的结尾移除空白字符，并返回一个新的字符串，而不会修改原始字符串。`trimRight()` 是该方法的别名。

尝试一下
----

语法
--


```js
trimEnd()

trimRight()
```

### 返回值

一个新的字符串，表示从 `str` 的末尾（右侧）去除空白字符后的结果。空白字符定义为空白符加上行终止符。

如果 `str` 的末尾没有空白字符，仍然会返回一个新的字符串（实际上是 `str` 的副本）。

### 别名

在 `trim()` 标准化后，引擎也实现了非标准的 `trimRight` 方法。然而，为了与 `padEnd()` 保持一致，在该方法标准化时，选择了 `trimEnd` 作为其名称。出于 Web 兼容性的考虑，`trimRight` 仍然作为 `trimEnd` 的别名，它们引用的是完全相同的函数对象。在某些引擎中，这意味着：


```js
String.prototype.trimRight.name === "trimEnd";
```

示例
--

### 使用 trimEnd()

下面的示例从 `str` 的末尾去除空白字符，但不会去除开头的空白字符。


```js
let str = " foo ";

console.log(str.length); // 8

str = str.trimEnd();
console.log(str.length); // 6
console.log(str); // ' foo'
```

规范
--

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

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

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

参见
--

* `core-js` 中 `String.prototype.trimEnd` 的 polyfill
* `String.prototype.trim()`
* `String.prototype.trimStart()`
String.prototype.fontsize()
===========================

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

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

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

语法
--


```js
fontsize(size)
```

### 参数

`size`

一个介于 1 和 7 之间的整数，或表示介于 1 和 7 之间的有符号整数的字符串。

### 返回值

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

描述
--

`fontsize()` 方法本身只是简单地将字符串部分连接在一起，没有进行任何验证或规范化。然而，为了创建有效的 `<font>` 元素，当你将大小指定为整数时，你将 `str` 的字体大小设置为 7 个定义的大小之一。你还可以将 `size` 指定为字符串，例如 `"-2"` 或 `"+3"`，以相对于默认值 3 调整 `str` 的字体大小。

示例
--

### 使用 fontsize()

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


```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 = "0.7em";
```

规范
--

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

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

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

参见
--

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

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

`String` 值的 **`anchor()`** 方法创建一个带有名称的 `<a>` 元素字符串，其中嵌入了调用的字符串（`<a name="...">str</a>`）。

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

HTML 规范不再允许 `<a>` 元素具有 `name` 属性，因此该方法甚至无法创建有效的标记。

语法
--


```js
anchor(name)
```

### 参数

`name`

一个字符串，表示要生成的 `<a name="...">` 开始标签的 `name` 属性。

### 返回值

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

示例
--

### 使用 anchor()


```js
const myString = "内容目录";

document.body.innerHTML = myString.anchor("内容锚点");
```


将会输出下面的 HTML：


```html
<a name="内容锚点">内容目录</a>
```

规范
--

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

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

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

参见
--

* `core-js` 中 `String.prototype.anchor` 的 polyfill
* `String.prototype.link()`
String.prototype.sub()
======================

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

`String` 值的 **`sub()`** 方法创建一个 `<sub>` 元素字符串，其中嵌入了调用的字符串（`<sub>str</sub>`），这会导致该字符串显示为下标。

**备注：** 所有 HTML 包装器方法 均已弃用，仅出于兼容性目的而进行标准化。请改用 DOM API，例如 `document.createElement()`。

语法
--


```js
sub()
```

### 参数

无。

### 返回值

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

示例
--

### 使用 sub() 和 sup() 方法

下面的示例使用了 `sub()` 和 `sup()` 方法来格式化字符串：


```js
const superText = "上标";
const subText = "下标";

console.log(`这就是${superText.sup()}的样子。`);
// "这就是<sup>上标</sup>的样子。"

console.log(`这就是${subText.sub()}的样子。`);
// "这就是<sub>下标</sub>的样子。"
```

规范
--

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

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

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

参见
--

* `core-js` 中 `String.prototype.sub` 的 Polyfill
* `String.prototype.sup()`
String.prototype.link()
=======================

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

`String` 值的 **`link()`** 方法创建一个 `<a>` 元素字符串，其中嵌入了调用的字符串（`<a href="...">str</a>`），用作指向另一个 URL 的超文本链接。

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

语法
--


```js
link(url)
```

### 参数

`url`

任何能够指定 `<a>` 元素的 `href` 属性的字符串；它应当是有效的 URL（相对或绝对），任何 `&` 字符将会被转义为 `&amp;`。

### 返回值

一个以 `<a href="url">` 开始标签开始（`url` 中的双引号被替换为 `&quot;`），接着是文本 `str`，最后是 `</a>` 结束标签的字符串。

示例
--

### 使用 link()

下面的示例将单词“MDN”显示为一个超文本链接，点击该链接将用户返回到 Mozilla Developer Network。


```js
const hotText = "MDN";
const url = "https://developer.mozilla.org/";

console.log(`点击返回 ${hotText.link(url)}`);
// 点击返回 <a href="https://developer.mozilla.org/">MDN</a>
```

规范
--

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

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

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

参见
--

* `core-js` 中 `String.prototype.link` 的 polyfill
* `String.prototype.anchor()`
* `document.links`
String.prototype.toString()
===========================

`String` 的 **`toString()`** 方法返回该字符串的值。

尝试一下
----

语法
--


```js
toString()
```

### 返回值

表示指定字符串值的字符串。

描述
--

`String` 对象重写了 `Object` 的 `toString` 方法；它不会继承 `Object.prototype.toString()`。对于 `String` 值，`toString` 方法返回字符串本身（如果它是原始值）或 `String` 对象封装的字符串。它的实现与 `String.prototype.valueOf()` 完全相同。

`toString()` 方法要求其 `this` 值为 `String` 原始值或封装对象。对于其他 `this` 值，它会抛出 `TypeError` 而不尝试将其转换为字符串值。

由于 `String` 没有 `[@@toPrimitive]()` 方法，当一个 `String` *对象*在期望字符串的上下文中使用时（比如在模板字面量中），JavaScript 会自动调用 `toString()` 方法。然而，`String` *原始值*不会使用 `toString()` 方法来进行字符串强制转换——因为它们已经是字符串，所以不会进行转换。


```js
String.prototype.toString = () => "已经被重写了";
console.log(`${"foo"}`); // "foo"
console.log(`${new String("foo")}`); // "已经被重写了"
```

示例
--

### 使用 toString()

以下示例输出一个 `String` 对象的字符串值：


```js
const x = new String("Hello world");

console.log(x.toString()); // "Hello world"
```

规范
--

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

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

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

参见
--

* `String.prototype.valueOf()`
String.prototype.repeat()
=========================

**`repeat()`** 方法构造并返回一个新字符串，其中包含指定数量的所调用的字符串副本，这些副本连接在一起。

尝试一下
----

语法
--


```js
repeat(count)
```

### 参数

`count`

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

### 返回值

包含指定字符串的指定数量副本的新字符串。

### 异常

`RangeError`

如果 `count` 为负值，或者 `count` 超过了字符串的最大长度，将抛出错误。

示例
--

### 使用 repeat()


```js
"abc".repeat(-1); // RangeError
"abc".repeat(0); // ''
"abc".repeat(1); // 'abc'
"abc".repeat(2); // 'abcabc'
"abc".repeat(3.5); // 'abcabcabc'（count 将被转换为整数）
"abc".repeat(1 / 0); // RangeError

({ toString: () => "abc", repeat: String.prototype.repeat }).repeat(2);
// 'abcabc'（repeat() 是一个通用方法）
```

规范
--

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

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

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

参见
--

* `core-js` 中 `String.prototype.repeat` 的 polyfill
* `String.prototype.concat()`
String.prototype.endsWith()
===========================

**`endsWith()`** 方法用于判断一个字符串是否以指定字符串结尾，如果是则返回 `true`，否则返回 `false`。

尝试一下
----

语法
--


```js
endsWith(searchString)
endsWith(searchString, endPosition)
```

### 参数

`searchString`

要搜索的作为结尾的字符串，不能是正则表达式。所有非正则表达式的值都会被强制转换为字符串，因此如果该参数被省略或传入 `undefined`，`endsWith()` 方法会在字符串中搜索 `"undefined"`，这通常不是你想要的。

`endPosition` 可选

预期找到 `searchString` 的末尾位置（即 `searchString` 最后一个字符的索引加 1）。默认为 `str.length`。

### 返回值

如果被检索字符串的末尾出现了指定的字符串（包括 `searchString` 为空字符串的情况），则返回 **`true`**；否则返回 **`false`**。

### 异常

`TypeError`

如果 `searchString` 是一个正则表达式，则会抛出。

描述
--

这个方法可以让你确定一个字符串是否以另一个字符串结尾。该方法区分大小写。

示例
--

### 使用 endsWith()


```js
const str = "生存还是毁灭，这是一个问题。";

console.log(str.endsWith("问题。")); // true
console.log(str.endsWith("毁灭")); // false
console.log(str.endsWith("毁灭", 6)); // true
```

规范
--

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

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

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

参见
--

* `core-js` 中 `String.prototype.endsWith` 的 polyfill
* `String.prototype.startsWith()`
* `String.prototype.includes()`
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
String.prototype.bold()
=======================

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

`String` 值的 **`bold()`** 方法创建一个 `<b>` 元素字符串，其中嵌入了调用的字符串（`<b>str</b>`），这会导致该字符串以粗体显示。

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

语法
--


```js
bold()
```

### 返回值

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

示例
--

### 使用 bold()

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


```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.bold |

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

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

参见
--

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

**`includes()`** 方法执行区分大小写的搜索，以确定是否可以在一个字符串中找到另一个字符串，并根据情况返回 `true` 或 `false`。

尝试一下
----

语法
--


```js
includes(searchString)
includes(searchString, position)
```

### 参数

`searchString`

要在 `str` 中搜索的字符串。不能是正则表达式。

`position` 可选

在字符串中开始搜索 `searchString` 的位置。（默认为 `0`。）

`searchString`

一个要在 `str` 中查找的字符串。不能是正则表达式。所有非正则表达式的值都会被强制转换为字符串，因此如果该参数被省略或传入 `undefined`，`includes()` 方法会在字符串中搜索 `"undefined"`，这通常不是你想要的。

`position` 可选

在字符串中开始搜索 `searchString` 的位置。默认值为 `0`。

### 返回值

如果在给定的字符串中找到了要搜索的字符串（包括 `searchString` 为空字符串的情况），则返回 **`true`**，否则返回 **`false`**。

### 异常

`TypeError`

如果 `searchString` 是一个正则表达式，则会抛出。

描述
--

此方法可以帮你判断一个字符串是否包含另外一个字符串。

### 区分大小写

`includes()` 方法是区分大小写的。例如，下面的表达式会返回 `false`：


```js
"Blue Whale".includes("blue"); // 返回 false
```


你可以通过将原字符串和搜索字符串全部转换为小写来解决这个约束：


```js
"Blue Whale".toLowerCase().includes("blue"); // 返回 true
```

示例
--

### 使用 includes()


```js
const str = "To be, or not to be, that is the question.";

console.log(str.includes("To be")); // true
console.log(str.includes("question")); // true
console.log(str.includes("nonexistent")); // false
console.log(str.includes("To be", 1)); // false
console.log(str.includes("TO BE")); // false
console.log(str.includes("")); // true
```

规范
--

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

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

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

参见
--

* `core-js` 中 `String.prototype.includes` 的 polyfill
* `Array.prototype.includes()`
* `TypedArray.prototype.includes()`
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* `String.prototype.startsWith()`
* `String.prototype.endsWith()`
String.prototype.trimStart()
============================

`String` 的 **`trimStart()`** 方法会从字符串的开头移除空白字符，并返回一个新的字符串，而不会修改原始字符串。`trimLeft()` 是该方法的别名。

尝试一下
----

语法
--


```js
trimStart()

trimLeft()
```

### 返回值

一个新的字符串，表示从 `str` 的开头（左侧）去除空白字符后的结果。空白字符定义为空白符加上行终止符。

如果 `str` 的开头没有空白字符，仍然会返回一个新的字符串（实际上是 `str` 的副本）。

### 别名

在 `trim()` 标准化后，引擎也实现了非标准的 `trimLeft` 方法。然而，为了与 `padStart()` 保持一致，在该方法标准化时，选择了 `trimStart` 作为其名称。出于 Web 兼容性的考虑，`trimLeft` 仍然作为 `trimStart` 的别名，它们引用的是完全相同的函数对象。在某些引擎中，这意味着：


```js
String.prototype.trimLeft.name === "trimStart";
```

示例
--

### 使用 trimStart()

下面的示例从 `str` 的开头去除空白字符，但不会去除结尾的空白字符。


```js
let str = " foo ";

console.log(str.length); // 8

str = str.trimStart();
console.log(str.length); // 5
console.log(str); // 'foo '
```

规范
--

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

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

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

参见
--

* `core-js` 中 `String.prototype.trimStart` 的 polyfill
* `String.prototype.trim()`
* `String.prototype.trimEnd()`
String() 构造函数
=============

**`String()`** 构造函数创建 `String` 对象。当作为函数调用时，它返回 String 类型的原始值。

语法
--


```js
new String(thing)
String(thing)
```


**备注：** `String()` 被调用时可以带或不带 `new`，但会有不同的效果。请参见返回值。

### 参数

`thing`

任何要转换为字符串的内容。

### 返回值

当 `String` 作为构造函数（使用 `new`）被调用时，它会创建一个 `String` 对象，该对象**不是**原始类型。

当 `String` 作为函数被调用时，它会将参数强制转换为一个字符串原始类型。Symbol 值会被转换成 `"Symbol(description)"`，其中 `description` 是该 Symbol 的 description 属性值，而不会抛出错误。

**警告：** 你应该很少需要使用 `String` 作为构造函数。

示例
--

### String 构造函数和 String 函数

String 函数和 String 构造函数产生不同的结果：


```js
const a = new String("Hello world"); // a === "Hello world" 为 false
const b = String("Hello world"); // b === "Hello world" 为 true
a instanceof String; // 为 true
b instanceof String; // 为 false
typeof a; // "object"
typeof b; // "string"
```


在这里，该函数生成了一个字符串（即原始值），如其所述。然而，构造函数生成了一个类型为 `String` 的实例（即一个对象包装器），这就是为什么你很少需要使用 `String` 作为构造函数的原因。

### 使用 String() 将 Symbol 转换为字符串：

`String()` 是唯一一种可以将 Symbol 转换为字符串而不抛出异常的方式，因为它非常明确。


```js
const sym = Symbol("示例");
`${sym}`; // TypeError: Cannot convert a Symbol value to a string
"" + sym; // TypeError: Cannot convert a Symbol value to a string
"".concat(sym); // TypeError: Cannot convert a Symbol value to a string
```



```js
const sym = Symbol("示例");
String(sym); // "Symbol(示例)"
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string-constructor |

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

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

参见
--

* JavaScript 指南中的文本格式化
String.prototype.padEnd()
=========================

**`padEnd()`** 方法会将当前字符串从末尾开始填充给定的字符串（如果需要会重复填充），直到达到给定的长度。填充是从当前字符串的末尾开始的。

尝试一下
----

语法
--


```js
padEnd(targetLength)
padEnd(targetLength, padString)
```

### 参数

`targetLength`

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

`padString` 可选

用于填充当前 `str` 的字符串。如果 `padString` 太长，无法适应 `targetLength`，则会被截断：对于从左到右的语言，左侧的部分将会被保留；对于从右到左的语言，右侧的部分将会被保留。默认值为“ ” (`U+0020`)。

### 返回值

在当前 `str` 末尾填充 `padString` 直到达到给定的 `targetLength` 所形成的 `String`。

示例
--

### 使用 padEnd


```js
"abc".padEnd(10); // "abc "
"abc".padEnd(10, "foo"); // "abcfoofoof"
"abc".padEnd(6, "123456"); // "abc123"
"abc".padEnd(1); // "abc"
```

规范
--

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

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

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

参见
--

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