การประกอบ IO
จัดลำดับผลข้างเคียง
การประกอบ IO เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 4 บทเรียน
การจัดลำดับด้วย flatMap
เนื่องจาก IO เป็นมอนาด คุณจึงประกอบผลกระทบด้วย flatMap แต่ละขั้นจะทำงานตามลำดับ และขั้นถัดไปสามารถใช้ผลลัพธ์จากขั้นก่อนหน้าได้
import cats.effect.IO
val program: IO[Unit] =
IO("Alice").flatMap(name => IO.println(s"Hello, $name"))for-comprehension
for-comprehension จะแปลงรูปเป็น flatMap/map และอ่านได้คล้ายสคริปต์เชิงคำสั่ง ขณะยังคงความบริสุทธิ์ไว้
import cats.effect.IO
val prog: IO[Unit] = for {
_ <- IO.println("What is your name?")
name <- IO("Bob")
_ <- IO.println(s"Hi $name")
} yield ()ลำดับยังคงเดิม
ผลกระทบใน for-comprehension จะทำงานจากบนลงล่างเมื่อเรียกใช้โปรแกรม โครงสร้างโค้ดจึงสอดคล้องกับลำดับการทำงาน
การรวมผลกระทบที่เป็นอิสระต่อกัน
เมื่อผลกระทบสองรายการไม่ขึ้นต่อกัน ให้ใช้ mapN หรือ (a, b).tupled เพื่อรวมเข้าด้วยกัน โดยค่าเริ่มต้นทั้งสองยังทำงานตามลำดับ แต่สื่อว่าเป็นอิสระต่อกัน
import cats.effect.IO
import cats.syntax.apply._
val combined: IO[Int] = (IO(2), IO(3)).mapN(_ + _)การเรียกใช้ผลกระทบแบบขนาน
ใช้ parMapN (จาก cats.syntax.parallel) เพื่อเรียกใช้ผลกระทบที่เป็นอิสระต่อกันพร้อมกันบนไฟเบอร์แยกกัน แล้วรวมผลลัพธ์
import cats.effect.IO
import cats.syntax.parallel._
val par: IO[Int] = (IO(2), IO(3)).parMapN(_ + _)การทิ้งผลลัพธ์
ใช้ *> เพื่อเรียกใช้ผลกระทบและเก็บผลลัพธ์ที่สอง หรือใช้ <* เพื่อเก็บผลลัพธ์แรก ส่วน void จะทิ้งผลลัพธ์ทั้งหมดและให้ค่าเป็น IO[Unit]
import cats.effect.IO
val r1: IO[Int] = IO.println("log") *> IO(42)
val r2: IO[Unit] = IO(99).voidการทำผลกระทบซ้ำ
replicateA(n) เรียกใช้ผลกระทบ n ครั้งและรวบรวมผลลัพธ์เป็นรายการ ส่วน foreverM จะทำซ้ำไม่สิ้นสุด
import cats.effect.IO
val three: IO[List[Unit]] = IO.println("tick").replicateA(3)การท่องผ่าน List
เปลี่ยน List[A] ให้เป็นผลกระทบที่ครอบคลุม List[B] ด้วย traverse สมาชิกแต่ละตัวจะสร้าง IO และมีการรวบรวมผลลัพธ์
import cats.effect.IO
import cats.syntax.traverse._
val names = List("a", "b", "c")
val prog: IO[List[Unit]] = names.traverse(n => IO.println(n))parTraverse
parTraverse เป็นเวอร์ชันแบบขนานของ traverse — ผลกระทบของสมาชิกแต่ละตัวทำงานบนไฟเบอร์ของตนเอง เหมาะอย่างยิ่งกับ IO พร้อมกัน เช่น การดึงข้อมูลจาก URL จำนวนมาก
import cats.effect.IO
import cats.syntax.parallel._
val ids = List(1, 2, 3)
val prog: IO[List[Int]] = ids.parTraverse(id => IO(id * 10))โปรแกรมที่ประกอบขึ้น
โปรแกรมนี้อ่านค่า เพิ่มค่าเป็นสองเท่า และพิมพ์ผลลัพธ์ โดยทั้งหมดประกอบจากขั้นตอน IO เล็ก ๆ ในคำอธิบายเดียว
import cats.effect.{IO, IOApp}
object Doubler extends IOApp.Simple {
def run: IO[Unit] = for {
n <- IO(21)
d = n * 2
_ <- IO.println(s"Doubled: $d")
} yield ()
}การจัดลำดับใน Scala ปกติ
เพื่อเปรียบเทียบ ต่อไปนี้คือการแสดงผลบนคอนโซลแบบลำดับใน Scala ปกติ — ประเมินผลทันทีและไม่บริสุทธิ์ ต่างจาก IO ที่เลื่อนการทำงานในตัวอย่างก่อนหน้า
object Main {
def main(args: Array[String]): Unit = {
val n = 21
val d = n * 2
println(s"Doubled: $d")
}
}ตรวจสอบอย่างรวดเร็ว
เมธอดใดเรียกใช้ผลกระทบที่ เป็นอิสระต่อกัน สองรายการพร้อมกันและรวมผลลัพธ์
สรุปทบทวน
คุณประกอบโปรแกรม IO ด้วย:
flatMapและforสำหรับการจัดลำดับmapN/parMapNสำหรับผลกระทบที่เป็นอิสระต่อกัน*>,<*,voidสำหรับการรวม/ทิ้งผลลัพธ์traverse/parTraverseสำหรับคอลเลกชัน
ถัดไป: การจัดการข้อผิดพลาดภายใน IO
คำถามที่พบบ่อย
บทเรียน “การประกอบ IO” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การประกอบ IO” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Scala for Backend Engineering & Functional Programming ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การประกอบ IO”
จัดลำดับผลข้างเคียง คุณปฏิบัติ Scala for Backend Engineering & Functional Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Scala for Backend Engineering & Functional Programming หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Scala for Backend Engineering & Functional Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “การประกอบ IO” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม
ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ