Wie konvertiere ich ein nullterminiertes Byte-Array in einen String?

Ich muss lesen [100]byte, um eine Reihe von stringDaten zu übertragen.

Da nicht alle strings genau 100 Zeichen lang sind, wird der verbleibende Teil von s byte arraymit 0s aufgefüllt .

Wenn ich [100]bytenach stringby konvertiere string(byteArray[:]), werden die Tailing 0s als ^@^@s angezeigt .

In C die stringenden auf 0, so frage ich mich , was der beste Weg, dies zu konvertieren , byte arrayum stringin Golang.

Methoden, die Daten in Byte-Slices lesen, geben die Anzahl der gelesenen Bytes zurück. Sie sollten diese Nummer speichern und dann zum Erstellen Ihrer Zeichenfolge verwenden. Wenn ndie Anzahl der gelesenen Bytes angegeben ist, sieht Ihr Code folgendermaßen aus:

s := string(byteArray[:n])

Um die vollständige Zeichenfolge zu konvertieren, kann Folgendes verwendet werden:

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

Dies entspricht:

s := string(byteArray)

Wenn Sie es aus irgendeinem Grund nicht wissen n, können Sie das bytesPaket verwenden, um es zu finden, vorausgesetzt, in Ihre Eingabe ist kein Nullzeichen eingebettet.

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

Oder wie icza betonte, können Sie den folgenden Code verwenden:

n := bytes.IndexByte(byteArray, 0)

Wie wäre es mit?

s := string(byteArray[:])

Einfache Lösung:

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

Ich bin mir nicht sicher, wie performant das ist.

Zum Beispiel,

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

Ausgabe:

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

Der folgende Code sucht nach '\ 0', und unter den Annahmen der Frage kann das Array als sortiert betrachtet werden, da alle Nicht-'\ 0' vor allen '\ 0' stehen. Diese Annahme gilt nicht, wenn das Array '\ 0' in den Daten enthalten kann.

Suchen Sie die Position des ersten Null-Bytes mithilfe einer binären Suche und schneiden Sie dann.

Sie finden das Null-Byte folgendermaßen:

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

Es kann schneller sein, das Byte-Array naiv nach dem Null-Byte zu durchsuchen, insbesondere wenn die meisten Ihrer Zeichenfolgen kurz sind.

Wenn Sie die genaue Länge der Nicht-Null-Bytes im Array nicht kennen, können Sie sie zuerst zuschneiden:

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

Warum nicht das?

bytes.NewBuffer(byteArray).String()

Nur zur Leistungsoptimierung verwenden.

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

• Verwenden Sie zum Lesen Slices anstelle von Arrays. zB io.Readerakzeptiert ein Slice, kein Array.

• Verwenden Sie das Schneiden anstelle der Nullpolsterung.

Beispiel:

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

Ich habe einige Male einige Methoden ausprobiert, als ich in Panik geriet:

Laufzeitfehler: Slice-Grenzen außerhalb des Bereichs.

Aber das hat endlich funktioniert.

string(Data[:])

Obwohl nicht extrem performant, ist die einzige lesbare Lösung

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

Vollständiges Beispiel für ein Byte-Array im C-Stil:

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

Vollständiges Beispiel für eine Go-Zeichenfolge ohne Nullen:

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

Dadurch wird ein Stück Byte zugewiesen. Behalten Sie also die Leistung im Auge, wenn sie stark oder wiederholt verwendet wird.

Hier ist der Code zum Komprimieren des Byte-Arrays in einen 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
}

Hier ist der schnellere Weg:

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

Ich wenn mit einer rekursiven Lösung.

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