¿Cómo convertir una matriz de bytes terminada en cero a una cadena?

Necesito leer [100]bytepara transferir un montón de stringdatos.

Debido a que no todos los strings tienen exactamente 100 caracteres de largo, la parte restante del mismo byte arrayse rellena con 0s.

Si convierto [100]bytea stringby:, string(byteArray[:])los 0s de cola se muestran como ^@^@s.

En la C stringse terminará con 0, por lo que me pregunto ¿cuál es la mejor manera de convertir esta byte arraya stringen Golang.

Los métodos que leen datos en segmentos de bytes devuelven el número de bytes leídos. Debe guardar ese número y luego usarlo para crear su cadena. Si nes el número de bytes leídos, su código se vería así:

s := string(byteArray[:n])

Para convertir la cadena completa, esto se puede usar:

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

Esto es equivalente a:

s := string(byteArray)

Si por alguna razón no lo sabe n, puede usar el bytespaquete para encontrarlo, suponiendo que su entrada no tenga un carácter nulo incrustado.

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

O como señaló icza, puede usar el siguiente código:

n := bytes.IndexByte(byteArray, 0)

¿Qué pasa?

s := string(byteArray[:])

Solución simplista:

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

Sin embargo, no estoy seguro de cuán eficiente es esto.

Por ejemplo,

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

Salida:

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

El siguiente código busca '\ 0', y bajo los supuestos de la pregunta, la matriz se puede considerar ordenada ya que todos los que no son '\ 0' preceden a todos '\ 0'. Esta suposición no se mantendrá si la matriz puede contener '\ 0' dentro de los datos.

Encuentre la ubicación del primer byte cero usando una búsqueda binaria, luego corte.

Puede encontrar el byte cero de esta manera:

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

Puede ser más rápido escanear ingenuamente la matriz de bytes en busca del byte cero, especialmente si la mayoría de sus cadenas son cortas.

Cuando no conoce la longitud exacta de bytes no nulos en la matriz, puede recortarla primero:

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

¿Por qué no esto?

bytes.NewBuffer(byteArray).String()

Solo se usa para ajuste de rendimiento.

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

• Use rebanadas en lugar de matrices para leer. por ejemplo, io.Readeracepta un segmento, no una matriz.

• Use rebanado en lugar de cero relleno.

Ejemplo:

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

Probé algunos métodos pocas veces me entró el pánico:

error de tiempo de ejecución: límites de corte fuera de rango.

Pero esto finalmente funcionó.

string(Data[:])

Aunque no es extremadamente eficiente, la única solución legible es

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

Ejemplo completo para tener una matriz de bytes de estilo 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)
}

Ejemplo completo para tener una cadena de estilo ir excluyendo los nulos:

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

Esto asigna una porción de porción de bytes. Por lo tanto, vigile el rendimiento si se usa en gran medida o repetidamente.

Aquí está el código para comprimir la matriz de bytes a una cadena

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
}

Aquí está la forma más rápida:

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

Yo cuando con una solución recursiva.

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