Làm thế nào để chuyển đổi một mảng byte kết thúc bằng không thành chuỗi?

Tôi cần đọc [100]byteđể chuyển một loạt stringdữ liệu.

Bởi vì không phải tất cả các strings đều dài chính xác 100 ký tự, phần còn lại của phần byte arrayđược đệm bằng 0s.

Nếu tôi chuyển đổi [100]byte thành string: string(byteArray[:]), các đuôi 0được hiển thị dưới dạng ^@^@s.

Trong C stringsẽ chấm dứt khi0 , vì vậy tôi tự hỏi đâu là cách tốt nhất để chuyển đổi nó byte arraythành stringGolang.

Các phương thức đọc dữ liệu thành các lát byte trả về số byte đã đọc. Bạn nên lưu số đó và sau đó sử dụng nó để tạo chuỗi của bạn Nếu nlà số byte được đọc, mã của bạn sẽ trông như thế này:

s := string(byteArray[:n])

Để chuyển đổi chuỗi đầy đủ, điều này có thể được sử dụng:

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

Điều này tương đương với:

s := string(byteArray)

Nếu vì lý do nào đó bạn không biết n, bạn có thể sử dụng bytesgói để tìm gói, giả sử đầu vào của bạn không có ký tự null được nhúng trong đó.

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

Hoặc như icza đã chỉ ra, bạn có thể sử dụng mã dưới đây:

n := bytes.IndexByte(byteArray, 0)

Thế còn?

s := string(byteArray[:])

Giải pháp đơn giản:

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

Tôi không chắc chắn làm thế nào biểu diễn này là mặc dù.

Ví dụ,

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

Đầu ra:

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

Đoạn mã sau đang tìm kiếm '\ 0' và theo các giả định của câu hỏi, mảng có thể được xem là được sắp xếp vì tất cả không - '\ 0' đứng trước tất cả '\ 0'. Giả định này sẽ không giữ nếu mảng có thể chứa '\ 0' trong dữ liệu.

Tìm vị trí của byte 0 đầu tiên bằng cách sử dụng tìm kiếm nhị phân, sau đó cắt.

Bạn có thể tìm thấy byte không như thế này:

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

Có thể nhanh hơn chỉ cần quét một cách ngây thơ mảng byte tìm kiếm byte không, đặc biệt nếu hầu hết các chuỗi của bạn ngắn.

Khi bạn không biết độ dài chính xác của các byte không có trong mảng, bạn có thể cắt nó trước:

chuỗi (byte.Trim (mảng, "\ x00"))

Tại sao không phải điều này?

bytes.NewBuffer(byteArray).String()

Chỉ sử dụng để điều chỉnh hiệu suất.

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

• Sử dụng lát thay vì mảng để đọc. ví dụ: io.Readerchấp nhận một lát cắt, không phải là một mảng.

• Sử dụng cắt thay vì không đệm.

Thí dụ:

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

Tôi đã thử vài phương pháp vài lần tôi thấy hoảng loạn:

lỗi thời gian chạy: giới hạn lát ngoài phạm vi.

Nhưng điều này cuối cùng đã làm việc.

string(Data[:])

Mặc dù không thực sự hiệu quả, giải pháp duy nhất có thể đọc được là

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

Ví dụ đầy đủ để có một mảng byte kiểu 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)
}

Ví dụ đầy đủ để có chuỗi kiểu đi không bao gồm 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)
}

Điều này phân bổ một lát byte. Vì vậy, hãy theo dõi hiệu suất nếu nó được sử dụng nhiều hoặc lặp đi lặp lại.

Đây là mã để nén mảng byte thành chuỗi

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
}

Đây là cách nhanh hơn:

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

Tôi khi với một giải pháp đệ quy.

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