recursal/MDN huggingface dataset:
DataView.prototype.byteOffset
=============================

**`byteOffset`** アクセサープロパティは、このビューの `ArrayBuffer` または `SharedArrayBuffer` の先頭からオフセットを表します。

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

解説
--

`byteOffset` プロパティは、設定アクセサー関数が `undefined` である、すなわち読み取りのみができるアクセサープロパティです。この値は `DataView` が構築されたときに確立され、変更することができません。

例
-

### byteOffset プロパティの使用


```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.byteOffset; // 0 (no offset specified)

var dataview2 = new DataView(buffer, 3);
dataview2.byteOffset; // 3 (as specified when constructing the DataView)
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-dataview.prototype.byteoffset |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`
* `SharedArrayBuffer`
DataView.prototype.setInt8()
============================

**`setInt8()`** メソッドは、符号付き 8 ビット整数 (byte) 値を `DataView` の指定されたバイト単位のオフセットの位置に格納します。

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

構文
--
```

dataview.setInt8(byteOffset, value)
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを格納する位置です。

`value`

設定する値です。

### 返値

`undefined`。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて格納するように設定されている場合に発生します。

例
-

### setInt8 メソッドの使用


```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.setInt8(1, 3);
dataview.getInt8(1); // 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.setint8 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`
WeakMap.prototype.has()
=======================

**`has()`** メソッドは、特定のキーをもつ要素が `WeakMap` オブジェクト内に存在するかどうかを示す真偽値を返します。

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

構文
--
```

ws.has(key);
```

### 引数

`key`

`WeakMap` オブジェクトに存在するかテストする要素のキーです。

### 返値

Boolean

`WeakMap` オブジェクト内に特定のキーをもつ要素が存在していたら `true` を返します。さもなければ `false` を返します。

例
-

### has() メソッドの使用


```js
var wm = new WeakMap();
wm.set(window, "foo");

wm.has(window); // true を返す
wm.has("baz"); // false を返す
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.has |

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

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

関連情報
----

* `WeakMap`
* `WeakMap.prototype.set()`
* `WeakMap.prototype.get()`
WeakMap.prototype.get()
=======================

**`get()`** メソッドは、`WeakMap` オブジェクトから指定された要素を返します。

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

構文
--
```

wm.get(key);
```

### 引数

`key`

必須。`WeakMap` オブジェクトから返す要素のキーです。

### 返値

指定されたキーと関連した要素を返します。キーが `WeakMap` オブジェクトに見つからない場合、 `undefined` を返します。

例
-

### get() メソッドの使用


```js
var wm = new WeakMap();
wm.set(window, "foo");

wm.get(window); // "foo" を返す
wm.get("baz"); // undefined を返す
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.get |

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

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

関連情報
----

* `WeakMap`
* `WeakMap.set()`
* `WeakMap.has()`
WeakMap.prototype.delete()
==========================

**`delete()`** メソッドは、 `WeakMap` オブジェクトから指定された要素を削除します。

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

構文
--
```

wm.delete(key);
```

### 引数

`key`

`WeakMap` オブジェクトから削除する要素のキーです。

### 返値

`WeakMap` オブジェクト内の要素を削除するのに成功した場合、`true` を返します。`WeakMap` 内でキーが見つからなかったり、キーがオブジェクトでなかったりした場合、`false` を返します。

例
-

### delete() メソッドの使用


```js
var wm = new WeakMap();
wm.set(window, "foo");

wm.delete(window); // true を返す。削除に成功。

wm.has(window); // false を返す。 window はもう WeakMap に存在しない。
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.delete |

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

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

関連情報
----

* `WeakMap`
WeakMap.prototype.set()
=======================

**`set()`** メソッドは、指定されたキーと値をもつ新しい要素を `WeakMap` オブジェクトへ追加します。

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

構文
--
```

wm.set(key, value);
```

### 引数

`key`

必須です。 `object` である必要があります。 `WeakMap` オブジェクトに追加する要素のキーです。

`value`

必須です。任意の値です。 `WeakMap` オブジェクトに追加する要素の値です。

### 返値

`WeakMap` オブジェクトです。

例
-

### set() メソッドの使用


```js
var wm = new WeakMap();
var obj = {};

// Add new elements to the WeakMap
wm.set(obj, "foo").set(window, "bar"); // chainable

// Update an element in the WeakMap
wm.set(obj, "baz");
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.set |

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

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

関連情報
----

* `WeakMap`
* `WeakMap.prototype.get()`
* `WeakMap.prototype.has()`
WeakMap() コンストラクター
==================

**`WeakMap()` コンストラクター**は、キーが弱く参照されている、キーと値の組のコレクションである `WeakMap` オブジェクトを生成します。キーはオブジェクトでなければならず、値は任意の値を指定することができます。

`WeakMap` については、キー付きコレクションの WeakMap オブジェクトの節を参照してください。

構文
--
```

new WeakMap([iterable])
```

### 引数

`iterable`

iterable は配列などの反復可能オブジェクトであり、その要素はキーと値の組 (2 要素の配列) となります。それぞれのキーと値の組は、新しい WeakMap に追加されます。 null は undefined として扱われます。

例
-

### WeakMap の使用


```js
const wm1 = new WeakMap(),
  wm2 = new WeakMap(),
  wm3 = new WeakMap();
const o1 = {},
  o2 = function () {},
  o3 = window;

wm1.set(o1, 37);
wm1.set(o2, "azerty");
wm2.set(o1, o2); // 値は何でもよく、オブジェクトでも関数でもよい
wm2.set(o3, undefined);
wm2.set(wm1, wm2); // キーと値はあらゆるオブジェクトになれる。 WeakMap も同様。

wm1.get(o2); // "azerty"
wm2.get(o2); // undefined、 o2 というキーが wm2 にないため
wm2.get(o3); // undefined、 設定された値がそうであるため

wm1.has(o2); // true
wm2.has(o2); // false
wm2.has(o3); // true (値自身が 'undefined' であっても)

wm3.set(o1, 37);
wm3.get(o1); // 37

wm1.has(o1); // true
wm1.delete(o1);
wm1.has(o1); // false
```

仕様書
---

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

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

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

関連情報
----

* `WeakMap` (JavaScript ガイド)
* Hiding Implementation Details with ECMAScript 6 WeakMaps
* `Map`
* `Set`
* `WeakSet`
Float64Array() コンストラクター
=======================

**`Float64Array()`** は型付き配列のコンストラクターで、新しい `Float64Array` オブジェクト、すなわち 64 ビット浮動小数点数 (C 言語の `double` データ型に相当) の配列をプラットフォームのバイトオーダーで生成します。バイトオーダーを制御する必要がある場合は、代わりに `DataView` を使用してください。生成後は、オブジェクトのメソッドや、標準の配列の添字構文 (すなわち角括弧表記) を用いて配列の要素を参照することができます。

構文
--
```

new Float64Array(); // new in ES2017
new Float64Array(length);
new Float64Array(typedArray);
new Float64Array(object);
new Float64Array(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` の残りがビューとなります。

例
-

### Float64Array を生成するための様々な方法


```js
// From a length
var float64 = new Float64Array(2);
float64[0] = 42;
console.log(float64[0]); // 42
console.log(float64.length); // 2
console.log(float64.BYTES\_PER\_ELEMENT); // 8

// From an array
var arr = new Float64Array([21, 31]);
console.log(arr[1]); // 31

// From another TypedArray
var x = new Float64Array([21, 31]);
var y = new Float64Array(x);
console.log(y[0]); // 21

// From an ArrayBuffer
var buffer = new ArrayBuffer(32);
var z = new Float64Array(buffer, 0, 4);

// From an iterable
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var float64 = new Float64Array(iterable);
// Float64Array[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 から、 `Float64Array` コンストラクターは `new` 演算子を使用して構築する必要があります。 `new` 演算子を使用せずに `Float64Array` コンストラクターを呼び出した場合、 `TypeError` が発生するようになりました。


```js
var dv = Float64Array([1, 2, 3]);
// TypeError: calling a builtin Float64Array constructor
// without new is forbidden
```



```js
var dv = new Float64Array([1, 2, 3]);
```

関連情報
----

* JavaScript typed arrays
* `ArrayBuffer`
* `DataView`
Function.arguments
==================

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

`***function*.arguments**` プロパティは、関数に渡される引数に対応する、配列風のオブジェクトです。より単純な `arguments` 変数を使用してください。このプロパティは厳格モードでは使用できません。

解説
--

`function.arguments` の構文は非推奨です。関数内で `arguments` オブジェクトにアクセスする方法としては、変数 `arguments` が利用できます。

再帰呼び出しの場合、すなわちコールスタックに関数 `f` が複数回現れる場合に、`f.arguments` はもっとも直近に実行された関数に対応する引数を表します。

実行中の関数の未処理の呼び出しがない (つまり、関数が呼び出された状態で返してない) 場合、 arguments プロパティの値は通常 null です。

例
-

### arguments オブジェクトの使用


```js
function f(n) {
  g(n - 1);
}

function g(n) {
  console.log("before: " + g.arguments[0]);
  if (n > 0) {
    f(n);
  }
  console.log("after: " + g.arguments[0]);
}

f(2);

console.log("returned: " + g.arguments);

// Output

// before: 1
// before: 0
// after: 0
// after: 1
// returned: null
```

仕様書
---

何れかの標準で定義されたものではありません。 ECMAScript 3 で `arguments` に置き換えられました。

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

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

関連情報
----

* `arguments` オブジェクト
* 関数と関数スコープ
Function.prototype.toString()
=============================

**`toString()`** メソッドは、関数のソースコードを表す文字列を返します。

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

構文
--
```

function.toString()
```

### 返値

関数のソースコードを表す文字列です。

解説
--

`Function` オブジェクトは、 `Object` から継承した `toString` メソッドをオーバーライドします。つまり、 `Object.prototype.toString` を継承しません。 `Function` オブジェクトについて、 `toString` メソッドは関数宣言を表現するオブジェクトを表す文字列を返します。

`Function` を文字列値として表現するとき、JavaScript は自動的に `toString` メソッドを呼び出します。例えば、関数が文字列と連結されるときです。

`this` 値のオブジェクトが `Function` オブジェクトでない場合、 `toString()` メソッドは `TypeError` 例外 ("Function.prototype.toString called on incompatible object") を発生します。


```js
Function.prototype.toString.call("foo"); // TypeError
```


`toString()` メソッドが組込み関数オブジェクトや `Function.prototype.bind` 作成された関数に対して呼び出されると、 `toString()` は、次のような*ネイティブ関数文字列*を返します。


```js
"function () {\n [native code]\n}";
```


`toString()` メソッドが `Function` コンストラクターで生成された関数に対して呼び出されると、 `toString()` は "anonymous" という名前の関数宣言に、提供された引数と関数の本体を合成したソースコードを返します。

`+` 演算子を使用して、関数の文字列表現を明示的に取得することもできます。


```js
function foo() {
  return "bar";
}
console.log(foo + ""); // "function foo() { return 'bar' }"
```

例
-

### 実際のソースコードと toString の結果との比較

| Function | Function.prototype.toString の結果 |
| --- | --- |
| 
```
function f(){}
```
 | 
```
"function f(){}"
```
 |
| 
```
class A { a(){} }
```
 | 
```
"class A { a(){} }"
```
 |
| 
```
function* g(){}
```
 | 
```
"function* g(){}"
```
 |
| 
```
a => a
```
 | 
```
"a => a"
```
 |
| 
```
({ a(){} }.a)
```
 | 
```
"a(){}"
```
 |
| 
```
({ *a(){} }.a)
```
 | 
```
"*a(){}"
```
 |
| 
```
({ [0](){} }[0])
```
 | 
```
"[0](){}"
```
 |
| 
```
Object.getOwnPropertyDescriptor({
    get a(){}
}, "a").get
```
 | 
```
"get a(){}"
```
 |
| 
```
Object.getOwnPropertyDescriptor({
    set a(x){}
}, "a").set
```
 | 
```
"set a(x){}"
```
 |
| 
```
Function.prototype.toString
```
 | 
```
"function toString() { [native code] }"
```
 |
| 
```
(function f(){}.bind(0))
```
 | 
```
"function () { [native code] }"
```
 |
| 
```
Function("a", "b")
```
 | 
```
"function anonymous(a\n) {\nb\n}"
```
 |

仕様書
---

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

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

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

関連情報
----

* `Object.prototype.toString()`
Function.length
===============

**`length`** プロパティは、関数が期待する引数の数を示します。

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

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

解説
--

`length` は function オブジェクトのプロパティであり、関数が期待する引数の数、つまり形式上の引数の数を示します。この数に残余引数 (en-US)は含まれず、既定値を持つ引数が最初に登場する前までしか含みません。これに対し、 `arguments.length` は関数のローカルスコープ内で用いられ、関数が実際に受け取った引数の数、つまり実引数の数を参照するのに用いるものです。

### Function コンストラクターのデータプロパティ

`Function` コンストラクター自体は、`Function` オブジェクトです。この `length` データプロパティの値は 1 です。プロパティの属性は、 Writable: `false`、Enumerable: `false`、Configurable: `true` です。

### Function プロトタイプのオブジェクトのプロパティ

`Function` プロトタイプオブジェクトの length プロパティの値は 0 です。

例
-

### 関数の length の使用


```js
console.log(Function.length); /\* 1 \*/

console.log(function () {}.length); /\* 0 \*/
console.log(function (a) {}.length); /\* 1 \*/
console.log(function (a, b) {}.length); /\* 2 etc. \*/

console.log(function (...args) {}.length);
// 0, rest parameter は数に含まれない

console.log(function (a, b = 1, c) {}.length);
// 1, 既定値を持つ引数が最初に登場する前までの
// 引数だけが数に含まれる
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-function-instances-length |

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

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

関連情報
----

* `Function`
Function.caller
===============

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

**`function.caller`** プロパティは、指定した関数の呼び出し元の関数を返します。厳格モード、非同期関数、ジェネレーター関数の呼び出し元については `null` を返します。

解説
--

関数 `f` が最上位のコードで呼び出された場合、 `f.caller` の値は `null` に、それ以外の場合の値は `f` を呼び出した関数になります。厳格モード、非同期関数、ジェネレーター関数の呼び出し元についても `null` を返します。

このプロパティは、廃止された `arguments` オブジェクトの `arguments.caller` プロパティを置き換えます。

特殊プロパティである `__caller__` は呼び出し元の activation オブジェクトを返し、スタックの再現に利用できましたが、セキュリティ上の理由により削除されました。

### 注

再帰呼び出しの場合、このプロパティを用いてコールスタックを再現することはできません。以下について考えてみましょう。


```js
function f(n) {
  g(n - 1);
}
function g(n) {
  if (n > 0) {
    f(n);
  } else {
    stop();
  }
}
f(2);
```


`stop()` が呼び出された時点のコールスタックは以下のようになるでしょう。


```js
f(2) -> g(1) -> f(1) -> g(0) -> stop()
```


以下は真になります。


```js
stop.caller === g && f.caller === g && g.caller === f;
```


従って、`stop()` 関数のスタックトレースを以下のようにして取得するとします。


```js
var f = stop;
var stack = "Stack trace:";
while (f) {
  stack += "\n" + f.name;
  f = f.caller;
}
```


これは無限ループになります。

例
-

### 関数の caller プロパティの値を確認する

以下のコードは、関数の `caller` プロパティの値を確認します。


```js
function myFunc() {
  if (myFunc.caller == null) {
    return "The function was called from the top!";
  } else {
    return "This function's caller was " + myFunc.caller;
  }
}
```

仕様書
---

いずれの標準仕様でも定義されていません。

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

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

関連情報
----

* `Function.name`
* `arguments`
Function.displayName
====================

**非標準:** この機能は標準ではなく、標準化の予定もありません。公開されているウェブサイトには使用しないでください。ユーザーによっては使用できないことがあります。実装ごとに大きな差があることもあり、将来は振る舞いが変わるかもしれません。

**`function.displayName`** プロパティは、関数の表示名を返します。

例
-

### displayName の設定

通常、コンソールやプロファイラーでは関数名を表示するのに `func.name` よりも好まれます。

以下のものをコンソールに入力すると、 "`function My Function()`" のように表示されます。


```js
var a = function () {};
a.displayName = "My Function";

a; // "function My Function()"
```


`displayName` プロパティが定義されると、関数の表示名が返されます。


```js
function doSomething() {}

console.log(doSomething.displayName); // "undefined"

var popup = function (content) {
  console.log(content);
};

popup.displayName = "Show Popup";

console.log(popup.displayName); // "Show Popup"
```

### 関数式の displayName の定義

関数式内で、関数と同時に表示名を定義できます。


```js
var object = {
  someMethod: function () {},
};

object.someMethod.displayName = "someMethod";

console.log(object.someMethod.displayName); // logs "someMethod"

try {
  someMethod;
} catch (e) {
  console.log(e);
}
// ReferenceError: someMethod is not defined
```

### 動的な displayName の変更

関数の `displayName` を動的に変更できます。


```js
var object = {
  // anonymous
  someMethod: function (value) {
    arguments.callee.displayName = "someMethod (" + value + ")";
  },
};

console.log(object.someMethod.displayName); // "undefined"

object.someMethod("123");
console.log(object.someMethod.displayName); // "someMethod (123)"
```

仕様書
---

どの仕様にも含まれていません。

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

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

関連情報
----

* `Function.name`
Function() コンストラクター
===================

**`Function` コンストラクター**は、新しい `Function` **オブジェクト**を生成します。コンストラクターを直接呼び出すと動的に関数を生成することができますが、セキュリティや、 `eval` (en-US) と似た性能の (ただし、はるかに重要性の低い) 問題を抱えます。ただし eval とは異なり、 `Function` コンストラクターはグローバルスコープで実行される関数のみを生成します。

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

構文
--
```

new Function([arg1 [, arg2 [, ...argN]] ,] functionBody)
```

### 引数

`arg1, arg2, ... argN`

仮引数の名前として関数で用いるための名前。各々は、妥当な JavaScript の識別子と一致する文字列か、カンマで区切られた文字列などのリストでなければなりません。例えば、 "`x`", "`theValue`", "`x,theValue`" などです。

`functionBody`

関数定義を形成する JavaScript の文を含む文字列。

解説
--

`Function` コンストラクターで生成された `Function` オブジェクトは、関数が作成されたときに解釈されます。これは、関数を関数式や関数文を使って定義してコード内で呼び出した場合に比べ、コードの他の部分と一緒に解釈されるため、効率が落ちます。

関数に渡されるすべての引数は、関数のパラメーター識別名として、渡される順番どおりに作成されます。引数を省略すると、その引数の値は `undefined` になります。

(`new` 演算子を用いずに) 関数として、`Function` コンストラクターを実行することは、コンストラクターとして実行することと同じです。

例
-

### Function コンストラクターに引数を指定する

以下のコードは二つの引数を取る `Function` オブジェクトを生成します。


```js
// この例は JavaScript コンソールで直接実行することができます

// 二つの引数を取り、その合計を返す関数を生成します
const adder = new Function("a", "b", "return a + b");

// 関数を呼び出します
adder(2, 6);
// 8
```


引数 "`a`" および "`b`" は関数の本体 "`return a + b`" の中で使用される形式的な引数名です。

仕様書
---

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

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

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

関連情報
----

* 関数と関数スコープ
* `function` 文
* `function` 式
* `function*` 文
* `function*` 式
* `AsyncFunction`
* `GeneratorFunction`
Function.prototype[@@hasInstance]()
===================================

`Function` インスタンスの **`[@@hasInstance]()`** メソッドは、コンストラクター関数がオブジェクトをそのコンストラクターのインスタンスの一つであると認識するかどうかを決定するデフォルトの手続きを定義します。これは、`instanceof` 演算子から呼ばれます。

構文
--


```js
func[Symbol.hasInstance](value)
```

### 引数

`value`

判定を行うオブジェクトです。プリミティブ値に対しては常に `false` を返します。

### 返値

`func.prototype` が `value` のプロトタイプチェーン内に存在する場合は `true` を返し、そうでない場合は `false` を返します。`value` がオブジェクトではないか、`this` が関数でない場合は、常に `false` を返します。`this` がバインド済み関数である場合は、`value` およびもとになったターゲット関数における `instanceof` 判定の結果を返します。

### 例外

`TypeError`

`this` がバインド済み関数ではなく、かつ `this.prototype` がオブジェクトではないとき投げられます。

説明
--

`instanceof` 演算子は、右辺の値に `[@@hasInstance]()` メソッドが存在する場合は、常にこのメソッドを呼びます。すべての関数はデフォルトで `Function.prototype` を継承しているので、それらはすべてこの `[@@hasInstance]()` メソッドを持ちます。そのため、ほとんどの場合、右辺が関数であれば `Function.prototype[@@hasInstance]` メソッドが `instanceof` の挙動を定義します。このメソッドは、`instanceof` 演算子のデフォルトの挙動 (`constructor` が `@@hasInstance` を持たないときと同じアルゴリズム) を実装します。

ほとんどのメソッドと違い、`Function.prototype[@@hasInstance]()` プロパティは設定不可能で、書込不可能です。これは、バインド済み関数のもとになったターゲット関数を取得されるのを防ぐためのセキュリティ機能です。例として、この StackOverflow での回答を参照してください。

例
-

### デフォルトの instanceof の挙動に戻す

このメソッドを直接呼ぶ必要が生じることはほとんどないでしょう。かわりに、このメソッドは `instanceof` 演算子から呼ばれます。以下の 2 種類の結果は通常等価であることを期待するべきです。


```js
class Foo {}
const foo = new Foo();
console.log(foo instanceof Foo === Foo[Symbol.hasInstance](foo)); // true
```


デフォルトの `instanceof` の挙動を呼び出したいが、コンストラクターにオーバーライドされた `[@@hasInstance]()` メソッドがあるかわからないとき、このメソッドを使いたくなるかもしれません。


```js
class Foo {
  static [Symbol.hasInstance](value) {
    // 独自の実装
    return false;
  }
}

const foo = new Foo();
console.log(foo instanceof Foo); // false
console.log(Function.prototype[Symbol.hasInstance].call(Foo, foo)); // true
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-function.prototype-@@hasinstance |

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

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

関連情報
----

* `instanceof`
* `Symbol.hasInstance`
SyntaxError() コンストラクター
======================

**`SyntaxError`** オブジェクトは、文法的に無効なコードを解釈しようとしたときのエラーを表します。

構文
--
```

new SyntaxError([message[, fileName[, lineNumber]]])
```

### 引数

`message` 省略可

人間が読むためのエラーの説明です。

`fileName` 省略可

例外が発生したコードを含むファイルの名前です。

`lineNumber` 省略可

例外が発生したコードの行番号です。

例
-

### SyntaxError の捕捉


```js
try {
  eval("hoo bar");
} catch (e) {
  console.error(e instanceof SyntaxError);
  console.error(e.message);
  console.error(e.name);
  console.error(e.fileName);
  console.error(e.lineNumber);
  console.error(e.columnNumber);
  console.error(e.stack);
}
```

### SyntaxError の生成


```js
try {
  throw new SyntaxError("Hello", "someFile.js", 10);
} catch (e) {
  console.error(e instanceof SyntaxError); // true
  console.error(e.message); // Hello
  console.error(e.name); // SyntaxError
  console.error(e.fileName); // someFile.js
  console.error(e.lineNumber); // 10
  console.error(e.columnNumber); // 0
  console.error(e.stack); // @debugger eval code:3:9
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-nativeerror-constructors |

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

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

関連情報
----

* `Error`
AsyncIterator.prototype[@@asyncIterator]()
==========================================

**`[@@asyncIterator]()`** は `AsyncIterator` インスタンスのメソッドで、非同期反復可能プロトコルを実装し、組み込みの非同期イテレーターを、 `for await...of` ループのような非同期反復可能オブジェクトを期待するほとんどの構文で利用できるようにします。これは `this` の値を返しますが、これは非同期イテレーターオブジェクトそのものです。

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

構文
--


```js
asyncIterator[Symbol.asyncIterator]()
```

### 引数

なし。

### 返値

`this` の値で、非同期イテレーターオブジェクトそのものです。

例
-

### for await...of ループを使用した反復処理

このメソッドを直接呼び出す必要はほとんどないことに注意してください。 `@@asyncIterator` メソッドが存在することで、すべての組み込み非同期イテレーターを非同期反復可能にすることができます、また、 `for await. ..of` ループなどの反復処理構文は、自動的にこのメソッドを呼び出し、ループ処理する非同期イテレーターを取得します。


```js
const asyncIterator = (async function\* () {
  yield 1;
  yield 2;
  yield 3;
})();
(async () => {
  for await (const value of asyncIterator) {
    console.log(value);
  }
})();
// ログ: 1, 2, 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-asynciteratorprototype-asynciterator |

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

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

関連情報
----

* `for await...of`
Atomics.exchange()
==================

静的な **`Atomics.exchange()`** メソッドは、指定された値を配列内の指定した位置に格納し、その値を返します。これは不可分操作で、古い値を読み取ってから新しい値を書き込むまでの間に他の物が書き込まないことを保証します。

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

構文
--


```js
Atomics.exchange(typedArray, index, value);
```

### 引数

`typedArray`

共有整数の型付き配列です。 `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array`, `Uint32Array` の何れかです。

`index`

`typedArray` で `value` と交換する位置です。

`value`

交換する数値です。

### 返値

指定された位置 (`typedArray[index]`) にあった古い値です。

### 例外

* `typedArray` が許可された整数型の何れでもない場合、`TypeError` が発生します。
* `index` が `typedArray` の範囲を超えている場合、 `RangeError` が発生します。
例
-

### exchange() の使用


```js
const sab = new SharedArrayBuffer(1024);
const ta = new Uint8Array(sab);

Atomics.exchange(ta, 0, 12); // 古い値である 0 を返す
Atomics.load(ta, 0); // 12
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.exchange |

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

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

関連情報
----

* `Atomics`
* `Atomics.compareExchange()`