Quel est le meilleur moyen de convertir le tableau d'octets de la chaîne?

Question

J'ai besoin de lire [100]byte pour le transfert d'un tas d' string données.

Parce que pas tous les string est précisément de 100 de long, la partie restante de l' byte array sont rembourrées avec de la 0s.

Si je tansfer [100]byte de string par: string(byteArra[:]), la filature 0s sont affichés en ^@^@s.

Dans C l' string prendra fin à l' 0, donc je me demande quelle est la meilleure façon de intelligemment transfert byte array de string.

Answer 1

méthodes de lire les données en octets tranches de retourner le nombre d'octets lus. Vous devez enregistrer le nombre et l'utiliser pour créer votre chaîne. n étant le nombre d'octets lus, votre code devrait ressembler à ceci:

s := string(byteArray[:n])

Si pour quelque raison vous n'avez pas d' n, vous pouvez utiliser des octets d'un paquet de trouver, en supposant que vos commentaires n'ont pas un caractère nul.

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

Answer 2

Sur quoi?

    s := string(byteArray[:])

Answer 3

Par exemple,

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

Sortie:

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

Answer 4

Trouver l'emplacement de la première de zéro octet à l'aide d'une recherche binaire, puis tranche.

Vous pouvez trouver le zéro octet comme ceci:

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

Il peut être plus rapide pour naïvement analyse le tableau d'octets à la recherche pour le zéro octet, surtout si la plupart de vos chaînes sont courtes.

Answer 5

• Utiliser les morceaux au lieu des tableaux pour la lecture. E. g. io.Reader accepte une tranche, pas un tableau.

• L'utilisation de découpage au lieu de zéro de remplissage.

Exemple:

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