recursal/MDN huggingface dataset:
in 演算子
======

**`in` 演算子**は、指定されたプロパティが指定されたオブジェクトにある場合に `true` を返します。

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

構文
--


```js
prop in object;
```

### 引数

`prop`

プロパティ名または配列のインデックスを表す文字列式またはシンボルです（シンボルではない場合は、文字列に強制変換されます）。

`object`

オブジェクト（またはそのプロトタイプチェーン）に、指定された名前（`prop`）のプロパティが含まれているかどうかを確認するオブジェクト。

例
-

### 基本的な使い方

次の例で `in` 演算子の使用法を示します。


```js
// 配列
let trees = ["redwood", "bay", "cedar", "oak", "maple"];
0 in trees; // true を返す
3 in trees; // true を返す
6 in trees; // false を返す
"bay" in trees; // false を返す (添字の指す値ではなく、添字の数値を指定しなければならない)
"length" in trees; // true を返す (length は Array のプロパティ)
Symbol.iterator in trees; // true を返す (配列は反復可能。 ES2015 以上で動作する)

// 定義済みオブジェクト
"PI" in Math; // true を返す

// ユーザー定義オブジェクト
let mycar = { make: "Honda", model: "Accord", year: 1998 };
"make" in mycar; // true を返す
"model" in mycar; // true を返す
```


`in` 演算子の右側には、オブジェクトを指定しなければなりません。例えば、`String` コンストラクターで作成した文字列は指定できますが、文字列リテラルは指定できません。


```js
let color1 = new String("green");
"length" in color1; // true を返す

let color2 = "coral";
// エラーが発生 (color2 は String オブジェクトではない)
"length" in color2;
```

### 削除済みあるいは未定義状態のプロパティへの `in` の使用

`delete` 演算子で削除されたプロパティについては、`in` 演算子は `false` を返します。


```js
let mycar = { make: "Honda", model: "Accord", year: 1998 };
delete mycar.make;
"make" in mycar; // false を返す

let trees = new Array("redwood", "bay", "cedar", "oak", "maple");
delete trees[3];
3 in trees; // false を返す
```


`undefined` を設定しているが削除されていないプロパティについて、`in` 演算子は true を返します。


```js
let mycar = { make: "Honda", model: "Accord", year: 1998 };
mycar.make = undefined;
"make" in mycar; // true を返す
```



```js
let trees = new Array("redwood", "bay", "cedar", "oak", "maple");
trees[3] = undefined;
3 in trees; // true を返す
```


`in` 演算子は、空の配列スロットに対して `false` を返します。直接アクセスしても `undefined` が返されます。


```js
let empties = new Array(3);
empties[2]; // undefined を返す
2 in empties; // false を返す
```


これを避けるためには、新しい配列が常に空でない値で埋められるようにするか、配列の終わりを超える位置に書き込まないようにしてください。


```js
let empties = new Array(3).fill(undefined);
2 in empties; // true を返す
```

### 継承されたプロパティ

`in` 演算子は、プロトタイプチェーンのプロパティに対して `true` を返します。(*継承されていない*プロパティのみをチェックする場合は、代わりに `Object.prototype.hasOwnProperty()` を使用してください)。


```js
"toString" in {}; // true を返す
```

### プライベートフィールドとメソッド

`in` 演算子を使用して、特定のクラスのプライベートフィールドまたはメソッドがクラスで定義されているかどうかを調べることができます。そのメソッドが存在すれば演算子は `true` を返し、そうでなければ `false` を返します。

**メモ:** クラスの定義されていない*プライベート*フィールドやメソッドにアクセスしようとすると、コードで `throw` が発生します。存在しない可能性があるプライベートフィールドを `in` 演算子でチェックすると、 `try/catch` を使用するより簡潔にすることができます。

以下のコードは、指定されたクラスが特定のプライベートメソッドやフィールドを持っているかどうかをチェックする静的関数です。


```js
class ClassWithPrivateFeatures {
  #a;
  #b = null;
  #c() {}
  get #d() {}
  static f(o) {
    return #a in o && #b in o && #c in o && #d in o;
  }
}
ClassWithPrivateFeatures.f(new ClassWithPrivateFeatures()); // true を返す
ClassWithPrivateFeatures.f({}); // false を返す
```

仕様書
---

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

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

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

関連情報
----

* `for...in`
* `delete`
* `Object.prototype.hasOwnProperty()`
* `Reflect.has()`
* プロパティの列挙可能性と所有権
ビット論理積 (&)
==========

**ビット論理積 (`&`)** 演算子は、両方のオペランドの対応するビットのいずれもが `1` である位置のビットで `1` を返します。

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

構文
--


```js
x & y
```

解説
--

演算子 `&` は数値と長整数の 2 種類のオペランドに対してオーバーロードされています。数値の場合、演算子は 32 ビット整数を返します。長整数の場合、演算子は長整数を返します。まず、両方のオペランドを数値に変換 して、それらの型をテストします。両方のオペランドが長整数になった場合、長整数の AND を実行します。そうでない場合は、両方のオペランドを 32 ビット整数に変換し、ビット単位の AND を行います。一方のオペランドが長整数になり、もう一方が数値になると `TypeError` が発生します。

この演算子は、オペランドのビット表現を 2 の補数で演算します。最初のオペランドの各ビットは、2 番目のオペランドの対応するビットとペアになります。第 1 ビットと第 1 ビット、第 2 ビットと第 2 ビットといった具合です。演算子は各ビットのペアに適用され、結果はビットごとに構成されます。

AND演算の真理値表は以下の通りです。

| x | y | x AND y |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
```

     9 (10 進数) = 00000000000000000000000000001001 (2 進数)
    14 (10 進数) = 00000000000000000000000000001110 (2 進数)
                   --------------------------------
14 & 9 (10 進数) = 00000000000000000000000000001000 (2 進数) = 8 (10 進数)
```


32 ビットを超える数値は、最上位ビットが破棄されます。例えば、以下の 32 ビットを超える整数は 32 ビット整数に変換されます。
```

Before: 11100110111110100000000000000110000000000001
After:              10100000000000000110000000000001
```


長整数では切り捨ては行われません。概念的には、正の長整数は先頭の `0` ビットが無限にあり、負の長整数は先頭の `1` ビットが無限にあると理解してください。

任意の数値 `x` と `-1` とのビットごとの AND 演算は、32 ビット整数に変換された `x` を返します。代わりに `Math.trunc()` を使用してください。

例
-

### ビット論理積の使用


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

14 & 9;
// 8 (00000000000000000000000000001000)

14n & 9n; // 8n
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-BitwiseANDExpression |

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

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

関連情報
----

* ビット演算子 (JavaScript ガイド)
* ビット論理積代入 (`&=`)
Null 合体代入 (??=)
===============

Null 合体代入 (`x ??= y`) 演算子は、`x` が nullish (`null` または `undefined`) である場合にのみ代入を行います。

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

構文
--


```js
expr1 ??= expr2;
```

解説
--

### 短絡評価 (ショートサーキット)

Null 合体演算子は左から右に評価され、次のルールを使って短絡評価の可能性があるかどうかテストされます。

`(null や undefined ではない式) ?? expr` は、左辺が `null` でも `undefined` でもないことが証明されたら、左辺の式が短絡評価されます。

短絡評価とは、上記の `expr` 部分が**評価されない**ことを意味します。したがって、評価された場合の副作用は発生しません (例えば、`expr` が関数呼び出しである場合、呼び出しは行われません)。

Null 合体代入も短絡評価されます。これは、`x ??= y` が以下と等価であることを意味します。


```js
x ?? (x = y);
```


そして、常に代入が行われる以下と等価ではありません。


```js
x = x ?? y;
```

例
-

### Null 合体代入演算子の使用


```js
function config(options) {
  options.duration ??= 100;
  options.speed ??= 25;
  return options;
}

config({ duration: 125 }); // { duration: 125, speed: 25 }
config({}); // { duration: 100, speed: 25 }
```

仕様書
---

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

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

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

関連情報
----

* Null 合体演算子 (`??`)
* Nullish
* 真値
* 偽値
カンマ演算子 (,)
==========

**カンマ演算子** (**`,`**) は、それぞれの演算対象を（左から右に）評価し、最後のオペランドの値を返します。これにより、複数の式が評価される複合式を作成することができ、複合式の最終値はそのメンバー式の一番右端の値となります。これは、`for` ループに複数の引数を提供する場合によく使用されます。

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

構文
--


```js
expr1, expr2, expr3...
```

引数
--

`expr1`, `expr2`, `expr3`...

1 つ以上の式で、最後の式が複合式の値として返されます。

使用上の注意
------

カンマ演算子は、単一の式が求められる場所で複数の式を記述したい場合に使うことができます。この演算子が最もよく使われるのは、 `for` ループで複数の引数を与えたいときです。

カンマ演算子は、配列、オブジェクト、関数の引数や引数の内部にあるカンマとは大きく異なります。

例
-

例えば次のコードでは、 `a` が、1 辺 10 要素からなる 2 次元配列内の要素を一度に 2 つ 変化させる為に、変数宣言部分でカンマ演算子を用いています。

このコードは、配列における対角線の要素の値を出力するものです。


```js
for (var i = 0, j = 9; i <= 9; i++, j--)
  console.log("a[" + i + "][" + j + "] = " + a[i][j]);
```


代入を行う際にカンマを使うと、カンマ演算子が通常どおりに働いていないかのように見える場合があります (カンマ演算子が式の中にないため)。以下の例では `a` には `b = 3` の値 (すなわち 3) が設定されますが、さらに `c = 4` が評価されて、その結果 (すなわち 4) がコンソールに返されます。これは演算子の優先順位と結合性のためです。


```js
var a, b, c;

(a = b = 3), (c = 4); // コンソールに 4 が返る
console.log(a); // 3 (もっとも左)

var x, y, z;

x = ((y = 5), (z = 6)); // コンソールに 6 が返る
console.log(x); // 6 (もっとも右)
```

### 処理と返値

カンマ演算子が行うことのもうひとつの例が、値を返す前の処理です。前述のとおり最後の要素のみを返しますが、その他すべての要素も評価します。よって、以下のようなことができます。


```js
function myFunc() {
  var x = 0;

  return (x += 1, x); // return ++x と同じ
}
```

仕様書
---

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

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

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

関連情報
----

* `for` ループ
import.meta
===========

**`import.meta`** オブジェクトはコンテキスト固有のメタデータを JavaScript のモジュールに公開します。これには、モジュールの URL のようなモジュールに関する情報が含まれています。

構文
--
```

import.meta
```

説明
--

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

`import.meta` オブジェクトは ECMAScript 実装によって生成され、プロトタイプは `null` です。オブジェクトは拡張でき、そのプロパティは書き込み、構成、列挙可能です。

例
-

### import.meta を使用する

`my-module.mjs` モジュールを指定します。


```html
<script type="module" src="my-module.js"></script>
```


`import.meta` オブジェクトを使用してモジュールのメタ情報にアクセスできます。


```js
console.log(import.meta); // { url: "file:///home/user/my-module.js" }
```


モジュールのベース URL を示す `url` プロパティを持つオブジェクトを返します。これは、外部スクリプトの場合はスクリプトを取得した URL、インラインスクリプトの場合はそれを含むドキュメントのベース URL です。

これには、クエリパラメータまたはハッシュ（つまり、`?` または `#`）が含まれることに注意してください。

例えば、以下のような HTML で


```html
<script type="module">
 import "./index.mjs?someURLInfo=5";
</script>
```


以下の JavaScript ファイルは、`someURLInfo` パラメータをログに記録します。


```js
// index.mjs
new URL(import.meta.url).searchParams.get("someURLInfo"); // 5
```


ファイルが別のファイルをインポートする場合も同様です。


```js
// index.mjs
import "./index2.mjs?someURLInfo=5";

// index2.mjs
new URL(import.meta.url).searchParams.get("someURLInfo"); // 5
```


メモ: 後者の例のように Node.js はクエリパラメータ（またはハッシュ）を渡しますが、Node 14.1.0 以降、クエリパラメータを持つ URL を `node --experimental-modules index.mjs?someURLInfo=5` という形式で読み込むとエラーになることに注意してください（この文脈では URL ではなくファイルとして扱われます）。

このようなファイル固有の引数の受け渡しは、アプリケーション全体の `location.href`（HTML ファイルパスの後にクエリ文字列やハッシュを追加したもの [Node.js では `process.argv` を介して]）で使用されているものを補完する場合があります。

仕様
--

| Specification |
| --- |
| ECMAScript Language Specification # prod-ImportMeta |
| HTML Standard # hostgetimportmetaproperties |

ブラウザー実装状況
---------

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

関連情報
----

* `import`
* `export`
等価 (==)
=======

等価演算子 (`==`) は、二つのオペランドが等しいことを検査し、論理値で結果を返します。厳密等価演算子とは異なり、オペランドの型が異なる場合には型の変換を試みてから比較を行います。

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

構文
--


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

解説
--

等価演算子 (`==` および `!=`) は、抽象等価比較アルゴリズムを使用して 2 つのオペランドを比較します。これは、およそ次のようにまとめることができます。

* 両方のオペランドがオブジェクトである場合、同じオブジェクトを指している場合に限り `true` を返します。
* 一方のオペランドが `null` で、もう一方が `undefined` であった場合は `true` を返します。
* オペランドの型が異なる場合は、比較前に同じ型に変換を試みます。
    + 数値と文字列を比較する場合、文字列を数値に変換しようとします。
    + 一方のオペランドが論理値である場合、その論理値のオペランドが `true` である場合は 1 に、 `false` である場合は +0 に変換します。
    + オペランドのうちの一方がオブジェクトで、もう一方が数値または文字列である場合は、そのオブジェクトの `valueOf()` および `toString()` メソッドを使用してプリミティブに変換を試みます。
* オペランドが同じ型である場合は、次のよう比較します。
    + 文字列型: 両方のオペランドが同じ文字を同じ順序で持っている場合のみ、 `true` を返します。
    + 数値型: 両方のオペランドが同じ値を持っている場合のみ、 `true` を返します。 `+0` と `-0` は同じ値と見なされます。一方のオペランドが `NaN` である場合は `false` を返します。
    + 論理型: 両方のオペランドが共に `true` であるか、共に `false` である場合のみ `true` になります。

この演算子と厳密等価 (`===`) 演算子の最も顕著な違いは、厳密等価演算子が型変換を試みない点です。厳密等価演算は、オペランドの型が異なる場合は常に異なるものと見なします。

例
-

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


```js
1 == 1; // true
"hello" == "hello"; // true
```

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


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

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

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


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

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

### 文字列と String オブジェクトの比較

`new String()` を使用して構築された文字列はオブジェクトであることに注意してください。文字列リテラルとの比較を行うと、 `String` オブジェクトは文字列リテラルに変換され、その中身が比較されます。ただし、両方のオペランドが `String` オブジェクトであった場合は、オブジェクトとして比較され、同じオブジェクトを参照している場合だけ比較に成功します。


```js
const string1 = "hello";
const string2 = String("hello");
const string3 = new String("hello");
const string4 = new String("hello");

console.log(string1 == string2); // true
console.log(string1 == string3); // true
console.log(string2 == string3); // true
console.log(string3 == string4); // false
console.log(string4 == string4); // true
```

### Date と文字列の比較


```js
const d = new Date("December 17, 1995 03:24:00");
const s = d.toString(); // for example: "Sun Dec 17 1995 03:24:00 GMT-0800 (Pacific Standard Time)"
console.log(d == s); //true
```

仕様書
---

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

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

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

関連情報
----

* 不等価演算子
* 厳密等価演算子
* 厳密不等価演算子
async function 式
================

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since April 2017.

* Learn more
* See full compatibility
* Report feedback
**`async function`** キーワードは、式の中で非同期関数を定義するために使用できます。

非同期関数は、`async function` 宣言またはアロー構文を使用して定義することもできます。

構文
--


```js
async function (param0) {
  statements
}
async function (param0, param1) {
  statements
}
async function (param0, param1, /\* …, \*/ paramN) {
  statements
}

async function name(param0) {
  statements
}
async function name(param0, param1) {
  statements
}
async function name(param0, param1, /\* …, \*/ paramN) {
  statements
}
```


**メモ:** 式文は `async function` キーワードを使用することができません。`async function` 宣言との混同を防ぐためです。`async function` キーワードは文を受け付けることができないコンテキストで現れた場合のみ、式の始まりになります。

### 引数

`name` 省略可

関数名です。関数が*無名*の場合は省略可能です。名前は関数の本体内のみのローカルです。

`paramN` 省略可

関数に渡される引数名です。引数の構文については、関数リファレンスを参照してください。

`statements` 省略可

関数本体を構成する文です。

解説
--

`async function` 式は `async function` 宣言とよく似ており、構文もほとんど同じです。async `function` 式と `async function` 宣言の主な違いは、`async function` 式が*関数名*を省略して*無名*関数を生成することができる点です。`async function` 式は、定義後直ちに実行される IIFE（即時実行関数式）として使用することもでき、最上位の await を模倣することができます。詳細は関数の章を見てください。

例
-

### シンプルな例


```js
function resolveAfter2Seconds(x) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(x);
    }, 2000);
  });
}

// 変数に代入された非同期関数式
const add = async function (x) {
  const a = await resolveAfter2Seconds(20);
  const b = await resolveAfter2Seconds(30);
  return x + a + b;
};

add(10).then((v) => {
  console.log(v); // 4 秒後に 60 を表示
});

// IIFE として使用される非同期関数式
(async function (x) {
  const p1 = resolveAfter2Seconds(20);
  const p2 = resolveAfter2Seconds(30);
  return x + (await p1) + (await p2);
})(10).then((v) => {
  console.log(v); // 2 秒後に 60 を表示
});
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-async-function-definitions |

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

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

関連情報
----

* `async function`
* `AsyncFunction`
* `await`
左シフト (<<)
=========

**左シフト演算子 (`<<`)** は、1 つ目のオペランドを指定されたビット数だけ左にずらします。左にずらしてあふれたビットは廃棄されます。0 のビットが右からずれて入ります。

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

構文
--


```js
a << b;
```

解説
--

この演算子は、1 つ目のオペランドを指定されたビット数だけ左にずらします。左にずらしてあふれたビットは廃棄されます。 0 のビットが右からずれて入ります。

例えば `9 << 2` は 36 になります。


```js
.    9 (10 進数): 00000000000000000000000000001001 (2 進数)
                  --------------------------------
9 << 2 (10 進数): 00000000000000000000000000100100 (2 進数) = 36 (10 進数)
```


 任意の数 `x` を `y` ビット分だけ左にビット単位にずらすと、 `x * 2 ** y` になります。
 ですから、例えば `9 << 3` は `9 * (2 ** 3) = 9 * (8) = 72` になります。

例
-

### 左シフトの使用


```js
9 << 3; // 72

// 9 \* (2 \*\* 3) = 9 \* (8) = 72
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-left-shift-operator |

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

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

関連情報
----

* ビット演算子 (JavaScript ガイド)
* 左シフト代入演算子
剰余 (%)
======

剰余演算子 (`%`) は、1 つ目のオペランドが 2 つ目のオペランドで除算されたときの余りである剰余を返します。これは常に被除数の符号を取ります。

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

構文
--


```js
x % y
```

解説
--

`%` 演算子のオペランドは、数値型と長整数型の 2 つの型ででオーバーロードされています。 これは、まず両方のオペランドを数値に変換し、それらの型を調べます。両方のオペランドが長整数型になった場合は長整数型の剰余を実行し、そうでない場合は数値型の剰余を実行します。一方のオペランドが長整数型になり、他方が数値型になった場合は `TypeError` が発生します。

`n % d` の演算では、`n` を被除数、`d` を除数と呼びます。この演算処理は、オペランドのいずれかが `NaN` であるか、 `n` が ±無限大であるか、または `d` が ±0 である場合に `NaN` を返します。

両方のオペランドが 0 ではなく有限であるとき、剰余 `r` は `r := n - d * q` として計算されます。ここで `q` は、 `r` ができるだけ 0 に近く、被除数 `n` と同じ符号を持つ整数です。

なお、多くの言語では '%' はリマインダー演算子ですが、言語によっては（例えば Python や Perl では）モジュロ演算子になります。モジュロは `k := n - d * q` と定義されます。ここで `q` は `k` が除数 `d` と同じ符号を持ち、かつ使用可能な限り 0 に近い整数です。 2 つのオペランドの符号が同じであれば、両者は等価になりますが、オペランドの符号が異なる場合、オペランドの符号が異なる場合、モジュロの結果は符号が常に *除数* と同じになり、リマインダーは被除数と同じになります。 JavaScript でモジュロを得るには、 `n % d` の代わりに `((n % d) + d) % d` を使用してください。 JavaScript では、ビット単位のシフト演算子（`<<`、`>>` など）の 2 つ目のオペランドを正規化するために、（専用の演算子のない）モジュロ演算が使用され、オフセットが常に正の値になります。

長整数型の除算では、被除数 `y` が `0n` の場合に `RangeError` が発生します。これはゼロによる剰余は `NaN` を返しますが、長整数には `NaN` の概念がないからです。

例
-

### 正の値の剰余


```js
13 % 5; // 3
1 % -2; // 1
1 % 2; // 1
2 % 3; // 2
5.5 % 2; // 1.5

3n % 2n; // 1n
```

### 負の値の剰余


```js
-13 % 5; // -3
-1 % 2; // -1
-4 % 2; // -0

-3n % 2n; // -1n
```

### NaN の剰余


```js
NaN % 2; // NaN
```

### 無限大の剰余


```js
Infinity % 2; // NaN
Infinity % 0; // NaN
Infinity % Infinity; // NaN
2 % Infinity; // 2
0 % Infinity; // 0
```

仕様書
---

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

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

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

関連情報
----

* 加算 (`+`)
* 減算 (`-`)
* 除算 (`/`)
* 乗算 (`*`)
* べき乗 (`**`)
* インクリメント (`++`)
* デクリメント (`--`)
* 単項マイナス (`-`)
* 単項プラス (`+`)
* Remainder operator vs. modulo operator by Dr. Axel Rauschmayer (2019)
単項プラス (+)
=========

単項プラス演算子 (`+`) は、オペランドの前に置かれ、そのオペランドを評価し、それが数値以外の場合は数値に変換します。

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

構文
--


```js
+x;
```

解説
--

単項マイナス (`-`) も非数値を数値に変換できますが、単項プラスは数値に対して他の演算を行わないため、非数値を数値に変換する最も高速で好ましい方法です。これは、整数や浮動小数点の文字列表現や、非文字列値である `true`、`false`、`null` を変換することができます。10 進数と 16 進数 (接頭辞 0x) の両形式の整数と負の数 (ただし 16 進数を除く) に対応しています。BigInt 値に対してこの演算子を使用すると TypeError が発生します。特定の値を解析できない場合は、`NaN` と評価されます。

例
-

### 数値での使い方


```js
const x = 1;
const y = -1;

console.log(+x);
// 1
console.log(+y);
// -1
```

### 数値以外での使い方


```js
+true; // 1
+false; // 0
+null; // 0
+function (val) {
  return val;
}; // NaN
+1n; // BigInt 値は数値に変換できないためエラーになります
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-unary-plus-operator |

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

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

関連情報
----

* 加算演算子
* 減算演算子
* 除算演算子
* 乗算演算子
* 剰余演算子
* べき乗演算子
* インクリメント演算子
* デクリメント演算子
* 単項マイナス演算子
論理否定 (!)
========

論理否定 (`!`) 演算子 (論理反転、否定) は、真値を取ると偽値になり、その逆も同様です。これは通常論理型 (ブール型) の値に使用されます。論理型以外の値に使用した場合、単一のオペランドが `true` に変換できる場合は `false` を返し、それ以外は `true` を返します。

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

構文
--


```js
!expr;
```

解説
--

単一のオペランドが `true` に変換できる場合は `false` を返し、それ以外は `true` を返します。

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

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

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

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

例
-

### 否定の使用

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


```js
n1 = !true; // !t は false を返す
n2 = !false; // !f は true を返す
n3 = !""; // !f は true を返す
n4 = !"Cat"; // !t は false を返す
```

### 二重否定 (`!!`)

複数の否定演算子を連続して使用することで、明示的にあらゆる値を対応する論理型プリミティブに変換することができます。変換は値の「真値性」または「偽値性」に基づいて行われます (truthy および falsy を参照)。

同じ変換は `Boolean` 関数を通じて行うこともできます。


```js
n1 = !!true; // !!truthy は true を返す
n2 = !!{}; // !!truthy は true: \*あらゆる\*オブジェクトは真値になります...
n3 = !!new Boolean(false); // ... .valueOF() が false の Boolean オブジェクトであっても
n4 = !!false; // !!falsy は false を返す
n5 = !!""; // !!falsy は false を返す
n6 = !!Boolean(false); // !!falsy は false を返す
```

### 否定同士の変換

以下の操作を**論理値**で行った場合、


```js
!!bCondition;
```


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


```js
bCondition;
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-logical-not-operator |

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

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

関連情報
----

* `Boolean`
* 真値
* 偽値
単項マイナス (-)
==========

単項マイナス演算子 (`-`) はオペランドの前に置かれ、符号を反転します。

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

構文
--


```js
-x;
```

例
-

### 数値の符号を反転


```js
const x = 3;
const y = -x;

// y = -3
// x = 3
```

### 数値以外の符号を反転

単項マイナス演算子は、数値でないものを数値に変換することができます。


```js
const x = "4";
const y = -x;

// y = -4
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-unary-minus-operator |

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

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

関連情報
----

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

単純代入演算子 (`=`) は、変数に値を代入するために使用されます。割り当て操作は、割り当てられた値として評価されます。代入演算子を使用して、単一の値を複数の変数に割り当てることができます。

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

構文
--


```js
x = y;
```

例
-

### 代入と連鎖


```ja
// 以下の変数を想定
//  x = 5
//  y = 10
//  z = 25

x = y     // x は 10
x = y = z // x, y そして z はすべて 25
```

仕様書
---

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

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

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

関連情報
----

* JavaScript ガイドの代入演算子
ビット否定 (~)
=========

ビット否定演算子 (`~`) は、オペランドの各ビットを反転します。他のビット演算子と同様、オペランドを 32 ビット符号付き整数に変換します。

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

構文
--


```js
~a;
```

解説
--

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

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


オペランドの各ビットが反転されて結果になります。

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

| a | NOT a |
| --- | --- |
| 0 | 1 |
| 1 | 0 |


```js
 9 (10 進数) = 00000000000000000000000000001001 (2 進数)
               --------------------------------
~9 (10 進数) = 11111111111111111111111111110110 (2 進数) = -10 (10 進数)
```


32 ビット符号付き整数のオペランドは、2 の補数によって反転されます。すなわち、最上位ビットが負の数であることを表します。

ある数 `x` のビット否定 は `-(x + 1)` になります。例えば、`~-5` は `4` になります。

数値に 32 ビット表現を使用するため `~-1` および `~4294967295` (2^32 - 1) はいずれも `0` になることに注意してください。

例
-

### ビット否定の使用


```js
~0; // -1
~-1; // 0
~1; // -2
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-bitwise-not-operator |

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

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

関連情報
----

* ビット演算子 (JavaScript ガイド)
ビット論理積代入 (&=)
=============

**ビット論理積代入 (`&=`)** 演算子は、 2 つのオペランドで論理積を取り、その結果を左オペランドへ代入します。

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

構文
--


```js
x &= y
```

解説
--

`x &= y` は `x = x & y` と同等ですが、 `x` は一度しか評価されません。

例
-

### ビット論理積代入の使用


```js
let a = 5;
// 5: 00000000000000000000000000000101
// 2: 00000000000000000000000000000010
a &= 2; // 0

let b = 5n;
b &= 2n; // 0n
```

仕様書
---

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

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

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

関連情報
----

* JavaScript ガイドの代入演算子
* ビット論理積 (`&`)
論理積代入 (&&=)
===========

論理積代入 (`x &&= y`) 演算子は、`x` が真値である場合にのみ代入を行います。

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

構文
--


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

解説
--

### 短絡評価 (ショートサーキット)

論理積演算子は左から右に評価され、次のルールを使って短絡評価の可能性があるかどうかテストされます。

`(偽値の式) && expr` は、偽値の式が短絡評価されます。

短絡評価とは、上記の `expr` 部分が**評価されない**ことを意味します。したがって、評価された場合の副作用は発生しません (例えば、`expr` が関数呼び出しである場合、呼び出しは行われません)。

論理積代入も短絡評価されます。これは、`x &&= y` が以下と等価であることを意味します。


```js
x && (x = y);
```


そして、常に代入が行われる以下とは等価ではありません。


```js
x = x && y;
```

例
-

### 論理積代入演算子の使用


```js
let x = 0;
let y = 1;

x &&= 0; // 0
x &&= 1; // 0
y &&= 1; // 1
y &&= 0; // 0
```

仕様書
---

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

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

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

関連情報
----

* 論理積演算子 (&&)
* Null 合体演算子 (`??`)
* ビット論理積代入 (`&=`)
* 真値
* 偽値