Bagaimana cara mengubah byte array yang diakhiri nol ke string?

Saya perlu membaca [100]byteuntuk mentransfer banyakstring data.

Karena tidak semua stringkarakter memiliki panjang 100 karakter, bagian sisanya byte arraydiisi dengan0 s.

Jika saya mengonversi [100]byteke stringoleh string(byteArray[:]):, tailing 0akan ditampilkan sebagai^@^@ s.

Di C stringakan berakhir 0, jadi saya bertanya-tanya apa cara terbaik untuk mengubahnya byte arrayke stringGolang.

Metode yang membaca data menjadi irisan byte mengembalikan jumlah byte yang dibaca. Anda harus menyimpan nomor itu dan kemudian menggunakannya untuk membuat string Anda. Jika njumlah byte dibaca, kode Anda akan terlihat seperti ini:

s := string(byteArray[:n])

Untuk mengonversi string penuh ini dapat digunakan:

s := string(byteArray[:len(byteArray)])

Ini setara dengan:

s := string(byteArray)

Jika karena alasan tertentu Anda tidak tahu n, Anda bisa menggunakan bytespaket untuk menemukannya, dengan asumsi input Anda tidak memiliki karakter nol yang tertanam di dalamnya.

n := bytes.Index(byteArray, []byte{0})

Atau seperti yang ditunjukkan icza, Anda dapat menggunakan kode di bawah ini:

n := bytes.IndexByte(byteArray, 0)

Bagaimana dengan?

s := string(byteArray[:])

Solusi sederhana:

str := fmt.Sprintf("%s", byteArray)

Saya tidak yakin bagaimana performant ini.

Sebagai contoh,

package main

import "fmt"

func CToGoString(c []byte) string {
    n := -1
    for i, b := range c {
        if b == 0 {
            break
        }
        n = i
    }
    return string(c[:n+1])
}

func main() {
    c := [100]byte{'a', 'b', 'c'}
    fmt.Println("C: ", len(c), c[:4])
    g := CToGoString(c[:])
    fmt.Println("Go:", len(g), g)
}

Keluaran:

C:  100 [97 98 99 0]
Go: 3 abc

Kode berikut mencari '\ 0', dan di bawah asumsi pertanyaan array dapat dianggap diurutkan karena semua bukan - '\ 0' mendahului semua '\ 0'. Asumsi ini tidak akan berlaku jika array dapat berisi '\ 0' dalam data.

Temukan lokasi nol-byte pertama menggunakan pencarian biner, kemudian iris.

Anda dapat menemukan nol-byte seperti ini:

package main

import "fmt"

func FirstZero(b []byte) int {
    min, max := 0, len(b)
    for {
        if min + 1 == max { return max }
        mid := (min + max) / 2
        if b[mid] == '\000' {
            max = mid
        } else {
            min = mid
        }
    }
    return len(b)
}
func main() {
    b := []byte{1, 2, 3, 0, 0, 0}
    fmt.Println(FirstZero(b))
}

Mungkin lebih cepat hanya dengan memindai secara naif array byte mencari nol-byte, terutama jika sebagian besar string Anda pendek.

Saat Anda tidak tahu panjang pasti byte non-nil dalam array, Anda bisa memotongnya terlebih dahulu:

string (bytes.Trim (arr, "\ x00"))

Kenapa tidak ini?

bytes.NewBuffer(byteArray).String()

Hanya digunakan untuk penyempurnaan kinerja.

package main

import (
    "fmt"
    "reflect"
    "unsafe"
)

func BytesToString(b []byte) string {
    return *(*string)(unsafe.Pointer(&b))
}

func StringToBytes(s string) []byte {
    return *(*[]byte)(unsafe.Pointer(&s))
}

func main() {
    b := []byte{'b', 'y', 't', 'e'}
    s := BytesToString(b)
    fmt.Println(s)
    b = StringToBytes(s)
    fmt.Println(string(b))
}

• Gunakan irisan alih-alih array untuk membaca. mis. io.Readermenerima irisan, bukan array.

• Gunakan mengiris bukannya nol padding.

Contoh:

buf := make([]byte, 100)
n, err := myReader.Read(buf)
if n == 0 && err != nil {
        log.Fatal(err)
}

consume(buf[:n]) // consume will see exact (not padded) slice of read data

Saya mencoba beberapa metode beberapa kali saya panik:

kesalahan runtime: iris batas di luar jangkauan.

Tapi ini akhirnya berhasil.

string(Data[:])

Meskipun tidak terlalu berkinerja, satu-satunya solusi yang dapat dibaca adalah

  //split by separator and pick the first one. 
  //This has all the characters till null excluding null itself.
  retByteArray := bytes.Split(byteArray[:], []byte{0}) [0]

  // OR 

  //If you want a true C-like string including the null character
  retByteArray := bytes.SplitAfter(byteArray[:], []byte{0}) [0]

Contoh lengkap untuk memiliki array byte gaya-C:

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var byteArray = [6]byte{97,98,0,100,0,99}

    cStyleString := bytes.SplitAfter(byteArray[:],  []byte{0}) [0]
    fmt.Println(cStyleString)
}

Contoh lengkap untuk memiliki string gaya go tidak termasuk nulls:

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var byteArray = [6]byte{97,98,0,100,0,99}

    goStyleString := string( bytes.Split(byteArray[:],  []byte{0}) [0] )
    fmt.Println(goStyleString)
}

Ini mengalokasikan sepotong byte. Jadi perhatikan kinerja jika digunakan banyak atau berulang kali.

Berikut adalah kode untuk mengompresi byte array ke string

package main

import (
    "fmt"
)

func main() {
    byteArr := [100]byte{'b', 'y', 't', 'e', 's'}
    firstHalf := ToString(byteArr)
    fmt.Println("Bytes to str", string(firstHalf))
}
func ToString(byteArr [100]byte) []byte {
    arrLen := len(byteArr)
    firstHalf := byteArr[:arrLen/2]
    secHalf := byteArr[arrLen/2:]
    for {
        // if the first element is 0 in secondHalf discard second half
        if len(secHalf) != 0 && secHalf[0] == 0 {
            arrLen = len(firstHalf)
            secHalf = firstHalf[arrLen/2:]
            firstHalf = firstHalf[:arrLen/2]
            continue
        } else {
            for idx := 0; len(secHalf) > idx && secHalf[idx] != 0; idx++ {
                firstHalf = append(firstHalf, secHalf[idx])
            }
        }
        break
    }
    return firstHalf
}

Inilah cara tercepat:

resp, _ := http.Get("https://www.something.com/something.xml")
bytes, _ := ioutil.ReadAll(resp.Body)
resp.Body.Close()
fmt.Println(string(bytes)) //just convert with string() function

Saya ketika dengan solusi rekursif.

func CToGoString(c []byte, acc string) string {

    if len(c) == 0 {
        return acc
    } else {
        head := c[0]
        tail := c[1:]
        return CToGoString(tail, acc + fmt.Sprintf("%c", head))
    }
}

func main() {
    b := []byte{some char bytes}
    fmt.Println(CToGoString(b, ""))
}