Jak przekonwertować tablicę bajtów zakończoną zerem na ciąg?

Muszę przeczytać, [100]byteaby przenieść sporo stringdanych.

Ponieważ nie wszystkie stringlitery mają dokładnie 100 znaków, pozostała część byte arrayjest wypełniona literą 0s.

Jeśli przekonwertować [100]bytedo stringprzez: string(byteArray[:]), odpadzie 0s są wyświetlane jako ^@^@s.

W C stringwygasa po 0, więc zastanawiam się, jaki jest najlepszy sposób przekonwertować to byte arraydo stringw Golang.

Metody, które odczytują dane do plasterków bajtów, zwracają liczbę odczytanych bajtów. Powinieneś zapisać tę liczbę, a następnie użyć jej do utworzenia łańcucha Jeśli njest to liczba odczytanych bajtów, kod wyglądałby następująco:

s := string(byteArray[:n])

Aby przekonwertować pełny ciąg, można tego użyć:

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

Jest to równoważne z:

s := string(byteArray)

Jeśli z jakiegoś powodu nie wiesz n, możesz użyć bytespakietu, aby go znaleźć, zakładając, że twój wpis nie zawiera znaku null.

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

Lub, jak wskazał icza, możesz użyć kodu poniżej:

n := bytes.IndexByte(byteArray, 0)

Co powiesz na?

s := string(byteArray[:])

Uproszczone rozwiązanie:

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

Nie jestem jednak pewien, jak wydajne to jest.

Na przykład,

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)
}

Wynik:

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

Poniższy kod szuka „\ 0” i przy założeniu pytania tablicę można uznać za posortowaną, ponieważ wszystkie inne niż „\ 0” poprzedzają wszystkie „\ 0”. To założenie nie będzie miało zastosowania, jeśli tablica może zawierać „\ 0” w danych.

Znajdź lokalizację pierwszego zera za pomocą wyszukiwania binarnego, a następnie pokrój.

Możesz znaleźć bajt zerowy w ten sposób:

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))
}

Szybsze może być tylko naiwne skanowanie tablicy bajtów w poszukiwaniu bajtu zerowego, szczególnie jeśli większość ciągów znaków jest krótka.

Jeśli nie znasz dokładnej długości bajtów innych niż zero w tablicy, możesz ją najpierw przyciąć:

string (bytes.Trim (arr, „\ x00”))

Dlaczego nie to

bytes.NewBuffer(byteArray).String()

Używaj tylko do strojenia wydajności.

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))
}

• Do czytania używaj wycinków zamiast tablic. np. io.Readerakceptuje plasterek, a nie tablicę.

• Zastosuj krojenie zamiast zerowania.

Przykład:

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

Kilka razy próbowałem kilka metod, wpadłem w panikę:

błąd czasu wykonania: plasterek jest poza zakresem.

Ale to w końcu zadziałało.

string(Data[:])

Chociaż nie jest to wyjątkowo wydajne, jedynym możliwym do odczytania rozwiązaniem jest

  //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]

Pełny przykład posiadania tablicy bajtów w stylu 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)
}

Pełny przykład posiadania łańcucha stylu go z wyłączeniem wartości null:

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)
}

To przydziela plasterek bajtu. Miej oko na wydajność, jeśli jest intensywnie lub wielokrotnie używana.

Oto kod do kompresji tablicy bajtów na ciąg

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
}

Oto szybszy sposób:

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

Ja z rozwiązaniem rekurencyjnym.

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, ""))
}