字节到带有无效字符的字符串转换

Question

我需要解析可能无效或包含一些错误的 UDP 数据包。我想在字节到字符串转换后用 . 替换无效字符，以显示数据包的内容。

我该怎么做？这是我的代码：

func main() {
   a := []byte{'a', 0xff, 0xaf, 'b', 0xbf}
   s := string(a)
   s = strings.Replace(s, string(0xFFFD), ".", 0)

   fmt.Println("s: ", s) // I would like to display "a..b."
   for _, r := range s {
      fmt.Println("r: ", r)
   }
   rs := []rune(s)
   fmt.Println("rs: ", rs)
}

Answer 1

你的方法的根本问题是类型转换 []byte 到 string 的结果中没有任何 U+FFFDs：这种类型转换只复制字节从源到目的，一字不差。
就像字节切片一样，Go 中的字符串不必包含 UTF-8 编码的文本；它们可以包含任何数据，包括与文本无关的不透明二进制数据。

但是一些对字符串的操作——即 type-converting them to []rune and iterating over them using range—do 将字符串解释为 UTF-8 编码的文本。这正是你被绊倒的地方：你的 range 调试循环试图解释字符串，并且每次尝试解码正确编码的代码点失败时，range 产生了一个替换字符，U+FFFD.
重申一下，通过类型转换获得的字符串不包含您想要用正则表达式替换的字符。

至于如何从数据中实际生成有效的 UTF-8 编码字符串，您可以采用两步过程：

将您的字节切片类型转换为字符串——就像您已经做的那样。
使用任何方法将字符串解释为 UTF-8——替换将在此过程中动态出现的 U+FFFD——在迭代时。

像这样：

var sb strings.Builder
for _, c := range string(b) {
  if c == '\uFFFD' {
    sb.WriteByte('.')
  } else {
    sb.WriteRune(c)
  }
}
return sb.String()

关于性能的注意事项：由于将 []byte 类型转换为 string 会复制内存——因为字符串是不可变的，而切片不是——类型转换的第一步可能会浪费处理大块数据的代码资源 and/or 在紧密的处理循环中工作。
在这种情况下，可能值得使用适用于字节切片的 DecodeRune function of the encoding/utf8 package 。它的文档中的一个示例可以很容易地适应上面的循环。

另请参阅：Remove invalid UTF-8 characters from a string

Answer 2

@kostix 的回答是正确的，并且非常清楚地解释了从字符串中扫描 unicode 符文的问题。

只需添加以下备注：如果您的目的是仅查看 ASCII 范围内的字符（可打印字符 < 127）并且您并不真正关心其他 unicode 代码点，您可以更直截了当：

// create a byte slice with the same byte length as s
var bs = make([]byte, len(s))

// scan s byte by byte :
for i := 0; i < len(s); i++ {
    switch {
    case 32 <= s[i] && s[i] <= 126:
        bs[i] = s[i]

    // depending on your needs, you may also keep characters in the 0..31 range,
    // like 'tab' (9), 'linefeed' (10) or 'carriage return' (13) :
    // case s[i] == 9, s[i] == 10, s[i] == 13:
    //   bs[i] = s[i]

    default:
        bs[i] = '.'
    }
}


fmt.Printf("rs: %s\n", bs)

playground

此函数将为您提供接近 hexdump -C 的“文本”部分的内容。

Answer 3

您可能需要为此使用 strings.ToValidUTF8()：

ToValidUTF8 returns a copy of the string s with each run of invalid UTF-8 byte sequences replaced by the replacement string, which may be empty.

它“看起来”正是您所需要的。测试它：

a := []byte{'a', 0xff, 0xaf, 'b', 0xbf}
s := strings.ToValidUTF8(string(a), ".")
fmt.Println(s)

输出（在 Go Playground 上尝试）：

a.b.

我写“貌似”是因为如你所见，a和b之间有一个点：因为可能有2个字节，但是一个无效序列。

请注意，您可以避免 []byte => string 转换，因为有一个 bytes.ToValidUTF8() 等价物可以在 returns 和 []byte 上运行：

a := []byte{'a', 0xff, 0xaf, 'b', 0xbf}
a = bytes.ToValidUTF8(a, []byte{'.'})
fmt.Println(string(a))

输出是一样的。在 Go Playground.

上试试这个

如果您对多个（无效序列）字节可能会缩成一个点感到困扰，请继续阅读。

另请注意，要检查可能包含或不包含文本的任意字节切片，您可以简单地使用 hex.Dump() 生成如下输出：

a := []byte{'a', 0xff, 0xaf, 'b', 0xbf}
fmt.Println(hex.Dump(a))

输出：

00000000  61 ff af 62 bf                                    |a..b.|

这是您的预期输出 a..b. 以及其他（有用的）数据，例如字节的十六进制偏移和十六进制表示。

要获得“更好”的输出图片，请尝试使用更长的输入：

a = []byte{'a', 0xff, 0xaf, 'b', 0xbf, 50: 0xff}
fmt.Println(hex.Dump(a))

00000000  61 ff af 62 bf 00 00 00  00 00 00 00 00 00 00 00  |a..b............|
00000010  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000030  00 00 ff                                          |...|

在 Go Playground 上试试。

字节到带有无效字符的字符串转换

bytes to string conversion with invalid characters

string

utf-8

go