Comment convertir un tableau d'octets à zéro en chaîne?

J'ai besoin de lire [100]bytepour transférer un tas de stringdonnées.

Étant donné que tous les strings ne comportent pas exactement 100 caractères, la partie restante du byte arrayest remplie de 0s.

Si je convertis [100]byteen stringpar string(byteArray[:]):, les 0s sont affichés comme ^@^@s.

En C la stringprendra fin à 0, alors je me demande quelle est la meilleure façon de convertir ce byte arrayà stringen golang.

Les méthodes qui lisent des données dans des tranches d'octets renvoient le nombre d'octets lus. Vous devez enregistrer ce nombre, puis l'utiliser pour créer votre chaîne. Si nest le nombre d'octets lus, votre code ressemblera à ceci:

s := string(byteArray[:n])

Pour convertir la chaîne complète, cela peut être utilisé:

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

Cela équivaut à:

s := string(byteArray)

Si pour une raison que vous ne connaissez pas n, vous pouvez utiliser le bytespackage pour le trouver, en supposant que votre entrée ne comporte pas de caractère nul.

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

Ou comme l'a souligné icza, vous pouvez utiliser le code ci-dessous:

n := bytes.IndexByte(byteArray, 0)

Qu'en est-il de?

s := string(byteArray[:])

Solution simpliste:

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

Je ne sais pas à quel point c'est performant.

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

Production:

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

Le code suivant recherche '\ 0', et sous les hypothèses de la question, le tableau peut être considéré comme trié puisque tous les non-'\ 0' précèdent tous les '\ 0'. Cette hypothèse ne tiendra pas si le tableau peut contenir «\ 0» dans les données.

Recherchez l'emplacement du premier octet zéro à l'aide d'une recherche binaire, puis découpez.

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 de balayer naïvement le tableau d'octets à la recherche du zéro octet, surtout si la plupart de vos chaînes sont courtes.

Lorsque vous ne connaissez pas la longueur exacte des octets non nuls dans le tableau, vous pouvez d'abord le couper:

chaîne (octets.Trim (arr, "\ x00"))

Pourquoi pas ça?

bytes.NewBuffer(byteArray).String()

À utiliser uniquement pour l'optimisation des performances.

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

• Utilisez des tranches au lieu de tableaux pour la lecture. par exemple io.Readeraccepte une tranche, pas un tableau.

• Utilisez le découpage au lieu du remplissage nul.

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

J'ai essayé quelques méthodes quelques fois, j'ai eu la panique:

erreur d'exécution: tranches hors limites.

Mais cela a finalement fonctionné.

string(Data[:])

Bien que peu performante, la seule solution lisible est

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

Exemple complet pour avoir un tableau d'octets de style 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)
}

Exemple complet pour avoir une chaîne de style go excluant les 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)
}

Cela alloue une tranche de tranche d'octets. Gardez donc un œil sur les performances en cas d'utilisation intensive ou répétée.

Voici le code pour compresser le tableau d'octets en chaîne

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
}

Voici le moyen le plus rapide:

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

Je quand avec une solution récursive.

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