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

การประกอบฟังก์ชันและสายส่งข้อมูล

สร้างสายส่งข้อมูลด้วยการประกอบฟังก์ชันขนาดเล็กให้เป็นการแปลงข้อมูลที่ใหญ่ขึ้น

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

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

การประกอบฟังก์ชันจะรวมฟังก์ชันขนาดเล็กที่มุ่งเน้นงานเฉพาะเข้าด้วยกันเป็นการแปลงที่ซับซ้อนขึ้น นี่คือแก่นของการเขียนโปรแกรมเชิงฟังก์ชัน — สร้างพฤติกรรมที่ซับซ้อนจากส่วนประกอบที่เรียบง่าย

การประกอบด้วยตนเอง

```swift func double(_ n: Int) -> Int { n * 2 } func addOne(_ n: Int) -> Int { n + 1 } let result = addOne(double(5)) // 11 ```

การประกอบด้วยตัวช่วย

```swift func compose(_ f: @escaping (B)->C, _ g: @escaping (A)->B) -> (A)->C { { f(g($0)) } } let doubleAndAdd = compose(addOne, double) print(doubleAndAdd(5)) // 11 ```

ตัวดำเนินการ >>> แบบกำหนดเอง

```swift infixop precedencegroup CompositionPrecedence { ... } func >>> (f: @escaping (A)->B, g: @escaping (B)->C) -> (A)->C { { g(f($0)) } } let pipeline = double >>> addOne >>> String.init print(pipeline(5)) // "11" ```

สายการประมวลผลด้วยการเชื่อม filter/map

```swift let process: ([Int]) -> [String] = { nums in nums.filter { $0 > 3 }.map { String($0 * 2) } } print(process([1,2,3,4,5])) // ["8","10"] ```

รูปแบบ Point-Free

รูปแบบ Point-Free หลีกเลี่ยงการตั้งชื่ออาร์กิวเมนต์ระหว่างกลาง: ```swift let words = ["hello","WORLD","Swift"] let lower = words.map { $0.lowercased() } // named let lower2 = words.map(\.description) // point-free where applicable ```

KeyPaths ในฐานะฟังก์ชัน

คีย์พาธของ Swift สามารถใช้เป็นฟังก์ชันได้: ```swift struct User { var name: String } let users = [User(name:"Alice"),User(name:"Bob")] let names = users.map(\.name) // ["Alice","Bob"] ```

การสร้างกระบวนการประมวลผลข้อมูล

```swift let pipeline: (String) -> Int? = { s in let trimmed = s.trimmingCharacters(in:.whitespaces) guard !trimmed.isEmpty else { return nil } return Int(trimmed) } [" 42 "," ","7"].compactMap(pipeline) // [42,7] ```

การประยุกต์ใช้ฟังก์ชันบางส่วน

```swift func add(_ a: Int) -> (Int) -> Int { { a + $0 } } let add5 = add(5) print([1,2,3].map(add5)) // [6,7,8] ```

เหตุใดการประกอบฟังก์ชันจึงสำคัญ

ประโยชน์: • แต่ละฟังก์ชันมีขนาดเล็กและทดสอบได้ • กระบวนการประมวลผลอ่านได้ง่ายจากบนลงล่าง • นำกลับมาใช้ใหม่ได้: `double` ทำงานได้ทั้งโดยลำพังหรือในกระบวนการประมวลผลใดก็ได้ • ประเมินผลแบบเลื่อนการประมวลผล: ใช้ร่วมกับ `.lazy` เพื่อหลีกเลี่ยงการจัดสรรข้อมูลระหว่างทาง

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

ความสามารถใดของ Swift ที่ทำให้สามารถใช้คีย์พาธเป็นฟังก์ชันแปลงข้อมูลโดยตรงใน map ได้

ทบทวน

ประเด็นสำคัญ: • ประกอบฟังก์ชันขนาดเล็กเข้าด้วยกันเป็นการแปลงข้อมูลที่ใหญ่ขึ้น • ใช้ `>>>` หรือการประกอบด้วยตนเองเพื่อสร้างกระบวนการประมวลผลที่นำกลับมาใช้ใหม่ได้ • ใช้คีย์พาธเป็นฟังก์ชันเพื่อดึงค่าพร็อพเพอร์ตีได้อย่างกระชับ • การประยุกต์ใช้ฟังก์ชันบางส่วนจะสร้างฟังก์ชันเฉพาะทาง • ใช้ร่วมกับ `.lazy` เพื่อสร้างกระบวนการประมวลผลแบบไม่คัดลอกข้อมูล ถัดไป: ลำดับแบบเลื่อนการประมวลผล

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

บทเรียน “การประกอบฟังก์ชันและสายส่งข้อมูล” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การประกอบฟังก์ชันและสายส่งข้อมูล”

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

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

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

บทเรียน “การประกอบฟังก์ชันและสายส่งข้อมูล” ใช้เวลานานแค่ไหน

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

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

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

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

  1. ฟังก์ชันบริสุทธิ์และการออกแบบที่ไม่มีผลข้างเคียง
  2. ฟังก์ชันลำดับสูง: map, flatMap, compactMap
  3. การประกอบฟังก์ชันและสายส่งข้อมูล
  4. ลำดับข้อมูลแบบขี้เกียจเพื่อประสิทธิภาพ
← กลับไปที่ Swift Academy