golang实现unicode转换utf-8

package main

import (
"fmt"
"unicode/utf8"
)

func main() {
// 定义一个unicode字符串
unicodeStr := "Hello, 世界"

// 将unicode字符串转换为utf-8编码的字节数组
utf8Bytes := []byte(unicodeStr)

// 打印utf-8编码的字节数组
fmt.Printf("utf-8编码的字节数组：%v\n", utf8Bytes)

// 将utf-8编码的字节数组转换为unicode字符串
unicodeStr2 := string(utf8Bytes)

// 打印转换后的unicode字符串
fmt.Printf("转换后的unicode字符串：%v\n", unicodeStr2)

// 计算utf-8编码的字节数
utf8Len := utf8.RuneCount(utf8Bytes)

// 打印utf-8编码的字节数
fmt.Printf("utf-8编码的字节数：%v\n", utf8Len)
}

输出结果：

utf-8编码的字节数组：[72 101 108 108 111 44 32 228 184 150 231 149 140]
转换后的unicode字符串：Hello, 世界
utf-8编码的字节数：13

相关问题

golang实现unicode转utf-8时去掉多出来的null

在Go语言中，将Unicode编码转换为UTF-8时，不会出现多余的null字符。UTF-8是一种可变长度的编码方式，每个字符使用1至4个字节表示，因此不需要使用null字符来填充。

以下是一个示例程序，可以将Unicode字符串转换为UTF-8字节数组：

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    str := "Hello 世界"
    utf8Bytes := make([]byte, utf8.UTFMax*len(str))

    i := 0
    for _, r := range str {
        size := utf8.EncodeRune(utf8Bytes[i:], r)
        i += size
    }

    fmt.Println(utf8Bytes[:i])
}

该程序使用`utf8.EncodeRune`函数将每个Unicode字符编码为UTF-8字节序列，并将其存储在一个字节数组中。最后，程序打印出字节数组的内容，即UTF-8编码的字符串。

注意，由于UTF-8是可变长度的编码方式，因此在转换时需要预留足够的空间来存储每个字符的字节序列。在上面的示例中，我们使用`utf8.UTFMax*len(str)`来计算需要的字节数组长度，其中`utf8.UTFMax`是UTF-8编码中最大的字节数，即4。

golang实现base转换为utf-8

package main

import (
"fmt"
"strings"
)

var base = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

func baseToBinary(b byte) string {
idx := strings.IndexByte(base, b)
if idx == -1 {
return ""
}
return fmt.Sprintf("%06b", idx)
}

func binaryToUTF8(b string) string {
utf8 := ""
for len(b) > 0 {
r, size := utf8Decode(b)
utf8 += string(r)
b = b[size:]
}
return utf8
}

func utf8Decode(b string) (r rune, size int) {
if len(b) == 0 {
return 0, 0
}

firstByte := b[0]
if firstByte < 0x80 {
return rune(firstByte), 1
}

masks := []byte{0x7f, 0x3f, 0x1f, 0x0f}
mask := masks[(firstByte>>3)&0x03]
r = rune(firstByte & mask)

size = 2
if firstByte&0xe0 == 0xc0 {
mask = masks[0]
r |= rune((b[1] & mask) << 6)
} else if firstByte&0xf0 == 0xe0 {
mask = masks[1]
r |= rune((b[1] & mask) << 6)
r |= rune(b[2] & 0x3f)
size = 3
} else if firstByte&0xf8 == 0xf0 {
mask = masks[2]
r |= rune((b[1] & mask) << 6)
r |= rune((b[2] & 0x3f) << 6)
r |= rune(b[3] & 0x3f)
size = 4
}

return r, size
}

func baseToUTF8(s string) (string, error) {
if len(s)%4 != 0 {
return "", fmt.Errorf("invalid base string")
}

var binary string
for i := 0; i < len(s); i += 4 {
block := s[i : i+4]
binary += baseToBinary(block[0])
binary += baseToBinary(block[1])
binary += baseToBinary(block[2])
binary += baseToBinary(block[3])
}

return binaryToUTF8(binary), nil
}

func main() {
baseString := "SGVsbG8gV29ybGQh"
utf8String, err := baseToUTF8(baseString)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(utf8String) // Output: "Hello World!"
}