Golang中如何比较十六进制和字符串

Golang中如何比较十六进制和字符串 我有一个十六进制表示和这个十六进制的字符串版本，我想比较它们。如果我将它们都转换为字节并比较它们的字节，这样正确吗？

还有一个问题，如何转换为固定大小的字节数组，例如 [32]byte？

实际上，我有一个哈希的 []uint8 表示和这个哈希的字符串，但不幸的是，如果我将这个字符串转换为字节并与 []uint8 比较，它们完全不同，但它们实际上是同一个哈希。

5 回复

@Akezhan_Esbolatov 为什么你要将自己的帖子标记为偏离主题？

更多关于Golang中如何比较十六进制和字符串的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


这看起来是合理的。Akezhan，如果这些答案对你都不起作用，请向我们展示你正在使用的数据类型示例（它们的声明方式以及你如何使用它们），如果可以的话，请更清楚地解释你想要实现的目标。

我认为他想比较 []byte{0xFF} 和 "FF"。

如果确实如此，hex.DecodeString 应该能帮到你：

https://golang.org/pkg/encoding/hex/#DecodeString

首先，byte 只是 uint8 的别名。

参考链接

只需选择其中一种使用。

我不确定是否理解了你的问题，但以下示例可能包含你所需的内容：

package main

import "fmt"

// A hexidecimal value ...
// ... as a simple integer
var x_int int =   0x1fe7d6df
// ... as a string
var x_string string = "1fe7d6df"
// ... as an array of bytes
var x_array [32]byte = [32]byte { '1', 'f', 'e', '7', 'd', '6', 'd', 'f', }

// the string version will be converted to an array of bytes and stored here:
var b_array [32]byte

func main() {
        var i int

        // print the integer and string versions

        fmt.Printf("integer: %x\n", x_int)
        fmt.Printf("string:  %s\n", x_string)

        // print the array version. Each byte is converted to a string

        fmt.Printf("array:   ")
        for i = 0; x_array[i] != 0; i++ {
                fmt.Printf("%s", string(x_array[i]))
        }
        fmt.Printf("\n");

        // compare the string version to the array version

        for i = 0; x_array[i] != 0; i++ {
                if x_string[i] != x_array[i] {
                        fmt.Printf("\nThe string and array differ at position %d\n",i+1)
                }
        }

        if x_array[i] == 0 { fmt.Printf("\nThe string and array are the same\n") }

        // convert the string version into an array of bytes

        for i = 0; i < len(x_string); i++ {
                b_array[i] = x_string[i]
        }

        // convert it back into another string and print the string

        s := string(b_array[:len(x_string)])
        fmt.Printf("\nstring:  %s\n",s)

        // compare the two arrays

        for i = 0; x_array[i] != 0; i++ {
                if b_array[i] != x_array[i] {
                        fmt.Printf("\nThe arrays differ at position %d\n",i+1)
                }
        }

        if x_array[i] == 0 { fmt.Printf("\nThe arrays are the same\n") }
}

上述代码可在 Go Playground 找到：链接

在Go语言中比较十六进制表示和字符串版本时，直接转换为字节比较通常是正确的做法，但需要注意编码方式。以下是具体实现方法：

方法1：将十六进制字符串解码为字节再比较

package main

import (
    "encoding/hex"
    "fmt"
)

func main() {
    // 原始字节数据（[]uint8）
    originalBytes := []byte{0x48, 0x65, 0x6c, 0x6c, 0x6f}
    
    // 十六进制字符串表示
    hexString := "48656c6c6f"
    
    // 将十六进制字符串解码为字节
    decodedBytes, err := hex.DecodeString(hexString)
    if err != nil {
        panic(err)
    }
    
    // 比较字节切片
    if string(originalBytes) == string(decodedBytes) {
        fmt.Println("相等")
    } else {
        fmt.Println("不相等")
    }
    
    // 或者直接比较字节切片
    if len(originalBytes) == len(decodedBytes) {
        equal := true
        for i := range originalBytes {
            if originalBytes[i] != decodedBytes[i] {
                equal = false
                break
            }
        }
        if equal {
            fmt.Println("字节比较：相等")
        }
    }
}

方法2：转换为固定大小的字节数组 [32]byte

package main

import (
    "encoding/hex"
    "fmt"
)

func main() {
    // 假设有一个32字节的哈希
    hashBytes := make([]byte, 32)
    for i := range hashBytes {
        hashBytes[i] = byte(i) // 示例数据
    }
    
    // 转换为十六进制字符串
    hexString := hex.EncodeToString(hashBytes)
    fmt.Printf("十六进制字符串: %s\n", hexString)
    
    // 将十六进制字符串解码为固定大小的 [32]byte
    var fixedArray [32]byte
    decodedBytes, err := hex.DecodeString(hexString)
    if err != nil {
        panic(err)
    }
    
    // 复制到固定数组
    copy(fixedArray[:], decodedBytes)
    
    // 比较原始字节和固定数组
    if string(hashBytes) == string(fixedArray[:]) {
        fmt.Println("哈希比较：相等")
    }
}

方法3：处理 []uint8 和字符串的比较问题

package main

import (
    "encoding/hex"
    "fmt"
)

func compareHash(byteHash []uint8, stringHash string) bool {
    // 将 []uint8 转换为 []byte
    byteSlice := make([]byte, len(byteHash))
    for i, v := range byteHash {
        byteSlice[i] = byte(v)
    }
    
    // 将十六进制字符串解码为字节
    decodedBytes, err := hex.DecodeString(stringHash)
    if err != nil {
        return false
    }
    
    // 比较两个字节切片
    return string(byteSlice) == string(decodedBytes)
}

func main() {
    // 示例：[]uint8 哈希
    uint8Hash := []uint8{0x12, 0x34, 0x56, 0x78}
    
    // 对应的十六进制字符串
    stringHash := "12345678"
    
    if compareHash(uint8Hash, stringHash) {
        fmt.Println("哈希值相等")
    } else {
        fmt.Println("哈希值不相等")
    }
}

关键点说明：

  1. 十六进制字符串解码：使用 hex.DecodeString() 将十六进制字符串转换回原始字节
  2. []uint8 转换：Go中 []uint8 和 []byte 本质相同，可以直接转换
  3. 固定大小数组：使用 [32]byte 类型声明，通过 copy() 函数填充数据
  4. 比较方法：可以直接比较字符串形式，或逐个字节比较

这种方法能正确处理十六进制表示和字符串版本之间的比较。

回到顶部