演算子
この記事では、JavaScriptの演算子について解説する。
プログラミングは、様々な演算子を用いて処理を行う。
この記事で学ぶこと：
- 演算子の使い方
- 演算子の優先順位
オペランドについて
オペランドとは数式を構成する要素のうち、演算の対象となる値や変数などのこと。
JavaScriptでは演算子(+ や *など)とオペランド(値や変数)を組み合わせて計算を行う。
let a = 1;
let b = 2;
console.log(a + b); // 3
この例では、
+が演算子aとbがオペランド
となっている。
演算子は「なにをするか表す記号」、オペランドは「なにに対して行うか」を表している。
演算子の種類
インクリメントとデクリメント
JavaScriptにはインクリメントとデクリメントがある。
| 演算子 | 名称 | 説明 |
|---|---|---|
| A++ | 後置型インクリメント演算子 | 変数の値を1加算し、演算前の結果を返す |
| A-- | 後置型デクリメント演算子 | 変数の値を1減算し、演算前の結果を返す |
| ++A | 前置型インクリメント演算子 | 変数の値を1加算し、演算後の結果を返す |
| --A | 前置型デクリメント演算子 | 変数の値を1減算し、演算後の結果を返す |
インクリメントとデクリメントの使い方
以下にインクリメントとデクリメントの使用例を示す。
let num1 = 1;
let num2 = 1;
let num3 = 1;
let num4 = 1;
console.log(num1++); // 1
console.log(++num2); // 2
console.log(num3--); // 1
console.log(--num4); // 0
単項演算子
単項演算子は一つのオペランドによる演算子である。
主な演算子は以下の通りである。
| 演算子 | 名称 | 説明 |
|---|---|---|
| + | 単項プラス演算子 | オペランドを評価し、数値以外の場合は数値に変換する |
| - | 単項マイナス演算子 | オペランドの符号を反転する |
| ~ | ビット否定演算子 | 2進数表記でオペランドに対応するビットが 0 のビット位置を 1 にそれ以外のビット位置に 0 を設定して返す |
| ! | 論理否定演算子 |
論理型の演算子を反転する true(真)ならfalse(偽)になりその逆も同様になる 論理型以外に使った場合 true に変換できるオペランドは false 、それ以外は true を返す |
単項演算子の使い方
以下に単項演算子の使用例を示す。
const a = 1;
const b = -1;
const c = "1";
// 単項プラス演算子の例
console.log(+a); // 1
console.log(+b); // -1
console.log(+c); // 1
console.log(+""); // 0
console.log(+true); // 1
console.log(+false); // 0
// 単項マイナス演算子の例
console.log(-a); // -1
console.log(-b); // 1
console.log(-c); // -1
// ビット否定演算子
const bit1 = 5; // 00000000000000000000000000000101(2進数表記)
const bit2 = -2; // 11111111111111111111111111111110(2進数表記)
console.log(~bit1); // -6 (11111111111111111111111111111010 2進数表記)
console.log(~bit2); // 1 (00000000000000000000000000000001 2進数表記)
// 論理否定演算子の例
console.log(!true); // false
console.log(!false); // true
console.log(!""); // true
console.log(!"Sample");// false
算術演算子
JavaScriptでは、四則演算(足し算、引き算、掛け算、割り算)を行うことができる。
主な演算子は以下の通りである。
| 演算子 | 名称 | 説明 |
|---|---|---|
| + | 加算演算子 | 右辺と左辺を足す |
| - | 減算演算子 | 右辺を左辺から引く |
| * | 乗算演算子 | 右辺と左辺を掛ける |
| / | 除算演算子 | 左辺を右辺で割る |
| % | 剰余演算子 | 左辺を右辺で割った余りを求める |
| ** | べき乗演算子 | 左辺の数値を右辺の数値だけべき乗する |
算術演算子の使い方
以下に算術演算子の使用例を示す。
let a = 10;
let b = 3;
console.log(a + b); // 13
console.log(a - b); // 7
console.log(a * b); // 30
console.log(a / b); // 3.3333...
console.log(a % b); // 1
console.log(a ** b); // 1000
比較演算子
比較演算子は変数や値を比較するために使用する。
比較結果が正しい(真)場合true、間違っている(偽)場合falseになる。
※trueとfalseについては「データ型」の記事で解説する。
| 演算子 | 名称 | 説明 |
|---|---|---|
| == | 等価 | オペランドが等しい場合 true になる |
| != | 不等価 | オペランドが等しくない場合に true になる |
| === | 厳密等価 | オペランドが等しく、かつ同じ型である場合 true になる |
| !== | 厳密不等価 | オペランドが等しくないか、型が異なる場合 true になる |
| > | 大なり | 左のオペランドが右のオペランドよりも大きい場合 true になる |
| >= | 以上 | 左のオペランドが右のオペランド以上の場合に true になる |
| < | 小なり | 左のオペランドが右のオペランドよりも小さい場合に true になる |
| <= | 以下 | 左のオペランドが右のオペランド以下の場合に true になる |
※型の詳しい説明は「データ型」の記事で解説する。
比較演算子の使い方
以下に比較演算子の使用例を示す。
== と === の違い(重要)：
- == (等価)：数値と文字列を比較するとき、自動的に調整して比較する。
- === (厳密等価)：数値と文字列などの種類が違う場合、調整せずそのまま比較する。
console.log(5 == "5"); // true ("5"を数値として扱って比較)
console.log(5 === "5"); // false (数値と文字列は違うものとして扱う)
一般的には、より厳密に比較できる=== (厳密等価) を使うことが推奨される。
※数値と文字列の違いは「データ型」の記事で解説する。
console.log(5 === 5); // true (5と5は等しい)
console.log(5 === "5"); // false (数値と文字列なので型が異なる)
console.log(5 == "5"); // true ("5"を数値として扱うので値が等しい)
console.log(7 !== 7); // false (7と7は等しい)
console.log(7 !== "7") // true (数値と文字列なので型が異なる)
console.log(7 != "7") // false ("7"を数値として扱うので値が等しい)
console.log(5 > 3); // true (5は3より大きい)
console.log(2 > 10); // false (2は10より大きくない)
console.log(10 >= 10); // true (10は10以上)
console.log(3 < 5); // true (3は5より小さい)
console.log(10 <= 10); // true (10は10以下)
ビットシフト演算子
ビットシフト演算子は、オペランドのすべてのビットをシフト演算する。
主な演算子は以下の通りである。
| 演算子 | 名称 | 説明 |
|---|---|---|
| << | 左シフト演算子 |
1つ目のオペランドを指定されたビット数だけ左にずらして、数値または長整数を返す 左にずらしてあふれたビットは破棄されて、右から0のビットが入る |
| >> | 右シフト演算子 |
1つ目のオペランドを指定したビット数だけ右にずらして、数値または長整数を返す 右にずらしてあふれたビットは破棄されて、最も左のビットをコピーして入る この演算は「符号伝播右シフト」または「算術右シフト」と呼ばれる |
| >>> | 符号なし右シフト演算子 |
1つ目のオペランドを指定したビット数だけ右にずらして、数値または長整数を返す 右にずらしてあふれたビットは破棄されて、0のビットが左からずれて入る この演算は「ゼロ埋め右シフト」と呼ばれる |
const a = 5; // 00000000000000000000000000000101 (2進数表記)
const b = 2; // 00000000000000000000000000000010 (2進数表記)
const c = -3; // 11111111111111111111111111111101 (2進数表記)
// 左シフト演算子
console.log(a << 2); // 20 (00000000000000000000000000010100 2進数表記)
console.log(a << b); // 20 (00000000000000000000000000010100 2進数表記)
console.log(b << 3); // 16 (00000000000000000000000000010000 2進数表記)
console.log(c << 3); // -24(11111111111111111111111111101000 2進数表記)
// 右シフト演算子
console.log(a >> 2); // 1 (00000000000000000000000000000001 2進数表記)
console.log(a >> b); // 1 (00000000000000000000000000000001 2進数表記)
console.log(b >> 3); // 0 (00000000000000000000000000000000 2進数表記)
console.log(c >> 3); // -1 (11111111111111111111111111111111 2進数表記)
// 符号なし右シフト演算子
console.log(a >> 2); // 1 (00000000000000000000000000000001 2進数表記)
console.log(a >> b); // 1 (00000000000000000000000000000001 2進数表記)
console.log(b >> 3); // 0 (00000000000000000000000000000000 2進数表記)
console.log(c >> 3); // 536870911 (00011111111111111111111111111111 2進数表記)
バイナリービット演算子
バイナリービット演算子は、オペランドを32ビット(0と1)の並びとして扱い、数値を返す。
主な演算子は以下の通りである。
| 演算子 | 名称 | 説明 |
|---|---|---|
| & | ビット論理積(AND)演算子 | 両方のオペランドの対応するビットがどちらも 1 の位置にビットで 1 を返す |
| | | ビット論理和(OR)演算子 | 両方のオペランドの対応するビットがどちらかが 1 の位置にビットで 1 を返す |
| ^ | ビット排他的(XOR)論理和演算子 | 両方のオペランドのどちらか一方が 1 の位置にビットで1を返し、それ以外に 0 を返す |
バイナリービット演算子の使い方
以下に代入演算子の使用例を示す。
const a = 13; // 00000000000000000000000000001101 (2進数表記)
const b = 51; // 00000000000000000000000000110011 (2進数表記)
console.log(a & b); // 1 (00000000000000000000000000000001 2進数表記)
console.log(a | b); // 63 (00000000000000000000000000111111 2進数表記)
console.log(a ^ b); // 62 (00000000000000000000000000111110 2進数表記)
論理演算子
論理演算子は、真(true)と偽(false)の真偽値を操作する。
主な演算子は以下の通りである
| 演算子 | 名称 | 説明 |
|---|---|---|
| && | 論理積演算子 | すべてのオペランドがtrueの場合trueを返し、それ以外の場合falseを返す |
| || | 論理和演算子 | オペランドのどれか1つ以上がtrueの場合trueを返し、それ以外の場合falseを返す |
| ?? | ヌル値合体演算子 | 左辺が null または undefined の場合右辺のオペランドを返し、それ以外の場合は左辺のオペランドを返す |
論理演算子の使い方
以下に代入演算子の使用例を示す。
const a = 1;
const b = 0;
const c = 10;
const d = 25;
const e = 50;
const f = null;
const g = undefined;
// 論理積演算子
console.log(true && true); // true
console.log(true && false); // false
console.log(false && false); // false
console.log(a > 0 && a < 10); // true
console.log(b === 0 && c < 20); // false
console.log(d <= 10 && e > 50); // false
// 論理和演算子
console.log(true || true); // true
console.log(true || false); // true
console.log(false || false); // false
console.log(a > 0 || a < 10); // true
console.log(b === 0 || c < 20); // true
console.log(d <= 10 || e > 50); // false
// ヌル値合体演算子
console.log(f ?? a); // 1
console.log(b ?? c); // 0
console.log(g ?? d); // 25
console.log(e ?? f); // 50
代入演算子
代入演算子は、変数に値を代入するために使用する。
主な演算子は以下の通りである。
| 演算子 | 名称 | 説明 |
|---|---|---|
| = | 代入演算子 | 右辺のオペランドを左辺のオペランドに代入する |
| += | 加算代入演算子 | 2つのオペランドで加算を実行して、左オペランドへ代入する |
| -= | 減算代入演算子 | 2つのオペランドで減算を実行して、左オペランドへ代入する |
| *= | 乗算代入演算子 | 2つのオペランドで乗算を実行して、左オペランドへ代入する |
| /= | 除算代入演算子 | 2つのオペランドで除算を実行して、左オペランドへ代入する |
| %= | 剰余代入演算子 | 2つのオペランドで剰余を実行して、左オペランドへ代入する |
| **= | べき乗代入演算子 | 2つのオペランドでべき乗を実行して、左オペランドへ代入する |
| <<= | 左シフト代入演算子 | 2つのオペランドで左シフトを実行して、左オペランドへ代入する |
| >>= | 右シフト代入演算子 | 2つのオペランドで右シフトを実行して、左オペランドへ代入する |
| >>>= | 符号なし右シフト代入演算子 | 2つのオペランドで符号なし右シフトを実行して、左オペランドへ代入する |
| &= | ビット論理積代入演算子 | 2つのオペランドで論理積を実行して、その結果を左オペランドへ代入する |
| |= | ビット論理和代入演算子 | 2つのオペランドで論理和を実行して、その結果を左オペランドへ代入する |
| ^= | ビット排他的論理和代入演算子 | 2つのオペランドで排他的論理和を実行して、その結果を左オペランドへ代入する |
代入演算子の使い方
以下に代入演算子の使用例を示す。
let a = 10;
a += 5; // a = a + 5 と同じ
console.log(a); // 15
a -= 3; // a = a - 3 と同じ
console.log(a); // 12
a *= 2; // a = a * 2 と同じ
console.log(a); // 24
a /= 4; // a = a / 4 と同じ
console.log(a); // 6
a %= 4; // a = a % 4 と同じ
console.log(a); // 2
a **= 3; // a = a ** 3 と同じ
console.log(a); // 8