您可以将其称为切片：

pass = string(b[:])

有点晚了，但请记住，使用string(b[:])将打印大多数无效字符。
如果你想得到一个像php一样的十六进制表示，你可以使用如下代码：

data := []byte("testing")
b := md5.Sum(data)

//this is mostly invalid characters
fmt.Println(string(b[:]))

pass := hex.EncodeToString(b[:])
fmt.Println(pass)
// or
pass = fmt.Sprintf("%x", b)
fmt.Println(pass)

playground

它可以这样解决

pass = fmt.Sprintf("%x", b)

或

import "encoding/base64"
pass = base64.StdEncoding.EncodeToString(b[:])

这将把它编码为base64字符串

切一片：

pass = string(b[:])

• • 2022年7月9日更新**

因此，unsafe: add StringData, String, SliceData、reflect.StringHeader和reflect.SliceHeader可能在Go 1.20中弃用。而unsafe.StringData、unsafe.String和unsafe.SliceData将取代它们。

func String2Bytes(s string) []byte {
    if s == "" {
        return nil
    }
    return unsafe.Slice(unsafe.StringData(s), len(s))
}

func Bytes2String(b []byte) string {
    if len(b) == 0 {
        return ""
    }
    return unsafe.String(unsafe.SliceData(b), len(b))
}

虽然这里有一些简单的答案，但我想给出一个更有效的解决方案

func Bytes2StrImp(b []byte) string{
    sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&b))
    sh := reflect.StringHeader{
        Data: sliceHeader.Data,
        Len:  sliceHeader.Len,
    }
    return *(*string)(unsafe.Pointer(&sh)) // go vet error possible misuse reflect.StringHeader
}

• • 更新**

func Bytes2StrImp(b []byte) string {
    sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&b))
    var s string
    sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
    sh.Data = sliceHeader.Data
    sh.Len = sliceHeader.Len
    return s
}

上述解决方案通过Pointer操作将字节数组转换为字符串，string(b[:])将做一个新的字符串对象，将字节数组中的数据复制到字符串中。
string(b[:])的基准测试结果
一个三个三个一个

你可以试试

b.decode("utf-8")

请告诉我，这对您有帮助吗？强文本

不用于打印十六进制编码的字符串，但在 * 一般 * 情况下，当[size]byte数组可能包含无效的UTF-8序列时，则根据this answer，可以使用以下命令将其转换为有效的UTF-8

s := string([]rune(string(b[:])))

Example：

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    b := [1]byte{0xff}
    s := string(b[:])
    fmt.Println(s, []byte(s), utf8.Valid([]byte(s)))
    // Output: � [255] false

    s = string([]rune(string(b[:])))
    fmt.Println(s, []byte(s), utf8.Valid([]byte(s)))
    // Output: � [239 191 189] true
}

我发现这些注解真的没有帮助，因为它们假设OP只需要[]byte的文字字符串...但是如果你像我一样，需要utf8解码的字节作为字符串，你可以使用以下代码：

import  "unicode/utf8"
func bytesToUtf8(b []byte) string {
    var myString = "";
    for i := 1; i <= len(b); i++ {
        r, _ := utf8.DecodeRune(b[i-1:i])
        myString += string(r)
    }
    return myString
}
var uselessBytes := []byte{123,34,...}
helpfulUtf8String := bytesToUtf8(uselessBytes)