Menggunakan Peta dengan selamat di Golang: Perbezaan dalam pengisytiharan dan permulaan

pengenalan

Minggu ini, saya sedang mengusahakan salah satu pakej pembalut API untuk golang, dan itu menangani penghantaran permintaan pos dengan nilai yang dikodkan URL, menetapkan kuki dan semua perkara yang menyeronokkan. Walau bagaimanapun, semasa saya membina badan, saya menggunakan jenis url.Value untuk membina badan dan menggunakannya untuk menambah dan menetapkan pasangan nilai kunci. Walau bagaimanapun, saya mendapat ralat rujukan penunjuk nil berwayar dalam beberapa bahagian, saya fikir ia adalah kerana beberapa pembolehubah yang saya tetapkan secara manual. Walau bagaimanapun, dengan menyahpepijat lebih dekat, saya mendapati perangkap biasa atau amalan buruk iaitu hanya mengisytiharkan jenis tetapi memulakannya dan yang menyebabkan tiada ralat rujukan.

Dalam siaran ini, saya akan membincangkan, apakah itu peta, cara membuat peta, dan terutamanya cara mengisytiharkan dan memulakannya dengan betul. Cipta perbezaan yang betul antara pengisytiharan dan permulaan peta atau mana-mana jenis data yang serupa dalam golang.

Apakah peta di Golang?

Peta atau peta cincang dalam golang ialah jenis data asas yang membolehkan kami menyimpan pasangan nilai kunci. Di bawah tudung, ia ialah struktur data seperti peta pengepala yang memegang baldi, yang pada asasnya adalah penunjuk kepada tatasusunan baldi (memori bersebelahan). Ia mempunyai kod cincang yang menyimpan pasangan nilai kunci sebenar dan menunjuk kepada baldi baharu jika arus melimpah dengan bilangan kunci. Ini ialah struktur data yang sangat pintar yang menyediakan akses masa yang hampir berterusan.

Cara membuat peta di Golang

Untuk mencipta peta mudah dalam golang, anda boleh mengambil contoh pembilang kekerapan huruf menggunakan peta rentetan dan integer. Peta akan menyimpan huruf sebagai kekunci dan kekerapannya sebagai nilai.

package main

import "fmt"

func main() {
    words := "hello how are you"
    letters := map[string]int{}

    for _, word := range words {
        wordCount[word]++
    }

    fmt.Println("Word counts:")
    for word, count := range wordCount {
        fmt.Printf("%s: %d\n", word, count)
    }
}

$ go run main.go

Word counts:
e: 2
 : 3
w: 1
r: 1
y: 1
u: 1
h: 2
l: 2
o: 3
a: 1

Jadi, dengan memulakan peta sebagai map[string]int{} anda akan mendapat peta kosong. Ini kemudiannya boleh digunakan untuk mengisi kekunci dan nilai, kami mengulangi rentetan, dan untuk setiap aksara (rune) kami menghantar bait aksara itu ke dalam rentetan dan menambah nilai, nilai sifar untuk int ialah 0, jadi secara lalai jika kunci tidak ada, ia akan menjadi sifar, ia adalah sedikit pedang bermata dua, kita tidak pernah tahu kunci itu ada dalam peta dengan nilai 0 atau kunci tidak ada tetapi nilai lalai ialah 0. Untuk itu, anda perlu menyemak sama ada kunci itu wujud dalam peta atau tidak.

Untuk butiran lanjut, anda boleh menyemak siaran Peta Golang saya secara terperinci.

Perbezaan antara pengisytiharan dan permulaan

Terdapat perbezaan dalam mengisytiharkan dan memulakan sebarang pembolehubah dalam bahasa pengaturcaraan dan perlu melakukan lebih banyak lagi dengan pelaksanaan jenis asas. Dalam kes jenis data utama seperti int, rentetan, apungan, dsb. terdapat nilai lalai/sifar, jadi ia adalah sama dengan pengisytiharan dan permulaan pembolehubah. Walau bagaimanapun, dalam kes peta dan hirisan, pengisytiharan hanya memastikan pembolehubah tersedia untuk skop program, namun untuk permulaan menetapkannya kepada nilai lalai/sifarnya atau nilai sebenar yang harus diberikan.

Jadi, pengisytiharan hanya menjadikan pembolehubah tersedia dalam skop program. Untuk peta dan kepingan, mengisytiharkan pembolehubah tanpa permulaan menetapkannya kepada sifar, bermakna ia menunjuk kepada tiada memori yang diperuntukkan dan tidak boleh digunakan secara langsung.

Manakala permulaan memperuntukkan memori dan menetapkan pembolehubah kepada keadaan yang boleh digunakan. Untuk peta dan kepingan, anda perlu memulakannya secara eksplisit menggunakan sintaks seperti myMap = make(map[keyType]valueType) atau slice = []type{}. Tanpa permulaan ini, percubaan untuk menggunakan peta atau kepingan akan membawa kepada ralat masa jalan, seperti panik untuk mengakses atau mengubah suai peta atau kepingan nil.

Mari kita lihat nilai peta apabila ia diisytiharkan/dimulakan/tidak dimulakan.

Bayangkan anda sedang membina pengurus konfigurasi yang membaca tetapan daripada peta. Peta akan diisytiharkan secara global tetapi dimulakan hanya apabila konfigurasi dimuatkan.

1. Diisytiharkan tetapi tidak dimulakan

Kod di bawah menunjukkan akses peta yang tidak dimulakan.

package main

import (
    "fmt"
    "log"
)

// Global map to store configuration settings
var configSettings map[string]string // Declared but not initialized

func main() {
    // Attempt to get a configuration setting before initializing the map
    serverPort := getConfigSetting("server_port")
    fmt.Printf("Server port: %s\n", serverPort)
}

func getConfigSetting(key string) string {
    if configSettings == nil {
        log.Fatal("Configuration settings map is not initialized")
    }
    value, exists := configSettings[key]
    if !exists {
        return "Setting not found"
    }
    return value
}

$ go run main.go
Server port: Setting not found

1. Diisytiharkan dan Dimulakan pada masa yang sama

Kod di bawah menunjukkan akses peta yang dimulakan pada masa yang sama.

package main

import (
    "fmt"
    "log"
)

// Global map to store configuration settings
var configSettings = map[string]string{
    "server_port":  "8080",
    "database_url": "localhost:5432",
}

func main() {
    serverPort := getConfigSetting("server_port")
    fmt.Printf("Server port: %s\n", serverPort)
}

func getConfigSetting(key string) string {
    value, exists := configSettings[key]
    if !exists {
        return "Setting not found"
    }
    return value
}

$ go run main.go
Server port: 8080

1. Diisytiharkan dan kemudiannya dimulakan

Kod di bawah menunjukkan akses peta yang dimulakan kemudian.

package main

import (
    "fmt"
    "log"
)

// Global map to store configuration settings
var configSettings map[string]string // declared but not initialized

func main() {
    // Initialize configuration settings
    initializeConfigSettings()
    // if the function is not called, the map will be nil

    // Get a configuration setting safely
    serverPort := getConfigSetting("server_port")
    fmt.Printf("Server port: %s\n", serverPort)
}

func initializeConfigSettings() {
    if configSettings == nil {
        configSettings = make(map[string]string) // Properly initialize the map
        configSettings["server_port"] = "8080"
        configSettings["database_url"] = "localhost:5432"
        fmt.Println("Configuration settings initialized")
    }
}

func getConfigSetting(key string) string {
    if configSettings == nil {
        log.Fatal("Configuration settings map is not initialized")
    }
    value, exists := configSettings[key]
    if !exists {
        return "Setting not found"
    }
    return value
}

$ go run main.go
Configuration settings initialized
Server port: 8080

In the above code, we declared the global map configSettings but didn't initialize it at that point, until we wanted to access the map. We initialize the map in the main function, this main function could be other specific parts of the code, and the global variable configSettings a map from another part of the code, by initializing it in the required scope, we prevent it from causing nil pointer access errors. We only initialize the map if it is nil i.e. it has not been initialized elsewhere in the code. This prevents overriding the map/flushing out the config set from other parts of the scope.

Pitfalls in access of un-initialized maps

But since it deals with pointers, it comes with its own pitfalls like nil pointers access when the map is not initialized.

Let's take a look at an example, a real case where this might happen.

package main

import (
    "fmt"
    "net/url"
)

func main() {
        var vals url.Values
        vals.Add("foo", "bar")
        fmt.Println(vals)
}

This will result in a runtime panic.

$ go run main.go
panic: assignment to entry in nil map

goroutine 1 [running]:
net/url.Values.Add(...)
        /usr/local/go/src/net/url/url.go:902
main.main()
        /home/meet/code/playground/go/main.go:10 +0x2d
exit status 2

This is because the url.Values is a map of string and a list of string values. Since the underlying type is a map for Values, and in the example, we only have declared the variable vals with the type url.Values, it will point to a nil reference, hence the message on adding the value to the type. So, it is a good practice to use make while declaring or initializing a map data type. If you are not sure the underlying type is map then you could use Type{} to initialize an empty value of that type.

package main

import (
    "fmt"
    "net/url"
)

func main() {
        vals := make(url.Values)
        // OR
        // vals := url.Values{}
        vals.Add("foo", "bar")
        fmt.Println(vals)
}

$ go run urlvals.go
map[foo:[bar]]
foo=bar

It is also recommended by the golang team to use the make function while initializing a map. So, either use make for maps, slices, and channels, or initialize the empty value variable with Type{}. Both of them work similarly, but the latter is more generally applicable to structs as well.

Conclusion

Understanding the difference between declaring and initializing maps in Golang is essential for any developer, not just in golang, but in general. As we've explored, simply declaring a map variable without initializing it can lead to runtime errors, such as panics when attempting to access or modify a nil map. Initializing a map ensures that it is properly allocated in memory and ready for use, thereby avoiding these pitfalls.

By following best practices—such as using the make function or initializing with Type{}—you can prevent common issues related to uninitialized maps. Always ensure that maps and slices are explicitly initialized before use to safeguard against unexpected nil pointer dereferences

Thank you for reading this post, If you have any questions, feedback, and suggestions, feel free to drop them in the comments.

Happy Coding :)

Atas ialah kandungan terperinci Menggunakan Peta dengan selamat di Golang: Perbezaan dalam pengisytiharan dan permulaan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!