Eine kurze Analyse der Bitoperationen (bitweise Operatoren) in Golang

In den guten alten Zeiten, als Computerspeicher teuer und die Rechenleistung begrenzt war, war die Verwendung von Bitoperationen im Hacker-Stil zur Verarbeitung von Informationen der bevorzugte Weg (und in manchen Fällen der einzige Weg). Bis heute ist die direkte Verwendung von Bitoperationen ein integraler Bestandteil vieler Computerbereiche, wie z. B. der Low-Level-Systemprogrammierung, der Grafikverarbeitung, der Kryptographie usw.

Die Programmiersprache Go unterstützt die folgenden bitweisen Operatoren:

&   bitwise AND
 |   bitwise OR
 ^   bitwise XOR
&^   AND NOT
<<   left shift
>>   right shift

Der Rest dieses Artikels beschreibt jeden Operator und Beispiele für seine Verwendung.

&-Operator

In Go führt der &-Operator eine bitweise AND-Operation für zwei ganzzahlige Operanden durch. Die AND-Operation hat die folgenden Attribute: & 运算符在两个整型操作数中执行按位 AND 操作。AND 操作具有以下属性:

Given operands a, b
AND(a, b) = 1; only if a = b = 1
               else = 0

AND 运算符具有选择性的把整型数据的位清除为 0 的好的效果。 例如，我们可以使用  & 运算符去清除（设置）最后 4 个最低有效位（LSB）全部为 0 。

func main() {
    var x uint8 = 0xAC    // x = 10101100
    x = x & 0xF0          // x = 10100000
}

所有的位运算都支持简写的赋值形式。 例如，前面的例子可以重写为如下。

func main() {
    var x uint8 = 0xAC    // x = 10101100
    x &= 0xF0             // x = 10100000
}

另外一个巧妙的技巧是：你可以用 & 操作去测试一个数字是奇数还是偶数。原因是当一个数字的二进制的最低位是 1 的时候，那他就是奇数。我们可以用一个数字和 1 进行 & 操作，然后在和 1 做 AND 运算，如果的到的结果是 1 ，那么这个原始的数字就是奇数

import (
    "fmt"
    "math/rand"
)
func main() {
    for x := 0; x < 100; x++ {
        num := rand.Int()
        if num&1 == 1 {
            fmt.Printf("%d is odd\n", num)
        } else {
            fmt.Printf("%d is even\n", num)
        }
    }
}

在  Playground  上运行上面的例子

| 操作符

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

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

我们可以利用按位或操作符为给定的整数有选择地设置单个位。例如，在如下示例中我们使用按位或将示例数（从低位到高位（MSB））中的第 3 ，第 7 和第 8 位置为 1 。

func main() {
    var a uint8 = 0
    a |= 196
    fmt.Printf("%b", a)
}

// 打印结果  11000100
            ^^   ^

练习场中可运行范例。

在使用位掩码技术为给定的整型数字设置任意位时，或运算非常有用。例如，我们可以扩展之前的程序为变量 a 存储的值设置更多的位。

func main() {
    var a uint8 = 0
    a |= 196
    a |= 3
    fmt.Printf("%b", a)
}

// 打印结果 11000111

在练习场中可以运行范例。

在前面的程序里，不仅要按位设置十进制的 196，而且要设置低位上的十进制 3。我们还可以继续（或上更多的值）设置完所有的位。

位运算的配置用法

现在，回顾一下 AND(a, 1) = a 当且仅当 a = 1。 我们可以利用这个特性去查询其设置位的值。例如，在上述代码中 a & 196 会返回 196 是因为这几位的值在 a 中确实都存在。所以我们可以结合使用 OR 和  AND 运算的方式来分别设置和读取某位的配置值。.

接下来的源码片段演示了这个操作。函数 procstr 会转换字符串的内容。它需要两个参数：第一个， str，是将要被转换的字符串，第二个， conf，是一个使用位掩码的方式指定多重转换配置的整数。

const (
    UPPER  = 1 // 大写字符串
    LOWER  = 2 // 小写字符串
    CAP    = 4 // 字符串单词首字母大写
    REV    = 8 // 反转字符串
)

func main() {
    fmt.Println(procstr("HELLO PEOPLE!", LOWER|REV|CAP))
}

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 & CAP) != 0 {
        str = strings.Title(str)
    }
    if (conf & REV) != 0 {
        str = rev(str)
    }
    return str
}

在 Playground上面运行代码.

上面的 procstr("HELLO PEOPLE!", LOWER|REV|CAP) 方法会把字符串变成小写，然后反转字符串，最后把字符串里面的单词首字母变成大写。这个功能是通过设置 conf 里的第二，三，四位的值为 14 来完成的。然后代码使用连续的 if 语句块来获取这些位操作进行对应的字符串转换。

^ 操作符

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

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

异或

func main() {
    var a uint16 = 0xCEFF
    a ^= 0xFF00 // same a = a ^ 0xFF00
}

// a = 0xCEFF   (11001110 11111111)
// a ^=0xFF00   (00110001 11111111)

Der AND-Operator hat den guten Effekt, dass er die Bits ganzzahliger Daten selektiv auf 0 löscht. Beispielsweise können wir den Operator & verwenden, um die letzten 4 niedrigstwertigen Bits (LSB) auf 0 zu setzen. 🎜

func main() {
    a, b := -12, 25
    fmt.Println("a and b have same sign?", (a ^ b) >= 0)
}

🎜Alle Bitoperationen unterstützen abgekürzte Zuweisungsformen. Das vorherige Beispiel könnte beispielsweise wie folgt umgeschrieben werden. 🎜

func main() {
    var a byte = 0x0F
    fmt.Printf("%08b\n", a)
    fmt.Printf("%08b\n", ^a)
}

// 打印结果
00001111     // var a
11110000     // ^a

🎜Ein weiterer netter Trick ist: Sie können die Operation & verwenden, um zu testen, ob eine Zahl ungerade oder gerade ist. Der Grund dafür ist, dass es sich um eine ungerade Zahl handelt, wenn das niedrigste Bit einer Zahl 1 ist. Wir können eine Zahl und 1 verwenden, um die Operation & auszuführen, und dann die Operation AND mit 1 ausführen. Wenn das Ergebnis 1 ist, ist die ursprüngliche Zahl eine ungerade Zahl 🎜

Given operands a, b
AND_NOT(a, b) = AND(a, NOT(b))

🎜Führen Sie das obige Beispiel auf Playground 🎜🎜🎜| aus. Operator🎜🎜🎜| Führt eine bitweise - oder -Operation für seinen Ganzzahloperanden aus. Denken Sie daran, dass der Operator oder die folgenden Eigenschaften hat: 🎜

AND_NOT(a, 1) = 0; clears a
AND_NOT(a, 0) = a;

🎜 Wir können den bitweisen Operator oder verwenden, um einzelne Bits für eine bestimmte Ganzzahl selektiv festzulegen. Im folgenden Beispiel verwenden wir beispielsweise bitweise oder , um das 3., 7. und 8. Bit in der Sample-Nummer (vom Low-Bit zum High-Bit (MSB)) auf 1 zu setzen. 🎜

func main() {
    var a byte = 0xAB
     fmt.Printf("%08b\n", a)
     a &^= 0x0F
     fmt.Printf("%08b\n", a)
}

// 打印：
10101011
10100000

🎜Beispiele können auf dem Trainingsgelände ausgeführt werden. 🎜🎜Die Operation oder ist sehr nützlich, wenn Bitmaskierungstechniken verwendet werden, um beliebige Bits für eine bestimmte Ganzzahl festzulegen. Beispielsweise können wir das vorherige Programm erweitern, um mehr Bits für den in der Variablen a gespeicherten Wert zu setzen. 🎜

Given integer operands a and n,
a << n; shifts all bits in a to the left n times
a >> n; shifts all bits in a to the right n times

🎜Beispiele können im Übungsbereich ausgeführt werden. 🎜🎜Im vorherigen Programm muss nicht nur die Dezimalzahl 196 bitweise gesetzt werden, sondern auch die Dezimalzahl 3 in den Low-Bits. Wir können fortfahren (mehr Werte auf oder ), um alle Bits zu setzen. 🎜🎜🎜 Konfiguration der Verwendung von Bitoperationen🎜🎜🎜Überprüfen Sie nun AND(a, 1) = a genau dann, wenn a = 1 . Wir können diese Funktion verwenden, um den Wert seines Einstellungsbits abzufragen. Im obigen Code gibt beispielsweise a & 196 196 zurück, da die Werte dieser Bits in a vorhanden sind. Wir können also die Operationen OR und AND in Kombination verwenden, um den Konfigurationswert eines bestimmten Bits festzulegen bzw. zu lesen. .🎜🎜Der folgende Quellcodeausschnitt demonstriert diesen Vorgang. Die Funktion procstr konvertiert den Inhalt eines Strings. Es sind zwei Parameter erforderlich: Der erste, str, ist die zu konvertierende Zeichenfolge und der zweite, conf, ist eine Bitmaske, die mehrere Ganzzahlen zum Konvertieren der Konfiguration angibt. 🎜

func main() {
    var a int8 = 3
    fmt.Printf("%08b\n", a)
    fmt.Printf("%08b\n", a<<1)
    fmt.Printf("%08b\n", a<<2)
    fmt.Printf("%08b\n", a<<3)
}

// 输出的结果:
00000011
00000110
00001100
00011000

🎜Führen Sie den obigen Code aus Playground 🎜🎜Der obige procstr(" HALLO LEUTE!", LOWER|REV|CAP)-Methode wandelt die Zeichenfolge in Kleinbuchstaben um, kehrt die Zeichenfolge dann um und ändert schließlich den ersten Buchstaben des Worts in der Zeichenfolge in Großbuchstaben. Diese Funktion wird erreicht, indem das zweite, dritte und vierte Bit in conf auf den Wert 14 gesetzt wird. Der Code verwendet dann aufeinanderfolgende if-Anweisungsblöcke, um diese Bitoperationen abzurufen und entsprechende Zeichenfolgenkonvertierungen durchzuführen. 🎜🎜🎜^-Operator 🎜🎜🎜In Go wird die bitweise XOR-Operation durch ^ dargestellt. Der XOR-Operator hat die folgenden Eigenschaften: 🎜

func main() {
 var a uint8 = 120
 fmt.Printf("%08b\n", a)
 fmt.Printf("%08b\n", a>>1)
 fmt.Printf("%08b\n", a>>2)
}

// 打印：
01111000
00111100
00011110

🎜 Diese Funktion des XOR-Operators kann verwendet werden, um einen Wert eines Binärbits in einen anderen Wert zu ändern. Bei einem gegebenen Hexadezimalwert können wir beispielsweise den folgenden Code verwenden, um die ersten 8 Bits (beginnend beim MSB) des Werts zu ändern. 🎜

func main() {
    var a uint16 = 0xCEFF
    a ^= 0xFF00 // same a = a ^ 0xFF00
}

// a = 0xCEFF   (11001110 11111111)
// a ^=0xFF00   (00110001 11111111)

在前面的代码片段中，与 1 进行异或的位被翻转（从 0 到 1 或从 1 到  0）。异或 运算的一个实际用途，例如，可以利用 异或运算去比较两个数字的符号是否一样。当 (a ^ b) ≥ 0 （或相反符号的 (a ^ b) 087d86671d155612d4f02e9d24199fd2> 操作符<p>与其他 C 的衍生语言类似， Go 使用 <code>036118feef1720dceedad2101673ba7c> 来表示左移运算符和右移运算符，如下所示：

Given integer operands a and n,
a << n; shifts all bits in a to the left n times
a >> n; shifts all bits in a to the right n times

例如，在下面的代码片段中变量 a （00000011）的值将会左移位运算符分别移动三次。每次输出结果都是为了说明左移的目的。

func main() {
    var a int8 = 3
    fmt.Printf("%08b\n", a)
    fmt.Printf("%08b\n", a<<1)
    fmt.Printf("%08b\n", a<<2)
    fmt.Printf("%08b\n", a<<3)
}

// 输出的结果:
00000011
00000110
00001100
00011000

在 Playground 运行代码

注意每次移动都会将低位右侧补零。相对应，使用右移位操作符进行运算时，每个位均向右方移动，空出的高位补零，如下示例 （有符号数除外，参考下面的算术移位注释）。

func main() {
 var a uint8 = 120
 fmt.Printf("%08b\n", a)
 fmt.Printf("%08b\n", a>>1)
 fmt.Printf("%08b\n", a>>2)
}

// 打印：
01111000
00111100
00011110

在 练习场中可以运行范例。

可以利用左移和右移运算中，每次移动都表示一个数的 2 次幂这个特性，来作为某些乘法和除法运算的小技巧。例如，如下代码中，我们可以使用右移运算将 200（存储在变量 a 中）除以 2 。

func main() {
    a := 200
    fmt.Printf("%d\n", a>>1)
}

// 打印：
100

在 练习场 中可以运行范例。

或是通过左移 2 位，将一个数乘以4：

func main() {
    a := 12
    fmt.Printf("%d\n", a<<2)
}
// 打印：

48

在 练习场 中可以运行范例。

位移运算符提供了有趣的方式处理二进制值中特定位置的值。例如，下列的代码中，| 和 << 用于设置变量 a 的第三个 bit 位。

func main() {
    var a int8 = 8
    fmt.Printf("%08b\n", a)
    a = a | (1<<2)
    fmt.Printf("%08b\n", a)
}
// prints:
00001000
00001100

可以在 练习场 中运行代码示例。

或者，您可以组合位移运算符和 & 测试是否设置了第n位，如下面示例所示：

func main() {
    var a int8 = 12
    if a&(1<<2) != 0 {
        fmt.Println("take action")
    }
}

// 打印:
take action

在 练习场中运行代码。

使用  &^ 和位移运算符，我们可以取消设置一个值的某个位。例如，下面的示例将变量 a 的第三位置为 0 ：

func main() {
    var a int8 = 13 
    fmt.Printf("%04b\n", a)
    a = a &^ (1 << 2)
    fmt.Printf("%04b\n", a)
}

// 打印:
1101
1001

在 练习场 中运行代码。

关于算术位移运算的笔记

当要位移的值（左操作数）是有符号值时，Go 自动应用算术位移。在右移操作期间，复制（或扩展）二进制补码符号位以填充位移的空隙。

Zusammenfassung

Wie andere moderne Operatoren unterstützt Go alle binären Bitmanipulationsoperatoren. Dieser Artikel enthält lediglich Beispiele für die verschiedenen Hacks, die mit diesen Operatoren durchgeführt werden können. Im Internet finden Sie viele Artikel, insbesondere „Bit Twiddling Hacks“ von Sean Eron Anderson. Folgen Sie Vladim

@vladimirvivien

auf Twitter. Wenn Sie Go lernen, lesen Sie Vladimir Viviens Buch über Go mit dem Titel „Learning Go Programming“ .

Dieser Artikel wurde ursprünglich auf Medium vom Autor Vladimir Vivien mit dem Titel „Bit Hacking with Go“ veröffentlicht.

Originaladresse: https://dev.to/vladimirvivien/bit-hacking-with-go

Übersetzungsadresse: https://learnku.com/go/t/23460/bit-operation-of-go

Empfohlenes Lernen:

Golang-Tutorial

Das obige ist der detaillierte Inhalt vonEine kurze Analyse der Bitoperationen (bitweise Operatoren) in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!