0Pricing
Learn Rust Coding · Pelajaran

Closure

Fungsi anonim

Closure adalah pelajaran Learn Rust Coding 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 Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Apa Itu Closure?

Closure adalah fungsi anonim yang dapat Anda simpan dalam variabel dan panggil nanti. Closure ditulis dengan garis vertikal yang mengapit parameternya.

fn main() {
    let add_one = |x| x + 1;
    println!("{}", add_one(4));
}

Sintaks Closure

Parameter ditulis di antara |...|, lalu diikuti badannya. Jika hanya terdiri dari satu ekspresi, kurung kurawal tidak diperlukan.

  • |x| x + 1 — satu parameter.
  • |a, b| a + b — dua parameter.
fn main() {
    let multiply = |a, b| a * b;
    println!("{}", multiply(3, 5));
}

Closure Multi-Baris

Untuk lebih dari satu pernyataan, bungkus badan closure dalam kurung kurawal, sama seperti fungsi.

fn main() {
    let describe = |n: i32| {
        let doubled = n * 2;
        println!("{} doubled is {}", n, doubled);
    };
    describe(7);
}

Menangkap Lingkungan

Berbeda dari fungsi biasa, closure dapat menangkap variabel dari scope di sekitarnya dan menggunakannya di dalam closure.

fn main() {
    let factor = 10;
    let scale = |x| x * factor;
    println!("{}", scale(5));
}

Inferensi Tipe pada Closure

Closure biasanya menginferensikan tipe parameter dan nilai kembali berdasarkan cara penggunaannya, sehingga anotasi bersifat opsional.

Anda dapat menambahkan tipe agar lebih jelas jika diperlukan.

fn main() {
    let greet = |name: &str| -> String {
        format!("Hello, {}!", name)
    };
    println!("{}", greet("Rust"));
}

Closure sebagai Argumen

Banyak metode standar menerima closure. Misalnya, map menerapkan closure ke setiap item.

fn main() {
    let nums = vec![1, 2, 3];
    let doubled: Vec<i32> = nums.iter().map(|x| x * 2).collect();
    println!("{:?}", doubled);
}

Memfilter dengan Closure

Metode filter hanya mempertahankan item yang menghasilkan true dari closure.

fn main() {
    let nums = vec![1, 2, 3, 4, 5, 6];
    let evens: Vec<i32> = nums.into_iter().filter(|x| x % 2 == 0).collect();
    println!("{:?}", evens);
}

Menyimpan Closure

Closure memiliki tipe anonim yang unik, tetapi Anda dapat menyimpannya dalam variabel dan menggunakannya kembali.

fn main() {
    let is_even = |n: i32| n % 2 == 0;
    println!("{} {}", is_even(4), is_even(7));
}

Closure vs Fungsi

Perbedaannya:

  • Fungsi tidak dapat menangkap variabel di sekitarnya, sedangkan closure dapat.
  • Closure bersifat anonim dan biasanya singkat.
  • Tipe closure biasanya diinferensikan.
fn main() {
    let base = 100;
    let bonus = |earned: i32| earned + base;
    println!("{}", bonus(25));
}

Mengembalikan Nilai Hasil Perhitungan

Gabungkan closure dengan iterator untuk menghitung hasil dalam pipeline yang bersih dan ekspresif.

fn main() {
    let nums = vec![10, 20, 30];
    let total: i32 = nums.iter().map(|x| x + 1).sum();
    println!("total {}", total);
}

Closure Menangkap melalui Referensi

Secara default, closure meminjam variabel yang ditangkap. Anda tetap dapat membacanya di luar closure setelahnya (selama hanya dipinjam).

fn main() {
    let name = String::from("Ada");
    let printer = || println!("Name: {}", name);
    printer();
    println!("still usable: {}", name);
}

Pemeriksaan Singkat

Ingat kembali kemampuan utama closure.

Ringkasan

Closure dalam Rust:

  • Fungsi anonim yang ditulis sebagai |params| body.
  • Dapat menangkap variabel dari lingkungannya.
  • Tipe biasanya diinferensikan.
  • Banyak digunakan dengan metode iterator seperti map dan filter.
fn main() {
    let tax = 0.2;
    let with_tax = |price: f64| price * (1.0 + tax);
    println!("{}", with_tax(50.0));
}

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Closure” gratis?

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

Apa yang akan aku pelajari di “Closure”?

Fungsi anonim Kamu berlatih Learn Rust Coding 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 Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding 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 “Closure” 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 Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding 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. Mendefinisikan Fungsi
  2. Expression dan Pernyataan
  3. Closure
  4. Fn, FnMut, FnOnce
← Kembali ke Learn Rust Coding