Swift Academy · Pelajaran

Pertukaran Lazy dan Eager

Ketahui kapan evaluasi lazy membantu atau justru merugikan.

Pertukaran Lazy dan Eager adalah pelajaran Swift Academy gratis di CoddyKit. Ini adalah pelajaran 3 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 Swift Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Swift Academy mencakup 4 pelajaran total.

Tidak Ada Makan Siang Gratis

Evaluasi malas tidak selalu lebih cepat. Evaluasi ini menukar alokasi di awal dengan overhead setiap akses dan mengubah kapan efek samping dijalankan. Memahami pertukaran ini membantu Anda memilih dengan tepat.

Evaluasi Malas Unggul: Konsumsi Sebagian

Hanya sebagian dari transformasi yang sangat besar yang diperlukan — evaluasi malas melewati sisanya:

let data = Array(1...1_000_000)
let top = data.lazy.map { $0 * 2 }.prefix(3)
print(Array(top))  // [2, 4, 6]  -- 999,997 transforms skipped

Evaluasi Langsung Unggul: Penggunaan Ulang Sepenuhnya

Jika Anda melakukan iterasi pada hasil berkali-kali, evaluasi langsung menghitungnya sekali; evaluasi malas menghitung ulang pada setiap putaran:

let doubled = [1, 2, 3].map { $0 * 2 }  // computed once
print(doubled.reduce(0, +))  // 12
print(doubled.max()!)        // 6  -- no recompute

Evaluasi Malas Menghitung Ulang

Tampilan malas yang sama melakukan pekerjaan lagi pada setiap iterasi:

var work = 0
let view = [1, 2, 3].lazy.map { (n: Int) -> Int in work += 1; return n }
_ = view.reduce(0, +)
_ = view.max()
print(work)  // 6  -- transformed twice

Overhead untuk Setiap Elemen

Setiap langkah evaluasi malas membungkus urutan dalam tipe lain dan memanggil melalui closures untuk setiap elemen. Pada array kecil, overhead tersebut dapat lebih besar daripada alokasi yang dihemat.

Array Kecil, Evaluasi Langsung Sudah Cukup

Untuk beberapa elemen yang dikonsumsi sepenuhnya, pilih evaluasi langsung biasa — pendekatan ini lebih sederhana dan alokasinya sepele:

let nums = [3, 1, 2]
let sorted = nums.map { $0 + 1 }.sorted()
print(sorted)  // [2, 3, 4]

Waktu Efek Samping Berbeda

Dengan evaluasi malas, isi closure dijalankan setelah baris yang mendefinisikannya. Hindari mengandalkan efek samping di dalam transformasi malas:

var log: [Int] = []
let v = [1, 2].lazy.map { (n: Int) -> Int in log.append(n); return n }
print(log)        // []  -- nothing ran yet
_ = Array(v)
print(log)        // [1, 2]

Operasi yang Memaksa Evaluasi Langsung

Beberapa operasi tetap harus membaca seluruh urutan, jadi evaluasi malas tidak memberikan manfaat di sana:

let nums = Array(1...10)
print(nums.lazy.map { $0 * 2 }.sorted())  // sorted must see all -> [2,4,...,20]
print(nums.lazy.map { $0 }.count)         // count walks everything

Evaluasi Malas plus contains

Operasi yang berhenti lebih awal seperti contains(where:) mendapat manfaat dari evaluasi malas pada input yang besar:

let big = Array(1...1_000_000)
let found = big.lazy.map { $0 * 2 }.contains { $0 == 8 }
print(found)  // true  -- stops at element 4

Daftar Periksa untuk Memilih

Gunakan evaluasi malas ketika: sumbernya besar DAN Anda hanya menyimpan sebagian (prefix / first / contains) DAN Anda melakukan iterasi sekali. Gunakan evaluasi langsung ketika: array kecil, hasilnya digunakan kembali, atau keterbacaan lebih penting daripada optimasi mikro.

let huge = Array(1...100_000)
let first = huge.lazy.filter { $0 % 9973 == 0 }.first
print(first!)  // 9973

Ukur, Jangan Menebak

Intuisi tentang kinerja sering kali keliru. Jika hal ini penting, ukur kinerja kedua versi dengan data yang realistis sebelum menetapkan evaluasi malas.

let nums = Array(1...50)
let eager = nums.filter { $0 > 25 }.count
let lazyC = nums.lazy.filter { $0 > 25 }.count
print(eager == lazyC)  // true -- same answer, profile for speed

Pemeriksaan Singkat

Kapan eager menjadi pilihan yang lebih baik daripada evaluasi malas?

Ringkasan

Anda telah mempelajari pertukaran berikut:

Evaluasi malas unggul pada sumber besar dengan konsumsi sebagian dalam satu lintasan
Evaluasi langsung unggul untuk array kecil dan hasil yang digunakan kembali (evaluasi malas menghitung ulang)
Efek samping dalam transformasi malas dijalankan belakangan — jangan bergantung padanya
Lakukan pengukuran sebelum mengoptimalkan

Berikutnya: membangun urutan malas kustom.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pertukaran Lazy dan Eager” gratis?

Ya — teks lengkap “Pertukaran Lazy dan Eager” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Swift Academy, upgrade ke CoddyKit PRO. Kursus Swift Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pertukaran Lazy dan Eager”?

Ketahui kapan evaluasi lazy membantu atau justru merugikan. Kamu berlatih Swift Academy 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 Swift Academy?

Tidak diperlukan pengalaman sebelumnya. Swift Academy 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 3 dari 4.

Berapa lama pelajaran “Pertukaran Lazy dan Eager” 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 Swift Academy ini?

Ya. Setiap pelajaran Swift Academy 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

← Kembali ke Swift Academy