0x03 – Rust Concept

Biến – Tính thay đổi

Mặc định khi tạo một biến, biến đó không thể được thay đổi giá trị.

Để tạo một biến có thể thay đổi được giá trị, hãy làm như sau:

fn main() {
    let mut x = 5;
}

Khác nhau giữa biến và hằng số

Hằng số luôn luôn không thể thay đổi giá trị, do đó từ khóa mut sẽ không dùng được trong trường hợp này.

Khi khai báo một hằng số, sữ dụng từ khóa const và phải luôn luôn khai báo kiểu dữ liệu.

const PI: f32 = 3.141592654;

Shadowing

Khi tạo ra một biến, sau đó tiếp tục khai báo một biến trùng với tên biến vừa rồi, thì ta gọi biến thứ nhất shadow biến thứ hai.

Khi truy cập tên biến, giá trị của biến sẽ là giá trị sau cùng nó được định nghĩa, trong trường hợp này là biến thứ hai.

fn main() {
    let x = 10;
    println!("Before shadow, x = {}", x);
    
    let x = 5;
    println!("After shadow, x = {}", x);
    
}

Kết quả khi thực thi sẽ là

Before shadow, x = 10
After shadow, x = 5

Note: Khi định nghĩa lại biến sau lần thứ nhất, nếu kiểu dữ liệu của hai lần khác nhau, sẽ có lỗi khi compile.

Kiểu dữ liệu

Mỗi giá trị trong Rust có một kiểu dữ liệu.

Kiểu vô hướng (scalar types)

Rust cung cấp 4 kiểu dữ liệu vô hướng, đó là số nguyên, số thập phân, chữ cái và boolean

Số nguyên

Độ dài dữ liệu cho số nguyên sẽ được định nghĩa dựa vào bảng dưới đây

Độ dài arch sẽ do hệ điều hành quyết định, phụ thuộc vào kiến trúc 32bit hay 64bit.

Note: Biểu thị số nguyên có thể ỡ các dạng khác, như 0u8 hoặc có thêm các dấu ngăn cách như 1_000_000 (1000000 == 1_000_000)

Ngoài ra, kiểu số nguyên còn có thể được định nghĩa thông qua cách sau

Cách dùng sẽ là

let x: u8 = 50;
let y: i16 = 1_024;

Note: Kiểu dữ liệu mặc định là i32, và cho tốc độ nhanh nhất.

Số thập phân

Cách dùng sẽ là

let x: f32 = 10.4;
let y: f64 = 543.21;

Note: Kiểu dữ liệu mặc định là f64

Kiểu boolean

Kiểu boolean sẽ chứa một giá trị true hoặc false.

let a: bool = true;

Kiểu ký tự

Trong Rust, các kiểu ký tự là một biểu thị của Unicode Scalar Value.

Do đó, kiểu ký tự có thể đại diện cho các ký tự nhiều hơn so với ASCII.

Ví dụ

let china_char      = "火";
let japan_char      = "の";
let emoji_char      = "🥳";

Kiểu dữ liệu hỗn hợp (Compound Types)

Compound Type là một nhóm các dữ liệu có kiểu khác nhau. Rust có hai dạng compound: tuples và array.

Tuple Type

Tuple là một tập hợp các giá trị với da đang các kiểu dữ liệu.

Note: Kiểu tuple không thể mở rộng hay giảm bớt phần tử.

Ví dụ khi khai báo một tuple

fn main() {
    let my_tuple: (i32, f64, u32) = (150, 25.8, 344);
}

Hoặc không cần khai báo kiểu dữ liệu, Rust sẽ tự động lấy ra kiểu dữ liệu dựa vào giá trị.

fn main() {
    let my_tuple = (250, 3.1416, "A");
    
    // Get value from tuple
    let (x, y, z) = my_tuple;

    println!("x = {}, y = {}, z ={}", x, y, z);
}

Một cách khác để có thể lấy giá trị từ tuple đó là sử dụng một dấu chấm (.) theo sau là index của giá trị cần lấy.

Ví dụ như sau

fn main() {
    let my_tuple = (250, 3.1416, "A");
    
    // Get value from tuple
    let x = my_tuple.0;
    let y = my_tuple.1;
    let z = my_tuple.2;

    println!("x = {}, y = {}, z ={}", x, y, z);
}

Kiểu Mảng (Array)

Một dạng khác của tập hợp các giá trị là mảng.

Một mảng chỉ chứa các phần tử có cùng kiểu dữ liệu.

fn main() {
   let my_array = [1,2,3,4,5];
   let names = ["James", "CodeChoVui", "Kunix"]; 
}

Khai báo một mảng với giá trị và size

fn main() {
    // Create an array of i32 data type with size of 5.
    let arr: [i32; 5] = [1,2,3,4,5];
}

Khai báo một mảng với các phần tử giống nhau

fn main() {
    // Create an array with 10 values of 2.
    let arr = [2; 10];
    // the same as arr = [2,2,2,2,2,2,2,2,2,2];
}

Truy cập giá trị của một mảng.

fn main() {
    let arr = ["Sun", "Earth", "Moon"];
    
    let the_sun = arr[0];
    let the_moon = arr[2];
    
    println!("{} and {}", the_sun, the_moon);
}
// Output: Sun and Moon

Note: Nếu truy cập index vượt qua số lượng của mảng, sẽ xảy ra lỗi index out of bounds khi run time.