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

**`slice()`** メソッドは、元の文字列を変更せず、文字列の一部分を取り出し、それを新しい文字列として返します。

試してみましょう
--------

構文
--


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

### 引数

`indexStart`

返却する部分文字列に含める最初の文字の位置です。

`indexEnd` 省略可

返却する部分文字列から除外する最初の文字の位置です。

### 返値

文字列の取り出された部分を含んだ新しい文字列です。

解説
--

`slice()` は 1 つの文字列からテキストを取り出し、新しい文字列を返します。一方の文字列におけるテキストへの変更は、他の文字列に影響を与えません。

`slice()` は `indexEnd` を含まずにテキストを取り出します。例えば `str.slice(1, 4)` は、 2 番目から 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."; // The length of str1 is 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.prototype.at()
=====================

**`at()`** メソッドは整数値を受け取り、指定したオフセットに位置する 1 つの UTF-16 コード単位からなる新しい文字列を返します。このメソッドでは、正と負の整数を扱うことができます。負の整数の場合は、文字列の最後の文字から前へ数えます。

試してみましょう
--------

構文
--


```js
at(index)
```

### 引数

`index`

返す文字列のインデックス（位置）。負のインデックスを渡した場合、文字列の末尾からの相対位置指定に対応しています。つまり、負の数を使用した場合、文字列の末尾から数えて返す文字を見つけます。

### 返値

指定した位置にある単一の UTF-16 コード単位からなる文字列を返します。指定された位置が見つからない場合は `undefined` を返します。

例
-

### 文字列の最後の文字を返す

次の例は、指定した文字列の中で最後に見つかった文字を返す関数です。


```js
// 指定された文字列の最後の文字を返す関数
function returnLast(arr) {
  return arr.at(-1);
}

let invoiceRef = "myinvoice01";

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

invoiceRef = "myinvoice02";

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

### メソッドの比較

ここでは、`String` の最後から 2 番目の文字を選択する複数の方法を比較します。以下に示すどの方法も有効ですが、`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.

関連情報
----

* `String.prototype.at` のポリフィル (`core-js`)
* at() メソッドのポリフィル.
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* `String.prototype.charCodeAt()`
* `String.prototype.codePointAt()`
* `String.prototype.split()`
String: length
==============

**`length`** データプロパティは、`String` オブジェクトの文字列長を UTF-16 コード単位の数で表します。

試してみましょう
--------

値
-

非負の整数です。

| `String: length` のプロパティ属性 |
| --- |
| 書込可能 | 不可 |
| 列挙可能 | 不可 |
| 設定可能 | 不可 |

解説
--

このプロパティは、文字列内のコード単位の数を返します。JavaScript では UTF-16 エンコーディングを使用しており、すべての Unicode 文字が 1 つまたは 2 つのコード単位にエンコードされるため、`length` で返される値は文字列の実際の Unicode 文字数に一致しない可能性があります。よく使われるラテン、キリル、有名な漢字などはこのような問題にはなりませんが、絵文字、数学記号、難しい漢字などのような特定の文字体系では、`length` で返される値が文字列の実際の文字数と一致しなくなる可能性があるので、コード単位数と文字数の違いを考慮する必要があるかもしれません。

言語の仕様書では、文字列の最大長が 253 - 1 要素と制定されており、これは正確に表せる整数の上限となっています。しかし、この長さの文字列は 16,384TiB のストレージを必要とし、これは一般的な機器のメモリーに収まらないため、実装上はもっと低い閾値を設けている傾向があり、文字列の長さを便宜上 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(`空文字列の長さは ${empty.length} です`);
/\* "空文字の長さは 0 です" \*/
```

### 文字列の length は文字数と等しいとは限らない


```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 への代入

文字列はプリミティブであるため、文字列の `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` and Internationalizing Web Applications
String.prototype.trimStart()
============================

**`trimStart()`** メソッドは、元の文字列を変更せずに、文字列の先頭のホワイトスペースを削除した新しい文字列を返します。`trimLeft()` はこのメソッドの別名です。

試してみましょう
--------

構文
--


```js
trimStart()

trimLeft()
```

### 返値

`str` の先頭のホワイトスペースを取り除いた新しい文字列です。ホワイトスペースはホワイトスペース文字と改行文字で定義します。

`str` の先頭にホワイトスペースがなかった場合でも、新しい文字列が返されます（基本的には `str` のコピー）。

### 別名

`trim()` が標準化された後、エンジンは標準外の `trimLeft` メソッドも実装しました。しかし `padEnd()` との整合を取るため、このメソッドが標準化された際、`trimStart` という名前が選択されました。ウェブの互換性の理由から、`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.

関連情報
----

* `String.prototype.trimStart` のポリフィル (`core-js`)
* `String.prototype.trim()`
* `String.prototype.trimEnd()`
String.prototype.big()
======================

**非推奨:** この機能は非推奨になりました。まだ対応しているブラウザーがあるかもしれませんが、すでに関連するウェブ標準から削除されているか、削除の手続き中であるか、互換性のためだけに残されている可能性があります。使用を避け、できれば既存のコードは更新してください。このページの下部にある互換性一覧表を見て判断してください。この機能は突然動作しなくなる可能性があることに注意してください。

**`big()`** は `String` 値のメソッドで、ｋの文字列を `<big>` 要素の中に埋め込み (`<big>str</big>`)、この文字列が大きなフォントで表示されるようにします。

**警告:** HTML ラッパーメソッドはすべて非推奨となっており、互換性目的のみで標準化されています。`<big>` 要素自体は HTML 仕様書から削除されており、今後使用するべきではありません。代わりにウェブ開発者は CSS プロパティを使用してください。

構文
--


```js
big()
```

### 引数

なし。

### 返値

`<big>` 開始タグで始まり、`str` のテキストが来て、 `</big>` 終了タグが来る文字列です。

例
-

### big() の使用

下記のコードは HTML 文字列を作成し、文書内の本体を文字列で置き換えています。


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

document.body.innerHTML = contentString.big();
```


これで次の HTML が作成されます。


```html
<big>Hello, world</big>
```


**警告:** `big` は有効な要素ではなくなっているので、このマークアップは無効です。

`big()` を使用して直接 HTML テキストを作成する代わりに、 CSS を使用してフォントを操作しましょう。例えば、 `element.style` 属性を通して `font-size` を操作することができます。


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

関連情報
----

* `String.prototype.big` のポリフィル (`core-js`)
* HTML ラッパーメソッド
* `<big>`
String.prototype.sup()
======================

**非推奨:** この機能は非推奨になりました。まだ対応しているブラウザーがあるかもしれませんが、すでに関連するウェブ標準から削除されているか、削除の手続き中であるか、互換性のためだけに残されている可能性があります。使用を避け、できれば既存のコードは更新してください。このページの下部にある互換性一覧表を見て判断してください。この機能は突然動作しなくなる可能性があることに注意してください。

**`sup()`** メソッドは、文字列を `<sup>` 要素に埋め込んだ文字列 (`<sup>str</sup>`) を生成し、文字列が上付き文字として表示されるようにします。

**警告:** HTML ラッパーメソッドはすべて非推奨となっており、互換性目的のみで標準化されています。代わりに DOM API の `document.createElement()` などを使用してください。

構文
--


```js
sup()
```

### 返値

開始タグ `<sup>` で始まり、テキスト `str` が来て、終了タグ `</sup>` が来る文字列です。

例
-

### 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.sup |

ブラウザーの互換性
---------

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

関連情報
----

* `String.prototype.sup` のポリフィル (`core-js`)
* `String.prototype.sub()`
String.prototype.bold()
=======================

**非推奨:** この機能は非推奨になりました。まだ対応しているブラウザーがあるかもしれませんが、すでに関連するウェブ標準から削除されているか、削除の手続き中であるか、互換性のためだけに残されている可能性があります。使用を避け、できれば既存のコードは更新してください。このページの下部にある互換性一覧表を見て判断してください。この機能は突然動作しなくなる可能性があることに注意してください。

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

関連情報
----

* `String.prototype.bold` のポリフィル (`core-js`)
* `String.prototype.blink()`
* `String.prototype.italics()`
* `String.prototype.strike()`
String.prototype.includes()
===========================

**`includes()`** メソッドは、1 つの文字列を別の文字列の中に見出すことができるかどうかを判断し、必要に応じて `true` か `false` を返します。

試してみましょう
--------

構文
--


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

引数
--

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

関連情報
----

* `String.prototype.includes` のポリフィル (`core-js`)
* `Array.prototype.includes()`
* `TypedArray.prototype.includes()`
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* `String.prototype.startsWith()`
* `String.prototype.endsWith()`
String.prototype.search()
=========================

**`search()`** メソッドは、正規表現とこの `String` オブジェクトが一致するかどうかを調べます。

試してみましょう
--------

構文
--


```js
search(regexp)
```

### 引数

`regexp`

正規表現オブジェクト、または `Symbol.search` メソッドを持つ任意のオブジェクトです。

`regexp` が `RegExp` オブジェクトでなく、`Symbol.search` メソッドもなかった場合は、`RegExp` オブジェクトに `new 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() の使用

次の例は、2 つの異なる正規表現オブジェクトで文字列を検索し、成功した検索（正の値）と失敗した検索 (`-1`) を表示します。


```js
const str = "hey JudE";
const re = /[A-Z]/;
const reDot = /[.]/;
console.log(str.search(re)); // 最初の大文字 "J" のインデックスである 4 を返します
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.

関連情報
----

* `String.prototype.search` のポリフィル (`core-js`) （`Symbol.search` のようなの現代の修正や挙動つき）
* JavaScript の正規表現の使用
* `String.prototype.match()`
* `RegExp.prototype.exec()`
* `RegExp.prototype[@@search]()`
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` オブジェクトのメソッドではなく、常に `String.fromCodePoint()` として使用するようにしてください。

Unicode のコードポイントは `0` から `1114111` (`0x10FFFF`) までの範囲です。`charAt()` は常に `65536` より小さい値を返しますが、これは上位のコードポイントは 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); // Code Point U+1F303 "Night with
String.fromCharCode(55356, 57091); // Stars" === "\uD83C\uDF03"
```


一方、 `String.fromCodePoint()` はコードポイント（UTF-32 のコード単位に相当）を指定することで、 4 バイトの補助文字や、一般的な 2 バイトの BMP 文字を返すことができます。


```js
String.fromCodePoint(0x1f303); // または 10 進数で 127747
```

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

* `String.fromCodePoint` のポリフィル (`core-js`)
* `String.fromCharCode()`
* `String.prototype.charAt()`
* `String.prototype.codePointAt()`
* `String.prototype.charCodeAt()`
String.prototype.fixed()
========================

**非推奨:** この機能は非推奨になりました。まだ対応しているブラウザーがあるかもしれませんが、すでに関連するウェブ標準から削除されているか、削除の手続き中であるか、互換性のためだけに残されている可能性があります。使用を避け、できれば既存のコードは更新してください。このページの下部にある互換性一覧表を見て判断してください。この機能は突然動作しなくなる可能性があることに注意してください。

**`fixed()`** メソッドは、文字列を `<tt>` 要素に埋め込み (`<tt>str</tt>`)、文字列が固定ピッチフォントで表示されるような文字列を生成します。

**警告:** HTML ラッパーメソッドはすべて非推奨となっており、互換性目的のみで標準化されています。代わりに DOM API の `document.createElement()` などを使用してください。

構文
--


```js
fixed()
```

### 返値

`<tt>` 開始タグで始まり、`str` のテキストが来て、 `</tt>` 終了タグが来る文字列です。

例
-

### fixed() の使用

下記の例は、 `fixed` メソッドを使用して文字列の表示方法を変更します。


```js
const worldString = "世界のみなさん、こんにちは！";
console.log(worldString.fixed()); // "<tt>世界のみなさん、こんにちは！</tt>"
```

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

* `String.prototype.fixed` のポリフィル (`core-js`)
* `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` メソッドを持たない値は文字列に変換されます。

`regexp` が正規表現である場合、グローバルフラグ (`g`) が設定されます。そうでなければ `TypeError` が発生します。

`replacement`

文字列または関数を指定することができます。この置換は `String.prototype.replace()` と意味的に同じです。

### 返値

パターンに一致したすべての文字列を置換文字列で置き換えた新しい文字列です。

### 例外

`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` が空文字列の場合、`split()` の動作と同様に、UTF-16 のコード単位ごとに置換文字列が挿入されます。


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

関連情報
----

* `String.prototype.replaceAll` のポリフィル (`core-js`)
* `String.prototype.replace()`
* `String.prototype.match()`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`
String.prototype.valueOf()
==========================

**`valueOf()`** メソッドは、`String` オブジェクトのプリミティブ値を返します。

試してみましょう
--------

構文
--


```js
valueOf()
```

### 返値

与えられた `String` オブジェクトのプリミティブ値を表す文字列です。

詳細
--

`String` オブジェクトの `valueOf()` メソッドは、`String` オブジェクトの文字列型としてのプリミティブ値を返します。この値は、`String.prototype.toString()` の返値と等価です。

このメソッドは通常、JavaScript によって内部的に呼ばれ、コード中で明示的に呼ばれることはありません。

例
-

### `valueOf()` メソッドの使用


```js
const x = new String("Hello world");
console.log(x.valueOf()); // 'Hello world'
```

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

* `String.prototype.toString()`
* `Object.prototype.valueOf()`
String.prototype.endsWith()
===========================

**`endsWith()`** メソッドは文字列が引数で指定された文字列で終わるかを判定して `true` か `false` を返します。

試してみましょう
--------

構文
--


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

### 引数

`searchString`

`str` の末尾で検索される文字の集合です。正規表現にすることはできません。正規表現ではない値はすべて文字列に変換されますので、省略したり `undefined` を渡したりすると、`endsWith()` は `"undefined"` という文字列を検索します。これはおそらく望むところではないでしょう。

`endPosition` 省略可

`searchString` が見つかると期待される末尾の位置（`searchString` の最後の文字 +1 のインデックス）です。既定値は `str.length` です。

### 返値

文字列が指定された文字列で終わる場合、`searchString` が空文字列の場合は **`true`**、それ以外の場合は **`false`** です。

### 例外

`TypeError`

`searchString` が正規表現であった場合。

解説
--

文字列が特定の文字列で終わるかどうかを判断できます。このメソッドでは（英文字の）大文字小文字は区別されます。

例
-

### endsWith() の使用


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

console.log(str.endsWith("question.")); // true
console.log(str.endsWith("to be")); // false
console.log(str.endsWith("to be", 19)); // true
```

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

* `String.prototype.endsWith` のポリフィル (`core-js`)
* `String.prototype.startsWith()`
* `String.prototype.includes()`
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
String.prototype.anchor()
=========================

**非推奨:** この機能は非推奨になりました。まだ対応しているブラウザーがあるかもしれませんが、すでに関連するウェブ標準から削除されているか、削除の手続き中であるか、互換性のためだけに残されている可能性があります。使用を避け、できれば既存のコードは更新してください。このページの下部にある互換性一覧表を見て判断してください。この機能は突然動作しなくなる可能性があることに注意してください。

**`anchor()`** メソッドは、`<a>` 要素に name を付けたものに文字列を埋め込んだ文字列 (`<a name="...">str</a>`) を生成します。

**警告:** HTML ラッパーメソッドはすべて非推奨となっており、互換性目的のみで標準化されています。代わりに DOM API の `document.createElement()` などを使用してください。

HTML 仕様書では `<a>` 要素に `name` 属性を設定することを許容しなくなりましたので、このメソッドが生成するものは妥当なマークアップになりません。

構文
--


```js
anchor(name)
```

### 引数

`name`

`name` 値を表す文字列で、 `<a name="...">` 開始タグに入れられます。

### 返値

`<a name="name">` 開始タグで始まり（`name` の中の二重引用符は `&quot;` で置き換え）、`str` のテキストが続き、 `</a>` 終了タグで終わる文字列です。

例
-

### anchor() の使用


```js
const myString = "Table of Contents";

document.body.innerHTML = myString.anchor("contents\_anchor");
```


以下の HTML が生成されます。


```html
<a name="contents\_anchor">Table of Contents</a>
```

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

* `String.prototype.anchor` のポリフィル (`core-js`)
* `String.prototype.link()`