Go Academy · บทเรียน

ฟังก์ชันแบบรับอาร์กิวเมนต์ไม่จำกัดจำนวน

รับอาร์กิวเมนต์จำนวนแปรผัน

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

ฟังก์ชันที่รับอาร์กิวเมนต์จำนวนไม่แน่นอนคืออะไร

ฟังก์ชันที่รับอาร์กิวเมนต์จำนวนไม่แน่นอน รับอาร์กิวเมนต์ศูนย์ค่าหรือมากกว่าที่เป็นชนิดที่กำหนด และรวบรวมอาร์กิวเมนต์เหล่านั้นไว้ในสไลซ์:

func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

fmt.Println(sum(1, 2, 3, 4)) // 10

ไวยากรณ์ ...T

ใช้ ...T เป็นชนิดของพารามิเตอร์ตัวสุดท้าย ภายในฟังก์ชัน พารามิเตอร์นี้จะเป็น []T:

เรียกใช้โดยส่งอาร์กิวเมนต์ 0 ค่าหรือมากกว่าได้
พารามิเตอร์ที่รับอาร์กิวเมนต์จำนวนไม่แน่นอนต้องเป็นพารามิเตอร์ตัวสุดท้าย
แต่ละฟังก์ชันมีพารามิเตอร์ลักษณะนี้ได้เพียงหนึ่งตัว

การกระจายสไลซ์

ส่งสไลซ์ที่มีอยู่แล้วไปยังฟังก์ชันที่รับอาร์กิวเมนต์จำนวนไม่แน่นอนได้โดยใช้ตัวดำเนินการกระจาย ...:

nums := []int{1, 2, 3, 4, 5}
total := sum(nums...)  // spread the slice
fmt.Println(total)     // 15

fmt.Println รับอาร์กิวเมนต์จำนวนไม่แน่นอน

ฟังก์ชันจำนวนมากในไลบรารีมาตรฐานรับอาร์กิวเมนต์จำนวนไม่แน่นอน fmt.Println มีลายเซ็น func Println(a ...interface{}) (n int, err error) จึงรับค่าได้ไม่จำกัดจำนวนและไม่จำกัดชนิด

append รับอาร์กิวเมนต์จำนวนไม่แน่นอน

append ซึ่งเป็นฟังก์ชันในตัวของภาษา รับอาร์กิวเมนต์จำนวนไม่แน่นอน:

a := []int{1, 2, 3}
b := []int{4, 5, 6}
a = append(a, b...)   // append all of b into a
fmt.Println(a)         // [1 2 3 4 5 6]

ฟังก์ชันที่รับอาร์กิวเมนต์จำนวนไม่แน่นอนร่วมกับพารามิเตอร์อื่น

พารามิเตอร์ที่รับอาร์กิวเมนต์จำนวนไม่แน่นอนต้องอยู่ท้ายสุด คุณสามารถผสมพารามิเตอร์แบบกำหนดตายตัวกับแบบไม่แน่นอนได้:

func logf(level string, msg string, args ...interface{}) {
    fmt.Printf("[%s] "+msg+"\n", append([]interface{}{level}, args...)...)
}

การเรียกฟังก์ชันแบบไม่แน่นอนโดยไม่มีอาร์กิวเมนต์

สามารถเรียกฟังก์ชันที่รับอาร์กิวเมนต์จำนวนไม่แน่นอนโดยไม่ส่งอาร์กิวเมนต์ได้ สไลซ์จะเป็น nil (หรือว่างเปล่า):

fmt.Println(sum())   // 0 — nil slice, loop runs 0 times

พารามิเตอร์แบบไม่แน่นอนเทียบกับพารามิเตอร์สไลซ์

ควรใช้พารามิเตอร์แบบรับอาร์กิวเมนต์จำนวนไม่แน่นอนหรือพารามิเตอร์สไลซ์ในกรณีใด:

แบบไม่แน่นอน: เมื่อผู้เรียกส่งค่าแต่ละค่าโดยตรง (เช่น sum(1,2,3))
สไลซ์: เมื่อผู้เรียกมีชุดข้อมูลที่สร้างเตรียมไว้แล้วเสมอ
แบบไม่แน่นอนใช้งานสะดวกกว่าบริเวณจุดเรียกใช้ แต่ภายในฟังก์ชันทั้งสองแบบทำงานได้ดีเท่าเทียมกัน

การส่งอาร์กิวเมนต์แบบไม่แน่นอนไปยังอีกฟังก์ชันแบบไม่แน่นอน

ส่งต่ออาร์กิวเมนต์ที่รับมาแบบไม่แน่นอนโดยใช้การกระจาย:

func logError(args ...interface{}) {
    log.Println(args...) // forward to log.Println
}

การสร้างรูปแบบตัวเลือก

...Option แบบรับอาร์กิวเมนต์จำนวนไม่แน่นอนเป็นรูปแบบที่นิยมใช้สำหรับการกำหนดค่าที่เป็นตัวเลือก (ตัวเลือกเชิงฟังก์ชัน):

type Option func(*Server)

func NewServer(addr string, opts ...Option) *Server {
    s := &Server{addr: addr}
    for _, o := range opts {
        o(s)
    }
    return s
}

ตรวจสอบความเข้าใจ

คุณจะส่งสไลซ์ไปยังฟังก์ชันที่รับอาร์กิวเมนต์จำนวนไม่แน่นอนได้อย่างไร

สรุป: ฟังก์ชันที่รับอาร์กิวเมนต์จำนวนไม่แน่นอน

ฟังก์ชันที่รับอาร์กิวเมนต์จำนวนไม่แน่นอนช่วยให้จุดเรียกใช้กระชับและอ่านง่าย:

...T รวบรวมอาร์กิวเมนต์ท้ายรายการไว้ใน []T ภายในฟังก์ชัน
เรียกใช้โดยส่งค่าแต่ละค่า หรือกระจายสไลซ์ด้วย slice...
ฟังก์ชันในตัวอย่าง append และ fmt.Println รับอาร์กิวเมนต์จำนวนไม่แน่นอน
อนุญาตให้มีพารามิเตอร์แบบนี้ได้เพียงหนึ่งตัว และต้องอยู่ท้ายสุด
ใช้รูปแบบตัวเลือกเชิงฟังก์ชันเพื่อออกแบบส่วนเชื่อมต่อที่สื่อความหมายได้ดี

ถัดไป: defer ฟังก์ชันไม่ระบุชื่อ และโคลเชอร์

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

บทเรียน “ฟังก์ชันแบบรับอาร์กิวเมนต์ไม่จำกัดจำนวน” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ฟังก์ชันแบบรับอาร์กิวเมนต์ไม่จำกัดจำนวน”

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

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

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

บทเรียน “ฟังก์ชันแบบรับอาร์กิวเมนต์ไม่จำกัดจำนวน” ใช้เวลานานแค่ไหน

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

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

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

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

← กลับไปที่ Go Academy