วิธีการกำหนดสตริงให้กับอาร์เรย์ไบต์

ฉันต้องการกำหนดสตริงให้กับอาร์เรย์ไบต์:

var arr [20]byte
str := "abc"
for k, v := range []byte(str) {
  arr[k] = byte(v)
}

มีวิธีอื่นไหม

ปลอดภัยและเรียบง่าย:

[]byte("Here is a string....")

สำหรับการแปลงจากสตริงเป็นไบต์string -> []byte:

[]byte(str)

สำหรับการแปลงอาเรย์เป็นชิ้น[20]byte -> []byte:

arr[:]

สำหรับการคัดลอกสตริงไปยังอาร์เรย์string -> [20]byte:

copy(arr[:], str)

เหมือนข้างต้น แต่แปลงสตริงเป็นชิ้นอย่างชัดเจน:

copy(arr[:], []byte(str))

• copyฟังก์ชันในตัวคัดลอกไปยังชิ้นจากชิ้นเท่านั้น
• อาร์เรย์คือ "ข้อมูลพื้นฐาน" ในขณะที่ชิ้นส่วนคือ "วิวพอร์ตเป็นข้อมูลพื้นฐาน"
• การใช้[:]ทำให้อาร์เรย์มีคุณสมบัติเป็นชิ้น
• สตริงไม่มีคุณสมบัติเป็นชิ้นที่สามารถคัดลอกไปยังแต่มันมีคุณสมบัติเป็นชิ้นที่สามารถคัดลอกจาก (สตริงไม่เปลี่ยนรูป)
• หากสตริงยาวเกินไปcopyจะคัดลอกเฉพาะส่วนของสตริงที่พอดี

รหัสนี้:

var arr [20]byte
copy(arr[:], "abc")
fmt.Printf("array: %v (%T)\n", arr, arr)

... ให้ผลลัพธ์ต่อไปนี้:

array: [97 98 99 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] ([20]uint8)

ฉันยังให้บริการที่สนามเด็กเล่นโก

ตัวอย่างเช่น,

package main

import "fmt"

func main() {
    s := "abc"
    var a [20]byte
    copy(a[:], s)
    fmt.Println("s:", []byte(s), "a:", a)
}

เอาท์พุท:

s: [97 98 99] a: [97 98 99 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]

เค้กชิ้น:

arr := []byte("That's all folks!!")

ฉันคิดว่ามันจะดีกว่า ..

package main

import "fmt"

func main() {
    str := "abc"
    mySlice := []byte(str)
    fmt.Printf("%v -> '%s'",mySlice,mySlice )
}

ตรวจสอบที่นี่: http://play.golang.org/p/vpnAWHZZk7

ไปแปลงสตริงเป็นชิ้นไบต์

คุณต้องการวิธีที่รวดเร็วในการแปลงสตริง [] เป็น [] ประเภทไบต์ เพื่อใช้ในสถานการณ์ต่าง ๆ เช่นการจัดเก็บข้อมูลข้อความลงในไฟล์การเข้าถึงแบบสุ่มหรือการจัดการข้อมูลประเภทอื่นที่ต้องการให้ข้อมูลอินพุตเป็น [] ชนิดไบต์

package main

func main() {

    var s string

    //...

    b := []byte(s)

    //...
}

ซึ่งมีประโยชน์เมื่อใช้ ioutil.WriteFile ซึ่งยอมรับการแบ่งไบต์เป็นพารามิเตอร์ข้อมูล:

WriteFile func(filename string, data []byte, perm os.FileMode) error

ตัวอย่างอื่น

package main

import (
    "fmt"
    "strings"
)

func main() {

    stringSlice := []string{"hello", "world"}

    stringByte := strings.Join(stringSlice, " ")

    // Byte array value
    fmt.Println([]byte(stringByte))

    // Corresponding string value
    fmt.Println(string([]byte(stringByte)))
}

เอาท์พุท:

[104 101 108 108 111 32 119 111 114 108 100] สวัสดีชาวโลก

กรุณาตรวจสอบลิงค์สนามเด็กเล่น

จบลงด้วยการสร้างวิธีการเฉพาะของอาร์เรย์เพื่อทำสิ่งนี้ คล้ายกับแพ็คเกจการเข้ารหัส / ไบนารีด้วยวิธีการเฉพาะสำหรับแต่ละชนิด int binary.BigEndian.PutUint16([]byte, uint16)เช่น

func byte16PutString(s string) [16]byte {
    var a [16]byte
    if len(s) > 16 {
        copy(a[:], s)
    } else {
        copy(a[16-len(s):], s)
    }
    return a
}

var b [16]byte
b = byte16PutString("abc")
fmt.Printf("%v\n", b)

เอาท์พุท:

[0 0 0 0 0 0 0 0 0 0 0 0 0 97 98 99]

สังเกตว่าฉันต้องการแพ็ดดิ้งทางซ้ายไม่ใช่ทางขวา

http://play.golang.org/p/7tNumnJaiN

นอกเหนือจากวิธีการที่กล่าวข้างต้นคุณสามารถทำตาม

s := "hello"
b := *(*[]byte)(unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(&s))))

ไปเล่น: http://play.golang.org/p/xASsiSpQmC

คุณไม่ควรใช้ :-) นี้

อาร์เรย์เป็นค่า ... ตัวแบ่งเป็นเหมือนตัวชี้ ที่[n]typeไม่เข้ากันกับ[]typeพวกเขาเป็นสองสิ่งที่แตกต่างพื้นฐาน คุณสามารถได้รับชิ้นที่ชี้ไปที่อาร์เรย์โดยใช้arr[:]ที่ส่งกลับชิ้นที่มีarrมันเป็นที่เก็บข้อมูลสำรอง

วิธีหนึ่งที่จะแปลงชิ้นของตัวอย่างเช่น[]byteการ[20]byteคือการจัดสรรจริง[20]byteที่คุณสามารถทำโดยการใช้var [20]byte(ตามที่มันเป็นความคุ้มค่า ... ไม่makeจำเป็น) และคัดลอกข้อมูลลงในมัน

buf := make([]byte, 10)
var arr [10]byte
copy(arr[:], buf)

เป็นหลักสิ่งที่คำตอบอื่น ๆ มากมายผิดคือนั่น[]typeไม่ใช่อาเรย์

[n]Tและ[]Tเป็นสิ่งที่แตกต่างอย่างสิ้นเชิง!

เมื่อใช้การไตร่ตรอง[]Tไม่ได้เป็นอาเรย์ชนิดใด แต่เป็นชนิดสแลซและ[n]Tเป็นอาเรย์ที่มีเมตตา

นอกจากนี้คุณยังไม่สามารถใช้งานแต่คุณสามารถใช้map[[]byte]Tmap[[n]byte]T

นี้บางครั้งอาจจะยุ่งยากเพราะมากฟังก์ชั่นการใช้งานตัวอย่างเช่นใน[]byteขณะที่ฟังก์ชั่นบางส่วนจะกลับ[n]byte(ที่สะดุดตาที่สุดในฟังก์ชันแฮชcrypto/*) ตัวอย่างเช่นแฮช sha256 คือ[32]byteและไม่เป็น[]byteเช่นนั้นเมื่อผู้เริ่มต้นพยายามเขียนลงไฟล์เช่น:

sum := sha256.Sum256(data)
w.Write(sum)

พวกเขาจะได้รับข้อผิดพลาด วิธีที่ถูกต้องคือการใช้

w.Write(sum[:])

อย่างไรก็ตามคุณต้องการอะไร เพียงแค่เข้าถึงสตริง bytewise? คุณสามารถแปลงstringไป[]byteใช้:

bytes := []byte(str)

แต่นี่ไม่ใช่อาร์เรย์มันเป็นส่วนแบ่ง นอกจากนี้byte! = rune. ในกรณีที่คุณต้องการที่จะทำงานใน "ตัวละคร" คุณจำเป็นต้องใช้rune... byteไม่ได้