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

ข้อจำกัด: comparable และ interface

ข้อจำกัดแบบยูเนียนและชนิดข้อมูลในตัว comparable

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

ข้อจำกัดคืออะไร

ข้อจำกัดจะกำหนดว่าชนิดข้อมูลใดสามารถใช้เป็นอาร์กิวเมนต์ชนิดข้อมูลได้ หากไม่มีข้อจำกัด พารามิเตอร์ชนิดข้อมูลจะเป็น any (อินเทอร์เฟซว่าง ซึ่งรองรับเพียงการกำหนดค่าและการเปรียบเทียบด้วย ==)

ข้อจำกัด any

any (นามแฝงของ interface{}) เป็นข้อจำกัดที่กว้างที่สุด เพราะชนิดข้อมูลทั้งหมดสอดคล้องกับข้อจำกัดนี้ คุณสามารถใช้ได้เฉพาะการดำเนินการที่ชนิดข้อมูลทั้งหมดรองรับ เช่น การกำหนดค่าและการส่งค่าให้พารามิเตอร์อินเทอร์เฟซ

func Print[T any](v T) { fmt.Println(v) }

ข้อจำกัด comparable

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

func Contains[T comparable](s []T, v T) bool {
    for _, item := range s {
        if item == v { return true }
    }
    return false
}

ข้อจำกัดแบบอินเทอร์เฟซ

ใช้อินเทอร์เฟซเป็นข้อจำกัดเพื่อกำหนดให้ต้องมีเมธอดบางอย่าง พารามิเตอร์ชนิดข้อมูลต้องมีเมธอดทั้งหมดของอินเทอร์เฟซ

type Stringer interface { String() string }

func Print[T Stringer](v T) {
    fmt.Println(v.String())
}

ข้อจำกัดแบบยูเนียน

ใช้ยูเนียนของชนิดข้อมูลด้วย | เพื่อจำกัดให้เหลือชุดชนิดข้อมูลที่เป็นรูปธรรม วิธีนี้ทำให้สามารถใช้โอเปอเรเตอร์ เช่น + ที่ไม่ได้เป็นส่วนหนึ่งของอินเทอร์เฟซใด ๆ ได้

type Number interface {
    int | int64 | float64
}

func Sum[T Number](s []T) T {
    var total T
    for _, v := range s { total += v }
    return total
}

~T สำหรับชนิดที่มีชนิดพื้นฐานเป็น T

ใช้ ~T เพื่อรวมไม่เพียง T แต่รวมชนิดทั้งหมดที่มี T เป็นชนิดพื้นฐานด้วย (เช่น ชนิดกำหนดเองที่นิยามเป็น type MyInt int)

type Integer interface { ~int | ~int64 }

type MyInt int
// MyInt satisfies Integer because its underlying type is int

golang.org/x/exp/constraints

แพ็กเกจ constraints มีอินเทอร์เฟซข้อจำกัดทั่วไป ได้แก่ Ordered (รองรับ <), Integer, Float, Signed และ Unsigned

import "golang.org/x/exp/constraints"

func Min[T constraints.Ordered](a, b T) T {
    if a < b { return a }
    return b
}

แพ็กเกจ cmp (Go 1.21)

Go 1.21 เพิ่มข้อจำกัด cmp.Ordered และฟังก์ชัน cmp.Compare/cmp.Less ในไลบรารีมาตรฐาน เพื่อแทนที่การพึ่งพา exp/constraints

import "cmp"
func Min[T cmp.Ordered](a, b T) T { return min(a, b) }

การรวมข้อจำกัด

ฝังอินเทอร์เฟซหลายรายการไว้ในข้อจำกัด เพื่อกำหนดให้ต้องมีคุณสมบัติหลายอย่าง:

type Printable interface {
    comparable
    fmt.Stringer
}

การอนุมานข้อจำกัด

คอมไพเลอร์อนุมานพารามิเตอร์ชนิดจากอาร์กิวเมนต์ หากข้อจำกัดกว้างเกินไป (any) อาจต้องระบุอาร์กิวเมนต์ชนิดอย่างชัดเจนเพื่อช่วยการอนุมาน

เมื่อใดควรใช้ comparable

ใช้ comparable เมื่อฟังก์ชันเจเนอริกจำเป็นต้องใช้ == กับค่า เก็บค่าเหล่านั้นในแผนที่เป็นคีย์ หรือใช้เป็นสมาชิกของแผนที่/เซต ชนิดบางชนิดไม่สามารถเปรียบเทียบได้ (สไลซ์ แผนที่ และฟังก์ชันไม่สามารถเปรียบเทียบได้)

ตรวจสอบอย่างรวดเร็ว

คำนำหน้า ~ ในข้อจำกัดแบบยูเนียน เช่น ~int หมายถึงอะไร

สรุป: ข้อจำกัด

ประเด็นสำคัญ:

  • any: กว้างที่สุด; comparable: รองรับ ==; interface: ต้องมีเมธอด
  • ยูเนียน (int|float64) ทำให้ใช้ตัวดำเนินการทางคณิตศาสตร์ได้
  • ~T รวมชนิดที่มีชื่อซึ่งมี T เป็นชนิดพื้นฐาน
  • cmp.Ordered (Go 1.21 ขึ้นไป) สำหรับข้อจำกัดที่ใช้กับ <, >, <= และ >=

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

บทเรียน “ข้อจำกัด: comparable และ interface” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ข้อจำกัด: comparable และ interface”

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

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

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

บทเรียน “ข้อจำกัด: comparable และ interface” ใช้เวลานานแค่ไหน

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

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

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

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

  1. ไวยากรณ์พารามิเตอร์ชนิดข้อมูล
  2. ข้อจำกัด: comparable และ interface
  3. โครงสร้างข้อมูลทั่วไป
  4. Generics ในทางปฏิบัติ: ข้อควรระวัง
← กลับไปที่ Go Academy