0Pricing
Go Academy · บทเรียน

การตรวจสอบการมีอยู่

สำนวน comma-ok

การตรวจสอบการมีอยู่ เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

คีย์ที่หายไปคืนค่าศูนย์

เมื่อคุณอ่านคีย์ที่ไม่มีอยู่ Go จะคืนค่า ค่าศูนย์ของชนิดค่า ไม่ใช่ข้อผิดพลาด สำหรับ int ค่านั้นคือ 0 ส่วน string คือสตริงว่าง

package main

import "fmt"

func main() {
	m := map[string]int{"a": 5}
	fmt.Println(m["missing"])
}

ปัญหาความกำกวม

หากคืนค่า 0 คุณจะรู้ได้อย่างไรว่าคีย์นั้นมีอยู่และมีค่าเป็น 0 หรือไม่มีคีย์นั้นอยู่เลย คุณไม่สามารถบอกได้จากค่าเพียงอย่างเดียว

สำนวนจุลภาค-โอเค

การเข้าถึงแมปสามารถคืนค่าได้ สองค่า ได้แก่ ค่าและค่าบูลีน ค่าบูลีนจะเป็น true หากคีย์นั้นมีอยู่ นี่คือสำนวนจุลภาค-โอเค

package main

import "fmt"

func main() {
	m := map[string]int{"a": 0}
	val, ok := m["a"]
	fmt.Println(val, ok)
}

แยกแยะคีย์ที่ไม่มีอยู่

ตอนนี้คุณแยกแยะได้แล้ว คีย์ที่มีอยู่จะให้ค่า ok = true แม้ว่าค่าของคีย์นั้นจะเป็นค่าศูนย์

package main

import "fmt"

func main() {
	m := map[string]int{"a": 0}
	_, okA := m["a"]
	_, okB := m["b"]
	fmt.Println("a exists:", okA, "b exists:", okB)
}

ตรวจสอบก่อนดำเนินการ

รูปแบบที่ใช้บ่อยคือ ใช้สำนวนจุลภาค-โอเคภายใน if เพื่อดำเนินการเฉพาะเมื่อคีย์มีอยู่

package main

import "fmt"

func main() {
	prices := map[string]int{"pen": 3}
	if p, ok := prices["pen"]; ok {
		fmt.Println("price is", p)
	} else {
		fmt.Println("not found")
	}
}

ไม่สนใจค่า

หากคุณสนใจเพียงว่าคีย์มีอยู่หรือไม่ ให้ใช้ตัวระบุว่าง _ แทนค่า

package main

import "fmt"

func main() {
	seen := map[string]bool{"x": true}
	_, exists := seen["x"]
	fmt.Println("x seen:", exists)
}

การนับจำนวนครั้งที่ปรากฏ

สำนวนจุลภาค-โอเคใช้ร่วมกับตัวนับได้ดี แต่โปรดสังเกตว่าแม้ไม่ใช้ ok คำสั่ง m[key]++ ก็ทำงานได้ เพราะคีย์ที่หายไปจะเริ่มต้นด้วยค่าศูนย์

package main

import "fmt"

func main() {
	counts := map[string]int{}
	for _, w := range []string{"a", "b", "a"} {
		counts[w]++
	}
	fmt.Println(counts)
}

กำหนดค่าเริ่มต้นอย่างปลอดภัย

คุณกำหนดค่าเริ่มต้นเมื่อคีย์ไม่มีอยู่ได้ โดยใช้สำนวนจุลภาค-โอเคและตัวแปรค่าเริ่มต้น

package main

import "fmt"

func main() {
	cfg := map[string]string{}
	lang, ok := cfg["lang"]
	if !ok {
		lang = "en"
	}
	fmt.Println("lang:", lang)
}

จุลภาค-โอเคนอกเหนือจากแมป

รูปแบบสองค่านี้ยังพบได้กับการรับค่าจากแชนเนลและการยืนยันชนิดข้อมูลด้วย รูปแบบนี้สอดคล้องกัน คือค่าที่สองจะรายงานว่าสำเร็จหรือไม่

package main

import "fmt"

func main() {
	var i interface{} = "hello"
	s, ok := i.(string)
	fmt.Println(s, ok)
}

การตรวจสอบสมาชิกในเซต

มักใช้แมปที่มีค่าบูลีนหรือค่าโครงสร้างว่างเพื่อติดตามสมาชิก สำนวนจุลภาค-โอเคช่วยตอบได้อย่างชัดเจนว่าสิ่งนี้อยู่ในเซตหรือไม่

package main

import "fmt"

func main() {
	allowed := map[string]struct{}{"read": {}, "write": {}}
	_, ok := allowed["delete"]
	fmt.Println("delete allowed:", ok)
}

แนวทางปฏิบัติที่แนะนำ

ใช้สำนวนจุลภาค-โอเคเสมอเมื่อค่าศูนย์อาจเป็นค่าที่จัดเก็บไว้อย่างถูกต้อง วิธีนี้ช่วยขจัดความกำกวมและทำให้เจตนาของโค้ดชัดเจน

ตรวจสอบความเข้าใจอย่างรวดเร็ว

คุณอ่าน val, ok := m["x"] และได้ val = 0, ok = true สิ่งนี้หมายความว่าอย่างไร

สรุป

การตรวจสอบการมีอยู่ด้วยสำนวนจุลภาค-โอเค:

  • คีย์ที่หายไปจะคืนค่าศูนย์
  • val, ok := m[key] รายงานการมีอยู่ของคีย์ใน ok
  • ใช้รูปแบบนี้ทุกครั้งที่ค่าศูนย์อาจเป็นค่าจริง

คำถามที่พบบ่อย

บทเรียน “การตรวจสอบการมีอยู่” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การตรวจสอบการมีอยู่” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การตรวจสอบการมีอยู่”

สำนวน comma-ok คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “การตรวจสอบการมีอยู่” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม

ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. โครงสร้างภายในของแมป
  2. การตรวจสอบการมีอยู่
  3. แมปในรูปแบบเซต
  4. การวนซ้ำและลำดับ
← กลับไปที่ Go Academy