Go言語で排他的論理和（XOR）を活用する方法：ビット演算の基本から応用まで

2026年5月22日

演算子

Goプログラミングにおいて、ビット演算はパフォーマンスの最適化や低レイヤーの処理を行う上で欠かせない要素です。

その中でも「排他的論理和（XOR）」は、暗号化アルゴリズムやデータの誤り検出、フラグ操作など、非常に幅広いシーンで応用されています。

Go言語はシンプルな構文を持ちながら、強力なビット演算子を提供しており、これらを使いこなすことで効率的なコードを記述することが可能です。

本記事では、Go言語における排他的論理和の基本概念から、具体的なコード例を用いた応用手法までを詳しく解説します。

目次 [ close ]

排他的論理和（XOR）の基本概念

排他的論理和とは、2つのビットを比較した際に、「値が異なる場合にのみ 1 を返し、同じ場合には 0 を返す」論理演算のことです。

数学的な表現では「XOR」と呼ばれ、プログラミングにおいては論理回路の基本要素として広く知られています。

以下の表は、2つの入力 A と B に対する XOR 演算の結果を示した真理値表です。

入力 A	入力 B	出力（A XOR B）
0	0	0
0	1	1
1	0	1
1	1	0

この表から分かる通り、両方の値が 1 もしくは 0 で一致している場合は結果が 0 になります。

一方で、一方が 1 でもう一方が 0 の場合のみ、結果が 1 となります。

この性質を利用することで、データの反転や差分の抽出といった高度な操作が可能になります。

Go言語におけるXOR演算子の使い方

Go言語で排他的論理和を行うには、キャレット記号（^）を演算子として使用します。

Goのビット演算子は整数型（int, uint, byte, runeなど）に対して直接適用することができます。

まずは、最も基本的な数値同士の演算例を確認してみましょう。

package main

import "fmt"

func main() {
    // 10（バイナリ: 1010）と 12（バイナリ: 1100）のXOR
    var a int = 10
    var b int = 12
    result := a ^ b

    fmt.Printf("a: %04b (%d)\n", a, a)
    fmt.Printf("b: %04b (%d)\n", b, b)
    fmt.Printf("結果: %04b (%d)\n", result, result)
}

実行結果

a: 1010 (10)
b: 1100 (12)
結果: 0110 (6)

この例では、1010 と 1100 の各ビットを比較しています。

1番左のビットは共に 1 なので 0 に、2番目のビットは 0 と 1 なので 1 になります。

その結果、バイナリで 0110 すなわち 10進数の 6 が得られます。

Goにおけるビット反転（NOT）との関係

Go言語特有の注意点として、単項演算子としての ^ は「ビット反転（NOT）」として機能するという点があります。

C言語などの多くの言語ではビット反転に ~ を使用しますが、Go言語では ^ を使用します。

例えば、^x と記述した場合は x のすべてのビットを反転させる意味になります。

二項演算子として x ^ y と書いた場合は排他的論理和になりますので、混同しないように注意しましょう。

排他的論理和の重要な3つの性質

XORを応用するためには、その数学的な性質を理解しておくことが不可欠です。

特に以下の3つの法則は、アルゴリズムの設計において頻繁に利用されます。

自己反転の性質： x ^ x = 0 （同じ値を XOR すると 0 になる）
零元の性質： x ^ 0 = x （0 と XOR しても値は変わらない）
交換法則・結合法則： a ^ b = b ^ a および (a ^ b) ^ c = a ^ (b ^ c) が成り立つ

これらの性質を組み合わせると、特定のデータを2回 XOR 演算することで元のデータに戻すという「可逆性」が生まれます。

これが暗号化やデータのリカバリにおいて XOR が重宝される最大の理由です。

実践的な活用例1：変数の値を入れ替える（XOR Swap）

一時的な変数を使わずに、2つの変数の値を入れ替える手法として「XOR Swap」というテクニックがあります。

Go言語では通常 a, b = b, a というタプル代入を用いるのが一般的ですが、ビット演算の学習としては非常に有用な例です。

package main

import "fmt"

func main() {
    a, b := 5, 9
    fmt.Printf("入れ替え前: a=%d, b=%d\n", a, b)

    // XOR Swapアルゴリズム
    a = a ^ b
    b = a ^ b // (a ^ b) ^ b => a ^ (b ^ b) => a ^ 0 => a
    a = a ^ b // (a ^ b) ^ a => (a ^ a) ^ b => 0 ^ b => b

    fmt.Printf("入れ替え後: a=%d, b=%d\n", a, b)
}

実行結果

入れ替え前: a=5, b=9
入れ替え後: a=9, b=5

このコードは、先に紹介した「自己反転」と「結合法則」を巧みに利用しています。

現代のコンパイラでは通常の代入の方が最適化されやすいですが、メモリ制約が極端に厳しい環境や、低レイヤーのプログラミングでは今でも目にすることがあります。

実践的な活用例2：配列から重複していない唯一の要素を探す

コーディングテストやアルゴリズムの分野でよく出題される問題に、「ペアの中で1つだけ孤立している数値を見つける」というものがあります。

これには XOR の「同じ値を2回 XOR すると 0 になる」という性質が最適です。

package main

import "fmt"

func findUnique(nums []int) int {
    unique := 0
    for _, num := range nums {
        // 全ての要素を順にXORしていく
        unique ^= num
    }
    return unique
}

func main() {
    // 3, 5, 3 の場合、3 ^ 3 が 0 になり、残った 5 が結果となる
    data := []int{4, 1, 2, 1, 2}
    result := findUnique(data)
    fmt.Printf("唯一の要素は: %d\n", result)
}

実行結果

唯一の要素は: 4

この手法の素晴らしい点は、追加のメモリ（ハッシュマップなど）を一切必要とせず、時間計算量 O(n) で解決できる点にあります。

数値がどのような順番で並んでいても、最終的にペアが存在する数値はすべて 0 になり、1つだけの数値が残ります。

実践的な活用例3：簡易的なデータの暗号化（XOR暗号）

排他的論理和は、ストリーム暗号の最も基本的な形として利用されます。

特定の「鍵（Key）」を用いてデータに XOR を適用すると、一見ランダムなデータに変わります。

そして、もう一度同じ鍵で XOR を適用すると、元のデータが復元されます。

package main

import "fmt"

func xorEncryptDecrypt(input []byte, key byte) []byte {
    output := make([]byte, len(input))
    for i := 0; i < len(input); i++ {
        // 各バイトに対して鍵をXOR演算
        output[i] = input[i] ^ key
    }
    return output
}

func main() {
    message := "Go Language"
    var key byte = 42 // 秘密鍵

    // 暗号化
    encrypted := xorEncryptDecrypt([]byte(message), key)
    fmt.Printf("暗号化済み: %x\n", encrypted)

    // 復号
    decrypted := xorEncryptDecrypt(encrypted, key)
    fmt.Printf("復号済み: %s\n", string(decrypted))
}

実行結果

暗号化済み: 6d450a664b444d5f4b4d4f
復号済み: Go Language

もちろん、これは簡易的な手法であり、現代の高度なセキュリティ要件を満たすものではありません。

しかし、通信プロトコルの難読化や、簡単なチェックサムの生成など、高速性が求められる軽量な処理には非常に有効です。

Go言語でのビット操作におけるパフォーマンスの利点

なぜ 2026年という現代においても、このようなビット演算を学ぶ必要があるのでしょうか。

それは、ビット演算が CPU レベルで最も高速に実行される命令の一つだからです。

Go言語のコンパイラは非常に優秀であり、ビット演算をネイティブなマシンコードへ極めて効率的に変換します。

大量のデータを処理するシステムや、リアルタイム性が求められるアプリケーションにおいて、if文や算術演算をビット演算に置き換えることで、劇的なパフォーマンス向上が見込める場合があります。

特に Go 1.2x 系以降のバージョンでは、特定のハードウェア命令（SIMDなど）をより積極的に活用するように最適化が進んでいます。

math/bits パッケージなどと組み合わせることで、さらに高度なビット操作も可能になります。

ビットフラグの管理における XOR の役割

開発現場で XOR がよく使われるもう一つの例は、「フラグの反転」です。

ビットマスクを用いて特定のステータスを管理している場合、XOR を使うことで特定のフラグだけを「オンならオフに、オフならオンに」切り替えることができます。

package main

import "fmt"

const (
    Read    = 1 << 0 // 0001
    Write   = 1 << 1 // 0010
    Execute = 1 << 2 // 0100
)

func main() {
    permissions := Read | Write
    fmt.Printf("現在の権限: %03b\n", permissions)

    // Write権限を反転させる
    permissions ^= Write
    fmt.Printf("反転後の権限: %03b\n", permissions)

    // 再度Write権限を反転させて元に戻す
    permissions ^= Write
    fmt.Printf("再反転後の権限: %03b\n", permissions)
}

実行結果

現在の権限: 011
反転後の権限: 001
再反転後の権限: 011

このように、permissions ^= Write とするだけで、現在の状態を確認する if 文を書くことなく、状態をトグル（切り替え）させることが可能です。

コードが簡潔になるだけでなく、条件分岐（ブランチ）を減らすことができるため、CPU の分岐予測にも優しい実装となります。

まとめ

Go言語における排他的論理和（XOR）は、単なる数学的な演算を超えて、非常に実用性の高いツールです。

^ 演算子一つで、データの入れ替え、ユニークな要素の探索、簡易暗号化、フラグ操作といった多様な処理を高速に行うことができます。

ビット演算の基本特性である「同じ値を XOR すると 0 になる」「2回適用すると元に戻る」というルールを覚えるだけで、プログラミングの幅は大きく広がります。

パフォーマンスが重視される Go 言語の特性を最大限に引き出すためにも、ぜひこの機会に XOR をはじめとするビット演算をマスターしてください。

より深く学びたい方は、Goの標準ライブラリである math/bits パッケージのリファレンスを読み、さらに高度なビット操作に挑戦してみることをおすすめします。