Semua yang Perlu Anda Ketahui untuk Mulai Menulis Karat

Sejak dirilis pada tahun 2015, Rust telah mendapatkan popularitas sebagai salah satu bahasa pemrograman favorit para developer. Rust menawarkan kinerja luar biasa dan fitur keamanan dengan sintaks intuitif dan ringkas yang membuat bahasa ini diinginkan.

Rust cocok untuk membuat berbagai program, termasuk aplikasi web, alat baris perintah, dan layanan jaringan. Rust menyertakan banyak fitur yang Anda harapkan dari bahasa pemrograman modern, seperti konkurensi, inferensi jenis, dan banyak lagi.

Memulai Dengan Karat

Rust adalah bahasa pemrograman lintas platform yang berjalan di sebagian besar sistem operasi. Untuk memulai dengan Rust, pergilah ke pejabat Situs web karat dan instal versi pilihan untuk sistem operasi Anda.

Setelah Anda menginstal Rust, Anda dapat mulai menulis program di file Rust dengan a .rs perpanjangan. Karat itu serbaguna dan mudah dipelajari. Anda akan merasa mudah jika Anda memiliki pengalaman pemrograman sebelumnya.

Variabel dan Konstanta dalam Karat

Rust sangat ekspresif, dan ada banyak cara untuk mendeklarasikan variabel. Anda dapat menggunakan membiarkan kata kunci untuk mendeklarasikan variabel.

Inilah cara Anda mendeklarasikan variabel di Rust:

membiarkan A: Rangkaian;
membiarkan B: i32;
membiarkan c: () = ();

Itu A Dan B variabel adalah string dan integer, masing-masing. Itu C variabel adalah tipe unit Rust yang bertindak sebagai placeholder untuk fungsi dan ekspresi.

Setelah deklarasi tipe data opsional, Anda dapat mendeklarasikan dan menginisialisasi variabel dengan nilai menggunakan tanda sama dengan.

fnutama(){
membiarkan usia: Rangkaian = Rangkaian::dari("lima tahun");
membiarkan umur = 5; // setara dengan umur biarkan: i32 = 5;
cetak!("{}", usia);
}

Program mendeklarasikan dua usia variabel sebelum mencetak dengan cetak! makro. Pertama usia variabel menentukan tipe data, dan yang kedua tidak.

Anda tidak perlu menentukan tipe data dari suatu variabel saat Anda mendeklarasikannya. Kompiler Rust menyimpulkan tipe dari tipe data nilai pada waktu kompilasi.

Anda juga dapat mendeklarasikan konstanta di Rust dengan const kata kunci dengan cara yang sama seperti mendeklarasikan variabel:

const usia: &str = "lima tahun";

Anda tidak dapat mengubah nilai variabel yang Anda nyatakan sebagai konstanta.

Rust menyediakan fungsionalitas untuk satu baris dan memblokir komentar. Anda dapat menggunakan garis miring ganda (//) untuk komentar baris tunggal:

fnutama() {
// Ini adalah komentar baris
membiarkan x = 5; // Komentar ini menjelaskan tujuan dari variabel `x`
}

Untuk komentar multi-baris (komentar blokir), gunakan garis miring diikuti dengan tanda bintang (/*) dan tutup blok dengan tanda bintang diikuti dengan garis miring (*/):

fnutama() {
/*
 Ini adalah komentar blok yang mencakup beberapa baris.
 Ini sering digunakan untuk menggambarkan blok kode yang lebih besar.
 */
membiarkan x = 5;
}

Komentar Anda harus singkat dan lugas.

Array di Rust

Array adalah kumpulan elemen berukuran tetap dari tipe data yang sama. Rust mengalokasikan array pada stack secara default.

Inilah cara Anda mendeklarasikan array di Rust:

fnutama() {
membiarkan angka = [1, 2, 3, 4, 5];
}

Itu angka array berisi lima item. Anda dapat mengakses nilai di suatu lokasi dalam array menggunakan indeksnya:

fnutama() {
membiarkan angka = [1, 2, 3, 4, 5];
membiarkan x = angka[3];
cetak!("{}", X)
}

Itu utama fungsi mencetak X variabel yang mengakses elemen keempat dari array.

Vektor di Rust

Rust menyediakan vektor untuk menutupi keterbatasan array. Vektor berukuran dinamis; mereka dapat tumbuh dan menyusut sesuai kebutuhan.

Inilah cara Anda mendeklarasikan vektor di Rust:

fnutama() {
membiarkan my_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
membiarkan x = my_vec[3];
cetak!("{}", X)
}

Itu my_vec vektor adalah vektor bilangan bulat 32-bit. Itu X variabel mengakses elemen keempat vektor, dan utama fungsi mencetak nilai ke konsol.

Pernyataan Bersyarat Rust

Pernyataan bersyarat adalah salah satunya Struktur kontrol karat untuk pengambilan keputusan dalam program. Anda dapat menggunakan jika Dan kalau tidak kata kunci untuk menangani keputusan dalam program Anda.

Ini dia jika pernyataan yang mencetak string ke konsol berdasarkan persamaan dua bilangan bulat.

fnutama() {
membiarkan A: i32 = 12;
jika a == 12 {
cetak!("a sama dengan dua belas");
 }
}

Itu utama fungsi mencetak string dengan cetak! makro karena variabel sama dengan 12.

Anda dapat menggunakan kalau tidak kata kunci untuk menangani kasus di mana jika pernyataan mengevaluasi salah:

fnutama() {
membiarkan A: i32 = 12;
jika a == 123 {
cetak!("a sama dengan dua belas");
 } kalau tidak {
cetak!("a tidak sama dengan dua belas");
 }
}

Dalam contoh ini, kalau tidak pernyataan berjalan karena nilai a tidak sama dengan 123.

Anda dapat mendeklarasikan pernyataan kecocokan dengan cocok kata kunci untuk persyaratan kompleks:

fnutama() {
membiarkan usia: i32 = 7;
cocok usia {
1 => cetak!("satu"),
2 => cetak!("dua"),
3 => cetak!("tiga"),
 _ => cetak!("nol"),
 }
}

Itu utama fungsi cocok dengan usia variabel untuk kasus di cocok pernyataan dan mengeksekusi ekspresi yang cocok dengan nilai. Garis bawah (_) adalah pernyataan default yang dijalankan jika ada kecocokan untuk nilainya.

Loop di Rust

Rust menyediakan loop untuk tugas berulang. Karat memiliki tiga jenis loop utama: lingkaran, ketika, Dan untuk loop.

Itu lingkaran kata kunci membuat loop tak terbatas yang berjalan hingga menemukan kata kunci break :

fnutama() {
lingkaran {
cetak!("dicetak berulang kali sampai pernyataan break ditemukan.");
merusak;
 }
}

Itu ketika loop berguna ketika Anda ingin mengulang blok kode selama kondisi bernilai true:

fnutama() {
membiarkanmut menghitung = 0;
ketika menghitung < 5 {
cetak!("Hitungannya adalah {}", menghitung);
 hitung += 1;
 }
}

A untuk loop bagus untuk mengulangi kumpulan item, seperti array:

fnutama() {
membiarkan angka = [1, 2, 3, 4, 5];
untuk barang di dalam angka.iter() {
cetak!("Item saat ini adalah {}", barang);
 }
}

Ini untuk loop berulang melalui angka array dan mencetak setiap item ke konsol.

Mendeklarasikan dan Memanggil Fungsi Rust

Menggunakan fn kata kunci ke mendeklarasikan fungsi Rust, diikuti dengan nama fungsi, daftar parameter, dan tipe kembalian (jika ada).

Inilah cara Anda mendeklarasikan fungsi dengan parameter dan tipe kembalian:

fnmenambahkan(A: i32, B: i32) -> i32 {
kembali a + b;
}

Itu menambahkan fungsi mengambil dua bilangan bulat 32-bit dan mengembalikan bilangan bulat 32-bit, jumlah dari dua parameter.

Untuk memanggil fungsi dari tempat lain di kode Anda, cukup tentukan nama dan argumen (jika ada):

fnutama() {
membiarkan hasil = tambah(2, 3);
cetak!("2 + 3 = {}", hasil);
}

Itu hasil variabel memegang hasil dari memanggil menambahkan fungsi. Itu utama fungsi mencetak hasilnya ke konsol menggunakan cetak! makro.

Struktur di Rust

Rust menyediakan struct untuk menentukan tipe data kustom yang mengelompokkan nilai terkait. Struct adalah cetak biru untuk membuat objek dengan properti tertentu.

Inilah cara Anda dapat mendeklarasikan sebuah struct:

structOrang {
 nama: Rangkaian,
 usia: u32,
 is_male: bool,
}

Itu Orang struct memiliki tiga bidang: String, bilangan bulat 32-bit yang tidak ditandatangani, dan boolean.

Setelah mendefinisikan sebuah struct, Anda dapat membuat turunannya di bagian lain dari program Anda:

fnutama() {
membiarkan orang1 = Orang {
 nama: Rangkaian::dari("Candace Flynn"),
 usia: 16,
 is_male: PALSU,
 };
}

Itu orang1 variabel adalah turunan dari Orang struct. Pada pembuatan instance, Anda dapat menetapkan nilai ke bidang struct. Anda dapat membuat instance struct sebanyak yang Anda mau.

Anda Dapat Mengimplementasikan Konsep OOP di Rust

Rust fleksibel, dan Anda dapat menerapkan konsep OOP di Rust dengan struktur data bawaan seperti struct.

Anda akan menggunakan struct sebagai alternatif untuk kelas. Dengan struct Rust, Anda dapat menentukan cetak biru untuk tipe dan mengimplementasikan konsep OOP yang berbeda dengan fungsionalitas yang disediakan Rust pada struct.