[Golang cơ bản] Maps trong Golang
Post on: 2023-03-15 00:14:09 | in: Golang
Maps trong Go là một loại dữ liệu được sử dụng để lưu trữ các cặp key-value. Key trong map phải là duy nhất và không thể thay đổi, còn giá trị của mỗi key có thể được lưu trữ và truy xuất...
- [Golang cơ bản] Interface trong Golang
- [Golang cơ bản] IOTA trong Golang
- [Golang nâng cao] Goroutines trong Golang
Tổng quan
Maps là một kiểu dữ liệu có sẵn trong Go tương tự như bảng băm, nó ánh xạ một khóa vào một giá trị. Map là một bộ sưu tập không được sắp xếp trong đó mỗi khóa là duy nhất trong khi giá trị có thể giống nhau cho hai hoặc nhiều khóa khác nhau. Lợi ích của việc sử dụng map là nó cung cấp các hoạt động truy xuất, tìm kiếm, chèn và xóa nhanh chóng.
Map là kiểu dữ liệu được tham chiếu. Khi bạn gán một map cho một map khác, cả hai đều trỏ đến cùng một map cơ bản. Dưới đây là định dạng của một map
map[key_type]value_type
Cả key_type và value_type có thể khác nhau hoặc giống nhau về kiểu dữ liệu. Ví dụ dưới đây sử dụng string làm kiểu khóa và int làm kiểu giá trị.
map[string]int
Các kiểu dữ liệu được phép sử dụng làm khóa trong một Map
Khóa của map có thể là bất kỳ kiểu dữ liệu so sánh được nào. Một số trong số các kiểu dữ liệu so sánh được được định nghĩa bởi cú pháp Go là:
- boolean
- numeric
- string,
- pointer
- channel
- interface types
- structs – Nếu tất cả các trường (field) của một kiểu dữ liệu khai báo bởi người dùng (user-defined type) đều là so sánh được (comparable).
- array – Nếu kiểu dữ liệu của các phần tử trong mảng là so sánh được (comparable).
Một số kiểu dữ liệu không so sánh được (non-comparable) theo định nghĩa của Go và không thể được sử dụng làm khóa trong một Map bao gồm:
- Slice
- Map
- Function
Các kiểu dữ liệu được phép sử dụng làm giá trị trong một Map
Giá trị trong một Map ở Go có thể là bất kỳ kiểu dữ liệu nào.
Tạo một Map- Sử dụng cú pháp map[]{} (được gọi là map literal).
- Sử dụng hàm make.
Xem xét từng phương pháp một.
Sử dụng cú pháp map[]{}Một trong những cách phổ biến nhất để tạo một Map là sử dụng map literal:
map[key_type]value_type{}
Một ví dụ về cách sử dụng map literal với kiểu khóa là string và kiểu giá trị là integer:
employeeSalary := map[string]int{}
Một Map cũng có thể được tạo với một số giá trị khóa được khởi tạo sẵn bằng cách sử dụng map literal.
employeeSalary := map[string]int{
"John": 1000
"Sam": 2000
}
Một cặp key-value mới cũng có thể được thêm vào Map.
employeeSalary["Tom"] = 2000
Hãy xem một chương trình minh họa:
package main
import "fmt"
func main() {
//Declare
employeeSalary := map[string]int{}
fmt.Println(employeeSalary)
//Intialize using map lieteral
employeeSalary = map[string]int{
"John": 1000,
"Sam": 1200,
}
//Adding a key value
employeeSalary["Tom"] = 2000
fmt.Println(employeeSalary)
}
Output
map[]
map[John:1000 Sam:1200 Tom:2000]
Trong chương trình trên, chúng ta tạo một Map sử dụng map literal đã khởi tạo sẵn một số giá trị. Sau đó, chúng ta thêm một cặp key-value mới vào Map và in ra nó bằng cách sử dụng fmt.Println, trong đó in ra tất cả các cặp key-value theo định dạng map[key:value key:value].
Một Map cũng có thể được khai báo bằng từ khóa var, tuy nhiên nó sẽ tạo ra một Map nil vì giá trị khởi tạo mặc định của Map là nil. Việc thêm bất kỳ key-value trị nào vào Map này sẽ gây ra một lỗi panic. Hãy xem ví dụ cho điều này:
package main
func main() {
var employeeSalary map[string]int
employeeSalary["Tom"] = 2000
}
Output
panic: assignment to entry in nil map
Chương trình trên đã gặp lỗi panic vì Map này là nil.
Một trong những trường hợp sử dụng khi khai báo một Map với từ khóa var là khi một Map đã tồn tại cần được gán cho nó hoặc khi chúng ta muốn gán kết quả của một hàm cho nó.
Sử dụng Make để tạo Map.Đây là một cách khác để tạo Map. Hàm tích hợp sẵn make có thể được sử dụng để tạo ra một Map. Nó trả về một Map đã được khởi tạo. Do đó, các cặp key-value có thể được thêm vào đó.
package main
import "fmt"
func main() {
//Declare
employeeSalary := make(map[string]int)
//Adding a key value
employeeSalary["Tom"] = 2000
fmt.Println(employeeSalary)
}
Output
map[Tom:2000]
Trong chương trình trên, chúng ta đã tạo một Map bằng cách sử dụng hàm make. Sau đó, chúng ta đã thêm một cặp key-value vào đó. Sau đó, chúng ta đã in nó bằng fmt.Println, nó sẽ in ra tất cả các cặp key-value.
Các hoạt động trên Map.
Dưới đây là các hoạt động áp dụng cho Map:
- Thêm một cặp key-value
- Cập nhật một khóa
- Lấy giá trị tương ứng với một khóa
- Xóa một cặp key-value
- Kiểm tra xem một khóa có tồn tại hay không.
Dưới đây là định dạng để thêm một cặp khóa-giá trị vào một bản đồ (map).
mapName[key] = value
Hãy xem một ví dụ.
package main
import "fmt"
func main() {
//Declare
employeeSalary := make(map[string]int)
//Adding a key value
employeeSalary["Tom"] = 2000
fmt.Pr
Output
map[Tom:2000]
Cũng lưu ý rằng thêm vào một bản đồ (map) nil sẽ gây ra một sự cố (panic).
Cập nhật một cặp key-valueKhi cố gắng thêm một khóa vào bản đồ mà đã tồn tại, giá trị mới sẽ ghi đè lên giá trị cũ. Điều này tương tự như cập nhật một khóa trong bản đồ. Hãy xem một ví dụ.
package main
import "fmt"
func main() {
//Declare
employeeSalary := make(map[string]int)
//Adding a key value
fmt.Println("Before update")
employeeSalary["Tom"] = 2000
fmt.Println(employeeSalary)
fmt.Println("After update")
employeeSalary["Tom"] = 3000
fmt.Println(employeeSalary)
}
Output
Before update
map[Tom:2000]
After update
map[Tom:3000]
Trong chương trình trên, sau khi viết cùng một khóa "Tom" với giá trị mới là 3000, nó ghi đè lên giá trị hiện tại của 2000. Khi chúng ta in ra map lại, giá trị được in ra là 3000.
Lấy giá trị tương ứng với một khóa (key).Dưới đây là định dạng để truy xuất giá trị tương ứng với một khóa (key).
val := mapName[key]
Hãy xem một ví dụ.
package main
import "fmt"
func main() {
//Declare
employeeSalary := make(map[string]int)
//Adding a key value
employeeSalary["Tom"] = 2000
//Retrieve a value
salary := employeeSalary["Tom"]
fmt.Printf("Salary: %d", salary)
}
Xóa một cặp key-value
Dưới đây là định dạng để xóa một giá trị tương ứng với một khóa (key).
delete(map_name, key)
package main
import "fmt"
func main() {
//Declare
employeeSalary := make(map[string]int)
//Adding a key value
fmt.Println("Adding key")
employeeSalary["Tom"] = 2000
fmt.Println(employeeSalary)
fmt.Println("\nDeleting key")
delete(employeeSalary, "Tom")
fmt.Println(employeeSalary)
}
Output
Adding key
map[Tom:2000]
Deleting key
map[]
Trong chương trình trên, chúng ta đã xóa khóa và khi chúng ta in map lại, khóa đó không còn tồn tại nữa.
Kiểm tra xem một khóa có tồn tại trong map hay khôngDưới đây là định dạng để kiểm tra xem một khóa có tồn tại trong map hay không.
val, ok := mapName[key]
Có hai trường hợp:
- Nếu khóa tồn tại, biến val sẽ là giá trị của khóa trong bản đồ và biến ok sẽ là true.
- Nếu khóa không tồn tại, biến val sẽ là giá trị mặc định bằng không của kiểu giá trị và biến ok sẽ là false.
Hãy xem một ví dụ.
package main
import "fmt"
func main() {
//Declare
employeeSalary := make(map[string]int)
//Adding a key value
employeeSalary["Tom"] = 2000
fmt.Println("Key exists case")
val, ok := employeeSalary["Tom"]
fmt.Printf("Val: %d, ok: %t\n", val, ok)
fmt.Println("Key doesn't exists case")
val, ok = employeeSalary["Sam"]
fmt.Printf("Val: %d, ok: %t\n", val, ok)
}
Output
Key exists case
Val: 2000, ok: true
Key doesn't exists case
Val: 0, ok: false
Trong chương trình trên, khi khóa tồn tại, biến val được thiết lập thành giá trị thực tế, là 2000 trong ví dụ này, và biến ok là true. Khi khóa không tồn tại, biến val được thiết lập thành 0, là giá trị mặc định bằng không của kiểu int và biến ok là false. Biến ok là cách tốt nhất để kiểm tra xem khóa có tồn tại trong bản đồ hay không.
Trong trường hợp chúng ta chỉ muốn kiểm tra xem một khóa có tồn tại và không cần giá trị val, thì chúng ta có thể sử dụng từ khóa rỗng " _ " thay cho val.
_, ok = employeeSalary["Sam"]
Các hàm trên bản đồ (Maps)
Dưới đây là các hàm tích hợp sẵn có thể được sử dụng trên một map
- Hàm len()
Hàm len()
Hàm len() được sử dụng để lấy độ dài của map, là số lượng cặp key/value trong map. Dưới đây là định dạng để sử dụng hàm này trên map.
len(mapName)
Hãy xem một ví dụ.
package main
import "fmt"
func main() {
//Declare
employeeSalary := make(map[string]int)
//Adding a key value
employeeSalary["Tom"] = 2000
employeeSalary["Sam"] = 1200
lenOfMap := len(employeeSalary)
fmt.Println(lenOfMap)
}
Output
2
Giá trị không
Giá trị không của một map là nil. Điều này cũng được chứng minh khi chúng ta khai báo một map bằng từ khóa var. Xem chương trình dưới đây.
package main
import "fmt"
func main() {
var employeeSalary map[string]int
if employeeSalary == nil {
fmt.Println("employeeSalary map is nil")
}
}
Output
employeeSalary map is nil
Maps là kiểu dữ liệu tham chiếu.
Map là kiểu dữ liệu tham chiếu. Vì vậy, khi gán một map cho một biến mới, cả hai biến đều trỏ đến cùng một map. Bất kỳ thay đổi nào trong một map sẽ phản ánh trên map khác và ngược lại.
package main
import "fmt"
func main() {
//Declare
employeeSalary := make(map[string]int)
//Adding a key value
employeeSalary["Tom"] = 2000
employeeSalary["Sam"] = 1200
eS := employeeSalary
//Change employeeSalary
employeeSalary["John"] = 3000
fmt.Println("Changing employeeSalary Map")
fmt.Printf("employeeSalary: %v\n", employeeSalary)
fmt.Printf("eS: %v\n", eS)
//Change eS
employeeSalary["John"] = 4000
fmt.Println("\nChanging eS Map")
fmt.Printf("employeeSalary: %v\n", employeeSalary)
fmt.Printf("eS: %v\n", eS)
}
Trong chương trình trên, eS
là một biến map mới được gán bằng biến employeeSalary
đang tồn tại.
- Đầu tiên, chúng ta thêm một khóa mới vào biến
employeeSalary
. Sự thay đổi được phản ánh cả trong mapemployeeSalary
vàeS
.
- Thứ hai, chúng ta đã cập nhật một khóa đã tồn tại trong map
eS
. Sự thay đổi lại được phản ánh cả trong mapemployeeSalary
vàeS
.
Điều này cho thấy rằng maps là kiểu dữ liệu tham chiếu.
Lặp lại một mapToán tử phạm vi (range operator) có thể được sử dụng để lặp lại một map trong Go.
Hãy xác định một map trước.
sample := map[string]string{
"a": "x",
"b": "y",
}
- Lặp lại tất cả các khóa và giá trị
for k, v := range sample {
fmt.Printf("key :%s value: %s\n", k, v)
}
Output:
key :a value: x
key :b value: y
- Lặp lại chỉ các khóa
for k := range sample {
fmt.Printf("key :%s\n", k)
}
Output:
key :a
key :b
- Lặp lại chỉ các giá trị
for _, v := range sample {
fmt.Printf("value :%s\n", v)
}
Output:
value :x
value :y
- Lấy danh sách tất cả các khóa
keys := getAllKeys(sample)
fmt.Println(keys)
func getAllKeys(sample map[string]string) []string {
var keys []string
for k := range sample {
keys = append(keys, k)
}
return keys
}
Output:
[a b]
Maps không an toàn để sử dụng đồng thời
go maps không an toàn cho việc sử dụng đồng thời.
Mã lỗi: Dưới đây là một đoạn mã lỗi. Nó có thể dẫn đến sự cố nếu đọc và ghi đồng thời trên map xảy ra.
package main
var (
allData = make(map[string]string)
)
func get(key string) string {
return allData[key]
}
func set(key string, value string) {
allData[key] = value
}
func main() {
go set("a", "Some Data 1")
go set("b", "Some Data 2")
go get("a")
go get("b")
go get("a")
}
Possible Output:
fatal error: concurrent map read and map write
Correct Code:
Chúng ta có thể sử dụng một khóa để cho phép truy cập đồng thời vào map.
package main
import (
"fmt"
"sync"
)
var (
allData = make(map[string]string)
rwm sync.RWMutex
)
func get(key string) string {
rwm.RLock()
defer rwm.RUnlock()
return allData[key]
}
func set(key string, value string) {
rwm.Lock()
defer rwm.Unlock()
allData[key] = value
}
func main() {
set("a", "Some Data")
result := get("a")
fmt.Println(result)
}
Output
Some data
Tổng kết
Đó là tất cả về maps trong golang. Chúng ta đã tìm hiểu cách tạo ra một map, thực hiện các thao tác trên map, một số hàm được định nghĩa trên một map như hàm Glen(), cách chúng ta có thể lặp lại các phần tử trong map và cuối cùng nhưng không kém là map là không an toàn cho việc sử dụng đồng thời. Hy vọng bạn đã thích bài viết này. Vui lòng chia sẻ phản hồi/cải thiện/lỗi trong phần bình luận.