0으로 끝나는 바이트 배열을 문자열로 변환하는 방법은 무엇입니까?

[100]byte많은 string데이터 를 전송 하려면 읽어야 합니다 .

모든 strings의 길이가 정확히 100자인 것은 아니기 때문에 의 나머지 부분은 s byte array로 채워집니다 0.

내가 변환하면 [100]byte에 string의해 : string(byteArray[:])의 미행 0들로 표시됩니다 ^@^@의.

C에서이 string해지됩니다 0, 그래서 나는이를 변환하는 가장 좋은 방법은 무엇 궁금 byte array에 stringGolang에서.

바이트 슬라이스로 데이터를 읽는 메소드는 읽은 바이트 수를 리턴합니다. 해당 숫자를 저장 한 다음 문자열을 작성하는 데 사용해야합니다. n읽은 바이트 수가 코드이면 다음과 같습니다.

s := string(byteArray[:n])

전체 문자열을 변환하려면 다음을 사용할 수 있습니다.

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

이것은 다음과 같습니다.

s := string(byteArray)

어떤 이유로 든 모르는 n경우 bytes입력에 널 문자가 포함되어 있지 않다고 가정하면 패키지를 사용하여 찾을 수 있습니다.

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

또는 icza가 지적했듯이 아래 코드를 사용할 수 있습니다.

n := bytes.IndexByte(byteArray, 0)

이건 어떤가요?

s := string(byteArray[:])

간단한 솔루션 :

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

나는 이것이 얼마나 성능이 있는지 잘 모르겠습니다.

예를 들어

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

산출:

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

다음 코드는 '\ 0'을 찾고 있으며 질문의 가정에 따라 '\ 0'이 아닌 모든 '\ 0'이 앞에 오므로 배열을 정렬 된 것으로 간주 할 수 있습니다. 배열이 데이터 내에 '\ 0'을 포함 할 수 있으면이 가정은 유지되지 않습니다.

이진 검색을 사용하여 첫 번째 0 바이트의 위치를 ​​찾은 다음 슬라이스하십시오.

다음과 같이 0 바이트를 찾을 수 있습니다.

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

특히 대부분의 문자열이 짧은 경우 바이트 배열을 순전히 스캔하여 0 바이트를 찾는 것이 더 빠를 수 있습니다.

배열에서 0이 아닌 바이트의 정확한 길이를 모르는 경우 먼저 트리밍 할 수 있습니다.

문자열 (bytes.Trim (arr, "\ x00"))

왜 안돼?

bytes.NewBuffer(byteArray).String()

성능 조정에만 사용하십시오.

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

• 읽기 대신 배열 대신 슬라이스를 사용하십시오. 예를 들어 io.Reader배열이 아닌 슬라이스를 허용합니다.

• 제로 패딩 대신 슬라이싱을 사용하십시오.

예:

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

공황 상태에 빠졌을 때 몇 가지 방법을 시도했습니다.

런타임 오류 : 슬라이스 범위가 범위를 벗어났습니다.

그러나 이것은 마침내 효과가있었습니다.

string(Data[:])

성능이 좋지는 않지만 읽을 수있는 유일한 솔루션은

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

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

null을 제외한 go 스타일 문자열을 갖는 전체 예 :

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

이것은 바이트 슬라이스 조각을 할당합니다. 많이 사용하거나 반복적으로 사용하는 경우 성능을 주시하십시오.

다음은 바이트 배열을 문자열로 압축하는 코드입니다.

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
}

더 빠른 방법은 다음과 같습니다.

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

재귀 적 솔루션을 사용하는 경우

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