Golang中如何正确在字符串中添加\x以实现十六进制到整型或浮点型的转换

Golang中如何正确在字符串中添加\x以实现十六进制到整型或浮点型的转换 我已将我的代码粘贴到以下链接的Playground中：Go Playground - The Go Programming Language。我的问题是，当我像这样拼接字符串部分时：long2ComplimentHex := "\x" + completeString[0:2] + "\x" + completeString[2:4] + "\x" + completeString[4:6] + "\x" + completeString[6:8]，\x 会被计算为值的一部分。我需要这个操作来实现正确的正负数转换。我该如何进行正确的拼接过程以避免这个额外的值？

func main() {
    fmt.Println("hello world")
}

更多关于Golang中如何正确在字符串中添加\x以实现十六进制到整型或浮点型的转换的实战教程也可以访问 https://www.itying.com/category-94-b0.html

7 回复

您或许应该使用 strconv.ParseUint(completeString[i:i+2],16,8) 来构建您的字节切片，而不是试图将十六进制字面量硬塞进字符串。

strconv.ParseUint(completeString[i:i+2],16,8)

更多关于Golang中如何正确在字符串中添加\x以实现十六进制到整型或浮点型的转换的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


这是我未经测试、临时想到的代码。在倒数第二行添加一个 uint8 类型转换。

https://go.dev/tour/basics/13

嗨 Jeff， 我不太明白你的意思，你是说我应该这样做吗：long2ComplimentHex := strconv.ParseUint(completeString[0:0+2], 16, 8)？

类似这样的：

long2ComplimentByte := make([]byte,len(completeString)/2)
for i:=0;i<len(completeString);i++ {
 b,err := strconv.ParseUint(completeString[i:i+2],16,8)
 if err!=nil {
   log.Fatalf("bad hex: %s", err)
 }
 long2ComplimentByte[i/2] = b
}

你好 Jeff， 感谢你提供的信息，这对未来的任何人都有帮助。以下是完整的代码片段。我对你的代码做了一些修改，以适应仅处理字符串前4个字节的需求。

long2ComplimentByte := make([]byte, 4)
	for i := 0; i < 8; i = i + 2 {
		b, err := strconv.ParseUint(completeString[i:i+2], 16, 8)
		if err != nil {
			log.Fatalf("bad hex: %s", err)
		}
		long2ComplimentByte[i/2] = uint8(b)
	}

mje:

long2ComplimentByte := make([]byte,len(completeString)/2)
 for i:=0;i<len(completeString);i++ {
  b,err := strconv.ParseUint(completeString[i:i+2],16,8)
  if err!=nil {
    log.Fatalf("bad hex: %s", err)
  }
  long2ComplimentByte[i/2] = b
}

我尝试了你的代码，但在这一行遇到了错误：无法将 b（类型为 uint64 的变量）用作 byte 类型进行赋值。

在Go语言中，\x 是字符串字面量中的十六进制转义序列，不能通过字符串拼接来动态创建。你需要使用 []byte 切片和 strconv.ParseUint 来正确解析十六进制值。

以下是正确的实现方法：

package main

import (
	"fmt"
	"strconv"
)

func main() {
	completeString := "FFEEDDCC" // 示例十六进制字符串
	
	// 方法1：直接解析为整数
	if len(completeString) == 8 {
		// 解析为无符号整数
		val, err := strconv.ParseUint(completeString, 16, 32)
		if err != nil {
			fmt.Println("解析错误:", err)
			return
		}
		
		// 转换为有符号32位整数（处理负数）
		intVal := int32(val)
		fmt.Printf("十六进制 %s 转换为整数: %d\n", completeString, intVal)
		
		// 转换为浮点数
		floatVal := float64(intVal)
		fmt.Printf("十六进制 %s 转换为浮点数: %f\n", completeString, floatVal)
	}
	
	// 方法2：按字节解析
	fmt.Println("\n按字节解析:")
	bytes := make([]byte, 4)
	for i := 0; i < 4; i++ {
		start := i * 2
		end := start + 2
		byteVal, err := strconv.ParseUint(completeString[start:end], 16, 8)
		if err != nil {
			fmt.Println("字节解析错误:", err)
			return
		}
		bytes[i] = byte(byteVal)
	}
	
	// 将字节切片转换为整数（小端序）
	var result int32
	for i, b := range bytes {
		result |= int32(b) << (8 * uint(i))
	}
	
	fmt.Printf("字节数组: %v\n", bytes)
	fmt.Printf("转换结果: %d\n", result)
	
	// 方法3：使用encoding/hex包
	fmt.Println("\n使用encoding/hex包:")
	import "encoding/hex"
	
	decoded, err := hex.DecodeString(completeString)
	if err != nil {
		fmt.Println("hex解码错误:", err)
		return
	}
	
	// 转换为整数（假设是小端序）
	var intFromHex int32
	for i, b := range decoded {
		intFromHex |= int32(b) << (8 * uint(i))
	}
	
	fmt.Printf("解码后的字节: %v\n", decoded)
	fmt.Printf("转换后的整数: %d\n", intFromHex)
}

对于处理补码表示的负数，可以这样处理：

func hexToInt32(hexStr string) (int32, error) {
	if len(hexStr) != 8 {
		return 0, fmt.Errorf("十六进制字符串长度必须为8")
	}
	
	// 解析为无符号整数
	val, err := strconv.ParseUint(hexStr, 16, 32)
	if err != nil {
		return 0, err
	}
	
	// 直接转换为int32（Go会自动处理补码）
	return int32(val), nil
}

// 使用示例
func main() {
	// 正数示例
	posHex := "0000000A"
	posVal, _ := hexToInt32(posHex)
	fmt.Printf("%s -> %d\n", posHex, posVal)
	
	// 负数示例（补码表示）
	negHex := "FFFFFFF6" // -10的补码
	negVal, _ := hexToInt32(negHex)
	fmt.Printf("%s -> %d\n", negHex, negVal)
	
	// 转换为浮点数
	floatVal := float64(negVal)
	fmt.Printf("%s -> %.2f\n", negHex, floatVal)
}

关键点：

  1. 不要尝试拼接 \x 转义序列，这在Go中无法动态创建
  2. 使用 strconv.ParseUint 或 encoding/hex.DecodeString 解析十六进制字符串
  3. Go的 int32() 转换会自动处理补码表示
  4. 注意字节序问题，根据你的数据源选择正确的字节序处理方式
回到顶部