Regex #

Regular expressions (regex) adalah pola yang digunakan untuk mencocokkan dan memanipulasi teks berdasarkan aturan yang telah ditentukan. Di Rust, regex digunakan untuk berbagai operasi string seperti pencarian, penggantian, dan validasi. Rust tidak memiliki dukungan regex bawaan, tetapi ada crate populer yang disebut regex yang menyediakan fungsionalitas regex secara lengkap.

Menginstal Crate `regex` #

Untuk menggunakan regex di Rust, Anda harus menambahkan crate regex ke dalam proyek Anda. Ini dapat dilakukan dengan menambahkan dependensi ke file Cargo.toml:

[dependencies]
regex = "1"

Setelah menambahkan crate regex, Anda bisa mulai menggunakannya di dalam kode Anda dengan mengimpor modul yang sesuai.

Dasar-dasar Penggunaan Regex #

Regex di Rust diwakili oleh tipe Regex, yang dapat Anda buat dengan menggunakan fungsi Regex::new. Fungsi ini menerima pola regex sebagai string dan mengkompilasi pola tersebut menjadi objek Regex.

Contoh Dasar Regex:

use regex::Regex;

fn main() {
    let re = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
    let date = "2024-08-24";

    if re.is_match(date) {
        println!("Tanggal valid!");
    } else {
        println!("Tanggal tidak valid.");
    }
}

Penjelasan:

Regex::new(r"^\d{4}-\d{2}-\d{2}$"): Pola regex ini mencocokkan string yang sesuai dengan format tanggal YYYY-MM-DD.
re.is_match(date): Memeriksa apakah string date sesuai dengan pola regex yang diberikan.

Catatan:

r"..." adalah literal string mentah di Rust yang digunakan untuk menghindari perlunya escape karakter \.
unwrap() digunakan untuk menangani kemungkinan error saat kompilasi regex, misalnya jika pola regex tidak valid.

Pencocokan Dasar dengan Regex #

Ada beberapa metode utama yang digunakan untuk mencocokkan dan bekerja dengan regex di Rust:

`is_match` #

Metode is_match digunakan untuk memeriksa apakah suatu string sesuai dengan pola regex.

Contoh is_match:

use regex::Regex;

fn main() {
    let re = Regex::new(r"foo").unwrap();
    let text = "foobar";

    if re.is_match(text) {
        println!("'foo' ditemukan dalam '{}'", text);
    } else {
        println!("'foo' tidak ditemukan dalam '{}'", text);
    }
}

Penjelasan:

is_match mengembalikan true jika pola regex ditemukan dalam string, dan false jika tidak.

`find` #

Metode find mengembalikan posisi pertama yang cocok dalam string, sebagai tuple (start, end) yang menunjukkan indeks awal dan akhir dari kecocokan.

Contoh find:

use regex::Regex;

fn main() {
    let re = Regex::new(r"\d+").unwrap();
    let text = "The answer is 42";

    if let Some(matched) = re.find(text) {
        println!("Angka ditemukan di posisi: {:?}", matched);
    }
}

Penjelasan:

find mengembalikan Option<Match> di mana Match berisi informasi tentang kecocokan, termasuk posisi awal dan akhir kecocokan dalam string.

`captures` #

Metode captures digunakan untuk menangkap kelompok (groups) dalam regex. Ini berguna jika Anda ingin mengekstrak bagian-bagian tertentu dari string yang cocok.

Contoh captures:

use regex::Regex;

fn main() {
    let re = Regex::new(r"(\d{4})-(\d{2})-(\d{2})").unwrap();
    let date = "2024-08-24";

    if let Some(caps) = re.captures(date) {
        println!("Tahun: {}", &caps[1]);
        println!("Bulan: {}", &caps[2]);
        println!("Hari: {}", &caps[3]);
    }
}

Penjelasan:

captures mengembalikan Option<Captures>, di mana Captures berisi semua kelompok yang ditangkap.
Anda dapat mengakses kelompok yang ditangkap menggunakan indeks, dimulai dari 1 untuk kelompok pertama.

Iterasi dengan Regex #

Rust menyediakan metode untuk mengiterasi melalui semua kecocokan dalam sebuah string.

`find_iter` #

Metode find_iter mengembalikan iterator atas semua kecocokan yang ditemukan dalam string.

Contoh find_iter:

use regex::Regex;

fn main() {
    let re = Regex::new(r"\d+").unwrap();
    let text = "Ada 3 kucing, 4 anjing, dan 5 burung";

    for mat in re.find_iter(text) {
        println!("Ditemukan angka: {}", mat.as_str());
    }
}

Penjelasan:

find_iter mengembalikan iterator yang dapat digunakan untuk mengakses setiap kecocokan yang ditemukan dalam string.

`captures_iter` #

Metode captures_iter mengembalikan iterator atas semua kelompok yang ditangkap dari semua kecocokan dalam string.

Contoh captures_iter:

use regex::Regex;

fn main() {
    let re = Regex::new(r"(\w+):(\d+)").unwrap();
    let text = "kucing:3 anjing:4 burung:5";

    for caps in re.captures_iter(text) {
        println!("Hewan: {}, Jumlah: {}", &caps[1], &caps[2]);
    }
}

Penjelasan:

captures_iter mengembalikan iterator yang mengiterasi melalui semua kecocokan dan kelompok yang ditangkap.

Penggantian Teks dengan Regex #

Rust memungkinkan Anda untuk melakukan penggantian teks menggunakan regex dengan metode replace dan replace_all.

`replace` #

Metode replace menggantikan kecocokan pertama dalam string dengan teks baru.

Contoh replace:

use regex::Regex;

fn main() {
    let re = Regex::new(r"warna").unwrap();
    let text = "warna merah dan warna biru";

    let result = re.replace(text, "color");
    println!("Hasil penggantian: {}", result);
}

Penjelasan:

replace menggantikan kecocokan pertama dari warna dengan color.

`replace_all` #

Metode replace_all menggantikan semua kecocokan dalam string dengan teks baru.

Contoh replace_all:

use regex::Regex;

fn main() {
    let re = Regex::new(r"\b(\d{4})-(\d{2})-(\d{2})\b").unwrap();
    let text = "Tanggal 2024-08-24 dan 2023-07-23";

    let result = re.replace_all(text, "$2/$3/$1");
    println!("Hasil penggantian: {}", result);
}

Penjelasan:

replace_all menggantikan semua tanggal dari format YYYY-MM-DD ke MM/DD/YYYY menggunakan grup yang ditangkap ($1, $2, dll.).

Kompilasi Regex secara Efisien #

Jika Anda menggunakan regex yang sama berkali-kali, Anda bisa mengkompilasi regex tersebut satu kali dan menggunakan objek Regex yang dikompilasi berulang kali. Ini lebih efisien daripada mengkompilasi regex setiap kali digunakan.

Contoh Efisiensi Kompilasi:

use regex::Regex;

fn main() {
    let re = Regex::new(r"\d+").unwrap();

    let texts = vec!["abc123", "def456", "ghi789"];
    for text in &texts {
        if re.is_match(text) {
            println!("Kecocokan ditemukan di '{}'", text);
        }
    }
}

Penjelasan:

Dengan mengkompilasi regex di luar loop, Anda menghindari biaya kompilasi berulang.

Validasi dengan Regex #

Regex sering digunakan untuk validasi input, seperti memeriksa format email atau nomor telepon.

Contoh Validasi Email:

use regex::Regex;

fn main() {
    let re = Regex::new(r"^[\w\.-]+@[a-zA-Z\d\.-]+\.[a-zA-Z]{2,4}$").unwrap();
    let email = "[email protected]";

    if re.is_match(email) {
        println!("Email valid");
    } else {
        println!("Email tidak valid");
    }
}

Penjelasan:

Regex digunakan untuk memeriksa apakah format string sesuai dengan format email yang umum digunakan.

Penanganan Error dengan Regex #

Ketika Anda membuat regex menggunakan Regex::new, ada kemungkinan regex yang Anda tulis tidak valid. Oleh karena itu, Regex::new mengembalikan Result<Regex, Error> yang memungkinkan Anda menangani

kesalahan.

Contoh Penanganan Error:

use regex::Regex;

fn main() {
    match Regex::new(r"(\d{4}-\d{2}-\d{2") {
        Ok(re) => println!("Regex berhasil dikompilasi."),
        Err(e) => println!("Error saat mengkompilasi regex: {}", e),
    }
}

Penjelasan:

Regex yang tidak valid menyebabkan error, dan ini bisa ditangani dengan match atau metode penanganan error lainnya.

Fungsi-Fungsi Lain dalam Crate `regex` #

Crate regex juga menyediakan fungsi-fungsi tambahan seperti RegexSet untuk mencocokkan beberapa pola sekaligus, serta RegexBuilder untuk konfigurasi lebih lanjut saat membuat regex (misalnya, untuk mengaktifkan atau menonaktifkan case sensitivity).

Contoh RegexSet:

use regex::RegexSet;

fn main() {
    let set = RegexSet::new(&[
        r"foo",
        r"bar",
        r"baz",
    ]).unwrap();

    let matches = set.matches("foobarbaz");
    if matches.matched(0) {
        println!("Pola 'foo' cocok.");
    }
    if matches.matched(1) {
        println!("Pola 'bar' cocok.");
    }
    if matches.matched(2) {
        println!("Pola 'baz' cocok.");
    }
}

Penjelasan:

RegexSet memungkinkan Anda untuk mencocokkan banyak pola dalam satu kali operasi.

Kesimpulan #

Regex di Rust sangat kuat dan fleksibel, berkat crate regex yang menyediakan fungsionalitas lengkap untuk pencocokan, penggantian, dan manipulasi teks berbasis pola. Memahami bagaimana menggunakan regex di Rust memungkinkan Anda untuk menulis program yang lebih efisien dalam menangani teks dan data berbasis string. Dengan penanganan error yang baik, kompilasi regex yang efisien, dan fitur-fitur tambahan seperti RegexSet, Rust memberikan alat yang sangat kuat untuk bekerja dengan regular expressions.

« Date & Time

Crates »

Regex #

Menginstal Crate regex #

Dasar-dasar Penggunaan Regex #

Pencocokan Dasar dengan Regex #

is_match #

find #

captures #

Iterasi dengan Regex #

find_iter #

captures_iter #

Penggantian Teks dengan Regex #

replace #

replace_all #

Kompilasi Regex secara Efisien #

Validasi dengan Regex #

Penanganan Error dengan Regex #

Fungsi-Fungsi Lain dalam Crate regex #

Kesimpulan #

Menginstal Crate `regex` #

`is_match` #

`find` #

`captures` #

`find_iter` #

`captures_iter` #

`replace` #

`replace_all` #

Fungsi-Fungsi Lain dalam Crate `regex` #