golang variable json

JSON (JavaScript Object Notation) ialah format pertukaran data yang ringan. Mudah untuk manusia membaca dan menulis, dan juga mudah untuk komputer menghuraikan dan menjana. Walau bagaimanapun, satu had JSON ialah kunci mestilah daripada jenis rentetan. Ini bermakna bekerja dengan JSON boleh menjadi sedikit rumit apabila kita perlu lulus atau menghuraikan struktur data yang kompleks.

Dalam bahasa Go, kami mempunyai alat untuk menyelesaikan masalah ini, iaitu menggunakan pembolehubah jenis yang tidak ditaip interface{}. Menggunakan ciri ini kita boleh mencipta sebarang struktur tanpa mengetahui nama kunci. Dalam artikel ini, kami akan meneroka contoh penulisan JSON menggunakan pembolehubah tidak ditaip dalam golang.

Pembolehubah jenis tak tentu

Untuk memahami pembolehubah jenis tak tentu, kita perlu terlebih dahulu memahami beberapa pengetahuan asas penukaran jenis. Dalam bahasa Go, nilai boleh ditukar daripada satu jenis kepada jenis lain melalui penukaran jenis tersurat dan tersirat. Contohnya, kita boleh menukar string kepada int atau int kepada float.

Pembolehubah jenis tidak tentu ialah pembolehubah jenis tidak ditetapkan yang boleh mengandungi sebarang jenis nilai. Pembolehubah jenis ini sangat berguna apabila anda perlu mengendalikan pelbagai jenis data. Kita boleh menggunakan pembolehubah yang tidak ditaip untuk menulis JSON dengan nama kunci yang tidak ditentukan, malah mengandungi pasangan nilai kunci bersarang.

Mencipta pembolehubah ditaip tanpa had

Cara paling mudah untuk mencipta pembolehubah ditaip tanpa had ialah menggunakan sintaks yang tidak diisytiharkan. Sebagai contoh, penyataan berikut akan mencipta pembolehubah tidak ditaip bernama x:

var x interface{}

Pada ketika ini, pembolehubah x belum diberikan sebarang jenis, jadi ia boleh diberikan nilai apa-apa jenis:

x = 42       // int
x = "hello"  // string
x = true     // bool

Operasi pembolehubah jenis tak tentu

Memandangkan pembolehubah jenis tak tentu boleh mengandungi nilai mana-mana jenis, kita perlu menggunakan penegasan jenis untuk mengakses nilainya. Sebagai contoh, jika kita tahu bahawa pembolehubah x mengandungi nilai int, kita boleh menetapkannya kepada pembolehubah i baharu menggunakan penegasan jenis berikut:

i := x.(int)

Jika kita tidak pasti apakah x pembolehubah mengandungi jenis nilai, anda boleh menggunakan suis jenis dan pernyataan switch untuk menguji jenisnya:

switch v := x.(type) {
case int:
    fmt.Printf("x is an int with value %v
", v)
case string:
    fmt.Printf("x is a string with value %v
", v)
default:
    fmt.Printf("x is of type %T
", v)
}

Kod di atas akan mengeluarkan jenis dan nilai pembolehubah x.

Had pembolehubah ditaip

Walaupun pembolehubah ditaip sangat berguna, pembolehubah itu juga mempunyai beberapa had. Oleh kerana pembolehubah yang tidak ditaip kehilangan maklumat jenis yang disimpan, nilainya tidak boleh terus tertakluk kepada operasi aritmetik atau perbandingan. Sebagai contoh, kod berikut adalah salah:

x := 42
y := 50
z := x + y   // Error: invalid operation: x + y (mismatched types interface {} and interface {})

Dalam contoh di atas, pengkompil tidak mengenali jenis pembolehubah x dan y dan oleh itu tidak boleh melaksanakan operasi aritmetik. Untuk mengelakkan ini, kita boleh menggunakan penegasan jenis untuk menukar x dan y kepada jenis yang sepadan:

x := 42
y := 50
z := x.(int) + y.(int)

Menulis JSON dengan pembolehubah jenis tidak tentu

Dengan pembolehubah jenis tidak tentu, kami Anda boleh tulis JSON dengan mudah dengan nama kunci berubah-ubah. Mari lihat contoh menggunakan pembolehubah yang tidak ditaip untuk mencipta JSON dengan pasangan nilai kunci bersarang:

package main
import (
    "encoding/json"
    "fmt"
)
func main() {
    data := make(map[string]interface{})
    data["name"] = "Alice"
    data["age"] = 29
    data["email"] = "alice@example.com"
    address := make(map[string]interface{})
    address["city"] = "New York"
    address["state"] = "NY"
    data["address"] = address
    jsonString, _ := json.Marshal(data)
    fmt.Println(string(jsonString))
}

Dalam contoh di atas, kami menggunakan pembolehubah tidak ditaip untuk mencipta JSON dengan pasangan nilai kunci bersarang . Mula-mula, kami mencipta peta kosong dan menambah pasangan nilai kunci secara dinamik menggunakan kunci dan nilai jenis interface{}. Kemudian, kami mencipta satu lagi peta kosong untuk menyimpan pasangan nilai kunci bersarang. Akhir sekali, kami menambah peta bersarang pada peta utama sebagai pasangan nilai kunci dan kemudian mengekodnya ke dalam rentetan JSON menggunakan fungsi json.Marshal().

Menjalankan kod di atas akan mengeluarkan rentetan JSON berikut:

{
    "address": {
        "city": "New York",
        "state": "NY"
    },
    "age": 29,
    "email": "alice@example.com",
    "name": "Alice"
}

Kita dapat melihat bahawa rentetan JSON yang dijana mengandungi pasangan nilai kunci bersarang, yang diwakili dengan cara yang sama ialah kunci -pasangan nilai dalam peta. Contoh ini menunjukkan cara menggunakan pembolehubah yang tidak ditaip untuk menulis struktur data JSON yang kompleks tanpa mengetahui nama kunci.

Kesimpulan

Dalam artikel ini, kami mempelajari cara menulis struktur data JSON yang kompleks menggunakan pembolehubah tidak ditaip dalam bahasa Go. Untuk mencapai matlamat ini, kami menggunakan pembolehubah dan peta yang tidak ditaip, yang membolehkan kami membuat pasangan nilai kunci bersarang dengan nama kunci arbitrari dengan mudah. Walaupun pembolehubah yang tidak ditaip mempunyai beberapa had, ia sangat mudah dan berguna dalam mengawal pelbagai jenis data. Jika anda perlu menulis JSON dalam bahasa Go, menggunakan pembolehubah yang tidak ditaip boleh memenuhi keperluan anda.

Atas ialah kandungan terperinci golang variable json. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!