JavaScript/演算子のソースを表示

{{Nav}}
'''[[w:演算子|演算子]]'''（えんざんし、''operator''）とは、<code>2 + 3</code>の<code>+</code>のように、[[w:演算|演算]]を表す記号のことです。2や3は'''被演算子'''（ひえんざんし、''operand''、'''オペランド'''）といいます。JavaScriptには算術演算子以外にもさまざまな演算子があります。[[JavaScript/var|変数]]の代入で使用した<code>=</code>も演算子の一種ですし、コンマ<code>,</code>も演算子の一種です。
演算子はメソッドでは有りません。
演算子はメソッドと異なりオーバーロード出来ません。

== 算術演算子 ==
{{See|[[JavaScript/Number|数値]]}}
[[w:加法|加算]] (<code>+</code>)、[[w:減法|減算]] (<code>-</code>)、[[w:乗算|乗算]] (<code>*</code>)、[[w:除算|除算]] (<code>/</code>) の四則演算をはじめとする基本的な算術演算子が存在します。[[JavaScript/Number|数値]]は常に浮動小数点数として扱われます。
BigIntにも演算子を適用できますが、算術演算子の場合両方のオペランドがBigIntである必要があり異なる型が渡されると、暗黙の型変換は行われず TypeErroe となります。
数値の演算で NaN を返すケースは、BigIntではErrorとなります（例えばゼロ除算は数値ではNaNを返しますが、BigInt同士ではRangeErrorがthrowされます）。

{| class="wikitable"
|+ JavaScriptの算術演算子
! 演算子
! 意味
|-
| <code>''a'' + ''b''</code>
| 加算
|-
| <code>''a'' - ''b''</code>
| 減算
|-
| <code>''a'' * ''b''</code>
| 乗算
|-
| <code>''a'' / ''b''</code>
| 除算
|-
| <code>''a'' % ''b''</code>
| 剰余
|-
| <code>''a'' ** ''b''</code>
| べき乗
|-
| <code>+''a''</code>
| 単項プラス（数値化）
|-
| <code>-''a''</code>
| 単項マイナス（算術否定）
|-
| <code>''a''++</code> または <code>++''a''</code>
| インクリメント
|-
| <code>''a''--</code> または <code>--''a''</code>
| デクリメント
|}

=== 加算演算子 (+) ===
'''加算演算子'''（かさんえんざんし、''addition operator''）は<code>+</code>です<ref>[https://tc39.es/ecma262/#sec-addition-operator-plus ECMA-262::13.8.1 The Addition Operator ( + )]</ref>。

;[https://paiza.io/projects/ySNs2SNCO4Eko8b0HPCE-g 変数twoを1+1で初期化するとtwoの値は2となる]:<syntaxhighlight lang="javascript">
const two = 1 + 1;
console.log(two);
</syntaxhighlight>
;実行結果:<syntaxhighlight lang="text">
2
</syntaxhighlight>

=== 減算演算子 (-) ===
'''減算演算子'''（げんざんえんざんし、げんさんえんざんし、''subtraction operator''）は<code>-</code>です<ref>[https://tc39.es/ecma262/#sec-subtraction-operator-minus ECMA-262::13.8.2 The Subtraction Operator ( - )]</ref>。

;[https://paiza.io/projects/wxzLEVD2-1eOuxIr9L3tXA?language=javascript 変数minus_oneを0-1で初期化するとminus_oneの値は-1となる]:<syntaxhighlight lang="javascript">
const minus_one = 0 - 1;
console.log(minus_one);
</syntaxhighlight>
;実行結果:<syntaxhighlight lang="text">
-1
</syntaxhighlight>

=== 乗算演算子 (*) ===
'''乗算演算子'''（じょうざんえんざんし、じょうさんえんざんし、''multiplication operator''）は<code>*</code>です。

<syntaxhighlight lang="javascript">
const four = 2 * 2; // 変数fourを2×2で初期化するとfourは4となる
console.log(four); // 4
</syntaxhighlight>

=== 除算演算子 (/) ===
'''除算演算子'''（じょざんえんざんし、じょさんえんざんし、''division operator''）は<code>/</code>です。

<syntaxhighlight lang="javascript">
const one_half = 1 / 2; // 変数one_halfを1÷2で初期化するとone_halfは0.5となる
console.log(one_half); // 0.5
</syntaxhighlight>

ゼロ除算（ゼロじょざん、ゼロじょさん、''division by zero''）は[[JavaScript/例外処理|例外]]ではなく<code>[[JavaScript/Number#Infinity|Infinity]]</code>（あるいは<code>-Infinity</code>）を返します。
BigInt 同士のゼロ除算は RangeError となります。

<syntaxhighlight lang="javascript">
console.log( 1 / 0 ); // Infinity
console.log( -2 / 0 ); // -Infinity
console.log( 3 /-0 ); // -Infinity
console.log( -3 /-0 ); // Infinity
console.log( 1n / 0n ); // RangeError: Division by zero
</syntaxhighlight>

除数・被除数ともゼロの除算は<code>[[JavaScript/Number#NaN|NaN]]</code>を返します。
BigInt 同士の除数・被除数ともゼロの除算は RangeError となります。

<syntaxhighlight lang="javascript">
console.log( 0 / 0 ); // NaN
console.log( 0n / 0n ); // RangeError: Division by zero
</syntaxhighlight>

=== 剰余演算子 (%) ===
'''剰余演算子'''（じょうよえんざんし、''REMAINDER operator''）は<code>%</code>です。割り算の余りを求めます。

<syntaxhighlight lang="javascript">
const one = 10 % 3; // 10÷3は3余り1なので変数oneは1となる
console.log(one); // 1
</syntaxhighlight>

結果は必ず左オペランドの被除数（割られる数）と同じ符号になります。

<syntaxhighlight lang="javascript">
const minus_one = -10 % 3;
console.log(minus_one); // -1
</syntaxhighlight>

ゼロ剰余（ゼロじょうよ、''REMAINDER by zero''）は例外ではなく<code>NaN</code>を返します。
BigInt 同士の剰余は RangeError となります。

<syntaxhighlight lang="javascript">
console.log( 10 % 0 ); // NaN
console.log( 10n % 0n ); // RangeError: Division by zero
</syntaxhighlight>

<code>''a'' % ''b''</code>は<code>''a'' - ''b'' * [[JavaScript/Math/trunc|Math.trunc]](''a'' / ''b'')</code>と等価です。
Perl や Ruby のように<code>''a'' - ''b'' * [[JavaScript/Math/floor|Math.floor]](''a'' / ''b'')</code>と等価ではありません。これは IEEE754 の Remainder に定義された挙動で C 言語の libm にある fmod() と同じ動作です。

<syntaxhighlight lang="javascript">
const remainder = (a,b) => (a - b * Math.trunc(a/b));
for (let i = -1.2; i <= 1.2; i += 1.2)
  for (let j = -1.3; j <= 1.3; j += 1.3)
    console.log(`${i} % ${j}= ${i%j} (=${remainder(i,j)}), ${i} / ${j} = ${i / j}`);
/*
 -1.2 % -1.3= -1.2 (=-1.2), -1.2 / -1.3 = 0.923076923076923
 -1.2 % 0= NaN (=NaN), -1.2 / 0 = -Infinity
 -1.2 % 1.3= -1.2 (=-1.2), -1.2 / 1.3 = -0.923076923076923
 0 % -1.3= 0 (=0), 0 / -1.3 = 0
 0 % 0= NaN (=NaN), 0 / 0 = NaN
 0 % 1.3= 0 (=0), 0 / 1.3 = 0
 1.2 % -1.3= 1.2 (=1.2), 1.2 / -1.3 = -0.923076923076923
 1.2 % 0= NaN (=NaN), 1.2 / 0 = Infinity
 1.2 % 1.3= 1.2 (=1.2), 1.2 / 1.3 = 0.923076923076923
*/
</syntaxhighlight>

除数は浮動小数点数でもかまいません（元々 Number は64ビット倍精度浮動小数点数です）。
<syntaxhighlight lang="javascript">
const theta = Math.PI / 4;
console.log(Math.sin(theta) === Math.sin(theta % (2 * Math.PI))); // true
</syntaxhighlight>

=== 単項プラス演算子 +() ===
'''単項プラス演算子'''（たんこうプラスえんざんし、''unary plus operator''）は式を評価し、数値でなかった場合は暗黙な変換に従い数値に変換します。

<syntaxhighlight lang="javascript">
const two = "2";
console.log(+two); // 2
</syntaxhighlight>

==== 単項プラスと暗黙の型変換 ====
<syntaxhighlight lang="javascript">
const ary = [undefined, null, false, true, 0, 1, "", "1", [], [2]]
const json = ary.map(x => x === undefined ? "undefined" : JSON.stringify(x))
let s = ""
s += `{| class="wikitable"
|+ 単項プラスと暗黙の型変換
! ${json.join("!!")}
`
  s += `|-
| ${ary.map(x => `${+x}:${typeof(+x)}` ).join("||")}
`
s += `|}`
console.log(s)
</syntaxhighlight>

{| class="wikitable"
|+ 単項プラスと暗黙の型変換
! undefined!!null!!false!!true!!0!!1!!""!!"1"!![]!![2]
|-
| NaN:number||0:number||0:number||1:number||0:number||1:number||0:number||1:number||0:number||2:number
|}

=== 単項マイナス演算子 -() ===
'''単項マイナス演算子'''（たんこうマイナスえんざんし、''unary negation operator''）は符号を反転させた数（[[w:反数|反数]]）を返します。'''符号反転演算子'''（ふごうはんてんえんざんし）、'''算術否定演算子'''（さんじゅつひていえんざんし）などという言い方をする人もいます。

<syntaxhighlight lang="javascript">
const one = 1;
console.log(-one); // -1
</syntaxhighlight>

<code>''a'' * -1</code>と似ていますが BigInt が渡されても TypeError とはならない点が異なります。
<!-- 単項マイナス演算子は、デクリメント演算子と異なり左辺値式を取らない 
<code>-''a''</code>は<code>''a'' *= -1</code>、すなわち<code>''a'' = ''a'' * -1</code>と等価です。-->

=== インクリメント演算子 (++) ===
'''インクリメント演算子'''（インクリメントえんざんし、''increment operator''）は変数の値を1増やします。

<syntaxhighlight lang="javascript">
let x = 0;
x++;
console.log(x); // 1
</syntaxhighlight>

インクリメント演算子は後置<code>++</code>すると増やす前の値を返し、

<syntaxhighlight lang="javascript">
let x = 0;
const y = x++;
console.log(y); // 0
console.log(x); // 1
</syntaxhighlight>

<code>++</code>前置すると増やした後の値を返します。

<syntaxhighlight lang="javascript">
let x = 0;
const y = ++x;
console.log(y); // 1
console.log(x); // 1
</syntaxhighlight>

複数のインクリメント演算子を同時に適用することはできません。

<syntaxhighlight lang="javascript">
let x = 0;
(x++)++; // SyntaxError: Invalid left-hand side expression in postfix operation
</syntaxhighlight>

<code>''x''++</code>は<code>''x'' += 1</code>、すなわち<code>''x'' = ''x'' + 1</code>と等価です。インクリメント演算子は変数の値を増加させるので、<code>1++</code>のようにリテラル（定数）に対して適用することはできません。

=== デクリメント演算子 (--) ===
'''デクリメント演算子'''（デクリメントえんざんし、''decrement operator''）は変数の値を1減らします。

<syntaxhighlight lang="javascript">
let x = 0;
x--;
console.log(x); // -1
</syntaxhighlight>

デクリメント演算子は後置<code>--</code>すると減らす前の値を返し、

<syntaxhighlight lang="javascript">
let x = 0;
const y = x--;
console.log(y); // 0
console.log(x); // -1
</syntaxhighlight>

<code>--</code>前置すると減らした後の値を返します。

<syntaxhighlight lang="javascript">
let x = 0;
const y = --x;
console.log(y); // -1
console.log(x); // -1
</syntaxhighlight>

複数のデクリメント演算子を同時に適用することはできません。

<syntaxhighlight lang="javascript">
let x = 0;
(x--)--; // SyntaxError: Invalid left-hand side expression in postfix operation
</syntaxhighlight>

<code>''x''--</code>は<code>''x'' -= 1</code>、すなわち<code>''x'' = ''x'' - 1</code>と等価です。デクリメント演算子は変数の値を減少させるので、<code>1--</code>のようにリテラル（定数）に対して適用することはできません。

=== 冪乗演算子 (**) ===
冪乗演算子（べきじょうえんざんし）は、第1オペランドを第2オペランドの累乗した結果を返します。[[JavaScript/Math/pow|Math.pow]] と同等ですが、オペランドとして BigInt を受け入れることができます。

<syntaxhighlight lang="javascript">
const power = 2 ** 10;
console.log(power); // 1024
</syntaxhighlight>
なお、<code>^</code>はビットごとのXOR演算子です。

== ビット演算子 ==
'''ビット演算子'''（ビットえんざんし、''bitwise operator''）は、[[w:ビット演算|ビット演算]]の演算子です。ビット演算とは数値を32ビット整数変換し、各ビットに対して行う演算のことです。

{| class="wikitable"
|+ JavaScriptのビット演算子
! 演算子
! 意味
|-
| <code>''a'' & ''b''</code>
| ビットごとのAND
|-
| <code>''a'' <nowiki>|</nowiki> ''b''</code>
| ビットごとのOR
|-
| <code>''a'' ^ ''b''</code>
| ビットごとのXOR
|-
| <code>~''a''</code>
| ビットごとのNOT（補数）
|-
| <code>''a'' << ''b''</code>
| 左シフト
|-
| <code>''a'' >> ''b''</code>
| 右シフト
|-
| <code>''a'' >>> ''b''</code>
| 符号なし右シフト
|}

<code>''a'' >>> ''b''</code>は捨てられたビットの分だけ左から0を詰めます。
<code>' >>> </code>は BigInt に適用すると TypeError になります。
ビット演算子は算術演算子よりも優先順位が低いことに注意してください。

{{See also|[[JavaScript/ビット演算]]}}

== 文字列連結演算子 ==
<code>+</code>は加算演算子であると同時に、'''文字列連結演算子'''（もじれつれんけつえんざんし、''string concatenation operator''）でもあります。

<syntaxhighlight lang="javascript">
const str = "Wiki" + "books";
console.log(str); // "Wikibooks"
</syntaxhighlight>

文字列と数値を連結すると、文字列の方が強いので数値は文字列に変換されます。

<syntaxhighlight lang="javascript">
const str = "JavaScript " + 1.5;
console.log(str); // "JavaScript 1.5"
</syntaxhighlight>

これは足し算をしようとして文字列がまじっていると厄介なことになります。

<syntaxhighlight lang="javascript">
const one = "1";
const two = one + 1;
console.log(two); // "11" -- console.log()メソッドではわかりにくいですが、2文字の文字列です。
</syntaxhighlight>

文字列の連結よりも数値の加算を優先させるには、文字列を数値に変換した上で加算しなければなりません。文字列を数値に変換するには、教科書的には[[JavaScript/parseInt|parseInt]]関数や[[JavaScript/parseFloat|parseFloat]]関数、[[JavaScript/Number|Number]]オブジェクトのコンストラクタなどを使いますが、

<syntaxhighlight lang="javascript">
const one = "1";
const two = parseInt(one) + 1;
console.log(two); // 2
</syntaxhighlight>

一般的には単項プラス演算子を使用した方が高速です。

<syntaxhighlight lang="javascript">
const one = "1";
const two = +one + 1;
console.log(two); // 2
</syntaxhighlight>

ほかにも1を掛ける (<code>one * 1</code>)、0を引く (<code>one - 0</code>))などの方法があります。
これらの演算子は数値にしか適用できないので、処理系が被演算子を自動的に数値に変換（暗黙的な型変換）するためです。

かつてこの本で、'''0で符号なし右シフトをする (<code>one >>> 0</code>）'''あるいは '''補数の補数を得る(<code>~~one</code>)''' を'''文字列を数値に変換する方法'''として紹介されていましたが、前者は32ビット符号なし整数に、後者は32ビット符号付き整数への変換となり浮動小数点数を表す文字列に適用すると、、

<syntaxhighlight lang="javascript">
"3.14" >>> 0  === 3
"-3.14" >>> 0 === 4294967293
~~"3.14"  === 3
~~"-3.14" === -3
</syntaxhighlight>

の様になります。興味深い挙動ですが'''文字列を数値に変換する方法'''としては妥当とは言えません。

=== 加算と暗黙の型変換 ===
加算と暗黙の型変換の結果を表にしました。

<syntaxhighlight lang="javascript">
const ary = [undefined, null, false, true, 0, 1, "", "1", [], [2]]
const json = ary.map(x => x === undefined ? "undefined" : JSON.stringify(x))
let s = ""
s += `{| class="wikitable"
|+ 加算と暗黙の型変換
! ${["左辺＼右辺",...json].join("!!")}
`
for (const y of ary) {
  s += `|-
! ${y === undefined ? "undefined" : JSON.stringify(y)}
| ${ary.map(x => `${y + x}:${typeof(y + x)}` ).join("||")}
`
}
s += `|}`
console.log(s)
</syntaxhighlight>

{| class="wikitable"
|+ 加算と暗黙の型変換
! 左辺＼右辺!!undefined!!null!!false!!true!!0!!1!!""!!"1"!![]!![2]
|-
! undefined
| NaN:number||NaN:number||NaN:number||NaN:number||NaN:number||NaN:number||undefined:string||undefined1:string||undefined:string||undefined2:string
|-
! null
| NaN:number||0:number||0:number||1:number||0:number||1:number||null:string||null1:string||null:string||null2:string
|-
! false
| NaN:number||0:number||0:number||1:number||0:number||1:number||false:string||false1:string||false:string||false2:string
|-
! true
| NaN:number||1:number||1:number||2:number||1:number||2:number||true:string||true1:string||true:string||true2:string
|-
! 0
| NaN:number||0:number||0:number||1:number||0:number||1:number||0:string||01:string||0:string||02:string
|-
! 1
| NaN:number||1:number||1:number||2:number||1:number||2:number||1:string||11:string||1:string||12:string
|-
! ""
| undefined:string||null:string||false:string||true:string||0:string||1:string||:string||1:string||:string||2:string
|-
! "1"
| 1undefined:string||1null:string||1false:string||1true:string||10:string||11:string||1:string||11:string||1:string||12:string
|-
! []
| undefined:string||null:string||false:string||true:string||0:string||1:string||:string||1:string||:string||2:string
|-
! [2]
| 2undefined:string||2null:string||2false:string||2true:string||20:string||21:string||2:string||21:string||2:string||22:string
|}
この表は、二項演算子(+)と様々な値の組み合わせについて見てみました。

if文の条件式などのブーリアンコンテキストでの真理値への変換や、単項+の数値への変換は、また別の規則になります。

== 代入演算子 ==
{{See|[[JavaScript/変数]]}}
'''代入演算子'''（だいにゅうえんざんし、''assignment operator''）は変数に値を代入します。代入した値を返し、結合は右から左です<ref>[https://tc39.es/ecma262/#sec-assignment-operators ECMA-262::13.15 Assignment Operators]
</ref>。

<syntaxhighlight lang="javascript" line>
let x = 0;
console.log(x = 1); // 1

let a, b;
a = b = 0;
</syntaxhighlight>

=== 複合代入演算子 ===
複合代入演算子（ふくごうだいにゅうえんざんし、Compound assignment operators）は、<syntaxhighlight lang="javascript" inline>x = x OPERATOR y</syntaxhighlight>の形式を<syntaxhighlight lang="javascript" inline>x OPERATOR= y</syntaxhighlight>の形式に短縮表記したものです。代入演算子と同じ優先度を持ち、演算し代入した値を返し、結合は右から左です。<syntaxhighlight lang="javascript" inline>OPERATOR＝</syntaxhighlight>で１つのトークンで、<syntaxhighlight lang="javascript" inline>OPERATOR</syntaxhighlight>と<syntaxhighlight lang="javascript" inline>=</syntaxhighlight>の間に空白を含めることはできません。
例えば、<syntaxhighlight lang="javascript" inline>x *= y</syntaxhighlight>は<syntaxhighlight lang="javascript" inline>x = x * y</syntaxhighlight>と等価です。

<syntaxhighlight lang="javascript">
let x = 1;
x += 1;   // x = x + 1
console.log(x); // 2
</syntaxhighlight>

{| class="wikitable"
|+ JavaScriptの代入演算子の短縮表記
! 短縮表記
! 等価な表記
! 意味
|-
| <syntaxhighlight lang="javascript" inline>x += y</syntaxhighlight>
| <syntaxhighlight lang="javascript" inline>x = x + y</syntaxhighlight>
| 加算代入演算子 (Addition assignment operator)
|-
| <syntaxhighlight lang="javascript" inline>x -= y</syntaxhighlight>
| <syntaxhighlight lang="javascript" inline>x = x - y</syntaxhighlight>
| 減算代入演算子 (Subtraction assignment operator)
|-
| <syntaxhighlight lang="javascript" inline>x *= y</syntaxhighlight>
| <syntaxhighlight lang="javascript" inline>x = x * y</syntaxhighlight>
| 乗算代入演算子 (Multiplication assignment operator)
|-
| <syntaxhighlight lang="javascript" inline>x /= y</syntaxhighlight>
| <syntaxhighlight lang="javascript" inline>x = x / y</syntaxhighlight>
| 除算代入演算子 (Division assignment operator)
|-
| <syntaxhighlight lang="javascript" inline>x %= y</syntaxhighlight>
| <syntaxhighlight lang="javascript" inline>x = x % y</syntaxhighlight>
| 剰余代入演算子 (Remainder assignment operator)
|-
| <syntaxhighlight lang="javascript" inline>x **= y</syntaxhighlight>
| <syntaxhighlight lang="javascript" inline>x = x ** y</syntaxhighlight>
| 冪乗代入演算子 (Exponentiation assignment operator)
|-
| <syntaxhighlight lang="javascript" inline>x <<= y</syntaxhighlight>
| <syntaxhighlight lang="javascript" inline>x = x << y</syntaxhighlight>
| 左シフト代入演算子 (Left shift assignment operator)
|-
| <syntaxhighlight lang="javascript" inline>x >>= y</syntaxhighlight>
| <syntaxhighlight lang="javascript" inline>x = x >> y</syntaxhighlight>
| 右シフト代入演算子 (Right shift assignment operator)
|-
| <syntaxhighlight lang="javascript" inline>x >>>= y</syntaxhighlight>
| <syntaxhighlight lang="javascript" inline>x = x >>> y</syntaxhighlight>
| 符号なし右シフト代入演算子 (Unsigned right shift assignment operator)
|-
| <syntaxhighlight lang="javascript" inline>x &= y</syntaxhighlight>
| <syntaxhighlight lang="javascript" inline>x = x & y</syntaxhighlight>
| ビット間論理積代入演算子 (Bitwise AND assignment operator)
|-
| <syntaxhighlight lang="javascript" inline>x ^= y</syntaxhighlight>
| <syntaxhighlight lang="javascript" inline>x = x ^ y</syntaxhighlight>
| ビット間排他的論理和代入演算子 (Bitwise XOR assignment operator)
|-
| <syntaxhighlight lang="javascript" inline>x |= y</syntaxhighlight>
| <syntaxhighlight lang="javascript" inline>x = x | y</syntaxhighlight>
| ビット間論理和代入演算子 (Bitwise OR assignment operator)
|-
| <syntaxhighlight lang="javascript" inline>x &&= y</syntaxhighlight>
| <syntaxhighlight lang="javascript" inline>x = x && y</syntaxhighlight>
| 論理積代入演算子 (Logical AND assignment operator)
|-
| <syntaxhighlight lang="javascript" inline>x ||= y</syntaxhighlight>
| <syntaxhighlight lang="javascript" inline>x = x || y</syntaxhighlight>
| 論理和代入演算子 (Logical OR assignment operator)
|-
| <syntaxhighlight lang="javascript" inline>x ??= y</syntaxhighlight>
| <syntaxhighlight lang="javascript" inline>x = x ?? y</syntaxhighlight>
| 論理Null合体代入演算子 (Logical nullish assignment operator)
|}

=== 分割代入 ===
分割代入（ぶんかつだいにゅう、''Destructuring assignment''）は、配列の値やオブジェクトのプロパティを個別の変数に展開することができるJavaScriptの表現方法です<ref>[https://tc39.es/ecma262/#sec-destructuring-assignment ECMA-262::13.15.5 Destructuring Assignment]</ref>。

JavaScriptには、様々な種類の分割代入があります。以下に代表的なものを示します。
;[https://paiza.io/projects/ijm6a3Z0cMjbRoJGJUUo3w?language=javascript 分割代入の例]:<syntaxhighlight lang="javascript" line>
// 配列の分割代入
const [a, b, c] = [1, 2, 3];
console.log(a); // => 1
console.log(b); // => 2
console.log(c); // => 3

// オブジェクトの分割代入
const person = { name: 'Alice', age: 20 };
const { name, age } = person;
console.log(name); // => 'Alice'
console.log(age); // => 20

// 別名の指定
const { name: firstName, age: years } = person;
console.log(firstName); // => 'Alice'
console.log(years); // => 20

// デフォルト値の指定
const { name: names  = 'Anonymous', age: ages = 0 } = {};
console.log(names); // => 'Anonymous'
console.log(ages); // => 0

// 関数の引数としての分割代入
function foo({ x, y }) {
  console.log(x, y);
}

const point = { x: 1, y: 2 };
foo(point); // => 1 2

// 可変長引数の受け取り
function sum(a, b, ...rest) {
  console.log(a + b);
  console.log(rest);
}

sum(1, 2, 3, 4, 5); 
// => 3
// => [3, 4, 5]
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
1
2
3
Alice
20
Alice
20
Anonymous
0
1 2
3 
[ 3, 4, 5 ]
</syntaxhighlight>
このコードは、JavaScriptにおける分割代入の様々な使い方を示しています。

最初の例では、配列の分割代入を使用して、3つの変数 <code>a</code>、<code>b</code>、<code>c</code> にそれぞれ配列 <code>[1, 2, 3]</code> の要素を代入しています。

次に、オブジェクトの分割代入を使用して、オブジェクト <code>person</code> のプロパティ <code>name</code> と <code>age</code> を変数 <code>name</code> と <code>age</code> に代入しています。

その後、別名を指定してオブジェクトの分割代入を行い、変数 <code>firstName</code> と <code>years</code> に <code>person</code> オブジェクトのプロパティ <code>name</code> と <code>age</code> をそれぞれ代入しています。

次に、デフォルト値を指定してオブジェクトの分割代入を行い、空のオブジェクトから <code>name</code> プロパティが <code>Anonymous</code>、<code>age</code> プロパティが <code>0</code> のデフォルト値を持つ変数 <code>names</code> と <code>ages</code> を作成しています。

次に、関数の引数としての分割代入を示しています。 <code>foo</code> 関数は、オブジェクト <code>{ x, y }</code> を引数として受け取り、そのプロパティを <code>console.log</code> で表示するように定義されています。この関数は、<code>point</code> オブジェクトを引数として呼び出され、その結果、<code>1 2</code> が表示されます。

最後に、可変長引数を受け取る関数 <code>sum</code> を定義し、 <code>1</code> と <code>2</code> を最初の2つの引数として、残りの引数を可変長引数 <code>rest</code> に代入しています。<code>console.log</code> を使用して、最初の2つの引数の合計値と残りの引数を表示します。<code>sum(1, 2, 3, 4, 5)</code> が呼び出されると、<code>3</code> と <code>[3, 4, 5]</code> が表示されます。

== 論理演算子 ==
'''論理演算子'''（ろんりえんざんし、''logical operator''）とは、真偽値を返す論理的な演算子です。[[w:短絡評価|短絡評価]]と[[w:副作用 (プログラム)|副作用]]に注意してください<ref>[https://tc39.es/ecma262/#sec-binary-logical-operators ECMA-262::13.13 Binary Logical Operators]</ref>。

=== 論理積演算子 (&&) ===
論理積演算子は、両方のオペランドが true であったら true を、それ以外は false を返します。
==== 論理積演算子の構文 ====
<syntaxhighlight lang="javascript">left && right</syntaxhighlight>

=== 論理和演算子 (||) ===
論理和演算子は、片方または両方のオペランドが true であったら true を、それ以外は false を返します。
==== 論理和演算子の構文 ====
<syntaxhighlight lang="javascript">left || right</syntaxhighlight>

=== 否定演算子 (!) ===
否定演算子は、オペランドを論理型に変換した後、true であったら false を、false であったら true を返します。
==== 否定演算子の構文 ====
<syntaxhighlight lang="javascript">! bool</syntaxhighlight>

JavaScriptに[[w:排他的論理和|排他的論理和]]演算子は存在しませんが、
* <code>Boolean(''p'') != Boolean(''q'')</code>
と真偽値に変換した後、不一致を評価する式で実現できます。
* <code>!''p'' != !''q''</code>
でも可。

== 関係演算子 ==
'''関係演算子'''（かんけいえんざんし、''Relational operator''）とは、大小関係あるいは包含関係を比較して[[JavaScript/Boolean|真偽値]]を返す演算子です<ref>[https://tc39.es/ecma262/#sec-relational-operators ECMA-262::13.10 Relational Operators]</ref>。

<code>=<</code> や <code>=></code> のようなに <code>=</code> が先にくる関係演算子は存在しないので気をつけてください（特に <code>=></code> はアロー関数の構文で書き方によっては SyntaxError とならず発見困難なバグの原因になります）。大小比較は必ず手前に大なり小なり、後にイコールが来ます。

=== in 演算子 ===
in 演算子は、プロパティがオブジェクトに含まれると true を返します。for in 文の in とは違います。
==== in 演算子の構文 ====
<syntaxhighlight lang="javascript">prop in obj</syntaxhighlight>

=== instanceof 演算子 ===
instanceof 演算子は、コンストラクタのprototype プロパティがオブジェクトのプロトタイプ・チェーンのどこかに現れるかどうかをテストします。戻り値は、論理値です<ref>[https://tc39.es/ecma262/#sec-instanceofoperator ECMA-262::13.10.2 InstanceofOperator ( V, target )]</ref>。
==== instanceof 演算子の構文 ====
<syntaxhighlight lang="javascript">obj1 instanceof obj2</syntaxhighlight>

=== 小なり演算子 ===
小なり演算子は、左辺が右辺より小さいかどうかをテストします。戻り値は、論理値です。
==== 小なり演算子の構文 ====
<syntaxhighlight lang="javascript">left < right</syntaxhighlight>

=== 小なりイコール演算子 ===
小なりイコール演算子は、左辺が右辺より小さいあるいは等しいかをテストします。戻り値は、論理値です。
==== 小なりイコール演算子の構文 ====
<syntaxhighlight lang="javascript">left <= right</syntaxhighlight>

=== 大なり演算子 ===
大なり演算子は、左辺が右辺より大きいかどうかをテストします。戻り値は、論理値です。
==== 大なり演算子の構文 ====
<syntaxhighlight lang="javascript">left > right</syntaxhighlight>

=== 大なりイコール演算子 ===
大なりイコール演算子は、左辺が右辺より大きいあるいは等しいかをテストします。戻り値は、論理値です。
==== 大なりイコール演算子の構文 ====
<syntaxhighlight lang="javascript">left >= right</syntaxhighlight>

== 等値演算子 ==
'''等値演算子'''（とうかえんざんし、''equality operators''）とは、比較して[[JavaScript/Boolean|真偽値]]を返す演算子です<ref>[https://tc39.es/ecma262/#sec-equality-operators ECMA-262::13.11 Equality Operators]</ref>。

=== 等価演算子 (==) ===
等価演算子は、左辺が右辺と等しいかをテストします。比較は暗黙の型変換の後に行われます。戻り値は、論理値です。
==== 等価演算子の構文 ====
<syntaxhighlight lang="javascript">left == right</syntaxhighlight>

=== 不等価演算子 (!=) ===
不等価演算子は、左辺が右辺と等しくないかをテストします。比較は暗黙の型変換の後に行われます。戻り値は、論理値です。
==== 不等価演算子の構文 ====
<syntaxhighlight lang="javascript">left != right</syntaxhighlight>

=== 同値演算子 (===) ===
同値演算子（厳密一致演算子）は、左辺が右辺と等しいかをテストします。型が異なれば直ちに不一致を返します。戻り値は、論理値です。N
==== 同値演算子の構文 ====
<syntaxhighlight lang="javascript">left === right</syntaxhighlight>

=== 不同値演算子 (!==) ===
不同値演算子（厳密不一致演算子）は、左辺が右辺と等しくないかをテストします。型が異なれば直ちに不一致を返します。戻り値は、論理値です。
==== 不同値演算子の構文 ====
<syntaxhighlight lang="javascript">left !== right</syntaxhighlight>

{{コラム|0と-0の比較|
<syntaxhighlight lang="javascript">
0 == -0;  // ES6 では true
0 === -0; // ES6 では true
</syntaxhighlight>
ES6より前は 0 と -0 は一致しませんでしたが、ES6 以降は  0 と -0 は一致するようになりました。これは厳密一致についても同じです。
}}

== プロパティアクセサ ==
'''プロパティアクセサ'''（''property accessor''）とは、オブジェクトの（メソッドを含む）プロパティにアクセスするための演算子式で、左辺値式です。

=== ドット記法のプロパティアクセサ ===
ドット記法のプロパティアクセサは、<code>object '''.''' property</code>の構文で、<code>'''.'''</code>を挟んだ二項式です。
ドット記法では、<code>property</code>が識別子として有効なときにのみ使え識別子以外を用いると SyntaxError を throw します。
<syntaxhighlight lang="javascript">
const object = {};
object.myName = "tom"; // 正常
object.123 = 0; // SyntaxError:
object.my-name = "lisa"; // SyntaxError:
</syntaxhighlight>

=== ブラケット記法のプロパティアクセサ ===
ブラケット記法のプロパティアクセサは、<code>''object'' '''[''' ''property'' ''']'''</code>の構文で、<code>'''[ ]'''</code>を使った配列アクセス似の記法です。文字列の他、Symbol もキーにできます。
<syntaxhighlight lang="javascript">
const object = {};
object["myName"] = "tom"; // 正常
object["123"] = 0; // 正常
object["my-name"] = "lisa"; // 正常
</syntaxhighlight>

== 条件演算子 ==
条件が真なら式1を評価しその値を返す、条件が真でなければ式2を評価しその値を返します。
<syntaxhighlight lang="js"> 条件 ? 式1 : 式2 </syntaxhighlight>

== カンマ演算子 ==
カンマで区切られた式を左から順に評価し、最後の式の値を返す
<syntaxhighlight lang="js"> 式1, 式2, 式3, 式4, 式5 ...,式n</syntaxhighlight>

== グループ化演算子 ==
グループ化演算子は、評価の優先順位を制御します。最上位の優先度を有しますが、短絡評価の影響を受けます<ref>[https://tc39.es/ecma262/#sec-grouping-operator ECMA-262::13.2.9 The Grouping Operator]</ref>。
<syntaxhighlight lang="js"> ( 式 )</syntaxhighlight>

== delete演算子 ==
delete演算子 はオブジェクトからプロパティを取り除きます。
<syntaxhighlight lang="js">delete プロパティ</syntaxhighlight>

== 関数呼び出し演算子 ==
関数名に続く括弧はグループ化演算子ではなく、関数呼び出しです。
<syntaxhighlight lang="js"> 関数名 ( 引数列 ) </syntaxhighlight>

== new演算子 ==
new 演算子は、ユーザー定義のオブジェクト型や、コンストラクタ機能を持つ組み込みオブジェクト型のインスタンスを作成します<ref>[https://tc39.es/ecma262/#sec-new-operator ECMA-262::13.3.5 The new Operator]</ref>。

=== new演算子の構文 ===
;構文:<syntaxhighlight lang="js"> new コンストラクタ [ ( [ パラメータ列 ] ) ]</syntaxhighlight>
;[https://paiza.io/projects/dWM8oB-5HTzZe7vbjg29Jw?language=javascript 例]:<syntaxhighlight lang="js">
/*
 * function 製のコンストラクタに適用した例
 */
const T = function(x = 0) {
    this.x = x;
}
T.prototype.value = function() {
    return this.x;
}

const t = new T(42);
console.log(t.value())

/*
 * class に適用した例
 */
class C {
    constructor(x = 0) {
        this.x = x;
    }
    value() {
        return this.x;
    }
}

const c = new C(13);
console.log(c.value())
</syntaxhighlight>
;実行結果:<syntaxhighlight lang=text>
42 
13
</syntaxhighlight>

== void 演算子 ==
式を評価し（結果に関わらず）undefined を返します。
<syntaxhighlight lang="js"> void 式 </syntaxhighlight>

== yield 演算子 ==
yieldキーワードは、ジェネレータ機能（[[JavaScript/関数#ジェネレーター関数|function*]]）を一時停止および再開するために使用します<ref>[https://tc39.es/ecma262/#prod-YieldExpression ECMA-262::YieldExpression]</ref>。
<syntaxhighlight lang="js"> yeild 式 </syntaxhighlight>

== yield* 演算子 ==
yield*式は、別のジェネレータやイテレート可能なオブジェクトに処理を委譲します<ref>[https://tc39.es/ecma262/#sec-generator-function-definitions-runtime-semantics-evaluation ECMA-262::15.5.5 Runtime Semantics: Evaluation]</ref>。
<syntaxhighlight lang="js"> yeild* 式 </syntaxhighlight>

== typeof 演算子 ==
'''typeof演算子'''（タイプオブえんざんし、''typeof operator''）はデータ型を返します。
<syntaxhighlight lang="js"> typeof 式 </syntaxhighlight>

<syntaxhighlight lang="javascript">
typeof 42;              // "number"
typeof "Hello, world!"; // "string"
typeof [1,2,3];         // "object"； Arrayラッパーオブジェクト
typeof new Array();     // "object"； Arrayラッパーオブジェクト
typeof new String("ab");// "object"； Stringラッパーオブジェクト
typeof new RegExp();    // "object"； RegExpラッパーオブジェクト
typeof new Set();       // "object"； Setラッパーオブジェクト
typeof new WeakSet();   // "object"； WeakSetラッパーオブジェクト
typeof new Map();       // "object"； Mapラッパーオブジェクト
typeof new WeakMap();   // "object"； WeakMapラッパーオブジェクト
typeof function(){};    // "function"
typeof true;            // "boolean"
typeof void 0;          // "undefined"
typeof null;            // "object"; ラッパーではなく互換性のための仕様
typeof 123n;            // "bigint"
typeof Symbol();        // "symbol"
typeof {};              // "object"
</syntaxhighlight>

== 結合性 ==
同じ優先順位の演算子（下表参照）が連なった時の評価順序を'''結合性'''（けつごうせい、associativity）といいます。

; '''左結合'''（ひだりけつごう、left-associative）
: '''左から右'''に評価される演算
: <syntaxhighlight lang="js" inline>( expr1 OP1 expr2 ) OP2 expr3</syntaxhighlight>と解釈される
: 典型的には四則
; '''右結合'''（みぎけつごう、right-associative）
: '''右から左'''に評価される演算
: <syntaxhighlight lang="js" inline>expr1 OP1 ( expr2 OP2 expr3 )</syntaxhighlight>と解釈される
: 典型的には代入

たとえば、<syntaxhighlight lang="js" inline>a - b - c</syntaxhighlight>は<syntaxhighlight lang="js" inline>a - (b - c)</syntaxhighlight>ではなく<syntaxhighlight lang="js" inline>(a - b) - c</syntaxhighlight>と左から右に評価されるため、減算演算子は左結合です。また、<syntaxhighlight lang="js" inline>a = b = c</syntaxhighlight>は<syntaxhighlight lang="js" inline>(a = b) = c</syntaxhighlight>ではなく<syntaxhighlight lang="js" inline>a = (b = c)</syntaxhighlight>と評価されるため、代入演算子は右結合です。インクリメント演算子<syntaxhighlight lang="js" inline>++</syntaxhighlight>やデクリメント演算子<syntaxhighlight lang="js" inline>--</syntaxhighlight>は、左辺値式ではないので <syntaxhighlight lang="js" inline>x++ ++</syntaxhighlight> とすると SyntaxErroor となり結合性は定義されません。

=== 結合性の例題 ===
次の式の演算子の結合性を述べ、それに従い括弧を補ってください。

# <syntaxhighlight lang="js" inline>typeof typeof object</syntaxhighlight>
# <syntaxhighlight lang="js" inline>p == q == r</syntaxhighlight>
# <syntaxhighlight lang="js" inline>a > 0 ? 1 : a < 0 ? -1 : 0</syntaxhighlight>
# <syntaxhighlight lang="js" inline>a, b, c</syntaxhighlight>


=== 結合性の例題の解答 ===
# 右結合：<syntaxhighlight lang="js" inline>typeof ( typeof object )</syntaxhighlight>と解釈されます。
# 左結合：<syntaxhighlight lang="js" inline>p == q == r</syntaxhighlight>は<syntaxhighlight lang="js" inline>( p == q ) == r</syntaxhighlight>と解釈されます。
# 右結合：<syntaxhighlight lang="js" inline>a > 0 ? 1 : ( a < 0 ? -1 : 0 )</syntaxhighlight>と解釈される<ref>条件演算子は短絡評価されるので、条件式が真であった場合には第三項は評価されないです。</ref>。
# 左結合：<syntaxhighlight lang="js" inline>( a, b ), c</syntaxhighlight>と解釈されます（式の値は、c となります）。

== 演算子の優先順位 ==
{| class="sortable wikitable"
|+ JavaScriptの演算子の優先順位と結合性<ref>スプレッド構文は演算子ではないので含めていません。</ref>
|- style="position:sticky; top:0"
!優先順位!!演算子のタイプ!!結合性!!構文
|-
! rowspan=1 | 21
| style="text-align:left;padding: 0 1em" | グループ化 
| style="text-align:center;padding: 0 1em" | なし 
| style="text-align: center ;padding: 0 1em" | ( ... )
|-
! rowspan=5 | 20
| style="text-align:left;padding: 0 1em" |ドット記法プロパティアクセサ
| rowspan=2 style="text-align:center;padding: 0 1em" | 左から右へ 
| style="text-align: center ;padding: 0 1em" | ... . ...
|-
| style="text-align:left;padding: 0 1em" | ブラケット記法プロパティアクセサ
| style="text-align: center ;padding: 0 1em" | ... [ ... ]
|-
| style="text-align:left;padding: 0 1em" | new（引数リスト付き） 
| rowspan=1 style="text-align:center;padding: 0 1em" | なし 
| style="text-align: center ;padding: 0 1em" | new ... ( ... )
|-
| style="text-align:left;padding: 0 1em" | 関数の呼び出し
| rowspan=2 style="text-align:center;padding: 0 1em" | 左から右へ 
| style="text-align: center ;padding: 0 1em" | ... ( ... )
|-
| style="text-align:left;padding: 0 1em" | オプショナルチェイニング 
| style="text-align: center ;padding: 0 1em" | ?.
|-
! rowspan=1 | 19
| style="text-align:left;padding: 0 1em" | new (引数リストなし) 
| style="text-align:center;padding: 0 1em" | 右から左へ 
| style="text-align: center ;padding: 0 1em" | new ...
|-
! rowspan=2 | 18
| style="text-align:left;padding: 0 1em" | 後置インクリメント
| rowspan=2 style="text-align:center;padding: 0 1em" | なし 
| style="text-align: center ;padding: 0 1em" | ... ++
|-
| style="text-align:left;padding: 0 1em" | 後置 デクリメント
| style="text-align: center ;padding: 0 1em" | ... --
|-
! rowspan=10 | 17
| style="text-align:left;padding: 0 1em" | ロジカルNOT (!)
| rowspan=4 style="text-align:center;padding: 0 1em" | 右から左へ
| style="text-align: center ;padding: 0 1em" | ! ...
|-
| style="text-align:left;padding: 0 1em" | ビット単位のNOT (~)
| style="text-align: center ;padding: 0 1em" | ~ ...
|-
| style="text-align:left;padding: 0 1em" | 単項プラス (+)
| style="text-align: center ;padding: 0 1em" | + ...
|-
| style="text-align:left;padding: 0 1em" | 単項マイナス (-)
| style="text-align: center ;padding: 0 1em" | - ...
|-
| style="text-align:left;padding: 0 1em" | 前置インクリメント 
| rowspan=2  style="text-align:center;padding: 0 1em" | なし
| style="text-align: center ;padding: 0 1em" | ++ ...
|-
| style="text-align:left;padding: 0 1em" | 前置 デクリメント  
| style="text-align: center ;padding: 0 1em" | -- ...
|-
| style="text-align:left;padding: 0 1em" | typeof 
| rowspan=4 style="text-align:center;padding: 0 1em" | 右から左へ 
| style="text-align: center ;padding: 0 1em" | typeof ...
|-
| style="text-align:left;padding: 0 1em" | void
| style="text-align: center ;padding: 0 1em" | void ...
|-
| style="text-align:left;padding: 0 1em" | delete
| style="text-align: center ;padding: 0 1em" | delete  ...
|-
| style="text-align:left;padding: 0 1em" | await
| style="text-align: center ;padding: 0 1em" | await ...
|-
! rowspan=1 | 16
| style="text-align:left;padding: 0 1em" | 累乗(**) 
| style="text-align:center;padding: 0 1em" | 右から左へ
| style="text-align: center ;padding: 0 1em" | ... ** ...
|-
! rowspan=3 | 15
| style="text-align:left;padding: 0 1em" | 乗算(*)
| rowspan=3 style="text-align:center;padding: 0 1em" | 左から右へ 
| style="text-align: center ;padding: 0 1em" | ... * ...
|-
| style="text-align:left;padding: 0 1em" | 除算(/)
| style="text-align: center ;padding: 0 1em" | ... / ...
|-
| style="text-align:left;padding: 0 1em" | 剰余(%)
| style="text-align: center ;padding: 0 1em" | ... % ...
|-
! rowspan=2 | 14
| style="text-align:left;padding: 0 1em" | 加算(+)
| rowspan=2 style="text-align:center;padding: 0 1em" | 左から右へ
| style="text-align: center ;padding: 0 1em" | ... + ...
|-
| style="text-align:left;padding: 0 1em" | 減算(-)
| style="text-align: center ;padding: 0 1em" | ... - ...
|-
! rowspan=3 | 13
| style="text-align:left;padding: 0 1em" | 左シフト(<<)
| rowspan=3 style="text-align:center;padding: 0 1em" | 左から右へ 
| style="text-align: center ;padding: 0 1em" | ... << ...
|-
| style="text-align:left;padding: 0 1em" | 右シフト (>>) 
| style="text-align: center ;padding: 0 1em" | ... >> ...
|-
| style="text-align:left;padding: 0 1em" | 符号なし右シフト (>>>)
| style="text-align: center ;padding: 0 1em" | ... >>> ...
|-
! rowspan=6 | 12
| style="text-align:left;padding: 0 1em" | 小さい (<) 
| rowspan=6 style="text-align:center;padding: 0 1em" |左から右へ
| style="text-align: center ;padding: 0 1em" | ... < ...
|-
| style="text-align:left;padding: 0 1em" | 小さいか同じ (<=)
| style="text-align: center ;padding: 0 1em" | ... <= ...
|-
| style="text-align:left;padding: 0 1em" | 大きい (>)
| style="text-align: center ;padding: 0 1em" | ... > ...
|-
| style="text-align:left;padding: 0 1em" | 大きいか同じ (>=)
| style="text-align: center ;padding: 0 1em" | ... >= ...
|-
| style="text-align:left;padding: 0 1em" | in
| style="text-align: center ;padding: 0 1em" | ... in ...
|-
| style="text-align:left;padding: 0 1em" | instanceof
| style="text-align: center ;padding: 0 1em" | ... instanceof ...
|-
! rowspan=4 | 11
| style="text-align:left;padding: 0 1em" | 等式(==) 
| rowspan=4 style="text-align:center;padding: 0 1em" | 左から右へ
| style="text-align: center ;padding: 0 1em" | ... == ...
|-
| style="text-align:left;padding: 0 1em" | 不等式(!=)
| style="text-align: center ;padding: 0 1em" | ... != ...
|-
| style="text-align:left;padding: 0 1em" | 厳密な等式(===)
| style="text-align: center ;padding: 0 1em" | ... === ...
|-
| style="text-align:left;padding: 0 1em" | 厳密な不等式(!==)
| style="text-align: center ;padding: 0 1em" | ... !== ...
|-
! rowspan=1 | 10
| style="text-align:left;padding: 0 1em" | ビット単位の論理積(&)
| style="text-align:center;padding: 0 1em" | 左から右へ
| style="text-align: center ;padding: 0 1em" | ... & ...
|-
! rowspan=1 | 9
| style="text-align:left;padding: 0 1em" | ビット単位の排他的論理和(^) 
| style="text-align:center;padding: 0 1em"| 左から右へ
| style="text-align: center ;padding: 0 1em" | ... ^ ...
|-
! rowspan=1 | 8
| style="text-align:left;padding: 0 1em" | ビット単位の論理和(<nowiki>|</nowiki>) 
| style="text-align:center;padding: 0 1em"| 左から右へ
| style="text-align: center ;padding: 0 1em" | ... <nowiki>|</nowiki> ...
|-
! rowspan=1 | 7
| style="text-align:left;padding: 0 1em" | 論理積(&&) 
| style="text-align:center;padding: 0 1em" | 左から右へ
| style="text-align: center ;padding: 0 1em" | ... && ...
|-
! rowspan=1 | 6
| style="text-align:left;padding: 0 1em" | 論理和(<nowiki>||</nowiki>) 
| style="text-align:center;padding: 0 1em" | 左から右へ
| style="text-align: center ;padding: 0 1em" | ... <nowiki>||</nowiki> ...
|-
! rowspan=1 | 5
| style="text-align:left;padding: 0 1em" | Null合体 
| style="text-align:center;padding: 0 1em" | 左から右へ
| style="text-align: center ;padding: 0 1em" | ... ?? ...
|-
! rowspan=1 | 4
| style="text-align:left;padding: 0 1em" | 条件演算子(?:) 
| style="text-align:center;padding: 0 1em" | 右から左へ
| style="text-align: center ;padding: 0 1em" | ... ? ... : ...
|-
! rowspan=16 | 3
| rowspan=16  style="text-align:left;padding: 0 1em"  | 代入演算子 
| rowspan=16 style="text-align:center;padding: 0 1em" | 右から左へ
| style="text-align: center ;padding: 0 1em" | … = …
|-
| style="text-align: center ;padding: 0 1em" | … += …
|-
| style="text-align: center ;padding: 0 1em" | … -= …
|-
| style="text-align: center ;padding: 0 1em" | … **= …
|-
| style="text-align: center ;padding: 0 1em" | … *= …
|-
| style="text-align: center ;padding: 0 1em" | … /= …
|-
| style="text-align: center ;padding: 0 1em" | … %= …
|-
| style="text-align: center ;padding: 0 1em" | … <<= …
|-
| style="text-align: center ;padding: 0 1em" | … >>= …
|-
| style="text-align: center ;padding: 0 1em" | … >>>= …
|-
| style="text-align: center ;padding: 0 1em" | … &= …
|-
| style="text-align: center ;padding: 0 1em" | … ^= …
|-
| style="text-align: center ;padding: 0 1em" | … <nowiki>|</nowiki>= …
|-
| style="text-align: center ;padding: 0 1em" | … &&= …
|-
| style="text-align: center ;padding: 0 1em" | … <nowiki>||</nowiki>= …
|-
| style="text-align: center ;padding: 0 1em" | … ??= …
|-
! rowspan=2 | 2
| style="text-align:left;padding: 0 1em" | yield	
| rowspan=2 style="text-align:center;padding: 0 1em" |右から左へ
| style="text-align: center ;padding: 0 1em" | yield …
|-
| style="text-align:left;padding: 0 1em" | yield*
| style="text-align: center ;padding: 0 1em" |	yield* …
|-
! rowspan=1 | 1
| style="text-align:left;padding: 0 1em" | カンマ演算子
| style="text-align:center;padding: 0 1em" | 左から右へ
| style="text-align: center ;padding: 0 1em" | ... , ...
|}

{{Nav}}

== 脚註 ==
<references />

[[Category:JavaScript|えんさんし]]
{{stub}}