Go语言中常用的位运算符

位运算（bitwise operations）是计算机科学中非常基础且重要的运算类型，它直接操作二进制位。Go语言中提供了一组位运算符，用于执行位级别的操作。

Go语言中的位运算符

按位与（&）：

作用：对两个操作数的每个位进行与运算，只有对应位都为1时，结果位才为1。

示例：5 & 3 （0101 & 0011 = 0001），结果为1。

按位或（|）：

作用：对两个操作数的每个位进行或运算，只有对应位有一个为1时，结果位才为1。

示例：5 | 3 （0101 | 0011 = 0111），结果为7。

按位异或（^）：

作用：对两个操作数的每个位进行异或运算，当对应位不同时，结果位为1。

示例：5 ^ 3 （0101 ^ 0011 = 0110），结果为6。

按位取反（^）：

作用：对操作数的每个位取反，0变1，1变0。

示例：^5 （取反0101 = 1010），结果为-6（在Go语言中，按位取反运算符作用于有符号整数时，结果为该数的补码减一）。

左移（<<）：

作用：将操作数的二进制位左移指定的位数，右侧用0填充。

示例：5 << 1 （0101 << 1 = 1010），结果为10。

右移（>>）：

作用：将操作数的二进制位右移指定的位数，左侧用0填充（对于无符号数），或用符号位填充（对于有符号数）。

示例：5 >> 1 （0101 >> 1 = 0010），结果为2。

位运算在真实业务中的使用场景

权限管理：

位运算在权限管理系统中非常有用。权限可以用二进制位表示，每个位表示一种权限。通过按位与操作，可以快速检查用户是否拥有某种权限。

示例：

const (

ReadPermission = 1 << iota // 0001

WritePermission // 0010

ExecutePermission // 0100

)

func hasPermission(permissions, perm int) bool {

return permissions&perm != 0

}

func main() {

userPermissions := ReadPermission | WritePermission // 0011

fmt.Println(hasPermission(userPermissions, ReadPermission)) // true

fmt.Println(hasPermission(userPermissions, ExecutePermission)) // false

}

状态标志：

在处理多种状态标志时，可以使用位运算来表示和操作状态。每个位代表一种状态，通过按位或操作可以设置状态，通过按位与和取反操作可以清除状态。

示例：

const (

FlagUp = 1 << iota // 0001

FlagBroadcast // 0010

FlagLoopback // 0100

FlagPointToPoint // 1000

)

func setFlag(flags, flag int) int {

return flags | flag

}

func clearFlag(flags, flag int) int {

return flags &^ flag

}

func hasFlag(flags, flag int) bool {

return flags&flag != 0

}

func main() {

var flags int

flags = setFlag(flags, FlagUp) | setFlag(flags, FlagBroadcast)

fmt.Println(hasFlag(flags, FlagUp)) // true

fmt.Println(hasFlag(flags, FlagLoopback)) // false

flags = clearFlag(flags, FlagBroadcast)

fmt.Println(hasFlag(flags, FlagBroadcast)) // false

}

数据压缩和解压：

位运算可以用于数据的压缩和解压，通过位移和掩码操作，可以将多个小的数据段打包成一个大数据段，或者从一个大数据段中提取出多个小的数据段。

示例：

func pack(r, g, b, a uint8) uint32 {

return uint32(r)<<24 | uint32(g)<<16 | uint32(b)<<8 | uint32(a)

}

func unpack(packed uint32) (r, g, b, a uint8) {

r = uint8(packed >> 24)

g = uint8(packed >> 16)

b = uint8(packed >> 8)

a = uint8(packed)

return

}

func main() {

packed := pack(255, 128, 64, 32)

fmt.Printf("Packed: %032b\n", packed) // Packed: 11111111010000000100000000100000

r, g, b, a := unpack(packed)

fmt.Printf("Unpacked: r=%d, g=%d, b=%d, a=%d\n", r, g, b, a) // Unpacked: r=255, g=128, b=64, a=32

}

网络编程：

位运算在网络编程中也很常见，例如，IP地址和端口的打包和解包、协议标志位的操作等。

示例：

func ipToUint32(ip string) uint32 {

var result uint32

parts := strings.Split(ip, ".")

for i, part := range parts {

num, _ := strconv.Atoi(part)

result |= uint32(num) << (24 - 8*i)

}

return result

}

func uint32ToIP(n uint32) string {

return fmt.Sprintf("%d.%d.%d.%d", byte(n>>24), byte(n>>16), byte(n>>8), byte(n))

}

func main() {

ip := "192.168.1.1"

packedIP := ipToUint32(ip)

fmt.Printf("Packed IP: %032b\n", packedIP) // Packed IP: 11000000101010000000000100000001

unpackedIP := uint32ToIP(packedIP)

fmt.Println("Unpacked IP:", unpackedIP) // Unpacked IP: 192.168.1.1

}

图形编程：

位运算在图形编程中广泛使用，例如颜色的表示和操作、位图的处理等。

示例：

type Color struct {

R, G, B, A uint8

}

func (c Color) ToUint32() uint32 {

return uint32(c.R)<<24 | uint32(c.G)<<16 | uint32(c.B)<<8 | uint32(c.A)

}

func Uint32ToColor(n uint32) Color {

return Color{

R: uint8(n >> 24),

G: uint8(n >> 16),

B: uint8(n >> 8),

A: uint8(n),

}

}

func main() {

color := Color{R: 255, G: 128, B: 64, A: 32}

packedColor := color.ToUint32()

fmt.Printf("Packed Color: %032b\n", packedColor) // Packed Color: 11111111010000000100000000100000

unpackedColor := Uint32ToColor(packedColor)

fmt.Printf("Unpacked Color: R=%d, G=%d, B=%d, A=%d\n", unpackedColor.R, unpackedColor.G, unpackedColor.B, unpackedColor.A) // Unpacked Color: R=255, G=128, B=64, A=32

}

通过这些示例，可以看到位运算在实际应用中的广泛使用。它们可以极大地提高代码的性能和效率，特别是在需要高效处理大量数据的场景中。