Trong phần này chúng ta sẽ tìm hiểu các thành phần cấu tạo nên một chương trình Rust.

Bình luận – Comment

Bình luận là các câu chữ chỉ có tác dụng giải thích code chứ không được biên dịch và chạy. Cú pháp bình luận trong Rust giống hoàn toàn với trong C:

• Bình luận 1 dòng: thêm dấu // vào trước dòng đó
• Bình luận nhiều dòng: bọc câu bình luận trong cặp dấu /* */

// Bình luận một dòng
fn main() {
/*
Bình luận
nhiều dòng
*/
println!("Hello world");
}

Ngoài ra Rust còn có cú pháp 3 dấu chéo /// dùng để bình luận theo dạng tài liệu, thường dùng khi số lượng câu bình luận rất lớn, có thể kéo theo thành các đoạn văn. Cách dùng cũng tương tự:

/// Bình luận tài liệu
fn main() {
// ..
}

Trình rustdoc của Rust có thể biên dịch các câu bình luận dạng tài liệu sang các dạng văn bản thường dùng.

Hằng số

Hằng số là các biến (chúng ta sẽ tìm hiểu về biến sau) chứa giá trị không thể thay đổi được. Chẳng hạn như tên chương trình, số PI…v.v Hằng có thể được truy xuất ở bất cứ đâu. Để khai báo một biến là hằng số thì chúng ta khai báo từ khóa static như sau:

static PI: f32 = 3.14;
static NAME: &’static str = "Constant";
fn main() {

}

Khi khai báo hằng, chúng ta nên đặt tên chúng viết HOA tất cả các kí tự, sau đó là dấu 2 chấm : và tên kiểu dữ liệu (chúng ta sẽ tìm hiểu kiểu dữ liệu sau), ở đây kiểu dữ liệu là f32 và str, rồi đến dấu bằng = và tiếp theo là giá trị (ở đây giá trị là 3.14 và "Constant")

Ở đây chúng ta chưa cần quan tâm đến đoạn &'static trong đoạn code trên, đây là cú pháp phải có trong Rust vì Rust là một ngôn ngữ lập trình cấp thấp, mọi thứ phải được khai báo rõ ràng. Ở đây mình chỉ giải thích đơn giản là &'static sẽ quy định cách Rust quản lý bộ nhớ cho hằng số đó.

Đoạn code trên sẽ biên dịch thành công nhưng Rust sẽ in một số câu thông báo với mục đích báo cho chúng ta biết là các hằng số được khai báo nhưng không được sử dụng ở bất kì chỗ nào, do đó gây lãng phí bộ nhớ:

warning: static item is never used: `PI`
...
warning: static item is never used: `NAME`
...

Ngoài từ khóa static thì chúng ta có thể dùng thêm từ khóa const nữa, chẳng hạn:

const PI: f32 = 3.14;

Điểm khác của const là các hằng số const có phạm vi truy xuất nhỏ hơn so với hằng số static.

Truyền giá trị vào chuỗi

Chúng ta có thể in giá trị của các hằng số bằng cách đặt bên trong các cặp dấu {} bên trong các chuỗi, các giá trị của hằng số sẽ được truyền vào các cặp dấu {} này. Ví dụ:

static PI: f32 = 3.14;
static NAME: &’static str = "Constant";
fn main() {
println!("Program Name: {}", NAME);
println!("PI = {}", PI);
}

Đoạn code trên sẽ cho ra kết quả như sau:

Program Name: Constant
PI = 3.14

Ngoài các hằng số mà chúng ta tự đặt, trong Rust cũng có rất nhiều hằng số nằm trong các thư viện có sẵn, trong đó có cả hằng số PI, để sử dụng hằng số PI của Rust thì chúng ta phải sử dụng bộ thư viện của Rust như sau:

use std::f32::consts;

static PI: f32 = 3.14;
static NAME: &’static str = "Constant";

fn main() {
println!("Program Name: {}", NAME);
println!("PI = {}", PI);
println!("Rust’s PI = {}", consts::PI);
}

Dòng use std::f32::consts; có nghĩa là chúng ta sử dụng module std::f32::consts, bên trong module này có một hằng số là PI, chúng ta gọi đến PI của module này bằng cách ghi consts::PI.

Chúng ta cũng có thể đặt tên trước cho các cặp dấu {} nếu trong hàm macro println!() có nhiều cặp dấu, ví dụ:

fn main() {
println!("Today is {month} {day}, {year}", year=2017, month="September", day=28);
}

Trong đoạn code trên, các cặp dấu {} sẽ lấy giá trị của các tham số có tên tương ứng, đoạn code sẽ cho kết quả như sau:

Today is September 28, 2017

Ngoài đặt tên cho các cặp dấu {} thì chúng ta có thể truyền vào một số từ khóa định dạng như sau:

static NUMBER_1: i32 = 2017;
static NUMBER_2: f32 = 1.234e+10;

fn main() {
println!("Octal: {:o}", NUMBER_1); // Hệ bát phân
println!("Lower Hexa: {:x}", NUMBER_1); // Hệ thập lục phân
println!("Upper Hexa: {:X}", NUMBER_1); // Hệ thập lục phân
println!("Pointer: {:p}", &NUMBER_1); // Địa chỉ con trỏ
println!("Binary: {:b}", NUMBER_1); // Hệ nhị phân
println!("Lower Exponential: {:e}", NUMBER_2); // Số mũ
println!("Upper Exponential: {:E}", NUMBER_2); // Số mũ
println!("Debugging: {:?}", NUMBER_1); // Giá trị
}

Chúng ta truyền vào dấu 2 chấm : kèm theo tên của kiểu định dạng.  Đoạn code trên sẽ in ra kết quả như sau:

Octal: 3741
Lower Hexa: 7e1
Upper Hexa: 7E1
Pointer: 0x7ff696fff300
Binary: 11111100001
Lower Exponential: 1.234e10
Upper Exponential: 1.234E10
Debugging: 2017