0Pricing
Scala for Backend Engineering & Functional Programming · บทเรียน

การแปลงและการดำเนินการ

การคำนวณแบบขี้เกียจ

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

การดำเนินการสองประเภท

การดำเนินการของ Spark แบ่งเป็นการแปลง (สร้างชุดข้อมูลใหม่และทำงานแบบขี้เกียจ) กับการดำเนินการ (เริ่มการคำนวณและคืนผลลัพธ์หรือเขียนผลลัพธ์ออก)

การประเมินแบบขี้เกียจ

การแปลงทำงานแบบขี้เกียจ: จะบันทึกสิ่งที่ต้องทำไว้แต่ยังไม่ทำงาน Spark จะสร้างกราฟแบบมีทิศทางและไม่มีวัฏจักร (DAG) ของการแปลง และจะเริ่มทำงานก็ต่อเมื่อมีการเรียกใช้การดำเนินการ

map และ filter

map แปลงสมาชิกแต่ละรายการ ส่วน filter จะเก็บสมาชิกที่ตรงตามเพรดิเคต ทั้งสองแบบคืนค่า RDD/Dataset ใหม่และยังไม่เริ่มทำงาน

val nums  = sc.parallelize(1 to 10)
val evens = nums.filter(_ % 2 == 0).map(_ * 10)
// nothing computed yet

flatMap

flatMap แปลงสมาชิกแต่ละรายการให้เป็นผลลัพธ์ศูนย์รายการขึ้นไป แล้วทำให้ผลลัพธ์แบนราบ เหมาะกับกรณีคลาสสิกอย่างการแบ่งบรรทัดออกเป็นคำ

val lines = sc.parallelize(Seq("hello world", "spark rocks"))
val words = lines.flatMap(_.split(" "))

การดำเนินการที่ใช้บ่อย

การดำเนินการจะทริกเกอร์การประมวลผล:

  • collect — นำผลลัพธ์ทั้งหมดมายังไดรเวอร์
  • count — นับจำนวนองค์ประกอบ
  • first / take(n) — สุ่มตัวอย่างแถว
  • reduce — รวมให้เหลือค่าเดียว
val total = sc.parallelize(1 to 100).reduce(_ + _)
println(total) // 5050 — runs now

การแปลงแบบแคบและแบบกว้าง

การแปลงแบบ แคบ (map, filter) ไม่ต้องย้ายข้อมูล ส่วนการแปลงแบบ กว้าง (groupByKey, reduceByKey, join) จะทริกเกอร์การสับเปลี่ยนข้อมูลผ่านเครือข่าย

reduceByKey

สำหรับ RDD แบบคู่คีย์-ค่า reduceByKey จะรวมค่าตามคีย์ โดยรวมค่าภายในเครื่องก่อนสับเปลี่ยนข้อมูล จึงมีประสิทธิภาพมากกว่า groupByKey

val pairs  = sc.parallelize(Seq(("a", 1), ("b", 1), ("a", 1)))
val counts = pairs.reduceByKey(_ + _)
// (a, 2), (b, 1)

การแคช

หากมีการนำชุดข้อมูลกลับมาใช้ซ้ำผ่านการดำเนินการหลายครั้ง cache หรือ persist จะเก็บชุดข้อมูลไว้ในหน่วยความจำ เพื่อไม่ต้องคำนวณใหม่ทุกครั้ง

val cached = sc.parallelize(1 to 1000).filter(_ % 3 == 0).cache()
println(cached.count())
println(cached.sum())

การแปลง DataFrame

DataFrame มีการแปลงแบบประเมินผลเมื่อจำเป็นของตนเอง ได้แก่ select, where, withColumn, orderBy การดำเนินการอย่าง show และ collect จะทริกเกอร์การแปลงเหล่านี้

import org.apache.spark.sql.functions._

val adults = df.where(col("age") >= 18)
               .withColumn("adult", lit(true))
adults.show()

บทเรียนคลาสสิกเรื่องการนับคำ

งาน Spark มาตรฐาน: แยกบรรทัด จับคู่แต่ละคำกับเลขหนึ่ง แล้วลดค่าตามคีย์ มีเพียง collect สุดท้ายเท่านั้นที่เรียกใช้กระบวนการประมวลผล

val text   = sc.textFile("book.txt")
val counts = text.flatMap(_.split(" "))
                 .map(w => (w, 1))
                 .reduceByKey(_ + _)
counts.collect().foreach(println)

แอนะล็อกแบบประเมินผลเมื่อจำเป็นใน Scala ธรรมดา

แอนะล็อกแบบโปรแกรม Scala ที่ทำงานได้ในตัวเอง: มุมมองแบบประเมินผลเมื่อจำเป็นจะเลื่อนการทำงานออกไปจนกว่าจะถูกบังคับให้ประเมิน ซึ่งจำลองการแยกระหว่างการแปลงและการดำเนินการของ Spark

object Main {
  def main(args: Array[String]): Unit = {
    val pipeline = (1 to 10).view.filter(_ % 2 == 0).map(_ * 10) // lazy
    val result = pipeline.toList // forces evaluation (action)
    println(result)
  }
}

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

Spark จะเริ่มดำเนินการสายการแปลงของ map และ filter เมื่อใด

สรุปทบทวน

คุณได้เรียนรู้รูปแบบการทำงานของ Spark:

  • การแปลงจะประเมินผลเมื่อจำเป็น (map, filter, flatMap, reduceByKey)
  • การดำเนินการจะทริกเกอร์การทำงาน (collect, count, reduce)
  • การดำเนินการแบบแคบและแบบกว้าง (การสับเปลี่ยนข้อมูล)
  • ใช้ cache เพื่อใช้ผลลัพธ์ซ้ำ

ถัดไป: Spark SQL

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

บทเรียน “การแปลงและการดำเนินการ” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การแปลงและการดำเนินการ”

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

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Scala for Backend Engineering & Functional Programming หรือไม่

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

บทเรียน “การแปลงและการดำเนินการ” ใช้เวลานานแค่ไหน

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

ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม

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

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

  1. RDD และ DataFrames
  2. การแปลงและการดำเนินการ
  3. Spark SQL
  4. การรวมกลุ่ม
← กลับไปที่ Scala for Backend Engineering & Functional Programming