โครงสร้างภายในของแมป
ทำความเข้าใจวิธีที่แมปจัดเก็บข้อมูล
โครงสร้างภายในของแมป เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
แมปคืออะไร
แมปใช้เก็บคู่คีย์-ค่า คีย์แต่ละรายการจะเชื่อมโยงกับค่าหนึ่งค่า และโดยเฉลี่ยแล้วการค้นหาจะรวดเร็วมาก
ในภาษา Go ให้เขียนเป็น map[KeyType]ValueType
package main
import "fmt"
func main() {
ages := map[string]int{"Ann": 30, "Bob": 25}
fmt.Println(ages["Ann"])
}ตารางแฮชเบื้องหลัง
แมปของ Go สร้างขึ้นด้วย ตารางแฮช ฟังก์ชันแฮชจะแปลงคีย์แต่ละรายการเป็นตัวเลขที่ชี้ไปยังช่องเก็บ ซึ่งเป็นตำแหน่งที่เก็บค่าไว้
ช่องเก็บ
แมปจะเก็บรายการต่าง ๆ ไว้ในช่องเก็บ แต่ละช่องเก็บคู่คีย์-ค่าได้หลายคู่ ค่าแฮชของคีย์จะกำหนดว่าคีย์นั้นไปอยู่ในช่องใด ทำให้การค้นหาโดยเฉลี่ยมีความเร็ว O(1)
การสร้างด้วยฟังก์ชันสร้าง
คุณสร้างแมปว่างได้ด้วย make และอาจระบุคำใบ้เกี่ยวกับขนาดเพื่อจองพื้นที่ล่วงหน้าได้
package main
import "fmt"
func main() {
scores := make(map[string]int)
scores["x"] = 10
fmt.Println(scores)
}แมป nil
แมปที่ประกาศโดยไม่เริ่มต้นค่าจะเป็น nil คุณอ่านค่าจากแมป nil ได้ ซึ่งจะได้ค่าศูนย์ แต่การเขียนค่าลงไปจะทำให้โปรแกรมแพนิก ดังนั้นให้เริ่มต้นค่าก่อนเขียนเสมอ
package main
import "fmt"
func main() {
var m map[string]int
fmt.Println(m == nil)
fmt.Println(m["missing"])
}การเพิ่มและการอัปเดต
การกำหนดค่าให้คีย์จะเพิ่มคีย์นั้นหากยังไม่มี หรือเขียนทับค่าที่มีอยู่
package main
import "fmt"
func main() {
m := map[string]int{"a": 1}
m["b"] = 2
m["a"] = 99
fmt.Println(m)
}การลบคีย์
ฟังก์ชันในตัว delete ใช้ลบคีย์ การลบคีย์ที่ไม่มีอยู่จะไม่ทำอะไรและปลอดภัย
package main
import "fmt"
func main() {
m := map[string]int{"a": 1, "b": 2}
delete(m, "a")
fmt.Println(m)
}ความยาวของแมป
len คืนค่าจำนวนคู่คีย์-ค่าที่มีอยู่ในแมปขณะนั้น
package main
import "fmt"
func main() {
m := map[string]int{"a": 1, "b": 2, "c": 3}
fmt.Println(len(m))
}แมปขยายโดยอัตโนมัติ
เมื่อคุณเพิ่มรายการ Go จะขยายตารางเบื้องหลังและอาจคำนวณแฮชของคีย์ใหม่เพื่อย้ายไปยังช่องเก็บใหม่ กระบวนการนี้เกิดขึ้นโดยอัตโนมัติ คุณจึงไม่ต้องจัดการความจุด้วยตนเอง
ชนิดคีย์ที่อนุญาต
คีย์ต้องเป็นชนิดที่ เปรียบเทียบได้ ซึ่งหมายถึงชนิดที่ใช้กับ == ได้ สตริง ตัวเลข ค่าบูลีน และโครงสร้างที่มีฟิลด์ซึ่งเปรียบเทียบได้สามารถใช้ได้ แต่สไลซ์และแมปใช้เป็นคีย์ไม่ได้
package main
import "fmt"
func main() {
type Point struct{ X, Y int }
m := map[Point]string{{1, 2}: "origin-ish"}
fmt.Println(m[Point{1, 2}])
}ความหมายแบบอ้างอิง
ค่าแมปเป็นการอ้างอิงไปยังข้อมูลเบื้องหลัง การส่งแมปให้ฟังก์ชันทำให้ฟังก์ชันนั้นแก้ไขแมปเดียวกันได้ โดยไม่ต้องใช้พอยน์เตอร์
package main
import "fmt"
func addOne(m map[string]int) {
m["count"]++
}
func main() {
m := map[string]int{"count": 0}
addOne(m)
fmt.Println(m)
}ตรวจสอบความเข้าใจอย่างรวดเร็ว
จะเกิดอะไรขึ้นหากคุณพยายามเขียนคีย์ลงในแมป nil
สรุป
ส่วนประกอบภายในของแมป:
- แมปคือตารางแฮชที่มีช่องเก็บ
- การค้นหา การแทรก และการลบมีความเร็วโดยเฉลี่ย O(1)
- คีย์ต้องเปรียบเทียบได้ และแมป nil จะทำให้โปรแกรมแพนิกเมื่อเขียนค่า
- แมปมีความหมายแบบอ้างอิง
คำถามที่พบบ่อย
บทเรียน “โครงสร้างภายในของแมป” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “โครงสร้างภายในของแมป” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “โครงสร้างภายในของแมป”
ทำความเข้าใจวิธีที่แมปจัดเก็บข้อมูล คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน
บทเรียน “โครงสร้างภายในของแมป” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม
ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- โครงสร้างภายในของแมป
- การตรวจสอบการมีอยู่
- แมปในรูปแบบเซต
- การวนซ้ำและลำดับ