วิธีการแปลงอาร์เรย์ไบต์สิ้นสุดลงเป็นศูนย์เพื่อสตริง?

ฉันต้องอ่าน[100]byteเพื่อถ่ายโอนstringข้อมูลจำนวนมาก

เนื่องจากไม่ใช่strings ทั้งหมดที่มีความยาว 100 อักขระอย่างแม่นยำส่วนที่เหลือของbyte arrayเบาะนั้นจะเต็มไปด้วย0s

ถ้าฉันแปลง[100]byteเป็นstringโดย: string(byteArray[:])tailing 0s จะแสดงเป็น^@^@s

ใน C stringจะสิ้นสุดลง0ดังนั้นฉันสงสัยว่าอะไรคือวิธีที่ดีที่สุดในการแปลงbyte arrayเป็นstring Golang

วิธีการที่อ่านข้อมูลลงในส่วนข้อมูลไบต์จะส่งกลับจำนวนไบต์ที่อ่าน คุณควรบันทึกหมายเลขนั้นแล้วใช้มันเพื่อสร้างสตริงของคุณหากnเป็นจำนวนไบต์อ่านรหัสของคุณจะมีลักษณะเช่นนี้:

s := string(byteArray[:n])

ในการแปลงสตริงแบบเต็มสามารถใช้:

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

นี่เทียบเท่ากับ:

s := string(byteArray)

หากคุณไม่ทราบด้วยเหตุผลบางอย่างnคุณสามารถใช้bytesแพ็คเกจเพื่อค้นหาได้โดยสมมติว่าข้อมูลที่คุณป้อนไม่มีอักขระ null ฝังอยู่

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' ในข้อมูล

ค้นหาตำแหน่งของ zero-byte แรกโดยใช้การค้นหาแบบไบนารีจากนั้นแบ่ง

คุณสามารถค้นหา zero-byte ดังนี้:

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

มันอาจจะเร็วกว่าเพียงแค่การสแกนอาเรย์อย่างไร้เดียงสาเพื่อค้นหา zero-byte โดยเฉพาะอย่างยิ่งหากสตริงส่วนใหญ่ของคุณสั้น

เมื่อคุณไม่ทราบความยาวที่แน่นอนของไบต์ที่ไม่เป็นศูนย์ในอาเรย์คุณสามารถเล็มได้ก่อน:

สตริง (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)
}

ตัวอย่างเต็มรูปแบบที่มีสตริงลักษณะ go ยกเว้นค่า 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)
}

สิ่งนี้จะจัดสรรส่วนแบ่งของไบต์ ดังนั้นจับตาดูประสิทธิภาพหากมีการใช้งานหนักหรือซ้ำ ๆ

นี่คือรหัสในการบีบอัดอาร์เรย์ไบต์กับสตริง

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