Intl.PluralRules() コンストラクター - JavaScript

Intl.PluralRules() コンストラクター
===========================

**`Intl.PluralRules()`** コンストラクターは `Intl.PluralRules` オブジェクトを作成します。

構文
--

```js
new Intl.PluralRules();
new Intl.PluralRules(locales);
new Intl.PluralRules(locales, options);
```

### 引数

`locales` 省略可

BCP 47 言語タグの文字列、またはそのような文字列の配列です。 `locales` 引数の一般的な形式と解釈ついては、 Intl のページを参照してください。

`options` 省略可

以下のプロパティの全部または一部を持つオブジェクトです。

`localeMatcher`

使用するロケールの照合アルゴリズムです。指定可能な値は "`lookup`" および "`best fit`" で、既定値は "`best fit`" です。このオプションの詳細は、 Intl のページを参照してください。

`type`

使用する種別です。指定可能な値は次の通りです。

* "`cardinal`" は基数です（物の数量を表します）。これが既定値です。
* "`ordinal`" は序数です（物事の順序や順位を表します。たとえば英語では "1st", "2nd", "3rd" です）。

 以下のプロパティは 2 つのグループに分けられます。
 `minimumIntegerDigits`, `minimumFractionDigits`, `maximumFractionDigits` が 1 つのグループで、
 `minimumSignificantDigits` と `maximumSignificantDigits` がもう一方です。第 2 のグループから 1 つでもプロパティが定義されると、第 1 のグループは無視されます。

`minimumIntegerDigits`

使用する整数部の最小桁数です。取りうる値は 1 から 21 までです。既定値は 1 です。

`minimumFractionDigits`

使用する小数部の最小桁数です。取りうる値は 0 から 20 までです。通常の数とパーセントの形式の既定値は 0 です。通貨形式の既定値は、 ISO 4217 通貨コードリストで提供される下位単位の桁数です（リストに情報がない場合は 2 です）。

`maximumFractionDigits`

使用する小数部の最大桁数です。取りうる値は 0 から 20 までです。通常の数の形式では既定値は `minimumFractionDigits` と 3 の大きい方です。通貨形式の既定値は、 `minimumFractionDigits` と ISO 4217 通貨コードリストで提供される下位単位の桁数（リストに情報がない場合は 2）の大きい方です。パーセント形式の既定値は、 `minimumFractionDigits` と 0 の大きい方です。

`minimumSignificantDigits`

使用する有効数字の最小桁数です。使用可能な値は 1 から 21 までです。既定値は 1 です。

`maximumSignificantDigits`

使用する有効数字の最大桁数です。使用可能な値は 1 から 21 までです。既定値は 21 です。

例
-

### 基本的な使い方

ロケールを指定しない基本的な使い方では、既定のロケールと既定のオプションで書式化された文字列が返されます。これは、例えば "dog" と "dogs" のように単数形と複数形を区別するのに便利です。

```js
var pr = new Intl.PluralRules();

pr.select(0);
// → 'other' （アメリカ英語のロケールの場合）

pr.select(1);
// → 'one' （アメリカ英語のロケールの場合）

pr.select(2);
// → 'other' （アメリカ英語のロケールの場合）
```

### options の使用

引数 `options` には `type` というプロパティがあり、`ordinal` に設定することで結果をカスタマイズすることができます。これは、例えば "1st", "2nd", "3rd", "4th", "42nd" などのように、序数を把握するのに便利です。

```js
var pr = new Intl.PluralRules("en-US", { type: "ordinal" });

const suffixes = new Map([
  ["one", "st"],
  ["two", "nd"],
  ["few", "rd"],
  ["other", "th"],
]);
const formatOrdinals = (n) => {
  const rule = pr.select(n);
  const suffix = suffixes.get(rule);
  return `${n}${suffix}`;
};

formatOrdinals(0); // '0th'
formatOrdinals(1); // '1st'
formatOrdinals(2); // '2nd'
formatOrdinals(3); // '3rd'
formatOrdinals(4); // '4th'
formatOrdinals(11); // '11th'
formatOrdinals(21); // '21st'
formatOrdinals(42); // '42nd'
formatOrdinals(103); // '103rd'
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl-pluralrules-constructor |

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

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

関連情報
----

* `Intl.PluralRules`
* `Intl`


Intl.Collator.supportedLocalesOf() - JavaScript

Intl.Collator.supportedLocalesOf()
==================================

**`Intl.Collator.supportedLocalesOf()`** メソッドは、ランタイムの既定のロケールで代替しなくても照合で対応するロケールを含む配列を返します。

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

構文
--

```js
Intl.Collator.supportedLocalesOf(locales);
Intl.Collator.supportedLocalesOf(locales, options);
```

### 引数

`locales`

BCP 47 言語タグを持つ文字列、またはそのような文字列の配列です。 `locales` 引数の一般的な形式については、 Intl のページを参照してください。

`options` 省略可

省略可能です。以下のプロパティを持つことがあるオブジェクトです。

`localeMatcher`

使用するロケールの照合アルゴリズムです。指定可能な値は "`lookup`" および "`best fit`" で、既定値は "`best fit`" です。このオプションの詳細は、 Intl のページを参照してください。

### 返値

指定したロケールタグのサブセットを表す文字列の配列で、ランタイムの既定のロケールで代替する必要なく複数形の書式で対応されているものを含みます。

解説
--

`locales` で指定されている言語タグのサブセットを含む配列を返します。返される言語タグは、ランタイムがロケールの照合に対応しているもので、使用しているロケール照合アルゴリズムが、既定のロケールで代替することなく一致するとみなすものです。

例
-

### supportedLocalesOf() の使用

インドネシア語とドイツ語に対応しているもの、バリ語に対応していないランタイムを想定すると、ピンインの照合がインドネシア語では使用されておらず、インドネシアに特化したドイツ語に対応している可能性が低いとしても、 `supportedLocalesOf` はインドネシア語とドイツ語の言語タグを変更せずに返します。これは "`lookup`" アルゴリズムの仕様であることに注意してください。 "`best fit`" マッチャーは、ほとんどのバリ語話者がインドネシア語も理解しているので、インドネシア語がバリ語に適切であると判断し、バリ語の言語タグも返すかもしれません。

```js
const locales = ["ban", "id-u-co-pinyin", "de-ID"];
const options = { localeMatcher: "lookup" };
console.log(Intl.Collator.supportedLocalesOf(locales, options).join(", "));
// → "id-u-co-pinyin, de-ID"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.collator.supportedlocalesof |

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

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

関連情報
----

* `Intl.Collator`


Intl.Collator() コンストラクター - JavaScript

Intl.Collator() コンストラクター
========================

**`Intl.Collator()`** コンストラクターは、言語を考慮した文字列の比較を可能にする
 `Intl.Collator` オブジェクトを生成します。

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

構文
--

```js
new Intl.Collator();
new Intl.Collator(locales);
new Intl.Collator(locales, options);
```

### 引数

`locales` 省略可

任意。 BCP47 言語タグの文字列またはその配列。 `locales` 引数の一般的な形式や解釈については Intl のページを参照してください。

次の Unicode 拡張キーが使用可能です。

**メモ:** これらのキーは通常、 `options` でも設定することができます（下記でリストアップします）。両方が設定されている場合は、 `options` のプロパティが優先されます。

`co`

特定のロケールにおける比較方法の変化形を指定します。指定可能な値は次の通りです。

* `big5han`
* `compat`
* `dict`
* `direct`
* `ducet`
* `eor`
* `gb2312`
* `phonebk` （ドイツ語のみ対応）
* `phonetic`
* `pinyin`
* `reformed`
* `searchjl`
* `stroke`
* `trad`
* `unihan`
* `zhuyin`

**メモ:** このオプションは `options` プロパティ "`collation`" からも設定できます。

`kn`

 "1" < "2" < "10" のような数値照合順序を使用するかどうかを指定します。設定可能な値は "`true`" と "`false`" です。
 このオプションは、 `options` の "`numeric`" プロパティでも設定することができます。

`kf`

大文字と小文字のどちらを先に並べるかを指定します。使用できる値は "`upper`", "`lower`", "`false`" （ロケールの既定値を使用）です。このオプションは、 `options` の "`caseFirst`" プロパティでも設定することができます。

`options` 省略可

任意。以下のプロパティの一部またはすべてを持つオブジェクトです。

`localeMatcher`

ロケールの照合に使用するアルゴリズム。指定可能な値は "`lookup`" と "`best fit`" で、既定値は "`best fit`" です。このオプションの詳細については Intl のページを参照してください。

`usage`

この比較がソートのためなのか、それとも一致する文字列を検索するためなのか。使用可能な値は "`sort`" および "`search`" で、既定値は "`sort`" です。

`sensitivity`

文字の違いをどの程度までを区別するかです。以下の値を指定可能です。

* "`base`": ベース文字が異なれば、異なる文字であると評価します。 例: a ≠ b, a = á, a = A
* "`accent`": ベース文字が異なるか、またはアクセントその他の発音区別符号が異なれば、異なる文字であると評価します。 例: a ≠ b, a ≠ á, a = A
* "`case`": ベース文字が異なるか、ベース文字が同一でも大文字小文字が異なれば、異なる文字であると評価します。 例: a ≠ b, a = á, a ≠ A
* "`variant`": ベース文字、アクセントその他の発音区別符号、および大文字小文字のいずれかが異なれば、異なる文字であると評価します。他の違いも考慮されるかもしれません。 例: a ≠ b, a ≠ á, a ≠ A

既定値は、 `usage` が "`sort`" の場合は "`variant`"、 "`search`" の場合はロケールに依存します。

`ignorePunctuation`

句読点を無視するかどうか。指定可能な値は `true` または `false` で、既定値は `false` です。

`numeric`

"1" < "2" < "10" のように数値として比較を行うかどうかです。可能な値は `true` および `false` です。既定値は `false` です。

**メモ:** このオプションは Unicode 拡張キーの `kn` でも設定することができます。両方が指定された場合は、この `options` のプロパティが優先されます。

`caseFirst`

大文字と小文字のどちらを先に並べるかです。指定可能な値は "`upper`", "`lower`", "`false`" （ロケールの既定の動作）です。大文字と小文字のどちらを先に並べるかは `options` のプロパティでも Unicode 拡張キーでも指定可能です。両方で指定された場合、 `options` プロパティの指定が優先されます。

**メモ:** このオプションは Unicode 拡張キーの `kf` でも設定することができます。両方が指定された場合は、この `options` のプロパティが優先されます。

`collation`

特定のロケールにおける比較方法の変化形を指定します。指定可能な値は次の通りです。

* `big5han`
* `compat`
* `dict`
* `direct`
* `ducet`
* `eor`
* `gb2312`
* `phonebk` （ドイツ語のみ対応）
* `phonetic`
* `pinyin`
* `reformed`
* `searchjl`
* `stroke`
* `trad`
* `unihan`
* `zhuyin`

**メモ:** このオプションは Unicode 拡張キーの `co` でも設定することができます。両方が指定された場合は、この `options` のプロパティが優先されます。

例
-

### Collator の使用

次の例では、文字列が別の文字列の前であるか、後であるか、または同じレベルで発生したのかの様々な可能性のある結果を示しています。

```js
console.log(new Intl.Collator().compare("a", "c")); // → 負の値
console.log(new Intl.Collator().compare("c", "a")); // → 正の値
console.log(new Intl.Collator().compare("a", "a")); // → 0
```

上記のコードで示された結果は、ブラウザーやブラウザーのバージョンによって異なる可能性があることに注意してください。これは、値が実装固有のものであるためです。つまり、仕様では前後の値が負と正の値であることだけが要求されています。

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-the-intl-collator-constructor |

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

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

関連情報
----

* `Intl.Collator`
* `Intl`


Intl.Collator.prototype.resolvedOptions() - JavaScript

Intl.Collator.prototype.resolvedOptions()
=========================================

**`Intl.Collator.prototype.resolvedOptions()`** メソッドは、この `Intl.Collator` オブジェクトの初期化時に計算されたロケールと照合オプションを反映したプロパティを持つ新しいオブジェクトを返します。

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

構文
--

```js
resolvedOptions();
```

### 返値

この `Intl.Collator` オブジェクトの初期化時に計算されたロケールと照合オプションを反映したプロパティを持つ新しいオブジェクトです。

解説
--

返されるオブジェクトには、以下のプロパティがあります。

`locale`

実際に使用したロケールの BCP 47 言語タグ。このロケールにつながる入力 BCP 47 言語タグに Unicode 拡張値が要求された場合、要求されたキーと値のペアのうち、このロケールで対応しているものが `locale` に含まれます。

`usage`, `sensitivity`, `ignorePunctuation`

`options` 引数の同名のプロパティで提供された値、または既定値が入ります。

`collation`

`locale` が対応している場合は、 Unicode 拡張キー "`co`" を使用して要求された値、そうでなければ "`default`" です。

`numeric`, `caseFirst`

`options` 引数の同名のプロパティ、または Unicode 拡張キーの "`kn`" および "`kf`" で要求された値、または既定値が入ります。実装がこれらのプロパティに対応していない場合は、省略されます。

例
-

### resolvedOptions メソッドの使用

```js
var de = new Intl.Collator("de", { sensitivity: "base" });
var usedOptions = de.resolvedOptions();

usedOptions.locale; // "de"
usedOptions.usage; // "sort"
usedOptions.sensitivity; // "base"
usedOptions.ignorePunctuation; // false
usedOptions.collation; // "default"
usedOptions.numeric; // false
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.collator.prototype.resolvedoptions |

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

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

関連情報
----

* `Intl.Collator`


Intl.Collator.prototype.compare() - JavaScript

Intl.Collator.prototype.compare()
=================================

**`Intl.Collator.prototype.compare()`** メソッドは、 2 つの文字列をこの `Intl.Collator` オブジェクトのソート順に従って比較します。

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

構文
--

```js
compare(string1, string2);
```

### 引数

`string1`, `string2`

互いに比較する文字列です。

解説
--

`compare` ゲッター関数は、 `string1` と `string2` をこの `Intl.Collator` オブジェクトのソート順に従って比較した結果を数値で返します。 `string1` が `string2` の前にくる場合は負の値、 `string1` が `string2` の後にくる場合は正の値、等しいとみなされる場合は 0 を返します。

例
-

### 配列の並べ替えにおける compare の使用

配列の並べ替えのために `compare` ゲッター関数を使用します。なお、この関数は、取得元の collator にバインドされているので、直接 `Array.prototype.sort()` に渡すことができます。

```js
var a = ["Offenbach", "Österreich", "Odenwald"];
var collator = new Intl.Collator("de-u-co-phonebk");
a.sort(collator.compare);
console.log(a.join(", "));
// → "Odenwald, Österreich, Offenbach"
```

### 配列の検索における compare の使用

配列内の文字列の検索のために `compare` ゲッター関数を使用します。

```js
var a = ["Congrès", "congres", "Assemblée", "poisson"];
var collator = new Intl.Collator("fr", {
  usage: "search",
  sensitivity: "base",
});
var s = "congres";
var matches = a.filter((v) => collator.compare(v, s) === 0);
console.log(matches.join(", "));
// → "Congrès, congres"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.collator.prototype.compare |

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

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

関連情報
----

* `Intl.Collator`
* `String.prototype.localeCompare()`


Intl.RelativeTimeFormat() コンストラクター - JavaScript

Intl.RelativeTimeFormat() コンストラクター
==================================

**`Intl.RelativeTimeFormat()`** コンストラクターは、 `Intl.RelativeTimeFormat` オブジェクトを生成します。

構文
--

```js
new Intl.RelativeTimeFormat([locales[, options]])
```

### 引数

`locales` 省略可

BCP 47 言語タグを持つ文字列か、そのような文字列の配列です。 `locales` 引数の一般的な形式と解釈については、 Intl のページを参照してください。

`options` 省略可

以下のプロパティのうち一部またはすべてを持つオブジェクトです。

`localeMatcher`

使用するロケールの一致アルゴリズムです。使用可能な値は "`lookup`" および "`best fit`" で、既定値は "`best fit`" です。このオプションの詳細は、 Intl のページを参照してください。

`numeric`

メッセージを出力する書式です。使用可能な値は次の通りです。

* "`always`" (既定値、例えば `1 日前`)
* "`auto`" (例えば `昨日`)。 "`auto`" にすると、出力に常に数値が入るとは限りません。

`style`

国際化されたメッセージの長さです。使用可能な値は次の通りです。

* "`long`" (既定値、例えば `in 1 month`)
* "`short`" (例えば `in 1 mo.`)
* "`narrow`" (例えば `in 1 mo.`) narrow スタイルは同じロケールでは short スタイルと同様になることがあります。

例
-

### 基本的な書式の使い方

以下の例は、英語を使用した相対時間のフォーマッターの生成方法を示しています。

```js
// Create a relative time formatter in your locale
// with default values explicitly passed in.
const rtf = new Intl.RelativeTimeFormat("en", {
  localeMatcher: "best fit", // other values: "lookup"
  numeric: "always", // other values: "auto"
  style: "long", // other values: "short" or "narrow"
});

// 負の値 (-1) を使った相対時間のフォーマット
rtf.format(-1, "day");
// > "1 day ago"

// 正の値 (1) を使った相対時間のフォーマット
rtf.format(1, "day");
// > "in 1 day"
```

### auto オプションの使用

`numeric:auto` オプションが渡された場合は、 `yesterday` や `tomorrow` の文字列が `1 day ago` や `in 1 day` の代わりに生成されます。これにより、出力に数値が含まれなくなることがあります。

```js
// Create a relative time formatter in your locale
// with numeric: "auto" option value passed in.
const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });

// Format relative time using negative value (-1).
rtf.format(-1, "day");
// > "yesterday"

// Format relative time using positive day unit (1).
rtf.format(1, "day");
// > "tomorrow"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl-relativetimeformat-constructor |

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

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

関連情報
----

* `Intl.RelativeTimeFormat`
* `Intl`
* The Intl.RelativeTimeFormat API


Intl.RelativeTimeFormat.prototype.formatToParts() - JavaScript

Intl.RelativeTimeFormat.prototype.formatToParts()
=================================================

**`Intl.RelativeTimeFormat.prototype.formatToParts()`** メソッドは、ロケールを考慮したカスタム書式設定に使用できる相対時間書式を部品単位で表すオブジェクトの配列 (`Array`) を返します。

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

構文
--

```js
RelativeTimeFormat.formatToParts(value, unit);
```

### 引数

`value`

国際化された相対時間のメッセージに使用する数値です。

`unit`

国際化された相対時間のメッセージに使用する単位です。利用可能な値は、 "`year`", "`quarter`", "`month`", "`week`", "`day`", "`hour`", "`minute`", "`second`" です。複数形も許容されています。

### 返値

書式化された相対時間を部品単位で含むオブジェクトの配列 (`Array`) です。

解説
--

`Intl.RelativeTimeFormat.prototype.formatToParts` メソッドは、書式化メソッドのバージョンの一つで、書式化された数値を他の周囲のテキストから分離し、それぞれの構成部品に分解した、オブジェクトの「部分」を表すオブジェクトの配列を返すものです。これらのオブジェクトには二つのプロパティがあります。 type は `NumberFormat` の formatToParts 型で、値は出力の構成要素である文字列です。もし "part" が `NumberFormat` から来たものであれば、書式化された単位を示す unit プロパティを持ちます。

例
-

### formatToParts の使用

```js
const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });

// Format relative time using the day unit
rtf.formatToParts(-1, "day");
// > [{ type: "literal", value: "yesterday"}]

rtf.formatToParts(100, "day");
// > [{ type: "literal", value: "in " },
// > { type: "integer", value: "100", unit: "day" },
// > { type: "literal", value: " days" }]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.RelativeTimeFormat.prototype.formatToParts |

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

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

関連情報
----

* `Intl.RelativeTimeFormat`


Intl.RelativeTimeFormat.prototype.format() - JavaScript

Intl.RelativeTimeFormat.prototype.format()
==========================================

**`Intl.RelativeTimeFormat.prototype.format()`** メソッドは `value` や `unit` を、この `Intl.RelativeTimeFormat` オブジェクトのロケールと整形オプションに従って整形します。

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

構文
--

```js
relativeTimeFormat.format(value, unit);
```

### 引数

`value`

国際化された相対時間のメッセージに使用する数値です。

`unit`

国際化された相対時間のメッセージに使用する単位です。利用可能な値は、 "`year`", "`quarter`", "`month`", "`week`", "`day`", "`hour`", "`minute`", "`second`" です。複数形も許容されています。

解説
--

`format` ゲッター関数は、この `Intl.RelativeTimeFormat` (en-US) オブジェクトのロケールと整形オプションに従って値や単位を整形し、文字列に格納します。

例
-

### 基本的な format の使い方

以下の例は、英語を使用した相対時間のフォーマッターの生成方法を示しています。

```js
// ロケールで既定値を明確に指定して
// 相対時間フォーマッターを作成
const rtf = new Intl.RelativeTimeFormat("en", {
  localeMatcher: "best fit", // other values: "lookup"
  numeric: "always", // other values: "auto"
  style: "long", // other values: "short" or "narrow"
});

// 負の値 (-1) を使った相対時間の書式化
rtf.format(-1, "day");
// > "1 day ago"

// 正の値 (1) を使った相対時間の書式化
rtf.format(1, "day");
// > "in 1 day"
```

### auto オプションの使用

`numeric:auto` オプションが渡された場合は、 `1 day ago` や `in 1 day` の代わりに `yesterday` や `tomorrow` の文字列が生成されます。これにより、出力に数値が含まれなくなることがあります。

```js
// ロケールで既定値を明確に指定して
// 相対時間フォーマッターを作成
const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });

// 負の値 (-1) を使った相対時間の書式化
rtf.format(-1, "day");
// > "yesterday"

// 正の値 (1) を使った相対時間の書式化
rtf.format(1, "day");
// > "tomorrow"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.RelativeTimeFormat.prototype.format |

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

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

関連情報
----

* `Intl.RelativeTimeFormat`


Intl.ListFormat.supportedLocalesOf() - JavaScript

Intl.ListFormat.supportedLocalesOf()
====================================

**`Intl.ListFormat.supportedLocalesOf()`** メソッドは、指定したロケールのうち、ランタイムの既定のロケールに代替する必要なくリストの書式化に対応しているロケールを含む配列を返します。

構文
--

```js
Intl.ListFormat.supportedLocalesOf(locales);
Intl.ListFormat.supportedLocalesOf(locales, options);
```

### 引数

`locales`

BCP 47 言語タグを持つ文字列、またはそのような文字列の配列です。 `locales` 引数の一般的な形式については、 Intl のページを参照してください。

`options` 省略可

以下のプロパティを持つ可能性があるオブジェクトです。

`localeMatcher`

使用するロケールの照合アルゴリズムです。指定可能な値は "`lookup`" および "`best fit`" で、既定値は "`best fit`" です。このオプションの詳細は、 Intl のページを参照してください。

### 返値

指定したロケールタグのサブセットを表す文字列の配列で、ランタイムの既定のロケールで代替する必要なくリストの書式化に対応されているものを含みます。

解説
--

`locales` で提供されている言語タグのサブセットを含む配列を返します。返される言語タグは、ランタイムがリストの書式化に対応しているロケールで、使用しているロケール照合アルゴリズムで一致しているとみなされているものです。

例
-

### supportedLocalesOf() の使用

リストの書式化でインドネシア語とドイツ語に対応しており、バリ語に対応していないランタイムを想定すると、 `supportedLocalesOf` はインドネシア語とドイツ語の言語タグを変更せずに返しますが、 `pinyin` の照合はリストの書式化には関係なく、インドネシア語でも使用されません。ここでの `lookup` アルゴリズムの仕様に注意してください — バリ語話者のほとんどはインドネシア語も理解しているので、 `best fit` のマッチャーはインドネシア語がバリ語に適切に一致すると判断し、バリ語の言語タグも返すかもしれません。

```js
const locales = ["ban", "id-u-co-pinyin", "de-ID"];
const options = { localeMatcher: "lookup" };
console.log(Intl.ListFormat.supportedLocalesOf(locales, options).join(", "));
// → "id-u-co-pinyin, de-ID"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.ListFormat.supportedLocalesOf |

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

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

関連情報
----

* `Intl.ListFormat`


Intl.ListFormat.prototype.formatToParts() - JavaScript

Intl.ListFormat.prototype.formatToParts()
=========================================

**`Intl.ListFormat.prototype.formatToParts()`** メソッドは、ロケールを考慮した値のリストの書式化で使用できる様々な部分を表すオブジェクトの配列 (`Array`) を返します。

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

構文
--

```js
formatToParts(list);
```

### 引数

`list`

ロケールに従って書式化する反復可能オブジェクト、例えば配列 (`Array`) です。

### 返値

リストから書式された部品を含むコンポーネントの配列 (`Array`) です。

解説
--

`Intl.ListFormat.prototype.format()` が、（渡されたロケールとスタイルのオプションに応じて）リストの書式化された文字列を返すのに対し、 `formatToParts()` は、書式化されたされた文字列のさまざまなコンポーネントの配列を返します。

結果として得られる配列の各要素には、 `type` と `value` の 2 つのプロパティがあります。 `type` プロパティはリストの値を指す "`element`" か、言語的な構成要素を指す "`literal`" かのどちらかです。 `value` プロパティはトークンの内容を文字列で指定します。

書式化に使用されるロケールとスタイルのオプションは、 `Intl.ListFormat` インスタンスを構築する際に与えられたものです。

例
-

### formatToParts の使用

```js
const fruits = ["Apple", "Orange", "Pineapple"];
const myListFormat = new Intl.ListFormat("en-GB", {
  style: "long",
  type: "conjunction",
});

console.table(myListFormat.formatToParts(fruits));
// [
// { "type": "element", "value": "Apple" },
// { "type": "literal", "value": ", " },
// { "type": "element", "value": "Orange" },
// { "type": "literal", "value": ", and " },
// { "type": "element", "value": "Pineapple" }
// ]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.ListFormat.prototype.formatToParts |

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

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

関連情報
----

* `Intl.ListFormat`
* `Intl.ListFormat.prototype.format()`
* `Intl.RelativeTimeFormat.prototype.formatToParts()`
* `Intl.NumberFormat.prototype.formatToParts()`
* `Intl.DateTimeFormat.prototype.formatToParts()`


Intl.ListFormat.prototype.format() - JavaScript

Intl.ListFormat.prototype.format()
==================================

**`format()`** メソッドは、リストの言語固有の表現を文字列で返します。

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

構文
--

```js
format();
format(list);
```

### 引数

`list`

Array などの反復可能オブジェクトです。

### 返値

リストのすべての要素を表現する、言語に依存した文字列表現です。

解説
--

**`format()`** メソッドは、 `Intl.ListFormat` オブジェクトで提供された引数に基づいて書式化された文字列を返します。 `locales` と `options` 引数で `format()` の動作をカスタマイズし、アプリケーションがリストを書式化する言語の慣習を指定することができます。

例
-

### format の使用

以下の例では、英語を使用したリストのフォーマッターの作り方を紹介します。

```js
const list = ["Motorcycle", "Bus", "Car"];

console.log(
  new Intl.ListFormat("en-GB", { style: "long", type: "conjunction" }).format(
    list,
  ),
);
// > Motorcycle, Bus and Car

console.log(
  new Intl.ListFormat("en-GB", { style: "short", type: "disjunction" }).format(
    list,
  ),
);
// > Motorcycle, Bus or Car

console.log(
  new Intl.ListFormat("en-GB", { style: "narrow", type: "unit" }).format(list),
);
// > Motorcycle Bus Car
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.ListFormat.prototype.format |

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

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

関連情報
----

* `Intl.ListFormat`


Intl.ListFormat() コンストラクター - JavaScript

Intl.ListFormat() コンストラクター
==========================

**`Intl.ListFormat()`** コンストラクターは、言語を考慮したリストの書式化を可能にする
 `Intl.ListFormat` オブジェクトを生成します。

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

構文
--

```js
new Intl.ListFormat();
new Intl.ListFormat(locales);
new Intl.ListFormat(locales, options);
```

### 引数

`locales` 省略可

BCP 47 言語タグの文字列、または、そのような文字列の配列です。 `locales` 引数の一般的な形式と解釈は、 Intl のページを参照してください。

`options` 省略可

以下のプロパティの一部またはすべてを持つオブジェクトです。

`localeMatcher`

使用するロケール照合アルゴリズム。取りうる値は以下の通りです。

* "`best fit`" （既定値）
* "`lookup`"
 このオプションについての詳細は、 Intl のページをご覧ください。

`type`

グループ化の種類を示します。取りうる値は以下の通りです。

* "`conjunction`" - リスト項目の "and" ベースのグループ化: "A, B, and C" （既定値）
* "`disjunction`" - リスト項目の "or" ベースのグループ化: "A, B, or C"
* "`unit`" - リスト項目の単位としてのグループ化（"and" ベースでも "or" ベースでもない）: "A, B, C"

`style`

グループ化のスタイルを示します（例えば、リストの区切り文字や結合などが含まれます）。取りうる値は以下の通りです。

* "`long`": "A, B, and C" （既定値）
* "`short`": "A, B, C"
* "`narrow`": "A B C"

例
-

### format の使用

次の例では、英語を使用するリストのフォーマッターを生成する方法を示します。

```js
const list = ["Motorcycle", "Bus", "Car"];

console.log(
  new Intl.ListFormat("en-GB", { style: "long", type: "conjunction" }).format(
    list,
  ),
);
// Motorcycle, Bus and Car

console.log(new Intl.ListFormat("en-GB", { style: "long" }).format(list));
// Motorcycle, Bus and Car

console.log(new Intl.ListFormat("en-US", { style: "long" }).format(list));
// Motorcycle, Bus, and Car

console.log(
  new Intl.ListFormat("en-GB", { style: "short", type: "conjunction" }).format(
    list,
  ),
);
// Motorcycle, Bus and Car

console.log(
  new Intl.ListFormat("en-US", { style: "short", type: "conjunction" }).format(
    list,
  ),
);
// Motorcycle, Bus, & Car

console.log(
  new Intl.ListFormat("en-GB", { style: "narrow", type: "conjunction" }).format(
    list,
  ),
);
// Motorcycle, Bus, Car

console.log(
  new Intl.ListFormat("en-GB", { style: "long", type: "disjunction" }).format(
    list,
  ),
);
// Motorcycle, Bus or Car

console.log(
  new Intl.ListFormat("en-GB", { style: "short", type: "disjunction" }).format(
    list,
  ),
);
// Motorcycle, Bus or Car

console.log(
  new Intl.ListFormat("en-GB", { style: "narrow", type: "disjunction" }).format(
    list,
  ),
);
// Motorcycle, Bus or Car

console.log(new Intl.ListFormat("en-US", { style: "narrow" }).format(list));
// Motorcycle, Bus, Car

console.log(
  new Intl.ListFormat("en-GB", { style: "narrow", type: "unit" }).format(list),
);
// Motorcycle Bus Car

console.log(
  new Intl.ListFormat("en-US", { style: "long" }).format([
    "30 degrees",
    "15 minutes",
    "50 seconds",
  ]),
);
// 30 degrees, 15 minutes, and 50 seconds

console.log(
  new Intl.ListFormat("en-US", { style: "narrow" }).format([
    "30 degrees",
    "15 minutes",
    "50 seconds",
  ]),
);
// 30 degrees, 15 minutes, 50 seconds

console.log(
  new Intl.ListFormat("en-US", { style: "narrow", type: "unit" }).format([
    "30°",
    "15′",
    "50″",
  ]),
);
// 30° 15′ 50″
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl-listformat-constructor |

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

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

関連情報
----

* `Intl.ListFormat`
* `Intl`


Intl.ListFormat.prototype.resolvedOptions() - JavaScript

Intl.ListFormat.prototype.resolvedOptions()
===========================================

**`Intl.ListFormat.prototype.resolvedOptions()`** メソッドは、現在の `Intl.ListFormat` オブジェクトの構築時に計算されたロケールとスタイル整形オプションを反映したプロパティを持つ新しいオブジェクトを返します。

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

構文
--

```js
listFormat.resolvedOptions();
```

### 返値

指定された `Intl.ListFormat` オブジェクトの構築時に計算されたロケールと整形オプションを反映したプロパティを持つオブジェクトです。

解説
--

`resolvedOptions()` から返されるオブジェクトには、以下のプロパティがあります。

`locale`

実際に使用したロケールの BCP 47 言語タグ。このロケールにつながる入力 BCP 47 言語タグに Unicode 拡張値が要求された場合、要求されたキーと値のペアのうち、このロケールで対応しているものが `locale` に含まれます。

`style`

コンストラクターの `options` 引数の中でこのプロパティに指定された値、または既定値 ("`long`") がです。この値は、"`long`"、"`short`"、"`narrow`" のいずれかです。

`type`

コンストラクターの `options` 引数の中でこのプロパティに指定された値、または既定値 ("`conjunction`") がです。この値は、"`conjunction`"、"`disjunction`"、"`unit`" のいずれかです。

例
-

resolvedOptions の使用
-------------------

```js
const deListFormatter = new Intl.ListFormat("de-DE", { style: "short" });

const usedOptions = de.resolvedOptions();
console.log(usedOptions.locale); // "de-DE"
console.log(usedOptions.style); // "short"
console.log(usedOptions.type); // "conjunction" (the default value)
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.ListFormat.prototype.resolvedoptions |

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

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

関連情報
----

* `Intl.ListFormat`
* `Intl.NumberFormat.prototype.resolvedOptions()`
* `Intl.Collator.prototype.resolvedOptions()`
* `Intl.DateTimeFormat.prototype.resolvedOptions()`
* `Intl.PluralRules.prototype.resolvedOptions()`


Intl.Segmenter() コンストラクター - JavaScript

Intl.Segmenter() コンストラクター
=========================

**`Intl.Segmenter()`** コンストラクターは、ロケールに依存したテキスト分割を可能にする `Intl.Segmenter` オブジェクトを生成します。

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

構文
--

```js
new Intl.Segmenter();
new Intl.Segmenter(locales);
new Intl.Segmenter(locales, options);
```

**メモ:** `Intl.Segmenter()` は `new` を使用してのみ構築可能です。`new` を使わずに呼び出そうとすると `TypeError` が発生します。

### 引数

`locales` 省略可

BCP 47 の言語タグを持つ文字列、またはそのような文字列の配列。引数 `locales` の一般的な形式と解釈については、`Intl` のページを参照してください。

`options` 省略可

以下のプロパティの一部または全部を持つオブジェクト。

`granularity` 省略可

文字列。使用可能な値は以下の通り。

`"grapheme"` (default)

ロケールに応じた書記素クラスター（ユーザーが認識する文字）の境界で、入力を分割します。

`"word"`

ロケールに応じた単語の境界で、入力を分割します。

`"sentence"`

ロケールに応じた文の境界で、入力を分割します。

`localeMatcher` 省略可

使用するロケールマッチングアルゴリズム。使用できる値は以下の通り。

`"best fit"` (default)

ランタイムは、ルックアップアルゴリズムの結果よりも適したロケールを選択する可能性があります。

`"lookup"`

BCP 47 Lookup algorithm を使用して、`locales` からロケールを選択します。`locales` に含まれる各ロケールについて、ランタイムは最初にサポートされるロケールを返します（場合によっては、サポートされるロケールを見つけるために、与えられたロケールタグのサブタグの制限を取り除きます。つまり、`locales` として `"de-CH"` を指定すると、`"de"` はサポートされているが `"de-CH"` はサポートされていない場合、`"de"` を使用することになる可能性があります）。

### 返値

新しい `Intl.Segments` のインスタンスです。

例
-

### 基本的な使い方

次の例は、日本語を使って文字列中の単語を数えるものです（`String` のメソッドで文字列を分割すると不正確な結果が得られます）。

```js
const text = "吾輩は猫である。名前はたぬき。";
const japaneseSegmenter = new Intl.Segmenter("ja-JP", { granularity: "word" });
console.log(
  [...japaneseSegmenter.segment(text)].filter((segment) => segment.isWordLike)
    .length,
);
// logs 8 as the text is segmented as '吾輩'|'は'|'猫'|'で'|'ある'|'。'|'名前'|'は'|'たぬき'|'。'
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl-segmenter-constructor |

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

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


Intl.Segmenter.prototype.resolvedOptions() - JavaScript

Intl.Segmenter.prototype.resolvedOptions()
==========================================

**`Intl.Segmenter.prototype.resolvedOptions()`** メソッドは、この `Intl.Segmenter` オブジェクトの初期化時に計算されたロケールおよび粒度のオプションを反映したプロパティを持つ新しいオブジェクトを返します。

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

構文
--

```js
resolvedOptions();
```

### 引数

なし。

### 返値

与えられた `Intl.Segmenter` オブジェクトの初期化時に計算されたロケールおよび照合順序のオプションを反映したプロパティを持つ新しいオブジェクトです。

解説
--

生成されたオブジェクトは以下のプロパティを持ちます。

`locale`

実際に使用されるロケールの BCP 47 言語タグ。初期化のための BCP 47 言語タグに Unicode 拡張値が含まれていた場合、要求され、このロケールに対応しているキーと値のペアが `locale` に含まれる。

`granularity`

オプション引数でこのプロパティに指定された値、またはデフォルト値。

例
-

### 基本的な使い方

```js
const spanishSegmenter = new Intl.Segmenter("es", { granularity: "sentence" });
const options = spanishSegmenter.resolvedOptions();
console.log(options.locale); // "es"
console.log(options.granularity); // "sentence"
```

### デフォルトの granularity

```js
const spanishSegmenter = new Intl.Segmenter("es");
const options = spanishSegmenter.resolvedOptions();
console.log(options.locale); // "es"
console.log(options.granularity); // "grapheme"
```

### locale のフォールバック

```js
const banSegmenter = new Intl.Segmenter("ban");
const options = banSegmenter.resolvedOptions();
console.log(options.locale);
// "fr" on a runtime where the Balinese locale
// is not supported and French is the default locale
console.log(options.granularity); // "grapheme"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.segmenter.prototype.resolvedoptions |

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

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


Intl.Segmenter.prototype.segment() - JavaScript

Intl.Segmenter.prototype.segment()
==================================

**`Intl.Segmenter.prototype.segment()`** メソッドは、この `Intl.Segmenter` オブジェクトのロケールおよび粒度に従って文字列を分割します。

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

構文
--

```js
segment(input);
```

### 引数

`input`

分割するテキストを `String` で指定します。

### 返値

入力文字列のセグメントを含む、反復可能な新しい `Segments` オブジェクトです。

例
-

```js
// Create a locale-specific word segmenter
const segmenter = new Intl.Segmenter("fr", { granularity: "word" });

// Use it to get an iterator over the segments of a string
const input = "Moi ? N'est-ce pas ?";
const segments = segmenter.segment(input);

// Use that for segmentation
for (const { segment, index, isWordLike } of segments) {
  console.log(
    "segment at code units [%d, %d]: «%s»%s",
    index,
    index + segment.length,
    segment,
    isWordLike ? " (word-like)" : "",
  );
}
// logs
// segment at code units [0, 3]: «Moi» (word-like)
// segment at code units [3, 4]: « »
// segment at code units [4, 5]: «?»
// segment at code units [5, 6]: « »
// segment at code units [6, 11]: «N'est» (word-like)
// segment at code units [11, 12]: «-»
// segment at code units [12, 14]: «ce» (word-like)
// segment at code units [14, 15]: « »
// segment at code units [15, 18]: «pas» (word-like)
// segment at code units [18, 19]: « »
// segment at code units [19, 20]: «?»
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.segmenter.prototype.segment |

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

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


Intl.Segmenter.supportedLocalesOf() - JavaScript

Intl.Segmenter.supportedLocalesOf()
===================================

**`Intl.Segmenter.supportedLocalesOf()`** メソッドは、指定したロケールのうち、ランタイムのデフォルトロケールにフォールバックすることなくサポートされているものを含む配列を返します。

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

構文
--

```js
supportedLocalesOf(locales);
supportedLocalesOf(locales, options);
```

### 引数

`locales`

BCP 47 の言語タグを持つ文字列、またはそのような文字列の配列。引数 `locales` の一般的な形式と解釈については、`Intl` のページを参照してください。

`options` 省略可

以下のプロパティを持つ可能性があるオブジェクト。

`localeMatcher`

使用するロケールマッチングアルゴリズム。使用可能な値は `"lookup"` および `"best fit"` で、デフォルトは `"best fit"` です。このオプションの詳細については、`Intl` のページを参照ください。

### 返値

指定したロケールタグのサブセットを表す文字列の配列で、ランタイムのデフォルトロケールにフォールバックすることなくセグメンテーションでサポートされるものです。

例
-

### supportedLocalesOf() の使用方法

実行環境がリスト形式でインドネシア語とドイツ語をサポートし、バリ語をサポートしないと仮定すると、`supportedLocalesOf` はインドネシア語とドイツ語の言語タグを変更せずに返します。`pinyin` の照合順序はインドネシア語のセグメンテーションに関係なく、またインドネシア語に特化したドイツ語はないためサポートされません。ここで `"lookup"` アルゴリズムの仕様に注意してください。`"best fit"` マッチでは、バリ島のほとんどの住民がインドネシア語を理解するため、インドネシア語がバリ島の言語に適切に一致すると判断し、バリ島の言語タグも返すことがあります。

```js
const locales = ["ban", "id-u-co-pinyin", "de-ID"];
const options = { localeMatcher: "lookup" };
console.log(Intl.Segmenter.supportedLocalesOf(locales, options).join(", "));
// → "id-u-co-pinyin, de-ID"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.segmenter.supportedlocalesof |

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

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


Intl.Segments - JavaScript

Intl.Segments
=============

**`Intl.Segments`** のインスタンスは、テキスト文字列のセグメントを反復可能なコレクションとして保持します。`Intl.Segmenter` オブジェクトの `segment()` メソッドをコールすると、このインスタンスが返されます。

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

インスタンスメソッド
----------

`Segments.prototype.containing()`

指定されたインデックスのコードユニットを含む元の文字列のセグメントを記述したオブジェクトを返します。

`Segments.prototype[@@iterator]()`

セグメントを反復処理するためのイテレーターを返します。

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-segments-objects |

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

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


Intl.Segments.prototype[@@iterator]() - JavaScript

Intl.Segments.prototype[@@iterator]()
=====================================

**`[@@iterator]()`** メソッドは、iterable プロトコルの一部で、`Intl.Segmenter` オブジェクトのエントリーを反復処理できる新しいイテレーターオブジェクトを返します。各エントリーは、オブジェクトとして返されます。

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

構文
--

```js
segments[Symbol.iterator];
```

利用できるイテレーター関数は、iterable プロトコルのページで説明したように、`.next()` の 1 つです。

### 返値

新しいイテレーターオブジェクト。

例
-

```js
const segmenter = new Intl.Segmenter("fr", { granularity: "word" });
const input = "Moi ? N'est-ce pas ?";
const segments = segmenter.segment(input);
const iterator = segments[Symbol.iterator]();

let result = iterator.next();

while (!result.done) {
  console.log(result.value);
  result = iterator.next();
}

/\* Logs
{segment: 'Moi', index: 0, input: "Moi ? N'est-ce pas ?", isWordLike: true}
{segment: ' ', index: 3, input: "Moi ? N'est-ce pas ?", isWordLike: false}
{segment: '?', index: 4, input: "Moi ? N'est-ce pas ?", isWordLike: false}
{segment: ' ', index: 5, input: "Moi ? N'est-ce pas ?", isWordLike: false}
{segment: "N'est", index: 6, input: "Moi ? N'est-ce pas ?", isWordLike: true}
{segment: '-', index: 11, input: "Moi ? N'est-ce pas ?", isWordLike: false}
{segment: 'ce', index: 12, input: "Moi ? N'est-ce pas ?", isWordLike: true}
{segment: ' ', index: 14, input: "Moi ? N'est-ce pas ?", isWordLike: false}
{segment: 'pas', index: 15, input: "Moi ? N'est-ce pas ?", isWordLike: true}
{segment: ' ', index: 18, input: "Moi ? N'est-ce pas ?", isWordLike: false}
{segment: '?', index: 19, input: "Moi ? N'est-ce pas ?", isWordLike: false}
\*/
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-%segmentsprototype%-@@iterator |

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

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

関連情報
----

* Iteration protocols
* `Array.prototype[@@iterator]()`


Intl.Segments.prototype.containing() - JavaScript

Intl.Segments.prototype.containing()
====================================

**`Intl.Segments.containing()`** メソッドは、指定されたインデックスのコードユニットを含む文字列中のセグメントを記述したオブジェクトを返します。

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

構文
--

```js
containing(codeUnitIndex);
```

### 引数

`codeUnitIndex` 省略可

元の入力文字列におけるコードユニットのインデックスを指定する数値。省略した場合のデフォルトは `0` となります。

### 返値

元の文字列のセグメントを記述するオブジェクトで以下のプロパティを持ちます。与えられたインデックス値が範囲外の場合は `undefined` となります。

`segment`

元の入力文字列から抽出されたセグメントを含む文字列。

`index`

セグメントを開始する元の入力文字列のコードユニットのインデックス。

`input`

セグメント化された完全な入力文字列。

`isWordLike`

`granularity` が `"word"` の場合のみブール値となり、それ以外は `undefined` です。`granularity` が `"word"` の場合、`isWordLike` は、セグメントが単語のようなもの（すなわち、文字／数字／英字／その他）である場合に `true`、それ以外の場合に `false` となります。

例
-

```js
// ┃0 1 2 3 4 5┃6┃7┃8┃9 ← code unit index
// ┃A l l o n s┃-┃y┃!┃ ← code unit
const input = "Allons-y!";

const segmenter = new Intl.Segmenter("fr", { granularity: "word" });
const segments = segmenter.segment(input);
let current = undefined;

current = segments.containing();
// → { index: 0, segment: "Allons", isWordLike: true }

current = segments.containing(4);
// → { index: 0, segment: "Allons", isWordLike: true }

current = segments.containing(6);
// → { index: 6, segment: "-", isWordLike: false }

current = segments.containing(current.index + current.segment.length);
// → { index: 7, segment: "y", isWordLike: true }

current = segments.containing(current.index + current.segment.length);
// → { index: 8, segment: "!", isWordLike: false }

current = segments.containing(current.index + current.segment.length);
// → undefined
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-%segmentsprototype%.containing |

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

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


Intl.NumberFormat.supportedLocalesOf() - JavaScript

Intl.NumberFormat.supportedLocalesOf()
======================================

**`Intl.ListFormat.supportedLocalesOf()`** メソッドは、ランタイムの既定のロケールで代替する必要なく数値の書式で対応されているものを含む配列を返します。

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

構文
--
```

Intl.NumberFormat.supportedLocalesOf(locales[, options])
```

### 引数

`locales`

BCP 47 言語タグを持つ文字列、またはそのような文字列の配列です。 `locales` 引数の一般的な形式については、 Intl のページを参照してください。

`options`

省略可能です。以下のプロパティを持つことがあるオブジェクトです。

`localeMatcher`

使用するロケールの一致アルゴリズムです。指定可能な値は `lookup` および `best fit` で、既定値は `best fit` です。このオプションの詳細は、 Intl のページを参照してください。

### 返値

指定したロケールタグのサブセットを表す文字列の配列で、ランタイムの既定のロケールで代替する必要なく数値の書式で対応されているものを含みます。

解説
--

`locales` で提供されている言語タグのサブセットを含む配列を返します。返される言語タグは、ランタイムが数値のロケールに対応しているもので、使用しているロケール照合アルゴリズムで一致しているとみなされているものです。

例
-

### supportedLocalesOf() の使用

数値の書式でインドネシア語とドイツ語に対応しており、バリ語に対応していないランタイムを想定すると、 `supportedLocalesOf` はインドネシア語とドイツ語の言語タグを変更せずに返しますが、 `pinyin` の照合は数値の書式には関係なく、インドネシア語でも使用されません。ここでの `lookup` アルゴリズムの仕様に注意してください — バリ語話者のほとんどはインドネシア語も理解しているので、 `best fit` のマッチャーはインドネシア語がバリ語に適切に一致すると判断し、バリ語の言語タグも返すかもしれません。

```js
var locales = ["ban", "id-u-co-pinyin", "de-ID"];
var options = { localeMatcher: "lookup" };
console.log(Intl.NumberFormat.supportedLocalesOf(locales, options).join(", "));
// → "id-u-co-pinyin, de-ID"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.numberformat.supportedlocalesof |

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

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

関連情報
----

* `Intl.NumberFormat`


Intl.NumberFormat.prototype.resolvedOptions() - JavaScript

Intl.NumberFormat.prototype.resolvedOptions()
=============================================

**`Intl.NumberFormat.prototype.resolvedOptions()`** メソッドは、この `NumberFormat` オブジェクトの初期化時に計算されたロケールと数値整形オプションを反映したプロパティを持つ新しいオブジェクトを返します。

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

構文
--
```

numberFormat.resolvedOptions()
```

### 返値

この `NumberFormat` オブジェクトの初期化時に計算されたロケールと数値整形オプションを反映したプロパティを持つ新しいオブジェクトです。

解説
--

返されるオブジェクトには以下のプロパティがあります。

`locale`

実際に使用したロケールの BCP 47 言語タグ。このロケールにつながる入力 BCP 47 言語タグに Unicode 拡張値が要求された場合、要求されたキーと値のペアのうち、このロケールで対応しているものが `locale` に含まれます。

`numberingSystem`

もし存在すれば、 `options` 引数でこのプロパティに指定された値、または Unicode 拡張キーの `"nu"` を使って要求された値、または既定として設定される値です。

`notation`

`options` 引数でこのプロパティに指定された値、または既定として設定される `standard` です。

`compactDisplay`

`options` 引数でこのプロパティに指定された値、または既定として設定される `short` です。

このプロパティは `notation` が "compact" に設定されている場合のみ存在します。

`signDisplay`

`options` 引数でこのプロパティに指定された値、または既定として設定される `auto` です。

`useGrouping`

`options` 引数でこのプロパティに指定された値、または既定として設定される値。

`currency`, `currencyDisplay`

`options` 引数でこのプロパティに指定された値、または既定として設定される値。`style`が`"currency"`の場合のみ、これらのプロパティは存在しています。

次の２つのプロパティのグループのうちどちらかのみが含まれています。:

`minimumIntegerDigits`, `minimumFractionDigits`, `maximumFractionDigits`

`options` 引数でプロパティに対して提供されるか既定で設定される値。 `minimumSignificantDigits` または `maximumSignificantDigits` が `options` 引数で提供されなかった場合のみ、これらのプロパティは存在しています。

`minimumSignificantDigits`, `maximumSignificantDigits`

`options`引数でプロパティに対して提供されるかデフォルトとして設定される値。 これらのプロパティのうち少なくとも１つが`options`引数で提供された場合のみ、これらのプロパティは存在しています。

例
-

### resolvedOptions メソッドの使用

```js
var de = new Intl.NumberFormat("de-DE");
var usedOptions = de.resolvedOptions();

usedOptions.locale; // "de-DE"
usedOptions.numberingSystem; // "latn"
usedOptions.notation; // "standard"
usedOptions.signDisplay; // "auto"
usedOption.style; // "decimal"
usedOptions.minimumIntegerDigits; // 1
usedOptions.minimumFractionDigits; // 0
usedOptions.maximumFractionDigits; // 3
usedOptions.useGrouping; // true
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.numberformat.prototype.resolvedoptions |

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

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

関連情報
----

* `Intl.NumberFormat`


Intl.NumberFormat.prototype.format() - JavaScript

Intl.NumberFormat.prototype.format()
====================================

**`Intl.NumberFormat.prototype.format()`** メソッドは、この `Intl.NumberFormat` オブジェクトのロケールと整形オプションに従って数値を整形します。

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

構文
--

```js
format(number);
```

### 引数

`number`

整形する `Number` または `BigInt` です。

解説
--

`format` ゲッター関数は、この `NumberFormat` オブジェクトのロケールと整形オプションに従って数値を整形し、文字列に格納します。

例
-

### `format` の使用

`format` ゲッター関数を使用して単一の通貨値を整形しましょう。こちらはロシアの例です。

```js
var options = { style: "currency", currency: "RUB" };
var numberFormat = new Intl.NumberFormat("ru-RU", options);
console.log(numberFormat.format(654321.987));
// → "654 321,99 руб."
```

### `format` と `map` の使用

`format` ゲッター関数を使用して、配列内のすべての数値を整形することができます。
 なお、この関数は供給元である `Intl.NumberFormat` に結び付けられているので、直接 `Array.prototype.map` に渡すことができます。これは、新しい機能に従わない習慣の一部として、歴史的な人工物と考えられていますが、既存のプログラムとの互換性のために保守されています。

```js
var a = [123456.789, 987654.321, 456789.123];
var numberFormat = new Intl.NumberFormat("es-ES");
var formatted = a.map((n) => numberFormat.format(n));
console.log(formatted.join("; "));
// → "123.456,789; 987.654,321; 456.789,123"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.numberformat.prototype.format |

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

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

関連情報
----

* `Intl.NumberFormat`
* `Number.prototype.toLocaleString()`


Intl.NumberFormat.prototype.formatToParts() - JavaScript

Intl.NumberFormat.prototype.formatToParts()
===========================================

**`Intl.Numberformat.prototype.formatToParts()`** メソッドは `NumberFormat` フォーマッターによって生成された文字列のロケールに応じた書式設定を可能にします。

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

構文
--
```

Intl.NumberFormat.prototype.formatToParts(number)
```

### 引数

`number` 省略可

書式化する `Number` または `BigInt`。

### 返値

書式化された数値を含む要素のオブジェクトの `Array`。

解説
--

`formatToParts()` メソッドは、数値文字列のカスタム書式設定を行うときに便利です。ロケール固有のトークンを含むオブジェクトの `Array` を返します。その `formatToParts()` メソッドが返す構造体は、次のようになります。

```js
[
  { type: "integer", value: "3" },
  { type: "group", value: "." },
  { type: "integer", value: "500" },
];
```

可能なタイプは以下のとおりです。

currency

通貨の文字列です。 "$" や "€" のような記号または "Dollar", "Euro" の文字列です。これらの文字列は `currencyDisplay` の特定方法に依存します。

decimal

小数点区切り文字 (".")。

fraction

小数点以下の数値。

group

グループ区切り文字 (",")。

infinity

`Infinity` 文字列 ("∞")。

integer

整数。

literal

書式設定された数字のリテラル文字列または空白。

minusSign

マイナス記号の文字列 ("-")。

nan

`NaN` の文字列 ("NaN")。

plusSign

プラス記号の文字列 ("+")。

percentSign

パーセント文字列 ("%")。

unit

単位の文字列、例えば "l" または "litres" で、 `unitDisplay` がどのように指定されているかに依存します。

例
-

### format と formatToParts の比較

`NumberFormat` はローカライズされた、直接操作できない文字列を出力します。

```js
var number = 3500;

var formatter = new Intl.NumberFormat("de-DE", {
  style: "currency",
  currency: "EUR",
});

formatter.format(number);
// "3.500,00 €"
```

しかし、多くのユーザーインターフェースでは、この文字列の書式形式をカスタマイズしたいと要望があります。 `formatToParts` メソッドは `NumberFormat` フォーマッターによって生成された文字列を要素ごとの文字列として提供することでロケールに応じた書式設定を可能にします。

```js
formatter.formatToParts(number);

// 返値:
[
  { type: "integer", value: "3" },
  { type: "group", value: "." },
  { type: "integer", value: "500" },
  { type: "decimal", value: "," },
  { type: "fraction", value: "00" },
  { type: "literal", value: " " },
  { type: "currency", value: "€" },
];
```

これで情報は個別に利用可能となり、カスタマイズされた方法でフォーマットして連結することができます。例えば `Array.prototype.map()`, アロー関数, switch 文, テンプレートリテラル, `Array.prototype.reduce()` を使います。

```js
var numberString = formatter
  .formatToParts(number)
  .map(({ type, value }) => {
    switch (type) {
      case "currency":
        return `<strong>${value}</strong>`;
      default:
        return value;
    }
  })
  .reduce((string, part) => string + part);
```

上記は`formatToParts()`メソッドを使い、通貨を太字にします。

```js
console.log(numberString);
// "3.500,00 <strong>€</strong>"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.numberformat.prototype.formattoparts |

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

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

関連情報
----

* `Intl.NumberFormat`
* `Intl.NumberFormat.prototype.format`
* 日付の書式化: `Intl.DateTimeFormat.prototype.formatToParts()`


Intl.NumberFormat() コンストラクター - JavaScript

Intl.NumberFormat() コンストラクター
============================

**`Intl.NumberFormat()`** コンストラクターは、言語に依存した数値の整形ができる `Intl.NumberFormat` オブジェクトを生成します。

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

構文
--

```js
new Intl.NumberFormat([locales[, options]])
```

### 引数

`locales` 省略可

BCP 47 言語タグを持つ文字列、またはそのような文字列の配列。 `locales` 引数の一般的な形式と解釈については、 Intl のページを参照してください。次の Unicode 拡張キーが許可されています。

`nu`

使用される数値システムです。指定可能な値には "`adlm`", "`ahom`", "`arab`", "`arabext`", "`bali`", "`beng`", "`bhks`", "`brah`", "`cakm`", "`cham`", "`deva`", "`diak`", "`fullwide`", "`gong`", "`gonm`", "`gujr`", "`guru`", "`hanidec`", "`hmng`", "`hmnp`", "`java`", "`kali`", "`khmr`", "`knda`", "`lana`", "`lanatham`", "`laoo`", "`latn`", "`lepc`", "`limb`", "`mathbold`", "`mathdbl`", "`mathmono`", "`mathsanb`", "`mathsans`", "`mlym`", "`modi`", "`mong`", "`mroo`", "`mtei`", "`mymr`", "`mymrshan`", "`mymrtlng`", "`newa`", "`nkoo`", "`olck`", "`orya`", "`osma`", "`rohg`", "`saur`", "`segment`", "`shrd`", "`sind`", "`sinh`", "`sora`", "`sund`", "`takr`", "`talu`", "`tamldec`", "`telu`", "`thai`", "`tibt`", "`tirh`", "`vaii`", "`wara`", "`wcho`" があります。 標準 Unicode 命数法一覧 を参照してください。

`options` 省略可

以下のプロパティのすべてまたは一部を持つオブジェクトです。

`compactDisplay`

`notation` が "`compact`" の場合のみ使用されます。 "`short`" (既定値) または "`long`" のどちらかを取ります。

`currency`

通貨の書式で使用するための通貨です。使用可能な値は ISO 4217 通貨コードであり、例えば米ドルは "`USD`"、ユーロは "`EUR`"、日本円には "`JPY`" です。 — Current currency & funds code list を参照してください。既定値はありません。 `style` が "`currency`" である場合、 `currency` プロパティを提供する必要があります。

`currencyDisplay`

通貨の書式で通貨を表示する方法です。使用可能な値は次の通りです。

* "`symbol`" はローカライズされた通貨記号、例えば € などを使用します。これが既定値です。
* "`narrowSymbol`" は短い形式の記号を使用します ("US$100" ではなく "$100")。
* "`code`" は ISO 通貨コードを使用します。
* "`name`" はローカライズされた通貨名、例えば "`dollar`" を使用します。

`currencySign`

多くのロケールでは、会計の書式はマイナス記号を追加する代わりに数値を括弧で囲みます。この形式は `currencySign` オプションを "`accounting`" に設定すると有効になります。既定値は "`standard`" です。

`localeMatcher`

使用するロケール比較アルゴリズムです。使用可能な値は "`lookup`" および "`best fit`" です。既定値は "`best fit`" です。このオプションについての情報は、 Intl page を参照してください。

`notation`

数値を表示するための書式です。既定値は "`standard`" です。

* "`standard`" は、通常の数値の書式です。
* "`scientific`" は、整形された数値の次数をを返します。
* "`engineering`" は、3 で割ることができる場合に 10 のべき乗を返します。
* "`compact`" は、指数表記を表す文字列で、既定値は "short" の形式を使用したものです。

`numberingSystem`

数値体系です。使用可能な値には、 "`arab`", "`arabext`", " `bali`", "`beng`", "`deva`", "`fullwide`", " `gujr`", "`guru`", "`hanidec`", "`khmr`", " `knda`", "`laoo`", "`latn`", "`limb`", "`mlym`", " `mong`", "`mymr`", "`orya`", "`tamldec`", " `telu`", "`thai`", "`tibt`" があります。

`signDisplay`

数値の符号を表示するときです。既定値は "`auto`" です。

* "`auto`" は、負の数のみ符号を表示します。
* "`never`" は、符号を表示しません。
* "`always`" は、常に符号を表示します。
* "`exceptZero`" は正の数と負の数には符号を表示しますが、ゼロには表示しません。

`style`

使用する整形スタイルで、既定値は "`decimal`" です。

* "`decimal`" は、ふつうの数値の整形に使用します。
* "`currency`" は、通貨の整形に使用します。
* "`percent`" は、パーセントの整形に使用します。
* "`unit`" は単位の整形に使用します。

`unit`

`unit` の整形で使用する単位で、使用可能な値は UTS #35, Part 2, Section 6 で定義されているコア単位識別子です。 全体リストから単位のサブセットが ECMAScript で使用するために選択されました。一組の単純な単位を "`-per-`" で結合し、複合単位を創ることができます。既定値はありません。 `style` が "`unit`" である場合、 `unit` プロパティを指定する必要があります。

`unitDisplay`

`unit` の整形で使用する単位の整形スタイルで、既定値は "`short`" です。

* "`long`" (例: `16 litres`)
* "`short`" (例: `16 l`)
* "`narrow`" (例: `16l`)

`useGrouping`

グループ化する区切り記号を使用するかどうかです。例えば、 3 桁区切りや 1000/ラク/クレオールの区切り記号など。設定可能な値は true と false で、既定値は true です。

以下のプロパティは 2 つのグループに分類できます。 `minimumIntegerDigits`、`minimumFractionDigits`、`maximumFractionDigits` が一方のグループ、 `minimumSignificantDigits` と `maximumSignificantDigits` が他方のグループに属します。 2 つ目のグループから少なくとも 1 つのプロパティが定義されていれば、 1 つ目のグループは無視されます。

`minimumIntegerDigits`

整数部に使用する最小桁数です。使用可能な値は 1 から 21 までです。既定値は 1 です。

`minimumFractionDigits`

小数部に使用する最小桁数です。使用可能な値は 0 から 20 までです。既定値は、通常の数値とパーセント形式では 0 です。通貨形式では ISO 4217 通貨コードリストで提供されている副単位の桁数です (このリストで情報が提供されていない場合は 2 です)。

`maximumFractionDigits`

小数部に使用する最大桁数です。使用可能な値は 0 から 20 までです。既定値は、通常の数値では `minimumFractionDigits` と 3 の大きい方、通貨形式では `minimumFractionDigits` と ISO 4217 通貨コードリストで提供されている副単位の桁数です (このリストで情報が提供されていない場合は 2)、パーセント形式の場合は `minimumFractionDigits` と 0 の大きい方です。

`minimumSignificantDigits`

使用する最小有効桁数です。使用可能な値は 1 から 21 までです。既定値は 1 です。

`maximumSignificantDigits`

使用する最大有効桁数です。使用可能な値は 1 から 21 までです。既定値は 1 です。

例
-

### 基本的な使用

特定のロケールなしで使用すると、既定のロケール、既定のオプションで整形された文字列が返されます。

```js
let amount = 3500;

console.log(new Intl.NumberFormat().format(amount));
// → '3,500' if in US English locale
```

### 十進数とパーセントの整形

```js
let amount = 3500;

new Intl.NumberFormat("en-US", { style: "decimal" }).format(amount);
// → '3,500'
new Intl.NumberFormat("en-US", { style: "percent" }).format(amount);
// → '350,000%'
```

### 単位の整形

`style` が `'unit'` である場合、 `unit` プロパティを提供する必要があります。オプションで、 `unitDisplay` が単位の整形を制御します。

```js
let amount = 3500;

new Intl.NumberFormat("en-US", { style: "unit", unit: "liter" }).format(amount);
// → '3,500 L'

new Intl.NumberFormat("en-US", {
  style: "unit",
  unit: "liter",
  unitDisplay: "long",
}).format(amount);
// → '3,500 liters'
```

### 通貨の整形

`style` が `'currency'` であった場合、 `currency` プロパティを提供する必要があります。オプションで、 `currencyDisplay` および `currencySign` が単位の整形を制御します。

```js
let amount = -3500;
new Intl.NumberFormat("en-US", { style: "currency", currency: "USD" }).format(
  amount,
);
// → '-$3,500.00'

new Intl.NumberFormat("bn", {
  style: "currency",
  currency: "USD",
  currencyDisplay: "name",
}).format(amount);
// → '-3,500.00 US dollars'

new Intl.NumberFormat("bn", {
  style: "currency",
  currency: "USD",
  currencySign: "accounting",
}).format(amount);
// → '($3,500.00)'
```

### 科学、工学、短縮表記

科学の短縮表記は `notation` オプションで表すことができ、以下のようになります。

```js
new Intl.NumberFormat("en-US", { notation: "scientific" }).format(987654321);
// → 9.877E8

new Intl.NumberFormat("pt-PT", { notation: "scientific" }).format(987654321);
// → 9,877E8

new Intl.NumberFormat("en-GB", { notation: "engineering" }).format(987654321);
// → 987.654E6

new Intl.NumberFormat("de", { notation: "engineering" }).format(987654321);
// → 987,654E6

new Intl.NumberFormat("zh-CN", { notation: "compact" }).format(987654321);
// → 9.9亿

new Intl.NumberFormat("fr", {
  notation: "compact",
  compactDisplay: "long",
}).format(987654321);
// → 988 millions

new Intl.NumberFormat("en-GB", {
  notation: "compact",
  compactDisplay: "short",
}).format(987654321);
// → 988M
```

### 符号の表示

正の数と負の数に符号を表示し、ゼロには表示しない場合は次のようにします。

```js
new Intl.NumberFormat("en-US", {
  style: "percent",
  signDisplay: "exceptZero",
}).format(0.55);
// → '+55%'
```

なお、通貨の符号が "accounting" である場合、負号の代わりに括弧が使用されることがあります。

```js
new Intl.NumberFormat("bn", {
  style: "currency",
  currency: "USD",
  currencySign: "accounting",
  signDisplay: "always",
}).format(-3500);

// → '($3,500.00)'
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl-numberformat-constructor |

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

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

関連情報
----

* `Intl.NumberFormat`
* `Intl`


Intl.DisplayNames() コンストラクター - JavaScript

Intl.DisplayNames() コンストラクター
============================

**`Intl.DisplayNames()`** コンストラクターは、言語、地域、文字体系の表示名の一貫した翻訳を可能にする `Intl.DisplayNames` オブジェクトを生成します。

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

構文
--

```js
new Intl.DisplayNames();
new Intl.DisplayNames(locales);
new Intl.DisplayNames(locales, options);
```

### 引数

`locales` 省略可

BCP 47 言語タグの文字列、または、そのような文字列の配列です。 `locales` 引数の一般的な形式と解釈は、 Intl のページをご覧ください。次の Unicode 拡張キーが利用できます。

`nu`

 使用する数値書式です。
 "`arab`", "`arabext`", "`bali`",
 "`beng`", "`deva`", "`fullwide`",
 "`gujr`", "`guru`", "`hanidec`",
 "`khmr`", "`knda`", "`laoo`",
 "`latn`", "`limb`", "`mlym`",
 "`mong`", "`mymr`", "`orya`",
 "`tamldec`", "`telu`", "`thai`",
 "`tibt`" です。

`options` 省略可

以下のプロパティの一部またはすべてを持つオブジェクトです。

`localeMatcher`

 使用するロケール照合アルゴリズムです。利用可能な値は、
 "`lookup`" と "`best fit`" です。既定値は
 "`best fit`" です。このオプションについての情報は、
 Intl ページを参照してください。

`style`

使用する書式化スタイルです。既定値は "`long`" です。

* "`narrow`"
* "`short`"
* "`long`"

`type`

使用する種類です。

* "`language`"
* "`region`"
* "`script`"
* "`currency`"

`fallback`

使用する代替法です。既定値は "`code`" です。

* "`code`"
* "`none`"

例
-

### 基本的な使用法

ロケールを指定しない基本的な使用法では、既定のロケールと既定のオプションで書式化された文字列が返されます。

```js
console.log(new Intl.DisplayNames([], { type: "language" }).of("US"));
// 期待される出力: 'us'
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl-displaynames-constructor |

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

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

関連情報
----

* `Intl.DisplayNames`
* `Intl`


Intl.DisplayNames.supportedLocalesOf() - JavaScript

Intl.DisplayNames.supportedLocalesOf()
======================================

**`Intl.DisplayNames.supportedLocalesOf()`** メソッドは、指定されたロケールのうち、ランタイムの既定のロケールで代替せずに表示名に対応しているものの配列を返します。

構文
--

```js
Intl.DisplayNames.supportedLocalesOf(locales);
Intl.DisplayNames.supportedLocalesOf(locales, options);
```

### 引数

`locales`

BCP 47 言語タグを持つ文字列、またはそのような文字列の配列です。 `locales` 引数の一般的な形式については、 Intl のページを参照してください。

`options` 省略可

以下のプロパティを持つオブジェクトです。

`localeMatcher`

使用するロケール照合アルゴリズムです。指定可能な値は "`lookup`" および "`best fit`" で、既定値は "`best fit`" です。このオプションの詳細は、 Intl のページを参照してください。

### 返値

指定したロケールタグうち、ランタイムの既定のロケールで代替せずに表示名に対応しているものを表す文字列の配列です。

解説
--

`locales` で指定された言語タグのサブセットが入った配列を返します。返される言語タグは、表示名について、使用するロケール照合アルゴリズムで一致しているとみなされ、ランタイムが既定のロケールで代替することなく対応しているものです。

例
-

### supportedLocalesOf() の使用

表示名についてインドネシア語とドイツ語に対応しているが、バリ語に対応していないランタイムを想定した場合、 `supportedLocalesOf` はインドネシア語とドイツ語の言語タグを変更せずに返しますが、 `pinyin` の照合は表示名には関係なく、インドネシア語では使用されません。これは "`lookup`" アルゴリズムの仕様であることに注意してください。 "`best fit`" で照合すると、バリ語の話者のほとんどはインドネシア語も理解しているので、インドネシア語がバリ語に適切に一致すると判断し、バリ語の言語タグも返すかもしれません。

```js
const locales = ["ban", "id-u-co-pinyin", "de-ID"];
const options = { localeMatcher: "lookup" };
console.log(Intl.DisplayNames.supportedLocalesOf(locales, options).join(", "));
// → "id-u-co-pinyin, de-ID"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.DisplayNames.supportedLocalesOf |

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

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

関連情報
----

* `Intl.DisplayNames`


Intl.DisplayNames.prototype.resolvedOptions() - JavaScript

Intl.DisplayNames.prototype.resolvedOptions()
=============================================

**`Intl.DisplayNames.prototype.resolvedOptions()`** メソッドは、現在の `Intl.DisplayNames` オブジェクトの初期化時に計算されたロケールとスタイルの書式オプションを反映したプロパティを持つ新しいオブジェクトを返します。

構文
--

```js
resolvedOptions();
```

### 返値

この `Intl.DisplayNames` オブジェクトの初期化時に計算されたロケールと書式オプションを反映したプロパティを持つ新しいオブジェクトです。

解説
--

`resolvedOptions()` で返されるオブジェクトには、以下のプロパティがあります。

`locale`

このロケールで実際に使用する BCP 47 言語タグです。入力されこのロケールに導いた BCP 47 言語タグで Unicode 拡張値が要求されていた場合、要求されたキーと値の組のうち、このロケールで対応しているものが `locale` に含まれます。

`style`

コンストラクターの `options` 引数でこのプロパティに与えられた値、または既定値 ("`long`") です。値は "`long`"、"`short`"、"`narrow`" のいずれかです。

`type`

コンストラクターの `options` 引数でこのプロパティに与えられた値、または既定値 ("`language`") です。値は "`language`"、"`region`"、"`script`"、"`currency`" のいずれかです。

`fallback`

コンストラクターの `options` 引数でこのプロパティに与えられた値、または既定値 ("`code`") です。値は "`code`" または "`none`" のどちらかです。

例
-

### resolvedOptions の使用

```js
const displayNames = new Intl.DisplayNames(["de-DE"], { type: "region" });

const usedOptions = displayNames.resolvedOptions();
console.log(usedOptions.locale); // "de-DE"
console.log(usedOptions.style); // "long"
console.log(usedOptions.type); // "region"
console.log(usedOptions.fallback); // "code"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.DisplayNames.prototype.resolvedOptions |

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

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

関連情報
----

* `Intl.DisplayNames`


Intl.DisplayNames.prototype.of() - JavaScript

Intl.DisplayNames.prototype.of()
================================

**`Intl.DisplayNames.prototype.of()`** メソッドは、コードを受け取り、Intl.DisplayNames をインスタンス化するときに指定されたロケールとオプションに基づいて文字列を返します。

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

構文
--

```js
of(code);
```

### 引数

`code`

与える `code` は、 `type` によって変わります。

* type が "region" である場合、コードは ISO-3166 地域の 2 文字コードまたは three digits UN M49 Geographic Regions である必要があります。
* type が "script" である場合、コードは ISO-15924 文字体系の 4 文字コードである必要があります。
* type が "language" である場合、コードは *languageCode* ["-" *scriptCode*] ["-" *regionCode* ] \*("-" *variant* ) の形である必要があり、これは UTS 35's Unicode Language and Locale Identifiers grammar の unicode\_language\_id の構文です。 *languageCode* は 2 文字の ISO 639-1 言語コードまたは 3 文字の ISO 639-2 言語コードです。
* type が "currency" である場合、コードは 3 文字の ISO 4217 通貨コードである必要があります。

### 返値

その言語における書式化された文字列です。

例
-

### of メソッドの使用

```js
let regionNames = new Intl.DisplayNames(["en"], { type: "region" });
regionNames.of("419"); // "Latin America"

let languageNames = new Intl.DisplayNames(["en"], { type: "language" });
languageNames.of("fr"); // "French"

let currencyNames = new Intl.DisplayNames(["en"], { type: "currency" });
currencyNames.of("EUR"); // "Euro"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.DisplayNames.prototype.of |

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

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

関連情報
----

* `Intl.DisplayNames`


Intl.Locale.prototype.hourCycles - JavaScript

Intl.Locale.prototype.hourCycles
================================

**`Intl.Locale.prototype.hourCycles`** プロパティは、この `Locale` に固有の時制識別子のリストを返すアクセサープロパティです。

解説
--

世界中で使用されている時刻保持規則（時制）には、主に 12 時制と 24 時制の 2 つの種類があります。 `hourCycles` プロパティを使用すると、特定のロケールで利用できるすべての時制に簡単にアクセスできるようになります。他の追加ロケールデータと同様に、時制種別は拡張サブタグであり、ロケール文字列に含まれるデータを拡張したものです。時制種別には、以下の表にある通り、いくつかの異なる値を設定することができます。

### 有効な時制種別

| 時制種別 | 説明 |
| --- | --- |
| `h12` | 1–12 を使用する時制で、パターンの 'h' に対応します。 12 時制で、正子は午前 12:00 から始まります。 |
| `h23` | 0–23 を使用する時制で、パターンの 'H' に対応します。 24 時制で、正子は 0:00 から始まります。 |
| `h11` | 0–11 を使用する時制で、パターンの 'K' に対応します。 12 時制で、正子は午前 0:00 から始まります。 |
| `h24` | 1–24 を使用する時制で、パターンの 'k' に対応します。 24 時制で、正子は 24:00 から始まります。 |

例
-

### 対応しているカレンダーを取得

指定された `Locale` で対応している時制のリストを出力します。

```js
let arEG = new Intl.Locale("ar-EG");
console.log(arEG.hourCycles); // logs ["h12"]
```

```js
let jaJP = new Intl.Locale("ja-JP");
console.log(jaJP.hourCycles); // logs ["h23"]
```

仕様書
---

| Specification |
| --- |
| Intl Locale Info Proposal # sec-Intl.Locale.prototype.getHourCycles |

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

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

関連情報
----

* `Intl.Locale`
* Unicode 時制拡張キー仕様書


Intl.Locale.prototype.minimize() - JavaScript

Intl.Locale.prototype.minimize()
================================

**`Intl.Locale.prototype.minimize()`** メソッドは、 `Locale.maximize()` を呼び出したことで追加されるロケールに関する情報を削除しようとします。

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

構文
--

```js
minimize();
```

### 返値

`Locale` インスタンスで、 `baseName` プロパティが、 Remove Likely Subtags アルゴリズムを *`locale.baseName`* に対して実行された結果になったものを返します。

解説
--

このメソッドは `maximize()` の逆の処理を行い、ロケールの言語識別子 (基本的には `baseName` の内容) から言語、文字体系、地域のサブタグをすべて削除します。これは、言語識別子の中に余分なサブタグがある場合に便利です。例えば "en-Latn" は "en" に簡略化できます。英語では "Latn" が書き言葉に使われる唯一の文字体系だからです。 `minimize()` が影響を与えるのは、言語識別子を構成する主要なサブタグである言語、文字体系、地域の各サブタグのみです。ロケール識別子の "-u" の後にあるその他のサブタグは拡張サブタグと呼ばれ、 `minimize()` メソッドの影響を受けません。これらのサブタグの例としては、`Locale.hourCycle`、`Locale.calendar`、`Locale.numeric` などがあります。

例
-

### minimize の使用

```js
let myLocale = new Intl.Locale("ja-Jpan-JP", {
  hourCycle: "h24",
  calendar: "gregory",
});
console.log(myLocale.baseName); // "ja-Jpan-JP" と表示
console.log(myLocale.toString()); // "ja-Jpan-JP-u-ca-gregory-hc-h24" と表示

let myLocMinimized = myLocale.minimize();

// "ja" のみを表示します。日本語は主に漢字かな交じり文 (Jpan) で
// 表記され、またほとんど日本で話されているためです。
console.log(myLocMinimized.baseName);

// "ja-u-ca-gregory-hc-h24" と表示します。
// なお、拡張タグ ("-u" 以降) はそのまま残ります。
console.log(myLocMinimized.toString());
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.Locale.prototype.minimize |

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

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

関連情報
----

* `Intl.Locale`
* `Intl.Locale.baseName`


Intl.Locale.prototype.maximize() - JavaScript

Intl.Locale.prototype.maximize()
================================

**`Intl.Locale.prototype.maximize()`** メソッドは、既存の値に基づいてロケールの言語、文字体系、地域の最も可能性の近い値を取得します。

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

構文
--

```js
maximize();
```

### 返値

`Locale` インスタンスのうち、 `baseName` プロパティが Add Likely Subtags アルゴリズムを *`locale.baseName`*.に対して実行した結果になっているものを返します。

解説
--

不完全な言語識別子をもとに、最も可能性の高いロケール言語識別子サブタグを識別できると便利な場合があります。 Add Likely Subtags アルゴリズムはこの機能を提供してくれます。例えば、言語識別子 "en" が与えられた場合、アルゴリズムは "en-Latn-US" を返すことになります。英語はラテン文字でしか書けませんし、世界最大の英語圏の国であるアメリカで使われている可能性が高いからです。この機能は、 `maximize()` メソッドを介して JavaScript プログラマーに提供されています。 `maximize()` は、言語識別子を構成する主要なサブタグのうち言語サブ、文字体系、地域の各サブタグにのみ影響を与えます。ロケール識別子の "-u" の後にあるその他のサブタグは拡張サブタグと呼ばれ、 `maximize()` メソッドの影響を受けません。これらのサブタグの例としては、`Locale.hourCycle`、`Locale.calendar`、`Locale.numeric` などがあります。

例
-

### maximize の使用

```js
let myLocale = new Intl.Locale("ja", { hourCycle: "h24", calendar: "gregory" });
console.log(myLocale.baseName); // "ja" と表示
console.log(myLocale.toString()); // "ja-u-ca-gregory-hc-h24" と表示
let myLocMaximized = myLocale.maximize();

// "ja-Jpan-JP"。 "Jpan" と "JP" タグが追加されます。
// これは、日本語が主に漢字かな交じり文 (Jpan) で書かれ、また主に日本 (JP) で話されているためです。
console.log(myLocMaximized.baseName);

// "ja-Jpan-JP-u-ca-gregory-hc-h24" と表示します。
// なお、拡張タグ ("-u" 以降) はそのまま残ります。
console.log(myLocMaximized.toString());
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.Locale.prototype.maximize |

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

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

関連情報
----

* `Intl.Locale`
* `Intl.Locale.baseName`
* Unicode's Likely
Subtags spec


Intl.Locale.prototype.language - JavaScript

Intl.Locale.prototype.language
==============================

**`Intl.Locale.prototype.language`** プロパティは、ロケールに関連付けられた言語を返すアクセサープロパティです。

解説
--

言語はロケールの中核的な特徴の一つです。 Unicode 仕様書では、ロケールの言語識別子を言語と地域を合わせたものとして扱います（イギリス英語とアメリカ英語などの方言や変化形を区別するためです）。 `Locale` の `language` プロパティは、ロケールの言語サブタグを厳密に返します。

例
-

### ロケール識別子の文字列引数で言語を設定

有効な Unicode 言語識別子となるためには、文字列は言語サブタグで始めなければなりません。 `Locale` コンストラクターの主要な引数には、有効な Unicode ロケール識別子がなければならないので、コンストラクターを使用する際には必ず言語サブタグを持つ識別子を渡さなければなりません。

```js
let locale = new Intl.Locale("en-Latn-US");
console.log(locale.language); // "en" と表示
```

### 構成オブジェクトにより言語を上書き

言語サブタグは指定する必要がありますが、 `Locale` コンストラクターは構成オブジェクトを取り、これを用いて言語サブタグを上書きすることができます。

```js
let locale = new Intl.Locale("en-Latn-US", { language: "es" });
console.log(locale.language); // "es" と表示
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.Locale.prototype.language |

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

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

関連情報
----

* `Intl.Locale`
* Unicode 言語サブタグ仕様書


Intl.Locale.prototype.calendars - JavaScript

Intl.Locale.prototype.calendars
===============================

**`Intl.Locale.prototype.calendars`** プロパティは、 `Locale` のカレンダー識別子の配列を返すアクセサープロパティです。

解説
--

`calendar` プロパティは、 `Locale` で対応しているすべてのカレンダーを配列で返します。配列の項目は、 `Locale` オブジェクトの暦年代を表します。以下の表は、有効なすべての Unicode 暦キー文字列と、それらが表す暦の時代の説明を示しています。

### Unicode 暦キー

`buddhist`

タイの仏教暦

`chinese`

古来の中国の暦

`coptic`

コプト暦

`dangi`

古来の韓国の暦

`ethioaa`

Ethiopic calendar, Amete Alem (epoch approx. 5493 B.C.E)

`ethiopic`

Ethiopic calendar, Amete Mihret (epoch approx, 8 C.E.)

`gregory`

グレゴリオ暦

`hebrew`

古来のヘブライ暦

`indian`

インド暦

`islamic`

イスラム暦

`islamic-umalqura`

イスラム暦、ウンムアルクーラ

`islamic-tbla`

イスラム暦、表形式 (閏年 [2,5,7,10,13,16,18,21,24,26,29] - 天体暦)

`islamic-civil`

イスラム暦、表形式 (閏年 [2,5,7,10,13,16,18,21,24,26,29] - 市民暦)

`islamic-rgsa`

イスラム暦、サウジアラビア地方

`iso8601`

ISO カレンダー (ISO 8601 カレンダーの曜日規則を使用したグレゴリオ暦)

`japanese`

日本の皇紀

`persian`

ペルシャ暦

`roc`

中華民国暦 (中華民国)

`islamicc`

シビル（アルゴリズム）アラビア暦

**警告:** `islamicc` 暦は非推奨です。 `islamic-civil` を使用してください。

例
-

### 対応しているカレンダーを取得

この `Locale` が対応しているカレンダーをリスト出力します。

```js
let arEG = new Intl.Locale("ar-EG");
console.log(arEG.calendars); // logs ["gregory", "coptic", "islamic", "islamic-civil", "islamic-tbla"]
```

```js
let jaJP = new Intl.Locale("ja-JP");
console.log(jaJP.calendars); // logs ["gregory", "japanese"]
```

仕様書
---

| Specification |
| --- |
| Intl Locale Info Proposal # sec-Intl.Locale.prototype.getCalendars |

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

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

関連情報
----

* `Intl.Locale`
* Unicode カレンダー識別子


Intl.Locale.prototype.textInfo - JavaScript

Intl.Locale.prototype.textInfo
==============================

**`Intl.Locale.prototype.textInfo`** プロパティは、関連する `Locale` に対して `ltr` （左書き）または `rtl` （右書き）で示される文字の並び順を返すアクセサープロパティです。

解説
--

UTS 35's Layouts Elements で定義されているロケールのデータに結び付けた `Locale` 情報を返します。

例
-

### テキスト情報の取得

指定された `Locale` で対応している書字方向を返します。

```js
let ar = new Intl.Locale("ar");
console.log(ar.textInfo); // logs { direction: "rtl" }
console.log(ar.textInfo.direction); // logs "rtl"
```

```js
let es = new Intl.Locale("es");
console.log(es.textInfo); // logs { direction: "ltr" }
console.log(es.textInfo.direction); // logs "ltr"
```

仕様書
---

| Specification |
| --- |
| Intl Locale Info Proposal # sec-Intl.Locale.prototype.getTextInfo |

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

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

関連情報
----

* `Intl.Locale`


Intl.Locale() コンストラクター - JavaScript

Intl.Locale() コンストラクター
======================

**`Intl.Locale`** コンストラクターは、 Intl オブジェクトの標準組み込みプロパティで、 Unicode ロケール識別子を表します。

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

構文
--

```js
new Intl.Locale(tag);
new Intl.Locale(tag, options);
```

### 引数

`tag`

Unicode ロケール識別子の文字列です。

`options`

ロケールの構成を含むオブジェクトです。キーは Unicode ロケールタグで、値は有効な Unicode タグ値です。

例
-

### 基本的な使用

もっとも単純なものでは、`Intl.Locale` コンストラクターはロケール識別子の文字列を引数に取ります。

```js
let us = new Intl.Locale("en-US");
```

### Locale コンストラクターに options オブジェクトを渡して使用

コンストラクターには、オプションで構成オブジェクトの引数を取ることができ、そこに複数の拡張型を指定することができます。たとえば、設定オブジェクトの `hourCycle` プロパティに任意の時間周期を設定し、それをコンストラクターに渡します。

```js
let locale = new Intl.Locale("en-US", { hourCycle: "h12" });
console.log(locale.hourCycle); // Prints "h12"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl-locale-constructor |

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

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

関連情報
----

* `Intl.Collator`
* Unicode ロケール識別子の仕様書
* FormatJS における `Intl.Locale` のポリフィル


Intl.Locale.prototype.timeZones - JavaScript

Intl.Locale.prototype.timeZones
===============================

**`Intl.Locale.prototype.timeZones`** プロパティはアクセサープロパティで、選択した `Locale` で対応しているタイムゾーンの配列を返します。

解説
--

関連付けられた `Locale` で対応しているタイムゾーンを配列で返します。返されるタイムゾーンは IANA タイムゾーン を表します。

**メモ:** Unicode 言語識別子が Unicode 地域サブタグシーケンスの `-` を含んでいない場合、返される値は `undefined` です。

例
-

### 対応しているタイムゾーンの取得

指定された `Locale` で対応しているタイムゾーンをリストアップします。

```js
let arEG = new Intl.Locale("ar-EG");
console.log(arEG.timeZones); // logs ["Africa/Cairo"]
```

```js
let jaJP = new Intl.Locale("ja-JP");
console.log(jaJP.timeZones); // logs ["Asia/Tokyo"]
```

```js
let ar = new Intl.Locale("ar");
console.log(ar.timeZones); // logs undefined
```

仕様書
---

| Specification |
| --- |
| Intl Locale Info Proposal # sec-Intl.Locale.prototype.getTimeZones |

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

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

関連情報
----

* `Intl.Locale`
* IANA タイムゾーンデータベース


Intl.Locale.prototype.hourCycle - JavaScript

Intl.Locale.prototype.hourCycle
===============================

**`Intl.Locale.prototype.hourCycle`** プロパティは、ロケールで使用される時刻保持書式の規則を返すアクセサープロパティです。

解説
--

世界中で使用されている時刻保持規則（時制）には、主に 12 時制と 24 時制の 2 つの種類があります。 `hourCycle` プロパティを使用すると、 JavaScript のプログラマーが特定のロケールで使用されている時制に簡単にアクセスできるようになります。他の追加ロケールデータと同様に、時制種別は拡張サブタグであり、ロケール文字列に含まれるデータを拡張したものです。時制種別には、以下の表にある通り、いくつかの異なる値を設定することができます。

### 有効な時制種別

| 時制種別 | 説明 |
| --- | --- |
| `h12` | 1–12 を使用する時制で、パターンの 'h' に対応します。 12 時制で、正子は午前 12:00 から始まります。 |
| `h23` | 0–23 を使用する時制で、パターンの 'H' に対応します。 24 時制で、正子は 0:00 から始まります。 |
| `h11` | 0–11 を使用する時制で、パターンの 'K' に対応します。 12 時制で、正子は午前 0:00 から始まります。 |
| `h24` | 1–24 を使用する時制で、パターンの 'k' に対応します。 24 時制で、正子は 24:00 から始まります。 |

例
-

これらの例は、時制データを `Locale` オブジェクトに追加する方法を示しています。

### ロケール文字列による時制の追加

Unicode ロケール文字列仕様書では、時制はロケール文字列の「拡張サブタグ」です。これらのサブタグはロケールについての追加データであり、拡張キー `-u` を使用してロケール識別子に追加されます。このようして、時制の種類を `Locale` コンストラクターに渡される初期のロケール識別子文字列に追加することができます。時制種別の値を設定するには、まず文字列に `-u` 拡張キーを追加します。次に、 `-hc` 拡張キーを追加して、時制種別の値を追加していることを示します。最後に、時制種別の値を文字列に追加します。

```js
let locale = new Intl.Locale("fr-FR-u-hc-h23");
console.log(locale.hourCycle); // "h23" と表示
```

### 構成オブジェクト引数から時制を追加

`Intl.Locale` コンストラクターには、オプションで構成オブジェクトの引数があり、これには時制種別を含む任意の拡張の種類をいくつか含めることができます。構成オブジェクトの `hourCycle` プロパティを任意の時制種別に設定し、コンストラクターに渡します。

```js
let locale = new Intl.Locale("en-US", { hourCycle: "h12" });
console.log(locale.hourCycle); // "h12" と表示
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.Locale.prototype.hourCycle |

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

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

関連情報
----

* `Intl.Locale`
* Unicode 時制拡張キー仕様書


Intl.Locale.prototype.numberingSystems - JavaScript

Intl.Locale.prototype.numberingSystems
======================================

**`Intl.Locale.prototype.numberingSystems`** プロパティは、 `Locale` が使用する命数法に関わる 1 つ以上の識別子を返すアクセサープロパティです。

解説
--

命数法とは、数値を表現するための体系のことです。 `numberingSystem` プロパティは、世界中のさまざまな国、地域、文化で使用されているさまざまな命数法を表現する支援をします。ほとんどの国際化スキーマと同様に、 `Locale` オブジェクトで `numberingSystem` によって表現できる命数法は、 Unicode で標準化されています。標準的な Unicode の命数法の表を以下に示します。

| 値 | 説明 |
| --- | --- |
| adlm | アドラム数字 |
| ahom | アコム数字 |
| arab | アラビア・インド数字 |
| arabext | 拡張アラビア・インド数字 |
| armn | 大文字のアルメニア数字 — アルゴリズム |
| armnlow | 小文字のアルメニア数字 — アルゴリズム |
| bali | Balinese digits |
| beng | Bengali digits |
| bhks | Bhaiksuki digits |
| brah | Brahmi digits |
| cakm | Chakma digits |
| cham | Cham digits |
| cyrl | キリル数字 — アルゴリズム |
| deva | Devanagari digits |
| ethi | エチオピア数字 — アルゴリズム |
| finance | 金融数字 — アルゴリズムの場合あり |
| fullwide | 全角数字 |
| geor | ジョージア数字 — アルゴリズム |
| gong | Gunjala Gondi digits |
| gonm | Masaram Gondi digits |
| grek | 大文字のギリシャ数字 — アルゴリズム |
| greklow | 小文字のギリシャ数字 — アルゴリズム |
| gujr | Gujarati digits |
| guru | Gurmukhi digits |
| hanidays | 太陰暦またはその他の旧暦向けの漢字による日付の数字 |
| hanidec | 漢数字表意文字による位置決め十進法 |
| hans | 簡体字の漢数字 — アルゴリズム |
| hansfin | 簡体字の金融用漢数字 — アルゴリズム |
| hant | 繁体字の漢数字 — アルゴリズム |
| hantfin | 繁体字の金融用漢数字 — アルゴリズム |
| hebr | ヘブライ数字 — アルゴリズム |
| hmng | Pahawh Hmong digits |
| hmnp | Nyiakeng Puachue Hmong digits |
| java | Javanese digits |
| jpan | 日本語の漢数字 — アルゴリズム |
| jpanfin | 日本語の金融用漢数字 — アルゴリズム |
| jpanyear | 最初の年を元年とした日本の暦用の命数法 |
| kali | Kayah Li digits |
| khmr | Khmer digits |
| knda | Kannada digits |
| lana | Tai Tham Hora (secular) digits |
| lanatham | Tai Tham (ecclesiastical) digits |
| laoo | Lao digits |
| latn | ラテン数字 |
| lepc | Lepcha digits |
| limb | Limbu digits |
| mathbold | 数学的太数字 |
| mathdbl | 数学的二重打鍵の数字 |
| mathmono | 数学的等幅数字 |
| mathsanb | 数学的三セリフ太字数字 |
| mathsans | 数学的サンセリフ数字 |
| mlym | Malayalam digits |
| modi | Modi digits |
| mong | Mongolian digits |
| mroo | Mro digits |
| mtei | Meetei Mayek digits |
| mymr | Myanmar digits |
| mymrshan | Myanmar Shan digits |
| mymrtlng | Myanmar Tai Laing digits |
| native | ネイティブの数字 |
| newa | Newa digits |
| nkoo | N'Ko digits |
| olck | Ol Chiki digits |
| orya | Oriya digits |
| osma | Osmanya digits |
| rohg | Hanifi Rohingya digits |
| roman | 大文字のローマ数字 — アルゴリズム |
| romanlow | 小文字のローマ数字 — アルゴリズム |
| saur | Saurashtra digits |
| shrd | Sharada digits |
| sind | Khudawadi digits |
| sinh | Sinhala Lith digits |
| sora | Sora\_Sompeng digits |
| sund | Sundanese digits |
| takr | Takri digits |
| talu | New Tai Lue digits |
| taml | タミル数字 — アルゴリズム |
| tamldec | Modern Tamil decimal digits |
| telu | Telugu digits |
| thai | Thai digits |
| tirh | Tirhuta digits |
| tibt | Tibetan digits |
| traditio | 伝統的な数字 — アルゴリズムの場合あり |
| vaii | Vai digits |
| wara | Warang Citi digits |
| wcho | Wancho digits |

例
-

### ロケール文字列から `numberingSystem` の値を受け取る

Unicode ロケール文字列仕様書では、 `numberingSystem` が表す値はキー `nu` に対応しています。 `nu` はロケール文字列の「拡張サブタグ」とみなされます。これらのサブタグは、ロケールに関する追加データを追加するもので、拡張キー `-u` を使用してロケール識別子に追加されます。このようして、 `numberingSystem` の値を `Locale` コンストラクターに渡される初期のロケール識別子文字列に追加することができます。 `numeric` の値を設定するには、まず文字列に `-u` 拡張キーを追加します。次に、 `-nu` 拡張キーを追加して、 `numberingSystem` の値を追加していることを示します。最後に、文字列に `numberingSystem` の値を追加します。

指定された `Locale` が対応する命数法の一覧を出力します。

```js
let arEG = new Intl.Locale("ar-EG");
console.log(arEG.numberingSystems); // logs ["arab"]
```

```js
let ja = new Intl.Locale("ja");
console.log(ja.numberingSystems); // logs ["latn"]
```

仕様書
---

| Specification |
| --- |
| Intl Locale Info Proposal # sec-Intl.Locale.prototype.getNumberingSystems |

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

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

関連情報
----

* `Intl.Locale`
* 標準 Unicode 命数法の詳細


Intl.Locale.prototype.weekInfo - JavaScript

Intl.Locale.prototype.weekInfo
==============================

**`Intl.Locale.prototype.weekInfo`** プロパティはアクセサープロパティで、関連する `Locale` の `firstDay`, `weekend`, `minimalDays` プロパティを持つ `weekInfo` オブジェクトを返します。

解説
--

UTS 35's Week Elements で指定されたロケールデータに関連する `Locale` 情報を返します。

例
-

### 週情報の取得

指定された `Locale` の週情報を返します。

```js
let he = new Intl.Locale("he");
console.log(he.weekInfo); // logs {firstDay: 7, weekend: [5, 6], minimalDays: 1}

let af = new Intl.Locale("af");
console.log(af.weekInfo); // logs {firstDay: 7, weekend: [6, 7], minimalDays: 1}

let enGB = new Intl.Locale("en-GB");
console.log(enGB.weekInfo); // logs {firstDay: 1, weekend: [6, 7], minimalDays: 4}

let msBN = new Intl.Locale("ms-BN");
console.log(msBN.weekInfo); // logs {firstDay: 7, weekend: [5, 7], minimalDays: 1} // ブルネイでは週末は金曜日と日曜日ですが、土曜日ではありません
```

仕様書
---

| Specification |
| --- |
| Intl Locale Info Proposal # sec-Intl.Locale.prototype.getWeekInfo |

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

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

関連情報
----

* `Intl.Locale`


Intl.Locale.prototype.numeric - JavaScript

Intl.Locale.prototype.numeric
=============================

**`Intl.Locale.prototype.numeric`** プロパティは、ロケールが特別な数字の照合処理を行うかどうかを返すアクセサープロパティです。

解説
--

`Intl.Locale.caseFirst` と同様、 `numeric` はロケールが使用する照合規則を変更するものです。 `numeric` は論理値で、 `true` か `false` のどちらかになります。 `numeric` を `false` に設定した場合は、文字列内の数値を特別に扱うことはありません。 `numeric` を `true` に設定した場合は、ロケールは文字列を照合する際に数値を考慮します。この数値の特別な扱いとは、数字の並びを数値として比較するということです。例えば、 "A-21" という文字列は "A-123" よりも小さいとみなされます。

例
-

### ロケール文字列から `numeric` の値を設定

Unicode ロケール文字列仕様書では、 `numeric` が表す値はキー `kn` に対応しています。 `kn` はロケール文字列の「拡張サブタグ」とみなされます。これらのサブタグは、ロケールに関する追加データを追加するもので、拡張キー `-u` を使用してロケール識別子に追加されます。このようして、 `numeric` の値を `Locale` コンストラクターに渡される初期のロケール識別子文字列に追加することができます。 `numeric` の値を設定するには、まず文字列に `-u` 拡張キーを追加します。次に、 `-kn` 拡張キーを追加して、 `numeric` の値を追加していることを示します。最後に、文字列に `numeric` の値を追加します。 `numeric` を `true` に設定したい場合は、単に `kn` キーを追加するだけで十分です。値を `false` にするには、 `kn` キーの後に "`false`" を指定する必要があります。

```js
let locale = new Intl.Locale("fr-Latn-FR-u-kn-false");
console.log(locale.numeric); // "false" と表示
```

### 構成オブジェクト引数から `numeric` の値を設定

`Intl.Locale` コンストラクターには、オプションで構成オブジェクトの引数があり、これを使用して拡張の種類を渡すことができます。構成オブジェクトの `numeric` プロパティを任意の `numeric` に設定し、コンストラクターに渡します。

```js
let locale = new Intl.Locale("en-Latn-US", { numeric: true });
console.log(locale.numeric); // "true" と表示
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.Locale.prototype.numeric |

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

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

関連情報
----

* `Intl.Locale`


Intl.Locale.prototype.collation - JavaScript

Intl.Locale.prototype.collation
===============================

**`Intl.Locale.prototype.collation`** プロパティは、 `Locale` の照合種別を返すアクセサープロパティです。

解説
--

照合順序とは、文字列を順番に並べる処理のことです。検索クエリーの結果やデータベース内のレコードの順序など、文字列を一定の順序に並べ替える必要がある場合に使用されます。文字列を順番に並べるという考えは些細なことと思えるかもしれませんが、順番の考え方は地域や言語によって異なる場合があります。 `collation` プロパティは、 JavaScript プログラマーが特定のロケールで使用される照合順序の種類に簡単にアクセスできるようにするためのものです。

利用可能な照合種別は下記の表にあります。 Unicode 照合仕様書から引用したものです。

有効な照合種別
-------

| 照合種別 | 説明 |
| --- | --- |
| big5han | ラテン文字はピンイン順、漢字は big5 文字セット順（中国語向け）

**注:** `big5han` 照合種別は Chrome や Edge では使用できません。
 |
| compat | 前の版の順序で、互換性のため（アラビア語向け） |
| dict | 辞書形式の順序（シンハラ語向け） |
|
**警告:** `direct` 照合種別は非推奨です。使用しないでください。

direct | バイナリコードポイント順 |
| ducet | 既定の Unicode 照合順で、要素表順

**警告:** `ducet` 照合種別はウェブでは利用できません。代わりに `und` ロケールを照合種別指定子なしで使用してください。 `und` は DUCET に最も近い照合種別です。
 |
| emoji | 絵文字に推奨される順序（`und` ロケール向け） |
| eor | ヨーロッパ語の順序の規則（`und` ロケール向け） |
| gb2312 | ラテン文字はピンイン順、漢字は gb2312han 文字セット順（中国語向け）

**注:** `gb2313` 照合種別は Chrome や Edge では使用できません。
 |
| phonebk | 電話帳形式の順序（ドイツ語向け） |
| phonetic | 発音順（発音に基づく順序、リンガラ語向け） |
| pinyin | ラテン文字と漢字はピンイン順（中国語向け） |
| reformed | リフォーム順（スウェーデン語向け）

**注:** これは、 2022 年 5 月現在、スウェーデン語の既定の順序ですが、照合順序の名前が異常です。これは既定値なので、 `sv-u-co-reformed` をリクエストするのではなく、 `sv` をリクエストしてください。
 |
| search | 文字列検索のための特殊な照合種別

**警告:** 使用しないでください。 `Intl.Collator` ではこの照合種別は `usage` オプションで `search` の値を設定すると有効になります。
 さらに、この照合を検索で使用する API は今のところありません。

 |
| searchjl | 韓国語の頭文字子音検索用の特殊な照合種別 |
| standard | 各言語の既定の照合順。ただし、中国語と、 2022 年 5 月時点ではスウェーデン語を除きます。

**警告:** 明示的に使用しないでください。一般に、明示的に指定する必要はありません。また、スウェーデン語に対してこれを指定すると、将来、スウェーデン語の照合順序の命名が他の言語と整合するように変更された場合に問題があります。
 |
| stroke | ラテン文字はピンイン順、漢字は画数順（中国語向け） |
| trad | 歴史的なスタイルの順序（スペイン語など） |
| unihan |
 漢字の部首の画数順（中国語、日本語、韓国語向け）。
 中国語の場合はラテン文字はピンイン順。

**注:** `unihan` 照合種別は Chrome や Edge では使用できません。
 |
| zhuyin | ラテン語はピンイン順、ボポモフォと漢字は竹簡順（中国語向け） |

例
-

他のロケールのサブタグと同様、照合種別はロケール文字列やコンストラクターの構成オブジェクトの引数で `Intl.Locale` オブジェクトに追加することができます。

### ロケール文字列による照合種別の追加

Unicode ロケール文字列仕様書では、照合種別はロケールキーの「拡張子サブタグ」となります。これらのサブタグは、ロケールに関するデータを追加するもので、 `-u` 拡張を使用してロケール識別子に追加されます。つまり、照合種別は、ロケールのコンストラクターに渡される初期のロケール識別子文字列に追加することができます。照合種別を追加するには、まず文字列に `-u` 拡張を追加します。次に、照合順序の型を追加することを示すために `-co` 拡張を追加します。最後に、照合順序を文字列に追加します。

```js
let locale = new Intl.Locale("zh-Hant-u-co-zhuyin");
console.log(locale.collation); // "zhuyin" と表示
```

### 構成オブジェクト引数による照合種別の追加

`Intl.Locale` コンストラクターには、オプションで構成オブジェクトの引数があり、これには照合種別を含む任意の拡張の種類をいくつか含めることができます。構成オブジェクトの `collation` プロパティを任意の照合種別に設定し、コンストラクターに渡します。

```js
let locale = new Intl.Locale("zh-Hant", { collation: "zhuyin" });
console.log(locale.collation); // "zhuyin" と表示
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.Locale.prototype.collation |

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

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

関連情報
----

* `Intl.Locale`


Intl.Locale.prototype.region - JavaScript

Intl.Locale.prototype.region
============================

**`Intl.Locale.prototype.region`** プロパティは、ロケールに関連付けられた世界の地域（ふつうは国）を返すアクセサープロパティです。

解説
--

地域は、ロケールを世界の特定の地域に位置づけるための、ロケール識別子の重要な要素となります。ロケールの地域を知ることは、ロケール間の違いを識別する上で非常に重要です。たとえば、イギリスとアメリカ合衆国では英語が使われていますが、両国間では綴りやその他の言語の慣習に違いがあります。ロケールの地域を知ることで、 JavaScript プログラマーがサイトやアプリケーションのコンテンツを世界の様々な地域から見たときに正しく表示されるようにするのに役立ちます。

例
-

### ロケール識別子の文字列引数で地域を設定

地域は、有効な Unicode 言語識別子文字列の 3 番目の部分であり、これを `Locale` コンストラクターに渡すロケール識別子文字列に追加することで設定することができます。なお、地域はロケール識別子の必須項目ではありません。

```js
let locale = new Intl.Locale("en-Latn-US");
console.log(locale.region); // "US" と表示
```

### 構成オブジェクトから地域を設定

`Locale` コンストラクターは構成オブジェクトを取り、これを用いて地域のサブタグとプロパティを設定することができます。

```js
let locale = new Intl.Locale("ja-Jpan", { region: "JP" });
console.log(locale.region); // "JP" と表示
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.Locale.prototype.region |

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

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

関連情報
----

* `Intl.Locale`
* Unicode 地域一覧表


Intl.Locale.prototype.caseFirst - JavaScript

Intl.Locale.prototype.caseFirst
===============================

**`Intl.Locale.prototype.caseFirst`** プロパティは、ロケールの照合規則に大文字小文字を考慮するかどうかを返すアクセサープロパティです。

解説
--

ロケールの照合規則は、そのロケールでの文字列の並び順を決定するために用いられます。ロケールによっては、照合処理で文字の大文字小文字を使用する場合があります。この追加ルールは、 `Locale` の `caseFirst` プロパティで表現することができます。

`caseFirst` プロパティには下記の表にある通り、 3 種類の値を指定することができます。

### `caseFirst` の値

| 値 | 説明 |
| --- | --- |
| `upper` | 大文字が小文字よりも前に並べられます。 |
| `lower` | 小文字が大文字よりも前に並べられます。 |
| `false` | 大文字と小文字で特別な並べ替えはしません。 |

例
-

### ロケール文字列による `caseFirst` 値の設定

Unicode ロケール文字列仕様書では、 `caseFirst` が表す値は `kf` キーに対応します。 `kf` はロケール文字列の「拡張子サブタグ」として扱われます。これらのサブタグは、ロケールに関するデータを追加するもので、 `-u` 拡張を使用してロケール識別子に追加されます。つまり、 `caseFirst` の値は、 `Locale` コンストラクターに渡される初期のロケール識別子文字列に追加することができます。 `caseFirst` の値を追加するには、まず文字列に `-u` 拡張キーを追加します。次に、照合順序の型を追加することを示すために `-kf` 拡張キーを追加します。最後に、 `caseFirst` の値を文字列に追加します。

```js
let locale = new Intl.Locale("fr-Latn-FR-u-kf-upper");
console.log(locale.caseFirst); // "upper" と表示
```

### 構成オブジェクト引数による caseFirst の値の設定

`Intl.Locale` コンストラクターには、オプションで構成オブジェクトの引数があり、拡張の種類を渡すために使用することができます。構成オブジェクトの `caseFirst` プロパティを望みの `caseFirst` の値に設定し、コンストラクターに渡します。

```js
let locale = new Intl.Locale("en-Latn-US", { caseFirst: "lower" });
console.log(locale.caseFirst); // "lower" と表示
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.Locale.prototype.caseFirst |

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

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

関連情報
----

* `Intl.Locale`
* Unicode case first collation spec


Intl.Locale.prototype.toString() - JavaScript

Intl.Locale.prototype.toString()
================================

**`Intl.Locale.prototype.toString()`** は、このロケールの完全なロケール識別子文字列を返します。

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

構文
--

```js
toString();
```

### 返値

この*ロケール*の Unicode ロケール識別子文字列です。

解説
--

`Locale` オブジェクトは、概念的な Unicode ロケール識別子を JavaScript で表現したものです。特定のロケールに関する情報 (言語、文字体系、カレンダーの種類など) を、ロケール識別子文字列で符号化することができます。これらのロケール識別子をより簡単に扱えるようにするために、 `Locale` オブジェクトが JavaScript に導入されました。 Locale オブジェクトの `toString` メソッドをコールすると、そのロケールの識別子文字列を返します。 `toString` メソッドを使用すると、 `Locale` のインスタンスが既存の `Intl` のコンストラクターへの引数ととして JSON におけるシリアライズにおいて、またはその他のコンテキストで正確な文字列表現が有用な場合に提供することができます。

例
-

### toString の使用

```js
let myLocale = new Intl.Locale("ja-Jpan-JP", {
  hourCycle: "h24",
  calendar: "gregory",
});
console.log(myLocale.baseName); // "ja-Jpan-JP" と表示
console.log(myLocale.toString()); // "ja-Jpan-JP-u-ca-gregory-hc-h24" と表示
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.Locale.prototype.toString |

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

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

関連情報
----

* `Intl.Locale`
* `Intl.Locale.baseName`


Intl.Locale.prototype.calendar - JavaScript

Intl.Locale.prototype.calendar
==============================

**`Intl.Locale.prototype.calendar`** プロパティは、 `Locale` で使用される暦の種類を返すアクセサープロパティです。

解説
--

`calendar` プロパティは `Locale` の一部、 `Locale` の暦を示す部分を返します。世界の大部分はグレゴリオ暦を使用していますが、世界各地で使用されている地域暦もいくつかあります。以下の表に、有効な Unicode 暦キー文字列をすべて示します。

### Unicode 暦キー

`buddhist`

タイの仏教暦

`chinese`

古来の中国の暦

`coptic`

コプト暦

`dangi`

古来の韓国の暦

`ethioaa`

Ethiopic calendar, Amete Alem (epoch approx. 5493 B.C.E)

`ethiopic`

Ethiopic calendar, Amete Mihret (epoch approx, 8 C.E.)

`gregory`

グレゴリオ暦

`hebrew`

古来のヘブライ暦

`indian`

インド暦

`islamic`

イスラム暦

`islamic-umalqura`

イスラム暦、ウンムアルクーラ

`islamic-tbla`

イスラム暦、表形式 (閏年 [2,5,7,10,13,16,18,21,24,26,29] - 天体暦)

`islamic-civil`

イスラム暦、表形式 (閏年 [2,5,7,10,13,16,18,21,24,26,29] - 市民暦)

`islamic-rgsa`

イスラム暦、サウジアラビア地方

`iso8601`

ISO カレンダー (ISO 8601 カレンダーの曜日規則を使用したグレゴリオ暦)

`japanese`

日本の皇紀

`persian`

ペルシャ暦

`roc`

中華民国暦 (中華民国)

`islamicc`

シビル（アルゴリズム）アラビア暦

**警告:** `islamicc` 暦は非推奨です。 `islamic-civil` を使用してください。

例
-

ロケール文字列へのカレンダーの追加
-----------------

暦は、ロケールキーの「拡張キー」に該当します。これらのキーは、ロケールに関するデータを追加するもので、拡張子 `-u` を使用してロケール識別子に追加します。したがって、 `Intl.Locale` コンストラクターに渡される初期のロケール識別子文字列に暦の種類を追加することができます。暦の種類を追加するには、まず文字列に `-u` 拡張を追加します。次に、暦の種類を追加することを示すために `-ca` 拡張を追加します。最後に、暦を文字列に追加します。

```js
let locale = new Intl.Locale("fr-FR-u-ca-buddhist");
console.log(locale.calendar); // "buddhist" と表示
```

### 構成オブジェクトによる暦の追加

`Intl.Locale` コンストラクターには、オプションで構成オブジェクトの引数があり、カレンダーを含めた拡張の種類を渡すために使用することができます。構成オブジェクトの `calendar` プロパティを望みの暦の値に設定し、コンストラクターに渡します。

```js
let locale = new Intl.Locale("fr-FR", { calendar: "buddhist" });
console.log(locale.calendar); // "buddhist" と表示
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.Locale.prototype.calendar |

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

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

関連情報
----

* `Intl.Locale`
* Unicode 暦識別子


Intl.Locale.prototype.script - JavaScript

Intl.Locale.prototype.script
============================

**`Intl.Locale.prototype.script`** プロパティは、ロケールで使われている特定の言語を書くための文字体系を返すアクセサープロパティです。

解説
--

文字体系は、用字系と呼ばれることもありますが、ロケールの核となる属性の一つです。これは、特定の言語を書くために使用される記号やグリフの集合を示しています。例えば、英語の文字はラテン文字ですが、韓国語の文字はハングルです。多くの場合、言語（これは必須）は単一の文字体系でしか書かれないので、文字体系を記述することは厳密には必要ありません。この規則には例外があり、完全な Unicode 言語識別子を持つためには、可能な限り文字体系を示すことが重要です。

例
-

### ロケール識別子の文字列引数で文字体系を設定

文字体系は、有効な Unicode 言語識別子文字列の 2 番目の部分であり、これを `Locale` コンストラクターに渡すロケール識別子文字列に追加することで設定することができます。なお、文字体系はロケール識別子の必須項目ではありません。

```js
let locale = new Intl.Locale("en-Latn-US");
console.log(locale.script); // "Latn" と表示
```

### 構成オブジェクトから文字体系を設定

`Locale` コンストラクターは構成オブジェクトを取り、これを用いて文字体系のサブタグとプロパティを設定することができます。

```js
let locale = new Intl.Locale("ja-JP", { script: "Jpan" });
console.log(locale.script); // "Jpan" と表示
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.Locale.prototype.script |

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

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

関連情報
----

* `Intl.Locale`
* Unicode の文字体系サブタグ仕様書


Intl.Locale.prototype.baseName - JavaScript

Intl.Locale.prototype.baseName
==============================

**`Intl.Locale.prototype.baseName`** プロパティは、 `Locale` の文字列表現の部分文字列を返し、そこには `Locale` についての中核情報が含まれています。

解説
--

`Intl.Locale` オブジェクトは、解析されたロケールとそのロケールのオプションを表します。 `baseName` プロパティは、ロケールに関する基本的な情報を、完全なデータ文字列の部分文字列の形で返します。具体的には、このプロパティは言語を含む部分文字列を返し、文字体系や地域があればそれも返します。

`baseName` は `言語 ["-" 文字体系] ["-" 地域] *("-" variant)` の形で unicode\_language\_id 構文の部分文字列を返します。

例
-

### 基本的な例

```js
let myLoc = new Intl.Locale("fr-Latn-CA"); // ロケールをカナダのフランス語に設定
console.log(myLoc.toString()); // "fr-Latn-CA-u-ca-gregory" と表示
console.log(myLoc.baseName); // "fr-Latn-CA" と表示
```

### 入力文字列のオプション付きの例

```js
// 言語を日本語、地域を日本に設定する。

// カレンダーをグレゴリオ暦、時制を 24 時制にする
let japan = new Intl.Locale("ja-JP-u-ca-gregory-hc-24");
console.log(japan.toString()); // "ja-JP-u-ca-gregory-hc-h24" と表示
console.log(japan.baseName); // "ja-JP" と表示
```

### 入力文字列を上書きするオプション付きの例

```js
// 入力文字列は言語がオランダ語、地域がベルギーであることを示していますが、

// ただし、オプションオブジェクトで地域を上書きしており、オランダに設定しています
let dutch = new Intl.Locale("nl-Latn-BE", { region: "NL" });

console.log(dutch.baseName); // "nl-Latn-NL" と表示
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.Locale.prototype.baseName |

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

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

関連情報
----

* `Intl.Locale`


Intl.Locale.prototype.numberingSystem - JavaScript

Intl.Locale.prototype.numberingSystem
=====================================

**`Intl.Locale.prototype.numberingSystem`** プロパティは、ロケールが使用する命数法を返すアクセサープロパティです。

解説
--

命数法とは、数値を表現するための体系のことです。 `numberingSystem` プロパティは、世界中のさまざまな国、地域、文化で使用されているさまざまな命数法を表現する支援をします。ほとんどの国際化スキーマと同様に、 `Locale` オブジェクトで `numberingSystem` によって表現できる命数法は、 Unicode で標準化されています。標準的な Unicode の命数法の表を以下に示します。

| 値 | 説明 |
| --- | --- |
| adlm | アドラム数字 |
| ahom | アコム数字 |
| arab | アラビア・インド数字 |
| arabext | 拡張アラビア・インド数字 |
| armn | 大文字のアルメニア数字 — アルゴリズム |
| armnlow | 小文字のアルメニア数字 — アルゴリズム |
| bali | Balinese digits |
| beng | Bengali digits |
| bhks | Bhaiksuki digits |
| brah | Brahmi digits |
| cakm | Chakma digits |
| cham | Cham digits |
| cyrl | キリル数字 — アルゴリズム |
| deva | Devanagari digits |
| ethi | エチオピア数字 — アルゴリズム |
| finance | 金融数字 — アルゴリズムの場合あり |
| fullwide | 全角数字 |
| geor | ジョージア数字 — アルゴリズム |
| gong | Gunjala Gondi digits |
| gonm | Masaram Gondi digits |
| grek | 大文字のギリシャ数字 — アルゴリズム |
| greklow | 小文字のギリシャ数字 — アルゴリズム |
| gujr | Gujarati digits |
| guru | Gurmukhi digits |
| hanidays | 太陰暦またはその他の旧暦向けの漢字による日付の数字 |
| hanidec | 漢数字表意文字による位置決め十進法 |
| hans | 簡体字の漢数字 — アルゴリズム |
| hansfin | 簡体字の金融用漢数字 — アルゴリズム |
| hant | 繁体字の漢数字 — アルゴリズム |
| hantfin | 繁体字の金融用漢数字 — アルゴリズム |
| hebr | ヘブライ数字 — アルゴリズム |
| hmng | Pahawh Hmong digits |
| hmnp | Nyiakeng Puachue Hmong digits |
| java | Javanese digits |
| jpan | 日本語の漢数字 — アルゴリズム |
| jpanfin | 日本語の金融用漢数字 — アルゴリズム |
| jpanyear | 最初の年を元年とした日本の暦用の命数法 |
| kali | Kayah Li digits |
| khmr | Khmer digits |
| knda | Kannada digits |
| lana | Tai Tham Hora (secular) digits |
| lanatham | Tai Tham (ecclesiastical) digits |
| laoo | Lao digits |
| latn | ラテン数字 |
| lepc | Lepcha digits |
| limb | Limbu digits |
| mathbold | 数学的太数字 |
| mathdbl | 数学的二重打鍵の数字 |
| mathmono | 数学的等幅数字 |
| mathsanb | 数学的三セリフ太字数字 |
| mathsans | 数学的サンセリフ数字 |
| mlym | Malayalam digits |
| modi | Modi digits |
| mong | Mongolian digits |
| mroo | Mro digits |
| mtei | Meetei Mayek digits |
| mymr | Myanmar digits |
| mymrshan | Myanmar Shan digits |
| mymrtlng | Myanmar Tai Laing digits |
| native | ネイティブの数字 |
| newa | Newa digits |
| nkoo | N'Ko digits |
| olck | Ol Chiki digits |
| orya | Oriya digits |
| osma | Osmanya digits |
| rohg | Hanifi Rohingya digits |
| roman | 大文字のローマ数字 — アルゴリズム |
| romanlow | 小文字のローマ数字 — アルゴリズム |
| saur | Saurashtra digits |
| shrd | Sharada digits |
| sind | Khudawadi digits |
| sinh | Sinhala Lith digits |
| sora | Sora\_Sompeng digits |
| sund | Sundanese digits |
| takr | Takri digits |
| talu | New Tai Lue digits |
| taml | タミル数字 — アルゴリズム |
| tamldec | Modern Tamil decimal digits |
| telu | Telugu digits |
| thai | Thai digits |
| tirh | Tirhuta digits |
| tibt | Tibetan digits |
| traditio | 伝統的な数字 — アルゴリズムの場合あり |
| vaii | Vai digits |
| wara | Warang Citi digits |
| wcho | Wancho digits |

例
-

### ロケール文字列から `numberingSystem` の値を設定

Unicode ロケール文字列仕様書では、 `numberingSystem` が表す値はキー `nu` に対応しています。 `nu` はロケール文字列の「拡張サブタグ」とみなされます。これらのサブタグは、ロケールに関する追加データを追加するもので、拡張キー `-u` を使用してロケール識別子に追加されます。このようして、 `numberingSystem` の値を `Locale` コンストラクターに渡される初期のロケール識別子文字列に追加することができます。 `numeric` の値を設定するには、まず文字列に `-u` 拡張キーを追加します。次に、 `-nu` 拡張キーを追加して、 `numberingSystem` の値を追加していることを示します。最後に、文字列に `numberingSystem` の値を追加します。

```js
let locale = new Intl.Locale("fr-Latn-FR-u-nu-mong");
console.log(locale.numberingSystem); // "mong" と表示
```

### 構成オブジェクト引数から `numberingSystem` の値を設定

`Intl.Locale` コンストラクターには、オプションで構成オブジェクトの引数があり、これを使用して拡張の種類を渡すことができます。構成オブジェクトの `numberingSystem` プロパティを任意の `numberingSystem` に設定し、コンストラクターに渡します。

```js
let locale = new Intl.Locale("en-Latn-US", { numberingSystem: "latn" });
console.log(locale.numberingSystem); // "latn" と表示
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.Locale.prototype.numberingSystem |

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

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

関連情報
----

* `Intl.Locale`
* 標準 Unicode 命数法の詳細


Uint8Array() コンストラクター - JavaScript

Uint8Array() コンストラクター
=====================

**`Uint8Array()`** は型付き配列のコンストラクターで、 8 ビット符号なし整数値の配列を生成します。中身は `0` で初期化されます。生成されると、配列の中の要素はオブジェクトのメソッドを使用するか、配列の標準的な添字の構文を使用するか (すなわち、ブラケット構文を使用するか) して参照することができます。

構文
--
```

new Uint8Array(); // new in ES2017
new Uint8Array(length);
new Uint8Array(typedArray);
new Uint8Array(object);
new Uint8Array(buffer [, byteOffset [, length]]);
```

### 引数

`length`

`length` 引数付きで呼び出されると、メモリ内に内部的な配列バッファーを作成し、大きさは `length` *を `BYTES_PER_ELEMENT`* で乗じたバイト数になり、ゼロになることもあります。

`typedArray`

`typedArray` 引数付きで呼び出されると、これはあらゆる型付き配列型 (例えば `Int32Array`) にすることができますが、 `typedArray` を新しい型付き配列にコピーします。 `typedArray` の中のそれぞれの値は、新しい配列にコピーされる前にコンストラクターの対応する型に変換されます。新しい型付き配列の長さは `typedArray` 引数の長さと同じになります。

`object`

`object` 引数付きで呼び出されると、あたかも `TypedArray.from()` メソッドであるかのように新しい型付き配列が生成されます。

`buffer`, `byteOffset`, `length`

`buffer` と、オプションで `byteOffset` と `length` 引数を指定して呼び出されると、指定された `ArrayBuffer` を表示する型付き配列ビューが生成されます。 `byteOffset` および `length` 引数は、型付き配列ビューが表示するメモリ範囲を指定する。 両方を省略した場合は `buffer` の全てを表示し、 `length` のみを省略した場合は `buffer` の残りを表示します。

例
-

### 様々な方法による Uint8Array の生成

```js
// 長さを指定
var uint8 = new Uint8Array(2);
uint8[0] = 42;
console.log(uint8[0]); // 42
console.log(uint8.length); // 2
console.log(uint8.BYTES\_PER\_ELEMENT); // 1

// 配列から
var arr = new Uint8Array([21, 31]);
console.log(arr[1]); // 31

// 他の型付き配列から
var x = new Uint8Array([21, 31]);
var y = new Uint8Array(x);
console.log(y[0]); // 21

// ArrayBuffer から
var buffer = new ArrayBuffer(8);
var z = new Uint8Array(buffer, 1, 4);

// 反復可能オブジェクトから
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var uint8 = new Uint8Array(iterable);
// Uint8Array[1, 2, 3]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-typedarray-constructors |

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

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

### 互換性メモ

ECMAScript 2015 から、 `Uint8Array` コンストラクターは構築に `new` 演算子が必要になりました。 `Uint8Array` コンストラクターを `new` なしで関数として呼び出すと、 `TypeError` が発生するようになりました。

```js
var dv = Uint8Array([1, 2, 3]);
// TypeError: calling a builtin Uint8Array constructor
// without new is forbidden
```

```js
var dv = new Uint8Array([1, 2, 3]);
```

関連情報
----

* JavaScript 型付き配列
* `ArrayBuffer`
* `DataView`


get SharedArrayBuffer[@@species] - JavaScript

get SharedArrayBuffer[@@species]
================================

**`SharedArrayBuffer[@@species]`** アクセサープロパティは、`SharedArrayBuffer` の各メソッドから返される値を作成するために使用されるコンストラクター（種）を返します。

**警告:** `@@species` が存在すると、任意のコードの実行が可能になり、セキュリティ上の脆弱性が生じる可能性があります。また、ある種の最適化も非常に難しくなります。エンジンの実装者たちは、この機能を削除するかどうか調査しています。可能であれば、この機能に頼ることは避けてください。

構文
--

```js
SharedArrayBuffer[Symbol.species]
```

### 返値

`get @@species` が呼び出されたコンストラクター (`this`) の値です。この返値は、新しい配列バッファーを作成するための配列バッファーのメソッドから返される値を構成するために使用されます。

解説
--

`@@species` アクセサープロパティは `SharedArrayBuffer` オブジェクトの既定のコンストラクターを返します。サブクラスのコンストラクターはこれを上書きして、コンストラクターの割り当てを変更することができます。既定の実装では、基本的に次のようになります。

```js
// 説明のための仮想的な基礎実装
class SharedArrayBuffer {
  static get [Symbol.species]() {
    return this;
  }
}
```

この多態的な実装のため、派生したサブクラスの `@@species` も既定でコンストラクター自身を返すことになります。

```js
class SubArrayBuffer extends SharedArrayBuffer {}
SubArrayBuffer[Symbol.species] === SharedArrayBuffer; // true
```

既存の配列を変更せず、新しい配列バッファーのインスタンスを返す配列バッファーのメソッド（例えば `slice()`）を呼び出すと、その配列の `constructor[@@species]` にアクセスすることになります。返されたコンストラクターは配列バッファーメソッドの返値を構築するために使用されます。

例
-

### 通常のオブジェクトにおける種

`@@species` プロパティは、既定のコンストラクター関数、つまり `SharedArrayBuffer` であれば `SharedArrayBuffer` コンストラクターが返されます。

```js
SharedArrayBuffer[Symbol.species]; // function SharedArrayBuffer()
```

### 派生オブジェクトにおける種

独自の `SharedArrayBuffer` サブクラスのインスタンス、例えば `MySharedArrayBuffer` では、その `MySharedArrayBuffer` の種は `MySharedArrayBuffer` コンストラクターになります。しかし、派生クラスのメソッドで親の `SharedArrayBuffer` オブジェクトを返すために、これを上書きしたいと思うかもしれません。

```js
class MySharedArrayBuffer extends SharedArrayBuffer {
  // 種を MySharedArrayBuffer から親である SharedArrayBuffer コンストラクターで上書きする。
  static get [Symbol.species]() {
    return SharedArrayBuffer;
  }
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-sharedarraybuffer-@@species |

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

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

関連情報
----

* `SharedArrayBuffer`
* `Symbol.species`


SharedArrayBuffer() コンストラクター - JavaScript

SharedArrayBuffer() コンストラクター
============================

**メモ:** `SharedArrayBuffer` は、 2018 年 1 月 5 日に Spectre への対策として、すべての主要ブラウザーで既定で無効化されました。 Chrome は、 Spectre スタイルの脆弱性から保護するためにサイトアイソレーション機能が有効になっているプラットフォームでは、 v67 で再有効化しました。

**`SharedArrayBuffer()` コンストラクター**は `SharedArrayBuffer` オブジェクトを生成し、これは `ArrayBuffer` オブジェクトと似た、汎用的な、固定長の生のバイナリーデータバッファーを表します。

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

構文
--

```js
new SharedArrayBuffer();
new SharedArrayBuffer(length);
```

### 引数

`length` 省略可

生成する配列バッファーの長さをバイト数で指定します。

### 返値

指定された長さの新しい `SharedArrayBuffer` オブジェクトです。中身は 0 で初期化されます。

例
-

### SharedArrayBuffer を生成するには常に new 演算子を使用する

`SharedArrayBuffer` コンストラクターは `new` 演算子で構築する必要があります。 `SharedArrayBuffer` コンストラクターを `new` なしで呼び出すと、 `TypeError` が発生します。

```js
var sab = SharedArrayBuffer(1024);
// TypeError: calling a builtin SharedArrayBuffer constructor
// new がない形は禁止されています
```

```js
var sab = new SharedArrayBuffer(1024);
```

仕様書
---

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

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

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

関連情報
----

* `Atomics`
* `ArrayBuffer`
* JavaScript の型付き配列