Mo

主题

00:00:00
2025-09-212025-09-29编程Go
6168
26.1m
0

go位运算 ​

概述 ​

在计算机内存昂贵，处理能力有限的美好旧时光里，用比较黑客范的位运算方式去处理信息是首选方式（某些情况下只能如此）。时至今日，直接使用位运算仍然是很多计算领域中不可或缺的部分，例如底层系统编程，图形处理，密码学等。

Go 编程语言支持以下按位运算符：

运算符含义（中英文）
&按位与（bitwise AND）
|按位或（bitwise OR）
^按位异或（bitwise XOR）
&^按位与非（AND NOT）
<<左移（left shift）
>>右移（right shift）

本文的余下部分详述了每个操作符以及它们如何使用的案例。

& 运算符 ​

在 Go 中， & 运算符在两个整型操作数中执行按位 AND 操作。AND 操作具有以下属性:

math
Given operands a, b
AND(a, b) = 1; only if a = b = 1
else = 0
  • Given operands a, b ：“给定操作数 a 和 b”，这里的 a 和 b 指的是两个二进制位（只能是 0 或 1，不是十进制数字）。
  • AND(a, b) = 1; only if a = b = 1 ：“当且仅当 a 和 b 都等于 1 时，a 和 b 的按位与结果为 1”。例：AND(1, 1) = 1（只有这一种情况结果为 1）。
  • else = 0：“其他情况下，结果为 0”。
  • 包含三种情况：
    • a=0, b=0 → AND(0, 0) = 0
    • a=0, b=1 → AND(0, 1) = 0
    • a=1, b=0 → AND(1, 0) = 0

在编程语言中，按位与运算会对两个整数的每一对对应二进制位执行上述规则。例如：

go
a := 3  // 二进制：011（十进制 3）
b := 5  // 二进制：101（十进制 5）
c := a & b  // 按位与运算
// 计算过程：
//  011
// &101
// ----
//  001  → 十进制 1
// 所以 c 的值为 1

这里的每一位都遵循 AND(a, b) 的规则：

  • 第 0 位：1 & 1 = 1
  • 第 1 位：1 & 0 = 0
  • 第 2 位：0 & 1 = 0

总结来说，这句话定义了 “按位与” 运算（用符号 & 表示）的计算规则，适用于二进制位（0 或 1）的运算：

  • 当参与运算的两个二进制位（a 和 b）同时为 1 时，运算结果为 1；
  • 其他所有情况（只要有一个位是 0），运算结果都为 0。

AND 运算符具有选择性清除整型数据对应位为 0 的特性。例如，我们可以使用 & 运算符将一个数的最后 4 个最低有效位（LSB）全部清除为 0（即保留高 4 位，清除低 4 位）。

go
// TestClearLast4LSB 使用 & 运算符清除最后 4 个最低有效位（LSB）为 0
func TestClearLast4LSB(t *testing.T) {
  var x uint8 = 0xAC // x = 10101100（二进制）
  x = x & 0xF0       // 与 11110000（0xF0）进行与运算，结果为 10100000（0xA0）
  // 验证结果：0xF0 与 0xAC 进行与运算后应得到 0xA0
  expected := uint8(0xA0)
  if x != expected {
    t.Errorf("位运算结果错误: 期望 0x%X，实际得到 0x%X", expected, x)
  }
  t.Logf("位运算结果: 期望 0x%X，实际得到 0x%X", expected, x)
}

所有位运算符都支持简写的赋值形式（即 op= 形式）。例如，前面的例子可以简化为：

go
// TestBitwiseShortAssignmentForLSB 使用 &= 简写形式清除最后 4 个最低有效位（LSB）为 0
func TestBitwiseShortAssignmentForLSB(t *testing.T) {
  var x uint8 = 0xAC // x = 10101100（二进制）
  // &= 是 & 运算符的简写赋值形式（等价于 x = x & 0xF0）
  x &= 0xF0 // 结果为 10100000（0xA0）

  // 验证结果：0xF0 与 0xAC 进行与运算后应得到 0xA0
  expected := uint8(0xA0)
  if x != expected {
    t.Errorf("位运算结果错误: 期望 0x%X，实际得到 0x%X", expected, x)
  }
  t.Logf("位运算结果: 期望 0x%X，实际得到 0x%X", expected, x)
}

另外一个巧妙的技巧是：你可以用 & 操作去测试一个数字是奇数还是偶数。原因是当一个数字的二进制最低位是 1 时，它就是奇数。我们可以用一个数字和 1 进行 & 操作，如果结果是 1，那么这个原始数字就是奇数；如果结果是 0，则为偶数。

go
// TestOddEvenWithBitwise 用 & 操作测试一个数字是奇数还是偶数
// 原理：任何整数与1进行与运算，结果为1则是奇数，为0则是偶数
func TestOddEvenWithBitwise(t *testing.T) {
  // 初始化随机数生成器
  r := rand.New(rand.NewSource(time.Now().UnixNano()))

  // 测试100个随机数
  for i := range make([]struct{}, 100) {
    num := r.Int() // 使用新生成器产生随机数
    // 使用位运算判断奇偶
    isOdd := num&1 == 1 
    // 使用取模运算作为对照验证
    expectedOdd := num%2 == 1 
    // 记录测试结果
    t.Logf("测试第%d个数字: %d, 位运算判断为%s",
      i+1, num, map[bool]string{true: "奇数", false: "偶数"}[isOdd])  
    // 验证位运算结果是否正确
    if isOdd != expectedOdd {
      t.Errorf("判断错误: 数字%d, 位运算判断为%s, 实际为%s",
        num,
        map[bool]string{true: "奇数", false: "偶数"}[isOdd],
        map[bool]string{true: "奇数", false: "偶数"}[expectedOdd])
    }
  }
}

| 操作符 ​

| （按位或）对整型操作数执行按位或运算。回想一下或操作符具备以下性质：

math
Given operands a, b
OR(a, b) = 1; when a = 1 or b = 1
else = 0

其运算规则为：

  • 对两个操作数的每一位分别进行逻辑或操作，当且仅当两位中至少有一位为 1 时，结果位为 1；否则为 0 。

按位或的核心特性是 “有选择地为整数设置特定位为 1”：通过构造一个 “掩码”（mask），将需要设置为 1 的位设为 1，其余位设为 0，再与目标数执行 | 运算，即可保留目标数原有 1 的位，同时将掩码中为 1 的位强制设为 1。

以下示例通过按位或操作，将 uint8 类型变量 a 的第 3 位、第 7 位和第 8 位（从低位开始计数，最低位为第 1 位）设置为 1。

go
// TestSetBitsWithOr 用按位或（|）操作有选择地设置整数的特定位为1
// 目标：将uint8类型变量的第3位、第7位、第8位（从低位开始计数）设为1
func TestSetBitsWithOr(t *testing.T) {
  var a uint8 = 0 // 初始值：00000000（二进制）

  // 构造掩码：需要设置的位为1，其余为0
  // 第3位（2^2）、第7位（2^6）、第8位（2^7）对应的掩码计算：
  // 2^2 = 4，2^6 = 64，2^7 = 128 → 掩码 = 4 + 64 + 128 = 196
  mask := uint8(196) // 掩码二进制：11000100（第3、7、8位为1）  

  a |= mask // 按位或操作：0 | 196 = 196（二进制11000100） 

  // 预期结果：196（二进制11000100）
  expected := uint8(196)
  if a != expected {
    t.Errorf("按位或结果错误：期望 %b（0x%X），实际 %b（0x%X）",
      expected, expected, a, a)
  } 

  // 验证特定位是否被正确设置（分别检查第3、7、8位）
  // 检查方法：用对应位的掩码与结果做&运算，若不为0则该位为1
  bitsToCheck := []struct {
    bit  int   // 位序号（从1开始）
    mask uint8 // 该位对应的掩码（2^(bit-1)）
  }{
    {bit: 3, mask: 1 << 2}, // 第3位：2^2 = 4（二进制00000100）
    {bit: 7, mask: 1 << 6}, // 第7位：2^6 = 64（二进制01000000）
    {bit: 8, mask: 1 << 7}, // 第8位：2^7 = 128（二进制10000000）
  } 

  for _, check := range bitsToCheck {
    if (a & check.mask) == 0 {
      t.Errorf("第%d位未被正确设置为1：实际值为0", check.bit)
    } else {
      t.Logf("第%d位设置正确：值为1", check.bit)
    }
  } 
  t.Logf("最终结果：%b（0x%X）", a, a)
}

位掩码技术是通过位运算实现多状态配置的高效方式，其中按位或（|） 用于组合多个配置项（设置特定位），按位与（&） 用于检查配置项是否生效（查询特定位）。这种方式的优势在于：用一个整数即可表示多种状态组合，且操作高效、扩展性强。

例如，通过定义一系列 2 的幂次方常量（确保每个常量对应唯一的位），可将其作为配置项。使用 | 可组合多个配置，使用 & 可判断某个配置是否被启用。下面的测试函数演示了如何用位掩码控制字符串的多种转换操作。

go
// 定义位掩码常量（每个常量对应一个2的幂，确保二进制中只有一位为1）
const (
  UPPER = 1 << iota // 1 << 0 = 1（二进制0001）：转换为大写
  LOWER             // 1 << 1 = 2（二进制0010）：转换为小写
  CAP               // 1 << 2 = 4（二进制0100）：单词首字母大写
  REV               // 1 << 3 = 8（二进制1000）：反转字符串
)

// procstr 根据位掩码配置对字符串执行转换操作
// 参数：
//
//  str: 待转换的字符串
//  conf: 位掩码配置（通过UPPER|LOWER|CAP|REV组合）
//
// 返回：转换后的字符串
func procstr(str string, conf byte) string {
  // 反转字符串的内部函数
  rev := func(s string) string {
    runes := []rune(s)
    n := len(runes)
    for i := 0; i < n/2; i++ {
      runes[i], runes[n-1-i] = runes[n-1-i], runes[i]
    }
    return string(runes)
  }

  // 根据位掩码配置执行对应操作（用&判断特定位是否被设置）
  if (conf & UPPER) != 0 {
    str = strings.ToUpper(str)
  }
  if (conf & LOWER) != 0 {
    str = strings.ToLower(str)
  }
  if (conf & REV) != 0 {
    str = rev(str)
  }
  if (conf & CAP) != 0 {
    str = cases.Title(language.English).String(str)
  }
  return str
}

// TestBitmaskConfig 测试位掩码技术在多配置场景中的应用
// 验证通过|组合配置项、通过&查询配置项的正确性
func TestBitmaskConfig(t *testing.T) {
  // 测试用例：输入字符串和预期结果
  testCases := []struct {
    name     string
    input    string
    conf     byte
    expected string
  }{
    {
      name:     "LOWER|REV|CAP组合",
      input:    "HELLO PEOPLE!",
      conf:     LOWER | REV | CAP, // 2|8|4=14（二进制1110）
      expected: "!Elpoep Olleh",
    },
    {
      name:     "UPPER|REV组合",
      input:    "hello",
      conf:     UPPER | REV, // 1|8=9（二进制1001）
      expected: "OLLEH",
    },
    {
      name:     "无配置",
      input:    "test",
      conf:     0,
      expected: "test",
    },
  }

  for _, tc := range testCases {
    t.Run(tc.name, func(t *testing.T) {
      result := procstr(tc.input, tc.conf)
      if result != tc.expected {
        t.Errorf("配置%s处理失败\n输入: %q\n预期: %q\n实际: %q",
          tc.name, tc.input, tc.expected, result)
        return
      }
      t.Logf("配置%s处理成功\n输入: %q\n配置值: %d（二进制%04b）\n结果: %q",
        tc.name, tc.input, tc.conf, tc.conf, result)
    })
  }
}

该方法通过位掩码组合配置实现字符串的多步转换，具体过程如下：

  • 配置组合：LOWER|REV|CAP 是通过按位或（|）组合的配置项，对应的值为 2|8|4=14（二进制 1110）。其中：
    • 第 2 位（从低位开始计数，对应值 2）代表 LOWER（转换为小写）；
    • 第 3 位（对应值 4）代表 CAP（单词首字母大写）；
    • 第 4 位（对应值 8）代表 REV（反转字符串）。
  • 执行逻辑：方法内部通过连续的按位与（&）判断配置项是否生效，按 “先转换大小写 → 再反转 → 最后首字母大写” 的顺序执行转换：
    • 第一步：(conf & LOWER) != 0 为真，将字符串转为小写 → "hello people!"；
    • 第二步：(conf & REV) != 0 为真，反转字符串 → "!elpoep olleh"；
    • 第三步：(conf & CAP) != 0 为真，将每个单词的首字母大写 → "!Elpoep Olleh"。
  • 优势：通过位掩码技术，仅用一个整数（14）即可表示多种操作的组合，且通过按位运算高效判断配置项，既节省内存又简化了多状态控制的逻辑。

^ 操作符 ​

在 Go 中 按位 异或 操作是用 ^ 来表示的。 异或运算符有如下的特点：

math
Given operands a, b
XOR(a, b) = 1; only if a != b
else = 0

异或运算（^）的核心特性是 “相同为 0，不同为 1”，即当两个操作数的对应位值不同时，结果位为 1；相同时为 0。这一特性可用于翻转二进制位：通过构造特定掩码（需要翻转的位设为 1，其余为 0），与目标数执行异或运算，即可将掩码中为 1 的位翻转（0 变 1，1 变 0）。

异或运算的另一实用场景是判断两个整数的符号是否相同：对于有符号整数，最高位（符号位）为 0 表示正数，为 1 表示负数。当 a ^ b 的结果≥0 时，说明两数符号位相同（均为 0 或均为 1）；若结果 < 0，则符号位不同。

go
// TestXORFeatures 测试异或运算的两个核心特性：翻转特定位、判断符号是否相同
func TestXORFeatures(t *testing.T) {
  // 测试1：异或运算翻转特定位（前8位，从MSB开始）
  t.Run("flip_bits", func(t *testing.T) {
    var a uint16 = 0xCEFF // 二进制：11001110 11111111
    mask := uint16(0xFF00) // 掩码：11111111 00000000（前8位为1）
    a ^= mask              // 异或运算：翻转前8位 
    expected := uint16(0x31FF) // 预期结果：00110001 11111111
    if a != expected {
      t.Errorf("特定位翻转失败\n原始值: 0x%X\n掩码: 0x%X\n实际结果: 0x%X\n预期结果: 0x%X",
        0xCEFF, mask, a, expected)
    }
    t.Logf("特定位翻转成功\n原始值: 0x%X → 异或0x%X → 结果: 0x%X", 0xCEFF, mask, a)
  })

  // 测试2：异或运算判断两个整数的符号是否相同
  t.Run("check_sign", func(t *testing.T) {
    // 测试用例：(a, b, 预期符号是否相同)
    testCases := []struct {
      name     string
      a, b     int
      expected bool
    }{
      {"均为正数", 12, 25, true},
      {"均为负数", -12, -25, true},
      {"一正一负", -12, 25, false},
      {"一负一正", 12, -25, false},
      {"包含零（零视为正数）", 0, -5, false},
      {"零与正数", 0, 5, true},
    }

    for _, tc := range testCases {
      t.Run(tc.name, func(t *testing.T) {
        // 核心逻辑：(a ^ b) >= 0 表示符号相同
        actual := (tc.a ^ tc.b) >= 0
        if actual != tc.expected {
          t.Errorf("符号判断错误\na=%d, b=%d\n实际: %v\n预期: %v",
            tc.a, tc.b, actual, tc.expected)
        }
        t.Logf("符号判断正确\na=%d, b=%d → 符号%s",
          tc.a, tc.b, map[bool]string{true: "相同", false: "不同"}[actual])
      })
    }
  })
}

^ 作为取反位运算符 （非） ​

Go 与其他语言（如 C/C++、Java、Python 等）不同，它没有专门的一元取反位运算符（如 ~）。取而代之的是，异或运算符 ^ 被复用为一元运算符，实现按位取反功能：对操作数的每一位执行 0 变 1、1 变 0 的反转。

go
// TestBitwiseNot 测试Go中的一元按位取反运算符^
// 验证^a对变量a的所有位进行取反操作（0变1，1变0）
func TestBitwiseNot(t *testing.T) {
  // 测试用例：原始值、预期取反结果（针对byte类型）
  testCases := []struct {
    name     string
    input    byte
    expected byte
  }{
    {
      name:     "0x0F取反",
      input:    0x0F, // 二进制：00001111
      expected: 0xF0, // 二进制：11110000
    },
    {
      name:     "0x00取反",
      input:    0x00, // 二进制：00000000
      expected: 0xFF, // 二进制：11111111
    },
    {
      name:     "0xFF取反",
      input:    0xFF, // 二进制：11111111
      expected: 0x00, // 二进制：00000000
    },
    {
      name:     "0xAB取反",
      input:    0xAB, // 二进制：10101011
      expected: 0x54, // 二进制：01010100
    },
  }

  // 测试一元^的取反功能
  for _, tc := range testCases {
    t.Run(tc.name, func(t *testing.T) {
      result := ^tc.input // 执行按位取反操作

      // 验证结果是否符合预期
      if result != tc.expected {
        t.Errorf("取反结果错误\n原始值: 0x%X (%08b)\n实际结果: 0x%X (%08b)\n预期结果: 0x%X (%08b)",
          tc.input, tc.input,
          result, result,
          tc.expected, tc.expected)
      } else {
        t.Logf("取反成功\n原始值: 0x%X (%08b) → 取反后: 0x%X (%08b)",
          tc.input, tc.input,
          result, result)
      }
    })
  }

  // 单独测试单个位的翻转（利用二元^运算符）
  t.Run("单个位翻转", func(t *testing.T) {
    // 测试用例：(原始位值, 翻转后预期值)
    bitTests := []struct {
      bit      int
      expected int
    }{
      {0, 1}, // 0与1异或 → 1
      {1, 0}, // 1与1异或 → 0
    }

    for _, bt := range bitTests {
      result := 1 ^ bt.bit // 用二元^实现单个位翻转
      if result != bt.expected {
        t.Errorf("位翻转错误\n原始位: %d → 翻转后: %d, 预期: %d",
          bt.bit, result, bt.expected)
      } else {
        t.Logf("位翻转成功\n原始位: %d → 翻转后: %d", bt.bit, result)
      }
    }
  })
}

&^ 操作符 ​

&^ 是 Go 特有的按位 “与非” 运算符，其运算逻辑等价于 AND(a, NOT(b))（先对第二个操作数 b 取反，再与第一个操作数 a 执行按位与运算）。

&^ 的核心特性是 “根据第二个操作数清除第一个操作数的位”：

  • 当 b 的某一位为 1 时，NOT(b) 对应位为 0，最终结果的该位被强制清除为 0（即 a 的对应位无论为 0 或 1，结果均为 0）。
  • 当 b 的某一位为 0 时，NOT(b) 对应位为 1，最终结果的该位保留 a 的原始值（即 a 的对应位是什么，结果就是什么）。

例如，若要清除 a 的低 4 位，只需将 b 的低 4 位设为 1（其余位为 0），通过 a &^= b 即可实现。

go
// TestAndNotOperator 测试按位与非运算符&^的功能
// 验证&^是否能根据第二个操作数清除第一个操作数的特定位
func TestAndNotOperator(t *testing.T) {
  // 测试用例：(原始值a, 掩码b, 预期结果)
  testCases := []struct {
    name     string
    a        byte
    b        byte
    expected byte
  }{
    {
      name:     "清除低4位",
      a:        0xAB, // 二进制：10101011
      b:        0x0F, // 掩码：00001111（低4位为1，用于清除）
      expected: 0xA0, // 结果：10100000（低4位被清除为0）
    },
    {
      name:     "清除高4位",
      a:        0xAB, // 10101011
      b:        0xF0, // 11110000（高4位为1）
      expected: 0x0B, // 00001011（高4位被清除为0）
    },
    {
      name:     "不清除任何位（b全为0）",
      a:        0xAB, // 10101011
      b:        0x00, // 00000000
      expected: 0xAB, // 保留原始值
    },
    {
      name:     "清除所有位（b全为1）",
      a:        0xAB, // 10101011
      b:        0xFF, // 11111111
      expected: 0x00, // 所有位被清除为0
    },
  }

  for _, tc := range testCases {
    t.Run(tc.name, func(t *testing.T) {
      // 执行&^=操作（等价于 a = a &^ tc.b）
      result := tc.a
      result &^= tc.b 
      // 验证结果
      if result != tc.expected {
        t.Errorf("与非运算结果错误\n原始值a: 0x%X (%08b)\n掩码b: 0x%X (%08b)\n实际结果: 0x%X (%08b)\n预期结果: 0x%X (%08b)",
          tc.a, tc.a,
          tc.b, tc.b,
          result, result,
          tc.expected, tc.expected)
      } else {
        t.Logf("与非运算成功\n原始值a: 0x%X (%08b) &^ 掩码b: 0x%X (%08b) → 结果: 0x%X (%08b)",
          tc.a, tc.a,
          tc.b, tc.b,
          result, result)
      }
    })
  }
}

<< 和 >> 操作符 ​

Go 中的移位运算符 <<（左移）和 >>（右移）与 C 系语言用法类似，用于将操作数的二进制位按指定位数移动，核心特性如下：

1. 基本功能 ​

  • 左移（a << n）：将 a 的所有二进制位向左移动 n 位，低位补 0。
    • 例：00000011 << 1 → 00000110（低位补 0）。
  • 右移（a >> n）：
    • 对无符号数：向右移动 n 位，高位补 0（逻辑移位）。
      • 例：01111000 >> 1 → 00111100（高位补 0）。
    • 对有符号数：向右移动 n 位，高位补符号位（算术移位，保持数值符号不变）。
      • 例：-8（11111000）>> 1 → 11111100（高位补符号位 1）。

2. 与乘除法的关系 ​

移位运算本质是对 2 的幂次方进行乘除：

  • a << n 等价于 a * 2^n（左移 n 位 = 乘以 2 的 n 次方）。
  • a >> n 等价于 a / 2^n（右移 n 位 = 除以 2 的 n 次方，向下取整）。

3. 与其他位运算结合的应用 ​

移位运算符常与 |、&、&^ 结合，实现位级操作：

  • 设置特定位：a | (1 << n) → 将第 n 位（从 0 开始计数）设为 1。
  • 测试特定位：a & (1 << n) != 0 → 判断第 n 位是否为 1。
  • 清除特定位：a &^ (1 << n) → 将第 n 位设为 0。

4. 代码例子 ​

go
// TestShiftOperators 测试移位运算符<<和>>的功能及应用
func TestShiftOperators(t *testing.T) {
  // 子测试1：左移基本功能（无符号数）
  t.Run("left_shift_basic", func(t *testing.T) {
    var a int8 = 3 // 二进制：00000011
    testCases := []struct {
      shift  int
      expect int8
      binary string
    }{
      {1, 6, "00000110"},
      {2, 12, "00001100"},
      {3, 24, "00011000"},
    }
    for _, tc := range testCases {
      result := a << tc.shift
      if result != tc.expect {
        t.Errorf("左移%d位错误\n原始值: %d (%08b)\n实际结果: %d (%08b)\n预期结果: %d (%s)",
          tc.shift, a, a, result, result, tc.expect, tc.binary)
      }
    }
  })

  // 子测试2：右移基本功能（无符号数，逻辑移位）
  t.Run("right_shift_unsigned", func(t *testing.T) {
    var a uint8 = 120 // 二进制：01111000
    testCases := []struct {
      shift  int
      expect uint8
      binary string
    }{
      {1, 60, "00111100"},
      {2, 30, "00011110"},
    }
    for _, tc := range testCases {
      result := a >> tc.shift
      if result != tc.expect {
        t.Errorf("右移%d位错误（无符号数）\n原始值: %d (%08b)\n实际结果: %d (%08b)\n预期结果: %d (%s)",
          tc.shift, a, a, result, result, tc.expect, tc.binary)
      }
    }
  })

  // 子测试3：右移（有符号数，算术移位）
  t.Run("right_shift_signed", func(t *testing.T) {
    var a int8 = -8 // 二进制：11111000（补码）
    testCases := []struct {
      shift  int
      expect int8
      binary string // 算术移位：高位补符号位1
    }{
      {1, -4, "11111100"},
      {2, -2, "11111110"},
    }
    for _, tc := range testCases {
      result := a >> tc.shift
      if result != tc.expect {
        t.Errorf("右移%d位错误（有符号数）\n原始值: %d (%08b)\n实际结果: %d (%08b)\n预期结果: %d (%s)",
          tc.shift, a, a, result, result, tc.expect, tc.binary)
      }
    }
  })

  // 子测试4：移位与乘除法（2^n）
  t.Run("shift_mult_div", func(t *testing.T) {
    // 左移 = 乘法（a << n = a * 2^n）
    {
      a := 12
      result := a << 2 // 12 * 4 = 48
      if result != 48 {
        t.Errorf("左移2位乘法错误\n原始值: %d, 实际结果: %d, 预期: 48", a, result)
      }
    }
    // 右移 = 除法（a >> n = a / 2^n）
    {
      a := 200
      result := a >> 1 // 200 / 2 = 100
      if result != 100 {
        t.Errorf("右移1位除法错误\n原始值: %d, 实际结果: %d, 预期: 100", a, result)
      }
    }
  })

  // 子测试5：结合|和<<设置特定位（第n位）
  t.Run("set_bit_with_or_shift", func(t *testing.T) {
    var a int8 = 8 // 二进制：00001000
    n := 2         // 要设置的位（从0开始，第2位）
    a |= 1 << n    // 00001000 | 00000100 = 00001100
    expected := int8(12)
    if a != expected {
      t.Errorf("设置第%d位错误\n结果: %d (%08b), 预期: %d (00001100)",
        n, a, a, expected)
    }
  })

  // 子测试6：结合&和<<测试特定位是否设置
  t.Run("check_bit_with_and_shift", func(t *testing.T) {
    var a int8 = 12 // 二进制：00001100（第2位为1）
    n := 2
    isSet := a&(1<<n) != 0 // 00001100 & 00000100 = 00000100 ≠ 0 → true
    if !isSet {
      t.Errorf("测试第%d位错误\n预期: 已设置, 实际: 未设置", n)
    }
  })

  // 子测试7：结合&^和<<清除特定位
  t.Run("clear_bit_with_andnot_shift", func(t *testing.T) {
    var a int8 = 13 // 二进制：00001101（第2位为1）
    n := 2
    a &^= 1 << n // 00001101 &^ 00000100 = 00001001
    expected := int8(9)
    if a != expected {
      t.Errorf("清除第%d位错误\n结果: %d (%08b), 预期: %d (00001001)",
        n, a, a, expected)
    }
  })
}

math/bits 包的新增与优化 ​

Go 1.22 对 math/bits 包进行了增强，新增了针对不同整数类型的位操作函数，通过查找表实现更高效的位运算，特别适合处理固定位数的二进制数据（如网络协议、图形像素等场景）。

1. 新增的位反转函数 ​

ReverseBytes32 和 ReverseBytes64 这两个函数分别用于反转 32 位和 64 位整数的字节顺序。例如：

go
package main

import (
    "fmt"
    "math/bits"
)

func main() {
    num32 := uint32(0x12345678) // 二进制：00010010 00110100 01010110 01111000
    reversed32 := bits.ReverseBytes32(num32)
    fmt.Printf("%x -> %x\n", num32, reversed32) // 输出：12345678 -> 78563412

    num64 := uint64(0x123456789abcdef0)
    reversed64 := bits.ReverseBytes64(num64)
    fmt.Printf("%x -> %x\n", num64, reversed64) // 输出：123456789abcdef0 -> f0debc9a78563412
}

对比旧方法：过去需要手动移位或使用循环反转字节，现在一行代码即可完成，且性能提升明显（尤其当数据量较大时）。

2. 更高效的通用反转函数 ​

ReverseBytes 该函数会根据输入整数的位数自动选择最优实现（例如，当输入为 32 位整数时，内部调用 ReverseBytes32）。例如：

go
num := uint32(0x12345678)
reversed := bits.ReverseBytes(num) // 等同于 ReverseBytes32(num)

优势： 无需手动选择具体类型的函数，代码更简洁，编译器会自动优化。

编译器优化：PGO 对高频位运算的加速 ​

Go 1.22 进一步优化了 Profile-Guided Optimization (PGO)，通过分析程序运行时的热点代码，对高频位运算进行更高效的编译。例如：

  • 内联优化：编译器会将频繁调用的位操作函数（如 bits.RotateLeft32）直接嵌入调用处，减少函数调用开销。
  • 去虚拟化：对于通过接口调用的位操作方法，编译器可根据运行时类型直接生成具体实现，避免动态调度的性能损失。

示例： 若程序中多次使用 bits.LeadingZeros32 判断前导零，PGO 会将其优化为更高效的机器码，提升执行速度。

与基础位运算的结合使用 ​

Go 1.22 的更新并未改变基础位运算符（如 &、|、^、<<、>>、&^）的行为，但新增的 math/bits 函数可与它们结合使用，简化代码逻辑。

1. 清除特定位（&^）与新函数的结合 ​

go
// 清除 num 的最低 8 位
num := uint32(0x12345678)
mask := uint32(0xFF) // 二进制：11111111
num &= ^mask         // 等价于 num = num &^ mask
fmt.Printf("%x\n", num) // 输出：12345600

// 更直观的写法（使用 ReverseBytes32）
num = bits.ReverseBytes32(num) &^ 0xFF // 先反转字节，再清除最低 8 位

2. 位掩码与位操作函数的结合 ​

go
// 检查 num 的第 3 位是否为 1
num := uint32(0x10) // 二进制：00010000
mask := uint32(1 << 3)
if num&mask != 0 {
    fmt.Println("第 3 位为 1")
}

// 使用新函数简化判断
if bits.LeadingZeros32(num ^ mask) < 32 { // 若异或结果不为 0，说明该位不同
    fmt.Println("第 3 位可能为 0")
}

注意事项 ​

  • 避免过早优化：基础位运算符（如 &^）在简单场景下仍足够高效，无需强制使用 math/bits 函数。
  • 注意整数类型：math/bits 函数的参数和返回值均为无符号整数（如 uint32、uint64），使用时需注意类型转换。
  • 结合文档学习：官方文档（pkg.go.dev/math/bits）提供了详细的函数说明和示例，建议结合学习。

总结 ​

Go 1.22 通过新增 math/bits 函数和优化编译器，提升了位运算的效率和代码可读性。但需要注意以下事项：

  • 基础场景：优先使用 &、|、^ 等运算符，保持代码简洁。
  • 复杂场景：引入 math/bits 函数（如 ReverseBytes32），减少手动计算。
  • 性能敏感场景：启用 PGO（通过 go build -pgo），进一步优化高频位运算。

通过合理结合新旧特性，可写出更高效、易维护的位运算代码。

最近更新