recursal/MDN huggingface dataset:
new.target
==========

**`new.target`** は擬似プロパティで、関数やコンストラクターが new 演算子を使用して呼び出されたかどうかを検出することができます。 new 演算子を使用して呼び出されたコンストラクターや関数の中では、 `new.target` はコンストラクターや関数への参照を返します。通常の関数呼び出しの場合、 `new.target` は `undefined` になります。

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

構文
--


```js
new.target;
```

解説
--

`new.target` の構文は、`new` キーワードとドット、 `target` 識別子で構成されています。通常、ドットの左側はプロパティアクセスが行われるオブジェクトですが、ここでの `new` はオブジェクトではありません。

`new.target` は、すべての関数で使用できる擬似プロパティです。

クラスのコンストラクターでは、構築されたクラスを参照します。

通常の関数では、new 演算子を介して呼び出されたと仮定して、関数自体を参照します。それ以外の場合、`new.target` は `undefined` になります。

アロー関数では、`new.target` は周囲のスコープから継承されます。

例
-

### 関数呼び出しにおける new.target の使用

通常の関数呼び出しでは (コンストラクター関数の呼び出しとは対照的に)、 `new.target` は `undefined` になります。これにより、関数が new でコンストラクターとして呼び出されたかを検出できます。


```js
function Foo() {
  if (!new.target) {
    throw "Foo() must be called with new";
  }
  console.log("Foo instantiated with new");
}

new Foo(); // "Foo instantiated with new" を出力
Foo(); // "Foo() must be called with new" 例外が発生
```

### コンストラクターにおける new.target

クラスのコンストラクターでは、`new.target` は `new` で直接実行されたコンストラクターを参照します。これは、コンストラクターが親クラスにあり、子コンストラクターから委任された場合も同様です。


```js
class A {
  constructor() {
    console.log(new.target.name);
  }
}

class B extends A {
  constructor() {
    super();
  }
}

let a = new A(); // logs "A"
let b = new B(); // logs "B"

class C {
  constructor() {
    console.log(new.target);
  }
}
class D extends C {
  constructor() {
    super();
  }
}

let c = new C(); // logs class C{constructor(){console.log(new.target);}}
let d = new D(); // logs class D extends C{constructor(){super();}}
```


上記の `C` および `D` クラスの例から、 `new.target` は初期化されたクラスのクラス定義を指しているように見えます。たとえば、`d` を `new D()` で初期化した場合は、 `D` のクラス定義が出力され、同様に `c` の場合は `C` のクラスが出力されます。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-built-in-function-objects |

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

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

関連情報
----

* 関数
* クラス
* `new`
* `this`
不等価 (!=)
========

不等価演算子 (`!=`) は、2 つのオペランドが等しくないことを検査し、論理値で結果を返します。厳密不等価演算子とは異なり、異なる型のオペランドを変換して比較を行おうとします。

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

構文
--


```js
x != y;
```

解説
--

不等価演算子は、そのオペランドが等しくないことを検査します。これは等価演算子の逆に当たるので、以下の 2 行は常に同じ結果になります。


```js
x != y;

!(x == y);
```


比較アルゴリズムの詳細については、等価演算子のページを参照して下さい。

等価演算子と同様に、不等価演算子は異なる型のオペランドを変換して比較しようとします。


```js
3 != "3"; // false
```


これを防止し、異なる型が異なる結果を返すようにするには、代わりに厳密不等価演算子を使用してください。


```js
3 !== "3"; // true
```

例
-

### 型変換がない場合の比較


```js
1 != 2; // true
"hello" != "hola"; // true

1 != 1; // false
"hello" != "hello"; // false
```

### 型変換がある場合の比較


```js
"1" != 1; // false
1 != "1"; // false
0 != false; // false
0 != null; // true
0 != undefined; // true
0 != !!null; // false (論理 NOT 演算子を参照)
0 != !!undefined; // false (論理 NOT 演算子を参照)
null != undefined; // false

const number1 = new Number(3);
const number2 = new Number(3);
number1 != 3; // false
number1 != number2; // true
```

### オブジェクトの比較


```js
const object1 = { key: "value" };
const object2 = { key: "value" };

object1 != object2; // true
object2 != object2; // false
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-equality-operators |

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

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

関連情報
----

* 等価演算子
* 厳密等価演算子
* 厳密不等価演算子
ビット排他的論理和 (^)
=============

ビット排他的論理和演算子 (`^`) は、両方のオペランドの対応するビットの一方だけが `1` である位置のビットで `1` を返します。

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

構文
--


```js
a ^ b;
```

解説
--

オペランドは 32 ビットの整数値に変換され、ビット (ゼロまたは 1) の並びによって表現されます。32 ビットを超える数値は最上位のビットが破棄されます。例えば、次の 32 ビットを超える整数は 32 ビット整数に変換されます。
```

変換前: 11100110111110100000000000000110000000000001
変換後:             10100000000000000110000000000001
```


第 1 オペランドの各ビットは、第 2 オペランドの対応するビットと組みになります。*第 1 ビット*は*第 1 ビット*へ、*第 2 ビット*は*第 2 ビット*へ、という具合にです。

この演算子は各ビットの組み合わせに適用され、結果はビット単位で構築されます。

XOR 演算の真理値表は次のようになります。

| a | b | a XOR b |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
```

     9 (10 進数) = 00000000000000000000000000001001 (2 進数)
    14 (10 進数) = 00000000000000000000000000001110 (2 進数)
                   --------------------------------
14 ^ 9 (10 進数) = 00000000000000000000000000000111 (2 進数) = 7 (10 進数)
```


ある数 `x` と `0` のビット排他的論理和は `x` になります。

例
-

### ビット排他的論理和の使用


```js
// 9 (00000000000000000000000000001001)
// 14 (00000000000000000000000000001110)

14 ^ 9;
// 7 (00000000000000000000000000000111)
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-BitwiseXORExpression |

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

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

関連情報
----

* ビット演算子 (JavaScript ガイド)
* ビット排他的論理和代入演算子
論理和 (||)
========

論理和 (`||`) 演算子 (論理的分割) をオペランドの組み合わせに対して使用すると、オペランドのうち 1 つ以上が true である場合に true になります。一般的には論理値（ブール値）で使用されます。その場合は論理値を返します。ただし `||` 演算子は実際には指定されたオペランドのうち一つの値を返すので、この演算子が論理値以外で使用された場合は、論理値以外の値を返すことになります。

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

構文
--


```js
expr1 || expr2;
```

解説
--

`expr1` が `true` に変換できる場合は `expr1` を返し、それ以外の場合は `expr2` を返します。

ある値が `true` に変換できる場合、その値は真値 (truthy) と呼ばれます。ある値が `false` に変換できる場合、その値は偽値 (falsy) と呼ばれます。

false に変換されうる式の例を示します。

* `null`
* `NaN`
* `0`
* 空文字列 (`""` または `''` または ````)
* `undefined`

`||` 演算子では論理値以外のオペランドを使用することができますが、返値が常に論理型プリミティブに変換することが可能であるため、論理演算子と見なすことができます。返値 (または一般的な式) を対応する論理値に明示的に変換するには、二重の否定演算子または `Boolean` コンストラクターを使用してください。

### 短絡評価

論理和の式は左から右へと評価され、下記の規則を使用して「短絡」評価が可能なように評価されます。

`(真値の式) || expr` は短絡評価で真値の式に評価されます。

短絡とは、上記の `expr` の部分が**評価されず**、したがって、これを行うことの副作用が効果を及ぼさないことを意味します（例えば、 `expr` が関数呼び出しであった場合、この場では呼び出されません）。これは、最初のオペランドが評価された時点で、すでに演算子の値が決定しているためです。例を示します。


```js
function A() {
  console.log("called A");
  return false;
}
function B() {
  console.log("called B");
  return true;
}

console.log(B() || A());
// 関数呼び出しによって "called B" がログ出力され、
// それから true (演算子の結果の値) が出力されます。
```

### 演算子の優先順位

以下の式は同じであるように見えるかもしれませんが、異なります。 `&&` 演算子は `||` 演算子よりも先に実行されるからです（演算子の優先順位を参照）。


```js
true || (false && false); // true を返す。 && が先に実行されるため
(true || false) && false; // false を返す。演算子の優先順位が適用されないため
```

例
-

### OR の使用

以下のコードは `||` (論理和) 演算子の例を示しています。


```js
o1 = true || true; // t || t は true を返す
o2 = false || true; // f || t は true を返す
o3 = true || false; // t || f は true を返す
o4 = false || 3 == 4; // f || f は false を返す
o5 = "Cat" || "Dog"; // t || t は "Cat" を返す
o6 = false || "Cat"; // f || t は "Cat" を返す
o7 = "Cat" || false; // t || f は "Cat" を返す
o8 = "" || false; // f || f は false を返す
o9 = false || ""; // f || f は "" を返す
o10 = false || varObject; // f || オブジェクトは varObject を返す
```


**メモ:** この演算子を使用していくつかの変数に既定値を提供する場合、*偽値*が使用されないことに注意してください。 `null` や `undefined` をフィルタリングする必要がある場合は、Null 合体演算子の使用を検討してください。

### 論理型の変換規則

#### AND から OR への変換

**論理型**に関する以下の操作は、


```js
bCondition1 && bCondition2;
```


常に以下のものと等しくなります。


```js
!(!bCondition1 || !bCondition2);
```


#### OR から AND への変換

**論理型**に関する以下の操作は、


```js
bCondition1 || bCondition2;
```


常に以下のものと等しくなります。


```js
!(!bCondition1 && !bCondition2);
```

### 入れ子になった括弧の除去

論理式は左から右に評価されるので、いくつかのルールに従って複雑な式から括弧を削除することは常に可能です。

**論理型**に関する以下の複合操作は、


```js
bCondition1 && (bCondition2 || bCondition3);
```


常に以下のものと等しくなります。


```js
!(!bCondition1 || (!bCondition2 && !bCondition3));
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-LogicalORExpression |

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

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

関連情報
----

* Null 合体演算子 (`??`)
* `Boolean`
* 真値
* 偽値
論理積 (&&)
========

論理積 (`&&`) 演算子 (論理結合) を一組の論理型のオペランドに対して使用すると、すべてのオペランドが `true` である場合にのみ `true` になります。それ以外の場合は `false` になります。

一般的には、この演算子は左から右に向けて評価した際に最初の偽値のオペランドに遭遇したときにはその値を、またはすべてが真値であった場合は最後のオペランドの値を返します。

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

構文
--


```js
expr1 && expr2;
```

解説
--

論理積 (`&&`) はオペランドを左から右に向けて評価し、遭遇した最初の偽値のオペランドを直ちに返します。すべての値が真値であった場合、最後のオペランドの値が返されます。

ある値が `true` に変換できる場合、その値は真値 (truthy) と呼ばれます。ある値が `false` に変換できる場合、その値は偽値 (falsy) と呼ばれます。

false に変換することができる式の例を示します。

* `false`
* `null`
* `NaN`
* `0`
* 空文字列 (`""` または `''` または ````)
* `undefined`

論理積演算子は次のように、論理型でない値はそのまま温存して返します。


```js
result = "" && "foo"; // result には "" (空文字列) が代入される
result = 2 && 0; // result には 0 が代入される
result = "foo" && 4; // result には 4 が代入される
```


`&&` 演算子では論理値以外のオペランドを使用することができますが、返値が常に論理型プリミティブに変換することが可能であるため、論理演算子と見なすことができます。
 返値（または一般的な式）を対応する論理値に明示的に変換するには、二重の否定演算子または `Boolean` コンストラクターを使用してください。

### 短絡評価

 論理積の式は短絡演算子です。
 各オペランドが論理値に変換されるとき、ある変換結果が `false` であった場合、論理積演算子は停止してその偽値のオペランドの元の値を返します。残りのオペランドは評価**されません**。

以下の擬似コードを考えてみてください。
```

(偽値の式) && expr
```


`expr` の部分は**評価されません**。最初のオペランドである `(偽値の式)` が偽値と評価されるからです。
 `expr` が関数であった場合、その関数は呼び出されません。
 以下の例を参照してください。


```js
function A() {
  console.log("called A");
  return false;
}
function B() {
  console.log("called B");
  return true;
}

console.log(A() && B());
// 関数 A の呼び出しによって "called A" をログ出力し、
// && が false に評価され（関数 A が false を返し）、それから false をコンソールに出力します。
// 論理積演算子はここで短絡となり、関数 B は無視されます。
```

### 演算子の優先順位

AND 演算子は OR 演算子よりも高い優先順位を持つので、 `&&` 演算子は `||` 演算子よりも先に実行されます（演算子の優先順位を参照）。


```js
false || (true && true); // true を返す
true && (false || false); // false を返す
2 == 3 || (4 < 0 && 1 == 1); // false を返す
```

例
-

### 論理積の使用

以下のコードは `&&` (論理積) 演算子の例を示しています。


```js
a1 = true && true; // t && t は true を返す
a2 = true && false; // t && f は false を返す
a3 = false && true; // f && t は false を返す
a4 = false && 3 == 4; // f && f は false を返す
a5 = "Cat" && "Dog"; // t && t は "Dog" を返す
a6 = false && "Cat"; // f && t は false を返す
a7 = "Cat" && false; // t && f は false を返す
a8 = "" && false; // f && f は "" を返す
a9 = false && ""; // f && f は false を返す
```

### 論理型の変換規則

#### AND から OR への変換

**論理型**に関する以下の操作は、


```js
bCondition1 && bCondition2;
```


常に以下のものと等しくなります。


```js
!(!bCondition1 || !bCondition2);
```


#### OR から AND への変換

**論理型**に関する以下の操作は、


```js
bCondition1 || bCondition2;
```


常に以下のものと等しくなります。


```js
!(!bCondition1 && !bCondition2);
```

### 入れ子になった括弧の除去

論理式は左から右に評価されるので、いくつかのルールに従って複雑な式から括弧を削除することは常に可能です。

以下の**論理型**に関する複合操作は、


```js
bCondition1 || (bCondition2 && bCondition3);
```


常に以下のものと等しくなります。


```js
bCondition1 || (Condition2 && bCondition3;
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-LogicalANDExpression |

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

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

関連情報
----

* `Boolean`
* 真値
* 偽値
大なり (>)
=======

大なり演算子 (`>`) は、左辺のオペランドが右辺のオペランドより大きい場合は `true` を返し、それ以外の場合は `false` を返します。

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

構文
--


```js
x > y;
```

解説
--

オペランドは、抽象関係比較アルゴリズムを使用して比較されます。このアルゴリズムの概要については、小なり演算子のドキュメントを参照して下さい。

例
-

### 文字列と文字列の比較


```js
console.log("a" > "b"); // false
console.log("a" > "a"); // false
console.log("a" > "3"); // true
```

### 文字列と数値の比較


```js
console.log("5" > 3); // true
console.log("3" > 3); // false
console.log("3" > 5); // false

console.log("hello" > 5); // false
console.log(5 > "hello"); // false

console.log("5" > 3n); // true
console.log("3" > 5n); // false
```

### 数値と数値の比較


```js
console.log(5 > 3); // true
console.log(3 > 3); // false
console.log(3 > 5); // false
```

### Number と BigInt の比較


```js
console.log(5n > 3); // true
console.log(3 > 5n); // false
```

### 論理値、null、undefined、NaN の比較


```js
console.log(true > false); // true
console.log(false > true); // false

console.log(true > 0); // true
console.log(true > 1); // false

console.log(null > 0); // false
console.log(1 > null); // true

console.log(undefined > 3); // false
console.log(3 > undefined); // false

console.log(3 > NaN); // false
console.log(NaN > 3); // false
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-relational-operators |

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

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

関連情報
----

* 大なりイコール演算子
* 小なり演算子
* 小なりイコール演算子
符号なし右シフト (>>>)
==============

**符号なし右シフト演算子 (`>>>`)** (ゼロ埋め右シフト) は、1つ目のオペランドを指定されたビット数だけ右にずらします。右にずらしてあふれたビットは廃棄されます。0 のビットが左からずれて入ります。符号ビットは `0` になりますので、結果は負の数にはなりません。他のビット毎演算子とは異なり、ゼロ埋め右シフトは符号なし 32 ビット整数を返します。

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

構文
--


```js
a >>> b;
```

解説
--

この演算子は、1 つ目のオペランドを指定されたビット数だけ右にずらします。右にずらしてあふれたビットは廃棄されます。0 のビットが左からずれて入ります。符号ビットは `0` になりますので、結果は負の数にはなりません。他のビット毎演算子とは異なり、ゼロ埋め右シフトは符号なし 32 ビット整数を返します。

負の数ではない場合、ゼロ埋め右シフトと符号保存右シフトは同じ結果をになります。例えば、 `9 >>> 2` は 2 となり、 `9 >> 2` と同じになります。


```js
.     9 (10 進数): 00000000000000000000000000001001 (2 進数)
                   --------------------------------
9 >>> 2 (10 進数): 00000000000000000000000000000010 (2 進数) = 2 (10 進数)
```


しかし、これは負の数の場合は当てはまりません。例えば、 `-9 >>> 2` は 1073741821 になり、 `-9 >> 2` とは異なります (`-3` になる)。


```js
.     -9 (10 進数): 11111111111111111111111111110111 (2 進数)
                    --------------------------------
-9 >>> 2 (10 進数): 00111111111111111111111111111101 (2 進数) = 1073741821 (10 進数)
```

例
-

### 符号なし右シフトの使用


```js
9 >>> 2; // 2
-9 >>> 2; // 1073741821
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-unsigned-right-shift-operator |

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

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

関連情報
----

* ビット演算子 (JavaScript ガイド)
* 符号なし右シフト代入演算子
super
=====

**super** キーワードは、オブジェクトの親の関数を呼び出すために使用できます。

`super.prop` および `super[expr]` 式は、class とオブジェクトリテラルの両方におけるあらゆるメソッド定義で有効です。

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

構文
--


```js
super([arguments]); // 親コンストラクターを呼び出します。
super.functionOnParent([arguments]);
```

解説
--

コンストラクターで使用する場合、`super` キーワードを単独で置き、`this` キーワードが使われる前に使用する必要があります。`super` キーワードは、親オブジェクトの関数を呼び出すためにも使用できます。

例
-

### クラス内での `super` の使用

このコードスニペットは、クラスの例 (ライブデモ) からとっています。`super()` を利用することで、`Rectangle` と `Square` のコンストラクターに共通する処理を重複して記述しないようにしています。


```js
class Rectangle {
  constructor(height, width) {
    this.name = "Rectangle";
    this.height = height;
    this.width = width;
  }
  sayName() {
    console.log("Hi, I am a ", this.name + ".");
  }
  get area() {
    return this.height \* this.width;
  }
  set area(value) {
    this._area = value;
  }
}

class Square extends Rectangle {
  constructor(length) {
    this.height; // ReferenceError になります。super を先に呼び出さなければなりません！

    // length の値で親クラスの constructor を呼びます。
    // Rectangle の width と height になります。
    super(length, length);

    // Note: 'this' を使う前に super() をコールしなければなりません。
    // でないと reference error になります。
    this.name = "Square";
  }
}
```

### 静的メソッドでの super の呼び出し

static メソッドでも super を呼び出すことができます。


```js
class Rectangle {
  static logNbSides() {
    return "I have 4 sides";
  }
}

class Square extends Rectangle {
  static logDescription() {
    return super.logNbSides() + " which are all equal";
  }
}
Square.logDescription(); // 'I have 4 sides which are all equal'
```

### super プロパティを削除するとエラーが発生する

親クラスのプロパティを削除するために、delete 演算子 や `super.prop`、`super[expr]` を使うことはできません。`ReferenceError` がスローされます。


```js
class Base {
  foo() {}
}
class Derived extends Base {
  delete() {
    delete super.foo; // this is bad
  }
}

new Derived().delete(); // ReferenceError: invalid delete involving 'super'.
```

### `super.prop` は書き込み不可能なプロパティを上書きできない

`Object.defineProperty` などで書き込み不可プロパティを定義した場合、`super` はプロパティの値を上書きできません。


```js
class X {
  constructor() {
    Object.defineProperty(this, "prop", {
      configurable: true,
      writable: false,
      value: 1,
    });
  }
}

class Y extends X {
  constructor() {
    super();
  }
  foo() {
    super.prop = 2; // 値を上書きできない
  }
}

var y = new Y();
y.foo(); // TypeError: "prop" は読み取り専用
console.log(y.prop); // 1
```

### オブジェクトリテラル内での `super.prop` の使用

super はオブジェクト初期化子 / リテラル記法内でも使用できます。この例では、 2 つのオブジェクトがメソッドを定義しています。 2 つ目のオブジェクトの中で、`super` が最初のオブジェクトのメソッドを呼び出しています。これは `Object.setPrototypeOf()` の助けで動作し、これは `obj2` のプロトタイプを `obj1` に設定するので、`super` は `method1` を `obj1` 上で見つけることができます。


```js
var obj1 = {
  method1() {
    console.log("method 1");
  },
};

var obj2 = {
  method2() {
    super.method1();
  },
};

Object.setPrototypeOf(obj2, obj1);
obj2.method2(); // logs "method 1"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-super-keyword |

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

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

関連情報
----

* クラス
ビット排他的論理和代入 (^=)
================

ビット排他的論理和代入演算子 (`^=`) は、両方のオペランドの二進表現を使用し、それらに対してビット単位の XOR 演算を実行し、結果を変数に代入します。

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

構文
--


```js
x ^= y; // x = x ^ y
```

例
-

### ビット排他的論理和代入の使用


```js
let a = 5; // 00000000000000000000000000000101
a ^= 3; // 00000000000000000000000000000011

console.log(a); // 00000000000000000000000000000110
// 6

let b = 5; // 00000000000000000000000000000101
b ^= 0; // 00000000000000000000000000000000

console.log(b); // 00000000000000000000000000000101
// 5
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-assignment-operators |

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

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

関連情報
----

* JavaScript ガイドの代入演算子
* ビット排他的論理和演算子
べき乗 (\*\*)
==========

べき乗演算子 (`**`) は、1 つ目のオペランドを2 つ目オペランドの累乗にした結果を返します。これは `Math.pow` と同等ですが、オペランドとして BigInt も受け入れます。

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

構文
--


```js
x \*\* y;
```

解説
--

べき乗演算子は右結合です。 `a ** b ** c` は `a ** (b ** c)` と等しくなります。

PHP や Python など、べき乗演算子 (`**`) を持つほとんどの言語では、べき乗演算子は単項演算子 (単項 `+` や単項 `-` など) よりも優先順位が高いと定義されていますが、いくつかの例外があります。例えば、Bash では `**` 演算子は単項演算子よりも優先順位が低いと定義されています。

JavaScript では、あいまいなべき乗式を記述することはできません。 つまり、基数の直前に単項演算子 (`+/-/~/!/delete/void/typeof`) を置くことはできません。 これを行うと、SyntaxError が発生します。


```js
-2 \*\* 2;
// Bashでは 4 他の言語では -4
// JavaScript では演算があいまいなため無効

-(2 \*\* 2);
// JavaScript では意図が明白なため -4
```


注意: 一部のプログラミング言語ではべき乗計算にキャレット記号 `^` を使用していますが、JavaScript ではビット排他的論理和にこの記号を使用しています。

例
-

### 基本的なべき乗


```js
2 \*\* 3; // 8
3 \*\* 2; // 9
3 \*\* 2.5; // 15.588457268119896
10 \*\* -1; // 0.1
NaN \*\* 2; // NaN
```

### 結合性


```js
2 \*\* 3 \*\* 2; // 512
2 \*\* (3 \*\* 2); // 512
(2 \*\* 3) \*\* 2; // 64
```

### 単項演算子との使用

べき乗式の結果の符号を反転させる例です。


```js
-(2 \*\* 2); // -4
```


べき乗式の基底を強制的に負の数にする例です。


```js
(-2) \*\* 2; // 4
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-exp-operator |

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

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

関連情報
----

* 加算演算子
* 減算演算子
* 除算演算子
* 乗算演算子
* 剰余演算子
* インクリメント演算子
* デクリメント演算子
* 単項マイナス演算子
* 単項プラス演算子
剰余代入 (%=)
=========

剰余代入演算子 (`%=`) は、変数を右辺のオペランドの値で除算し、剰余を変数に代入します。

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

構文
--


```js
x %= y; // x = x % y
```

例
-

### 剰余代入の使用


```js
// 以下の変数を想定
// bar = 5

bar %= 2; // 1
bar %= "foo"; // NaN
bar %= 0; // NaN
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-assignment-operators |

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

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

関連情報
----

* JavaScript ガイドの代入演算子
* 剰余演算子
小なりイコール (<=)
============

小なりイコール演算子 (`<=`) は、左のオペランドが右のオペランドより小さいか等しい場合に `true` を返し、それ以外の場合は `false` を返します。

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

構文
--


```js
x <= y;
```

解説
--

オペランドは、抽象関係比較アルゴリズムを使用して比較されます。 このアルゴリズムの概要については、小なり演算子のドキュメントを参照して下さい。

例
-

### 文字列と文字列の比較


```js
console.log("a" <= "b"); // true
console.log("a" <= "a"); // true
console.log("a" <= "3"); // false
```

### 文字列と数値の比較


```js
console.log("5" <= 3); // false
console.log("3" <= 3); // true
console.log("3" <= 5); // true

console.log("hello" <= 5); // false
console.log(5 <= "hello"); // false
```

### 数値と数値の比較


```js
console.log(5 <= 3); // false
console.log(3 <= 3); // true
console.log(3 <= 5); // true
```

### Number と BigInt の比較


```js
console.log(5n <= 3); // false
console.log(3 <= 3n); // true
console.log(3 <= 5n); // true
```

### 論理値、null、undefined、NaN の比較


```js
console.log(true <= false); // false
console.log(true <= true); // true
console.log(false <= true); // true

console.log(true <= 0); // false
console.log(true <= 1); // true

console.log(null <= 0); // true
console.log(1 <= null); // false

console.log(undefined <= 3); // false
console.log(3 <= undefined); // false

console.log(3 <= NaN); // false
console.log(NaN <= 3); // false
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-relational-operators |

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

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

関連情報
----

* 大なり演算子
* 大なりイコール演算子
* 小なり演算子
void 演算子
========

**`void` 演算子**は与えられた式 (`expression`) を評価し、`undefined` を返します。

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

構文
--


```js
void expression;
```

解説
--

この演算子により、何らかの値を生成する評価式を、式が `undefined` と評価されることが望ましい場面に置くことができます。

`void` 演算子は、よく単にプリミティブ値 `undefined` を得る目的で使われ、一般的に "`void(0)`" と書かれます（これは "`void 0`" と等価です）。この目的であれば、グローバル変数 `undefined` を使用することができます。

なお、`void` 演算子の 優先順位 を考慮するべきであり、括弧は `void` 演算子に続く式の解決を明確にするのに役立つとされています。


```js
void 2 == "2"; // (void 2) == '2', false を返す
void (2 == "2"); // void (2 == '2'), undefined を返す
```

例
-

### 即時実行関数式

即時実行関数式 を使用する場合、 `void` により `function` キーワードが宣言ではなく式として扱うよう強制することができます。


```js
void (function iife() {
  console.log("Executed!");
})();

// Output: "Executed!"
```


上記の関数を `void` キーワードなしで実行すると、**捕捉されない SyntaxError** が発生します。

### JavaScript URI

`javascript:` の URI に対応しているブラウザーでは、 URI の中のコードを評価し、返値が `undefined` でない限り、返された値でページの内容を置き換えます。 `void` 演算子は、`undefined` を返すために使用できます。


```html
<a href="javascript:void(0);"> Click here to do nothing </a>

<a href="javascript:void(document.body.style.backgroundColor='green');">
  Click here for green background
</a>
```


**メモ:** `javascript:` 擬似プロトコルは控えめなイベントハンドラーなどの代替であり、積極的に使用するべきではないでしょう。

### アロー関数からのリーク防止

 アロー関数は略式の中括弧のない構文を導入しており、式を返します。
 これは、以前は何も返さなかった関数呼び出しの結果を返すことで、意図しない副作用を引き起こす可能性があります。関数の返値が使用されないことを想定している場合は、安全のため void 演算子に渡すことで、（例えば） API の変更によってアロー関数の動作が変更されないようにすることができます。


```js
button.onclick = () => void doSomething();
```


これにより、 `doSomething` の返値が `undefined` から `true` に変わっても、このコードの動作が変わらないことが保証されます。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-void-operator |

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

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

関連情報
----

* `undefined`