Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian · Pelajaran

Operasi Fungsian pada Koleksi

Kuasai operasi fungsian lazim seperti map, filter, fold dan reduce untuk transformasi data.

Pelajaran 2 daripada 311 langkah

Operasi Fungsian pada Koleksi ialah pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian percuma di CoddyKit. Ini ialah pelajaran 2 daripada 3. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 3 pelajaran.

Operasi Berfungsi: Mengapa Menggunakannya?

Operasi fungsian pada koleksi membantu Anda mengubah dan menggabungkan data tanpa mengubah koleksi asal. Pendekatan ini menggalakkan ketakbolehubahan dan menjadikan kod Anda lebih mudah dibaca serta diuji.

Kita akan meneroka operasi utama seperti map, filter, reduce, dan fold.

Ubah dengan `map`

Operasi map menggunakan suatu fungsi pada setiap elemen koleksi dan mengembalikan koleksi baharu yang mengandungi hasil yang telah diubah. Koleksi asal kekal tidak berubah.

Cuba jalankan contoh ini:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4)
    val doubled = numbers.map(n => n * 2)
    println(s"Original: $numbers")
    println(s"Doubled: $doubled")
  }
}

`map` dengan Jenis Berbeza

map sangat fleksibel! Anda boleh mengubah elemen kepada jenis yang sama sekali berbeza. Di sini, kita menukar nombor kepada rentetan atau mendapatkan panjang rentetan.

Perhatikan bahawa hasilnya ialah List[Int], walaupun inputnya ialah List[String].

object Main {
  def main(args: Array[String]): Unit = {
    val names = List("Alice", "Bob", "Charlie")
    val lengths = names.map(name => name.length)
    println(s"Names: $names")
    println(s"Lengths: $lengths")
  }
}

Pilih dengan `filter`

Operasi filter mencipta koleksi baharu yang hanya mengandungi elemen yang memenuhi syarat tertentu (fungsi predikat). Operasi ini "menapis keluar" elemen yang tidak dikehendaki.

Mari kita cari nombor genap:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4, 5, 6)
    val evens = numbers.filter(n => n % 2 == 0)
    println(s"Original: $numbers")
    println(s"Evens: $evens")
  }
}

Lebih Banyak Contoh `filter`

Anda boleh menggunakan apa-apa ungkapan boolean sebagai syarat penapisan. Mari kita tapis senarai perkataan untuk mengekalkan hanya perkataan yang lebih panjang daripada 4 aksara.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("apple", "cat", "banana", "dog", "elephant")
    val longWords = words.filter(w => w.length > 4)
    println(s"Words: $words")
    println(s"Long words: $longWords")
  }
}

Gabungkan dengan `reduce`

Operasi reduce menggabungkan semua elemen koleksi menjadi satu hasil. Operasi ini mengambil operasi binari (fungsi yang menerima dua argumen dan mengembalikan satu nilai) lalu menggunakannya secara kumulatif.

Di sini, kita menjumlahkan semua elemen:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4)
    val sum = numbers.reduce((a, b) => a + b)
    println(s"Numbers: $numbers")
    println(s"Sum: $sum")
  }
}

`reduce` untuk Darab dan Maksimum

reduce boleh melakukan pelbagai pengagregatan. Kita boleh mengira hasil darab nombor atau mencari nilai maksimum.

Nota: reduce akan menghasilkan ralat pada koleksi kosong.

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 5, 2, 8)
    val product = numbers.reduce((a, b) => a * b)
    val maxNum = numbers.reduce((a, b) => if (a > b) a else b)
    println(s"Numbers: $numbers")
    println(s"Product: $product")
    println(s"Max: $maxNum")
  }
}

`fold`: Kuasa Nilai Awal

fold serupa dengan reduce tetapi mempunyai perbezaan penting: ia mengambil nilai awal (juga dipanggil "pengumpul"). Hal ini menjadikannya selamat untuk koleksi kosong dan membolehkan jenis hasil yang berbeza.

Mari kita jumlahkan nombor, bermula daripada 10:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3)
    // foldLeft(initialValue)(operation)
    val sumWithInitial = numbers.foldLeft(10)((acc, n) => acc + n)
    println(s"Numbers: $numbers")
    println(s"Sum (starting from 10): $sumWithInitial")
  }
}

Arah: `foldLeft` berbanding `foldRight`

Scala menyediakan foldLeft dan foldRight. Kedua-duanya berbeza dari segi susunan pemprosesan elemen dan cara pengumpul dihantar.

foldLeft(initial)(op): Memproses dari kiri ke kanan.
foldRight(initial)(op): Memproses dari kanan ke kiri.

Untuk operasi seperti penggabungan rentetan, arah pemprosesan adalah penting!

object Main {
  def main(args: Array[String]): Unit = {
    val chars = List('a', 'b', 'c')
    val leftFold = chars.foldLeft("")((acc, c) => acc + c)
    val rightFold = chars.foldRight("")((c, acc) => acc + c)
    println(s"Chars: $chars")
    println(s"foldLeft: $leftFold") // Output: abc
    println(s"foldRight: $rightFold") // Output: abc (due to string append order)

    // Example where order matters: (acc, char) => char + acc
    val rightFoldReversed = chars.foldRight("")((c, acc) => c + acc)
    println(s"foldRight (char + acc): $rightFoldReversed") // Output: abc

    // A common example where order matters is for operations like subtraction or division, but string concatenation also shows it.
  }
}

Semakan Operasi Fungsian

Pertimbangkan petikan kod Scala berikut:

val data = List(10, 20, 30, 40)
val result1 = data.map(x => x / 10)
val result2 = data.filter(x => x > 25)
val result3 = data.reduce((a, b) => a + b)

Antara pernyataan berikut, yang manakah TRUE tentang hasil tersebut?

Jawab dalam pelajaran interaktif

Ulang Kaji: Kuasa Operasi Fungsian

Anda telah menguasai operasi fungsian yang penting!

map mengubah setiap elemen.
filter memilih elemen berdasarkan suatu syarat.
reduce menggabungkan elemen menjadi satu hasil (memerlukan koleksi yang tidak kosong).
fold menggabungkan elemen dengan nilai awal (selamat untuk koleksi kosong).

Operasi ini penting untuk menulis kod Scala yang ringkas, tidak berubah dan berkuasa. Seterusnya, kita akan meneroka pengendalian ralat yang kukuh menggunakan Option, Try dan Either.

Percuma untuk bermula

Pelajari Scala dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 39
Pelajaran: 143

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Operasi Fungsian pada Koleksi” percuma?

Ya — teks penuh “Operasi Fungsian pada Koleksi” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, tingkat taraf kepada CoddyKit PRO. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 3 pelajaran.

Apakah yang akan saya pelajari dalam “Operasi Fungsian pada Koleksi”?

Kuasai operasi fungsian lazim seperti map, filter, fold dan reduce untuk transformasi data. Anda berlatih Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 3.

Berapa lamakah pelajaran “Operasi Fungsian pada Koleksi” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian ini?

Ya. Setiap pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian