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

ฟังก์ชันในฐานะค่าแบบชั้นหนึ่ง

จัดเก็บฟังก์ชันในตัวแปร ส่งเป็นอาร์กิวเมนต์ และคืนค่าจากฟังก์ชัน

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

ยินดีต้อนรับ

ใน Swift ฟังก์ชันเป็นค่าแบบชั้นหนึ่ง คุณจึงเก็บฟังก์ชันไว้ในตัวแปร ส่งฟังก์ชันเป็นอาร์กิวเมนต์ คืนฟังก์ชันจากฟังก์ชันอื่น และประกาศฟังก์ชันซ้อนอยู่ภายในฟังก์ชันอื่นได้

ชนิดของฟังก์ชัน

ฟังก์ชันทุกฟังก์ชันมีชนิดที่กำหนดจากชนิดของพารามิเตอร์และชนิดของค่าที่คืน: ```swift func add(_ a: Int, _ b: Int) -> Int { a + b } let operation: (Int, Int) -> Int = add print(operation(3, 4)) // 7 ``` ชนิดของ `add` คือ `(Int, Int) -> Int`

การส่งฟังก์ชันเป็นอาร์กิวเมนต์

```swift func apply(_ f: (Int) -> Int, to value: Int) -> Int { f(value) } func double(_ n: Int) -> Int { n * 2 } print(apply(double, to: 5)) // 10 ``` นี่คือพื้นฐานของฟังก์ชันลำดับสูง เช่น `map` และ `filter`

การคืนฟังก์ชัน

```swift func multiplier(by factor: Int) -> (Int) -> Int { return { value in value * factor } } let triple = multiplier(by: 3) print(triple(7)) // 21 ``` การคืนฟังก์ชันจะสร้าง *คลอเชอร์* ที่เก็บค่า `factor` ไว้

ฟังก์ชันซ้อน

สามารถประกาศฟังก์ชันไว้ภายในฟังก์ชันอื่นได้: ```swift func chooseStep(goForward: Bool) -> (Int) -> Int { func forward(_ n: Int) -> Int { n + 1 } func backward(_ n: Int) -> Int { n - 1 } return goForward ? forward : backward } let step = chooseStep(goForward: true) print(step(3)) // 4 ```

คลอเชอร์ในรูปแบบย่อ

ลิเทอรัลคลอเชอร์แบบไม่ระบุชื่อสามารถใช้แทนชนิดของฟังก์ชันใด ๆ ได้: ```swift let square: (Int) -> Int = { $0 * $0 } print(square(6)) // 36 let doubled = [1, 2, 3].map { $0 * 2 } // [2, 4, 6] ``` `$0` หมายถึงอาร์กิวเมนต์ตัวแรกในรูปแบบคลอเชอร์ย่อ

การเก็บฟังก์ชันในคอลเลกชัน

```swift let operations: [(Int, Int) -> Int] = [ { $0 + $1 }, { $0 - $1 }, { $0 * $1 } ] for op in operations { print(op(10, 3)) } // 13, 7, 30 ```

ไวยากรณ์คลอเชอร์ต่อท้าย

เมื่ออาร์กิวเมนต์สุดท้ายเป็นฟังก์ชัน คุณสามารถเขียนฟังก์ชันนั้นไว้นอกวงเล็บได้: ```swift func withLogging(_ label: String, action: () -> Void) { print("Start: \(label)") action() print("End: \(label)") } withLogging("fetch") { fetchData() } ```

เอกลักษณ์และความเท่ากันของฟังก์ชัน

คุณไม่สามารถเปรียบเทียบค่าฟังก์ชันสองค่าด้วย `==` ใน Swift ได้ เนื่องจากฟังก์ชันไม่ใช่ชนิดที่สอดคล้องกับ Equatable: ```swift // let same = add == add ❌ ``` หากต้องการเปรียบเทียบ ให้ห่อฟังก์ชันไว้ในโครงสร้างหรือคลาสที่สอดคล้องกับ Equatable

รูปแบบเคอร์รี

จำลองการทำเคอร์รีด้วยการคืนฟังก์ชันที่รับอาร์กิวเมนต์ไว้บางส่วน: ```swift func add(_ a: Int) -> (Int) -> Int { { b in a + b } } let add5 = add(5) print(add5(3)) // 8 print(add5(10)) // 15 ``` มีประโยชน์สำหรับสร้างฟังก์ชันเฉพาะทางจากฟังก์ชันทั่วไป

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

ชนิดของฟังก์ชันที่รับ `Int` สองค่าและคืนค่า `Int` คืออะไร

สรุป

ประเด็นสำคัญ: • ฟังก์ชันมีชนิด เช่น `(ParamTypes) -> ReturnType` • เก็บฟังก์ชันไว้ในตัวแปร ส่งเป็นอาร์กิวเมนต์ และคืนค่าจากฟังก์ชันได้ • คลอเชอร์ (`{ }`) คือค่าฟังก์ชันแบบไม่ระบุชื่อ • ไวยากรณ์คลอเชอร์ต่อท้ายช่วยให้จุดเรียกใช้กระชับขึ้น • การคืนฟังก์ชันจากฟังก์ชันจะสร้างคลอเชอร์ที่เก็บตัวแปรไว้ ถัดไป: บทเรียนเรื่องการเชื่อมต่อและการแกะค่าของออปชันนัล

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

บทเรียน “ฟังก์ชันในฐานะค่าแบบชั้นหนึ่ง” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ฟังก์ชันในฐานะค่าแบบชั้นหนึ่ง”

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

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

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

บทเรียน “ฟังก์ชันในฐานะค่าแบบชั้นหนึ่ง” ใช้เวลานานแค่ไหน

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

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

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

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

  1. ป้ายกำกับอาร์กิวเมนต์และชื่อพารามิเตอร์
  2. พารามิเตอร์ค่าเริ่มต้นและพารามิเตอร์จำนวนไม่แน่นอน
  3. พารามิเตอร์ In-Out และการคืนค่าหลายค่า
  4. ฟังก์ชันในฐานะค่าแบบชั้นหนึ่ง
← กลับไปที่ Swift Academy