Bắt đầu

Hôm nay chúng ta sẽ học về cách khai báo biến, các kiểu dữ liệu cơ bản và hiểu rõ hơn macro println! trong Rust.

Nếu chưa cài Rust, các bạn có thể thử trên http://play.rust-lang.org/

Để xem các bài cũ (mới) hơn, các bạn có thể ghé qua:

• Github của @nicklauri
  hoặc
• https://dungph.github.io/learnrust/book/

Cách khai báo biến.

Để khai báo biến, chúng ta sử dụng từ khóa let trước tên biến.
Xem đoạn code kèm comment bên dưới:

fn main(){
	// khai báo biến a với kiểu dữ liệu i32
	let a:i32; 
	
	// khai báo biến b với kiểu dữ liệu i32 và giá trị là 10
	let b:i32 = 10; 
	
	// khai báo biến c với giá trị là 10 và kiểu dữ liệu được 
	// Rust compiler tự động xác định dựa vào giá trị. 
	let c = 10;  
}

Các biến mặc định là immutable (không thể thay đổi giá trị). Để có thể thay đổi giá trị biến chúng ta dùng từ khóa mut. Chi tiết xin đề cập đến ở bài sau.

Để in ra màn hình 1 biến chúng ta dùng print!("{}", <tên biến>); hoặc println!("{}", <tên biến>); Sẽ nói rõ hơn về chúng ở cuối bài.

fn main(){
	let a = 10;
	println!("{}", a);
}

output:

10

Giá trị và các kiểu dữ liệu cơ bản.

Trong Rust hay các ngôn ngữ lập trình khác, các giá trị tồn tại ở các kiểu khác nhau. Ví dụ: 70 là một số nguyên(integer), 3.14 là một số thực(float), z và A là các ký tự (kiểu char, hay character). Character là các giá trị thuộc bảng mã Unicode dài 4byte. Hello world là 1 chuỗi thuộc kiểu &str (Unicode UTF8 by default). true và false thuộc kiểu bool(Boolean).
Interger có thể được biểu diễn bằng các định dạng khác nhau:

• Thập lục phân (Hexadecimal) bắt đầu với 0x. Ví dụ: 0x32A cho 810.
• Bát phân (Octal) bắt đầu với 0o. Ví dụ: 0o1452 cho 810.
• Nhị phân (Binary) bắt đầu với 0b. Ví dụ: 0b1100101010 cho 810.

Dấu gạch dưới (Underscores) _ có thể được dùng cho dễ đọc, ví dụ 1_000_000 tương đương với 1000000.

Các kiểu dữ liệu số trong Rust gần giống trong Golang.
Ví dụ int32, uint32, int, uint và float32 trong Go tương đương với i32, u32, isize, usize và f32 trong Rust.

Kiểu số nguyên (Integer)

Kiểu số nguyên trong Rust được bắt đầu bằng i, u và phía sau là kích thước (tính bằng bit) của nó. Trong đó, i<n> nghĩa là kiểu số nguyên có dấu (Signed Integer) có khoảng giá trị từ -2^n-1 đến 2^n-1-1, u<n> là kiểu số nguyên không dấu (Unsigned Integer) có khoảng giá trị từ 0 đến 2ⁿ-1.

Dưới đây là các kiểu số nguyên trong Rust:

Ngoài ra, Rust còn có 2 kiểu số nguyên phụ thuộc vào kiến trúc hệ điều hành là isize (số nguyên có dấu) và usize (số nguyên không dấu). Chúng có kích thước 32 bit trong hệ thống 32 bit và 64 bit trong hệ thống 64 bit.

Kiểu số thực (Float)

Trong Rust có 2 kiểu số thực là f32 và f64 tương đương với kích thước 32 và 64 bit.
cách khai báo

fn main(){
	let a = 3; // a thuộc kiểu integer(i32 by default), không phải float
	let b = 3.0; // b thuộc kiểu float (f64 by default)
	let c:f32 = 3; // c thuộc kiểu float(f32)
}

Các phép toán

Rust hỗ trợ các phép toán cơ bản sử dụng cho tất cả các kiểu dữ liệu số: cộng (addition), trừ (subtraction), nhân (multiplication), chia (division) và chia lấy phần dư (remainder).
Ví dụ:

fn main() {
    // addition
    let sum = 5 + 10;
    println!("{}", sum); // 15

    // subtraction
    let difference = 95.5 - 4.3;
    println!("{}", difference); // 91.2
    
    // multiplication
    let product = 4 * 30;
    println!("{}", product); // 120
    
    // division
    let quotient = 56.7 / 32.2; // float number
    let quotient2 = 56 / 32; // integer number
    println!("{}", quotient); // 1.7608695652173911
    println!("{}", quotient2); // 1
    

    // remainder
    let remainder = 43 % 5;
    println!("{}", remainder); // 3
}

Kiểu luận lý (Boolean)

Giống trong hầu hết các ngôn ngữ lập trình, kiểu bool trong rust có 2 giá trị là true và false

fn main(){
	let a:bool = false; // khai báo `a` kiểu bool giá trị false
	let b = true; // rust compiler tự suy luận `b` thuộc kiểu bool
}

Kiểu kí tự (Character)

Kiểu char trong Rust được biểu diễn bên trong dấu nháy đơn ' là các ký tự thuộc bảng mã Unicode:

fn main(){
	let a = 'a';
	let b = '