0Pricing
Scala for Backend Engineering & Functional Programming · Pelajaran

Transformasi dan Action

Komputasi malas.

Transformasi dan Action adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Dua Jenis Operasi

Operasi Spark terbagi menjadi transformasi (membangun dataset baru secara malas) dan tindakan (memicu perhitungan lalu mengembalikan hasil atau menulis keluaran).

Evaluasi Malas

Transformasi bersifat malas: transformasi hanya mencatat apa yang harus dilakukan, tetapi tidak menjalankan apa pun. Spark membangun graf asiklik berarah (DAG) transformasi dan baru mengeksekusinya saat suatu tindakan dipanggil.

map dan filter

map mengubah setiap elemen; filter mempertahankan elemen yang sesuai dengan predikat. Keduanya mengembalikan RDD/DataSet baru dan belum menjalankan apa pun.

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

flatMap

flatMap memetakan setiap elemen menjadi nol atau lebih keluaran lalu meratakannya—cara klasik untuk memisahkan baris menjadi kata-kata.

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

Tindakan Umum

Tindakan memicu eksekusi:

  • collect — membawa semua hasil ke pengandar
  • count — menghitung jumlah elemen
  • first / take(n) — mengambil sampel baris
  • reduce — menggabungkan menjadi satu nilai
val total = sc.parallelize(1 to 100).reduce(_ + _)
println(total) // 5050 — runs now

Sempit vs Lebar

Transformasi sempit (map, filter) tidak memerlukan pemindahan data. Transformasi lebar (groupByKey, reduceByKey, join) memicu pengocokan melalui jaringan.

reduceByKey

Pada RDD pasangan kunci-nilai, reduceByKey mengagregasikan nilai untuk setiap kunci. Operasi ini menggabungkan data secara lokal sebelum pengocokan, sehingga lebih efisien daripada groupByKey.

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

Penyimpanan dalam Tembolok

Jika sebuah kumpulan data digunakan kembali dalam beberapa tindakan, cache atau persist menyimpannya di memori agar tidak dihitung ulang setiap kali.

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

Transformasi DataFrame

DataFrames memiliki transformasi malasnya sendiri: select, where, withColumn, orderBy. Tindakan seperti show dan collect memicunya.

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

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

Klasik Penghitungan Kata

Pekerjaan Spark yang kanonis: memisahkan baris, memetakan setiap kata menjadi satu, lalu mengurangi berdasarkan kunci. Hanya collect terakhir yang menjalankan alur pemrosesan.

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

Analogi Malas Scala Sederhana

Analogi Scala mandiri: tampilan malas menunda pekerjaan hingga dipaksa, menyerupai pemisahan transformasi dan tindakan pada 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)
  }
}

Pemeriksaan Singkat

Kapan Spark benar-benar mengeksekusi rangkaian transformasi map dan filter?

Rangkuman

Anda telah mempelajari model eksekusi Spark:

  • Transformasi bersifat malas (map, filter, flatMap, reduceByKey)
  • Tindakan memicu pekerjaan (collect, count, reduce)
  • operasi sempit vs lebar (pengocokan)
  • cache untuk menggunakan kembali hasil

Berikutnya: Spark SQL.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Transformasi dan Action” gratis?

Ya — teks lengkap “Transformasi dan Action” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Transformasi dan Action”?

Komputasi malas. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?

Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Transformasi dan Action” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?

Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. RDD dan DataFrames
  2. Transformasi dan Action
  3. Spark SQL
  4. Agregasi
← Kembali ke Scala for Backend Engineering & Functional Programming