Sıfır sonlu bayt dizisini dizeye nasıl dönüştürebilirim?

[100]byteBir sürü stringveri aktarmak için okumam gerekiyor .

Tüm strings'ler tam olarak 100 karakter uzunluğunda olmadığından, kalan kısmı s byte arrayile doldurulur 0.

Ben dönüştürürseniz [100]byteiçin stringölçütü: string(byteArray[:]), atık 0ler olarak görüntülenir ^@^@s.

C stringfeshedilecektir 0, bu yüzden bu dönüştürmek için en iyi yolu ne var merak byte arrayetmek stringGolang içinde.

Verileri bayt dilimlerine okuyan yöntemler okunan bayt sayısını döndürür. Bu sayıyı kaydetmeli ve sonra dizenizi oluşturmak için kullanmalısınız nOkunan bayt sayısı ise, kodunuz şöyle görünecektir:

s := string(byteArray[:n])

Tam dizeyi dönüştürmek için bu kullanılabilir:

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

Bu şuna eşittir:

s := string(byteArray)

Herhangi bir nedenle bilmiyorsanız n, bytesgirdinizin içinde boş bir karakter bulunmadığını varsayarak paketi bulmak için kullanabilirsiniz .

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

Veya icza'nın işaret ettiği gibi, aşağıdaki kodu kullanabilirsiniz:

n := bytes.IndexByte(byteArray, 0)

Ne dersin?

s := string(byteArray[:])

Basit çözüm:

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

Bunun nasıl bir performans gösterdiğinden emin değilim.

Örneğin,

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

Çıktı:

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

Aşağıdaki kod '\ 0' değerini arar ve sorunun varsayımları altında dizi, '\ 0' olmayan tüm '\ 0' öğesinden önce geldiğinden sıralanabilir. Dizi veri içinde '\ 0' içerebilirse bu varsayım geçerli olmaz.

İkili bir arama kullanarak ilk sıfır baytın konumunu bulun, sonra dilimleyin.

Sıfır baytı şu şekilde bulabilirsiniz:

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

Özellikle dizelerin çoğu kısaysa, sıfır baytı arayan bayt dizisini saf olarak taramak daha hızlı olabilir.

Dizideki sıfır olmayan baytların tam uzunluğunu bilmiyorsanız, önce kesebilirsiniz:

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

Neden olmasın?

bytes.NewBuffer(byteArray).String()

Yalnızca performans ayarı için kullanın.

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

• Okumak için diziler yerine dilimler kullanın. örneğin io.Readerbir diziyi değil bir dilimi kabul eder.

• Sıfır dolgu yerine dilimleme kullanın.

Misal:

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

Paniğe kapıldığımda birkaç yöntem denedim:

çalışma zamanı hatası: dilim sınırların dışına çıkıyor.

Ama bu sonunda işe yaradı.

string(Data[:])

Son derece yüksek performans göstermese de okunabilir tek çözüm

  //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 stili bayt dizisine sahip olmak için tam örnek:

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'lar hariç go stili bir dizeye sahip olmak için tam örnek:

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

Bu bir dilim dilim bayt ayırır. Bu nedenle, yoğun veya tekrar tekrar kullanılıyorsa performansa dikkat edin.

Bayt dizisini dizeye sıkıştırmak için kod

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
}

İşte daha hızlı yol:

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

Ben özyinelemeli bir çözüm ile.

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