Come convertire un array di byte con terminazione zero in stringa?

Devo leggere [100]byteper trasferire un mucchio di stringdati.

Poiché non tutte le strings sono esattamente lunghe 100 caratteri, la parte rimanente byte arrayè riempita con 0s.

Se converto [100]bytein stringper string(byteArray[:]):, 0i tailing s vengono visualizzati come ^@^@s.

In C il stringterminerà al momento 0, quindi mi chiedo qual è il modo migliore per convertire questo byte arraya stringin Golang.

I metodi che leggono i dati in sezioni di byte restituiscono il numero di byte letti. Dovresti salvare quel numero e poi usarlo per creare la tua stringa Se nè il numero di byte letti, il tuo codice sarebbe simile al seguente:

s := string(byteArray[:n])

Per convertire l'intera stringa, è possibile utilizzare questo:

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

Ciò equivale a:

s := string(byteArray)

Se per qualche motivo non lo sai n, puoi usare il bytespacchetto per trovarlo, supponendo che il tuo input non abbia un carattere nullo incorporato in esso.

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

O come ha sottolineato icza, puoi usare il codice qui sotto:

n := bytes.IndexByte(byteArray, 0)

Che dire?

s := string(byteArray[:])

Soluzione semplicistica:

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

Non sono sicuro di quanto sia performante.

Per esempio,

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

Produzione:

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

Il codice seguente sta cercando '\ 0' e, sotto i presupposti della domanda, l'array può essere considerato ordinato poiché tutti i non - '\ 0' precedono tutti '\ 0'. Questa ipotesi non sarà valida se l'array può contenere '\ 0' all'interno dei dati.

Trova la posizione del primo byte zero usando una ricerca binaria, quindi taglia.

Puoi trovare il byte zero in questo modo:

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

Potrebbe essere più veloce scansionare in modo ingenuo l'array di byte cercando il byte zero, specialmente se la maggior parte delle stringhe sono brevi.

Quando non si conosce la lunghezza esatta di byte diversi da zero nell'array, è possibile tagliarlo prima:

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

Perché non questo?

bytes.NewBuffer(byteArray).String()

Utilizzare solo per l'ottimizzazione delle prestazioni.

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

• Utilizzare le sezioni anziché le matrici per la lettura. ad esempio io.Readeraccetta una sezione, non una matrice.

• Usa lo slicing anziché lo zero padding.

Esempio:

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

Ho provato alcuni metodi poche volte ho avuto il panico:

errore di runtime: limiti di fetta fuori intervallo.

Ma alla fine ha funzionato.

string(Data[:])

Sebbene non estremamente performante, l'unica soluzione leggibile è

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

Esempio completo per avere un array di byte in stile 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)
}

Esempio completo per avere una stringa di stile go escludendo i 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)
}

Ciò alloca una fetta di fetta di byte. Quindi tieni d'occhio la performance se viene usata pesantemente o ripetutamente.

Ecco il codice per comprimere l'array di byte in stringa

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
}

Ecco il modo più veloce:

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

Io quando con una soluzione ricorsiva.

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