JavaScriptの演算子の使い方と優先順位を徹底解説

let a = 5;
let b = 3;
let sum = a + b; // 結果は8

let str1 = "Hello, ";
let str2 = "world!";
let greeting = str1 + str2; // 結果は "Hello, world!"

let x = 10;
let y = 4;
let difference = x - y; // 結果は6

let m = 7;
let n = 6;
let product = m * n; // 結果は42

let p = 20;
let q = 4;
let quotient = p / q; // 結果は5

let r = 10;
let s = 3;
let remainder = r % s; // 結果は1

let base = 2;
let exponent = 3;
let power = base ** exponent; // 結果は8

let num1 = 5;
num1++; // 結果は6（後置インクリメント）

let num2 = 5;
++num2; // 結果は6（前置インクリメント）

let num3 = 5;
num3--; // 結果は4（後置デクリメント）

let num4 = 5;
--num4; // 結果は4（前置デクリメント）

let a = 5;
let b = '5';
console.log(a == b); // 結果はtrue（型が異なっても値が等しいため）

let c = 5;
let d = '5';
console.log(c === d); // 結果はfalse（型が異なるため）

let e = 5;
let f = '6';
console.log(e != f); // 結果はtrue（値が異なるため）

let g = 5;
let h = '5';
console.log(g !== h); // 結果はtrue（型が異なるため）

let i = 10;
let j = 5;
console.log(i > j); // 結果はtrue（10は5より大きいため）

let k = 3;
let l = 7;
console.log(k < l); // 結果はtrue（3は7より小さいため）

let m = 5;
let n = 5;
console.log(m >= n); // 結果はtrue（5は5以上であるため）

let o = 3;
let p = 5;
console.log(o <= p); // 結果はtrue（3は5以下であるため）

let a = true;
let b = false;
console.log(a && b); // 結果はfalse（片方がfalseのため）

let c = true;
let d = true;
console.log(c && d); // 結果はtrue（両方がtrueのため）

let e = true;
let f = false;
console.log(e || f); // 結果はtrue（片方がtrueのため）

let g = false;
let h = false;
console.log(g || h); // 結果はfalse（両方がfalseのため）

let i = true;
console.log(!i); // 結果はfalse（trueを反転させるため）

let j = false;
console.log(!j); // 結果はtrue（falseを反転させるため）

let age = 25;
let hasDrivingLicense = true;

// 年齢が18歳以上で、かつ運転免許を持っている場合
if (age >= 18 && hasDrivingLicense) {
    console.log("運転できます");
} else {
    console.log("運転できません");
}

// 年齢が18歳以上または運転免許を持っている場合
if (age >= 18 || hasDrivingLicense) {
    console.log("一部の条件を満たしています");
} else {
    console.log("条件を満たしていません");
}

let a = 5;  // 0101（2進数）
let b = 3;  // 0011（2進数）
let result = a & b; // 結果は1（0001）
console.log(result); // 1

let c = 5;  // 0101（2進数）
let d = 3;  // 0011（2進数）
let result = c | d; // 結果は7（0111）
console.log(result); // 7

let e = 5;  // 0101（2進数）
let f = 3;  // 0011（2進数）
let result = e ^ f; // 結果は6（0110）
console.log(result); // 6

let g = 5;  // 0101（2進数）
let result = ~g; // 結果は-6（反転してから符号反転、11111010 -> 2の補数表現）
console.log(result); // -6

let h = 5;  // 0101（2進数）
let result = h << 1; // 結果は10（1010）
console.log(result); // 10

let i = 5;  // 0101（2進数）
let result = i >> 1; // 結果は2（0010）
console.log(result); // 2

let j = -5;  // 11111111111111111111111111111011（2進数）
let result = j >>> 1; // 結果は2147483645（0111111111111111111111111111101）
console.log(result); // 2147483645

let result = 5 + 3 * 2; // 結果は11（3 * 2が先に評価されるため）
console.log(result);

   let result = (5 + 3) * 2; // 結果は16（括弧内が先に評価されるため）
   console.log(result);

   let arr = [1, 2, 3];
   console.log(arr[0]); // 結果は1

   let x = 5;
   console.log(!false); // 結果はtrue
   console.log(++x); // 結果は6

   let result = 10 / 2 * 3; // 結果は15
   console.log(result);

   let result = 10 - 5 + 3; // 結果は8
   console.log(result);

   console.log(5 > 3); // 結果はtrue

   console.log(5 === '5'); // 結果はfalse

   console.log(true && false); // 結果はfalse

   console.log(true || false); // 結果はtrue

let result = 5 + 3 * 2 > 10 || 4 < 2;
console.log(result); // 結果はtrue（3 * 2が先に評価され、次に加算と比較が行われる）

let result = 10 + 5 * 2 < 20 && 4 == 4;

console.log(result); // 結果はfalse

let result = 5 - 2 + 3; // 左から右へ順番に評価
// まず、5 - 2が評価される → 3
// 次に、3 + 3が評価される → 6
console.log(result); // 結果は6

let a = 10 / 2 * 3; // 左から右へ順番に評価
// まず、10 / 2が評価される → 5
// 次に、5 * 3が評価される → 15
console.log(a); // 結果は15

let x = y = 10; // 右から左へ順番に評価
// まず、yに10が代入される → y = 10
// 次に、xにyの値が代入される → x = 10
console.log(x); // 結果は10
console.log(y); // 結果は10

let b = 10;
let c = 5;
b += c *= 2; // 右から左へ順番に評価
// まず、c *= 2が評価される → c = 10
// 次に、b += cが評価される → b = 20
console.log(b); // 結果は20
console.log(c); // 結果は10

let result = 2 + 3 * 4 / 2 - 1; // 左結合と優先順位を考慮して評価
// まず、3 * 4が評価される（左結合のため左から右へ）→ 12
// 次に、12 / 2が評価される → 6
// 次に、2 + 6が評価される → 8
// 最後に、8 - 1が評価される → 7
console.log(result); // 結果は7

let result = 5 + 3 * 2 ** 2 / 4 - 1;
// 優先順位と結合規則に従って評価されるステップ
// 1. べき乗（**）が最初に評価される → 2 ** 2 = 4
// 2. 乗算（*）が次に評価される → 3 * 4 = 12
// 3. 除算（/）が次に評価される → 12 / 4 = 3
// 4. 加算（+）が次に評価される → 5 + 3 = 8
// 5. 減算（-）が最後に評価される → 8 - 1 = 7
console.log(result); // 結果は7

let a = 10;
let b = 5;
let result = (a > b) ? a : b * 2 && b + 1;
// 優先順位と結合規則に従って評価されるステップ
// 1. 比較演算子（>）が最初に評価される → 10 > 5 = true
// 2. 三項演算子（? :）の条件部分がtrueなので、次はtrue部分が評価される → a
console.log(result); // 結果は10

let x = 2;
let y = 3;
let z = 4;
x = y += z *= 2;
// 優先順位と結合規則に従って評価されるステップ
// 1. 乗算（*）が最初に評価される → z *= 2 → z = 8
// 2. 代入演算子（+=）が次に評価される → y += 8 → y = 11
// 3. 代入演算子（=）が最後に評価される → x = 11
console.log(x); // 結果は11
console.log(y); // 結果は11
console.log(z); // 結果は8

let a = true;
let b = false;
let c = true;
let result = a && b || c;
// 優先順位と結合規則に従って評価されるステップ
// 1. 論理AND（&&）が最初に評価される → true && false = false
// 2. 論理OR（||）が次に評価される → false || true = true
console.log(result); // 結果はtrue

let a = 5;
let b = 10;
let c = 15;
let result = (a + b) * c;
// 優先順位と結合規則に従って評価されるステップ
// 1. 括弧内の加算（+）が最初に評価される → 5 + 10 = 15
// 2. 乗算（*）が次に評価される → 15 * 15 = 225
console.log(result); // 結果は225

let a = 5;
let b = 10;
let c = 15;
let result = (a + b * c > 50) && (b - a < c);
// 優先順位と結合規則に従って評価されるステップ
// 1. 乗算（*）が最初に評価される → 10 * 15 = 150
// 2. 加算（+）が次に評価される → 5 + 150 = 155
// 3. 比較演算子（>）が次に評価される → 155 > 50 = true
// 4. 減算（-）が次に評価される → 10 - 5 = 5
// 5. 比較演算子（<）が次に評価される → 5 < 15 = true
// 6. 論理AND（&&）が最後に評価される → true && true = true
console.log(result); // 結果はtrue

function multiply(x, y) {
    return x * y;
}

function add(x, y) {
    return x + y;
}

let a = 5;
let b = 10;
let result = multiply(add(a, b), a);
// 優先順位と結合規則に従って評価されるステップ
// 1. 関数呼び出し（add）が最初に評価される → add(5, 10) = 15
// 2. 関数呼び出し（multiply）が次に評価される → multiply(15, 5) = 75
console.log(result); // 結果は75

let a = 20;
let b = 15;
let c = 10;
let result = (a > b) ? (b > c ? a + b : b + c) : (a > c ? a - c : b - a);
// 優先順位と結合規則に従って評価されるステップ
// 1. 最初の条件（a > b）が評価される → 20 > 15 = true
// 2. trueの場合の次の条件（b > c）が評価される → 15 > 10 = true
// 3. trueの場合の式（a + b）が評価される → 20 + 15 = 35
console.log(result); // 結果は35

let a = 7;
let b = 3;
let c = 5;
let result = (a % b == 1) || (a + b > c) && (c - b < a);
// 優先順位と結合規則に従って評価されるステップ
// 1. 剰余演算子（%）が最初に評価される → 7 % 3 = 1
// 2. 等値演算子（==）が次に評価される → 1 == 1 = true
// 3. 加算（+）が次に評価される → 7 + 3 = 10
// 4. 比較演算子（>）が次に評価される → 10 > 5 = true
// 5. 減算（-）が次に評価される → 5 - 3 = 2
// 6. 比較演算子（<）が次に評価される → 2 < 7 = true
// 7. 論理AND（&&）が次に評価される → true && true = true
// 8. 論理OR（||）が最後に評価される → true || true = true
console.log(result); // 結果はtrue