Mọi thứ bạn cần biết để bắt đầu viết Rust
Kể từ khi phát hành vào năm 2015, Rust đã trở nên phổ biến như một trong những ngôn ngữ lập trình yêu thích của các nhà phát triển. Rust cung cấp các tính năng bảo mật và hiệu suất tuyệt vời với cú pháp trực quan và ngắn gọn khiến ngôn ngữ trở nên hấp dẫn.
Rust phù hợp để xây dựng các chương trình khác nhau, bao gồm ứng dụng web, công cụ dòng lệnh và dịch vụ mạng. Rust bao gồm nhiều tính năng mà bạn mong đợi từ một ngôn ngữ lập trình hiện đại, như đồng thời, suy luận kiểu, v.v.
Mục Lục
Bắt đầu với Rust
Rust là ngôn ngữ lập trình đa nền tảng chạy trên hầu hết các hệ điều hành. Để bắt đầu với Rust, hãy truy cập trang web chính thức của Rust và cài đặt phiên bản ưa thích cho hệ điều hành của bạn.
Khi bạn đã cài đặt Rust, bạn có thể bắt đầu viết chương trình trong các tệp Rust với một .rs sự mở rộng. Rust rất linh hoạt và dễ học. Bạn sẽ thấy nó đơn giản nếu bạn có kinh nghiệm lập trình trước đó.
Biến và hằng trong Rust
Rust có tính biểu cảm cao và có nhiều cách để khai báo biến. Bạn có thể dùng cho phép từ khóa để khai báo biến.
Đây là cách bạn có thể khai báo các biến trong Rust:
let a: String;
let b: i32;
let c: () = ();
Các Một Và b các biến lần lượt là một chuỗi và một số nguyên. Các c biến là một loại đơn vị Rust hoạt động như một trình giữ chỗ cho các hàm và biểu thức.
Sau khi khai báo kiểu dữ liệu tùy chọn, bạn có thể khai báo và khởi tạo biến với giá trị bằng dấu bằng.
fn main(){
let age: String = String::from("five years old"); let age = 5;
println!("{}", age);
}
Chương trình khai báo hai tuổi biến trước khi in với inln! vĩ mô. đầu tiên tuổi biến chỉ định loại dữ liệu và biến thứ hai thì không.
Bạn không cần phải chỉ định kiểu dữ liệu của một biến khi bạn khai báo nó. Trình biên dịch Rust suy ra kiểu từ kiểu dữ liệu của giá trị tại thời điểm biên dịch.
Bạn cũng có thể khai báo các hằng số trong Rust với hằng số từ khóa theo cách tương tự như khai báo biến:
const age: &str = "five years old";
Bạn không thể sửa đổi giá trị của biến mà bạn khai báo là hằng số.
Rust cung cấp chức năng cho các bình luận một dòng và khối. Bạn có thể sử dụng dấu gạch chéo kép (//) cho nhận xét một dòng:
fn main() {
let x = 5;
}
Đối với nhận xét nhiều dòng (chặn nhận xét), hãy sử dụng dấu gạch chéo lên trước và sau dấu hoa thị (/*) và đóng khối bằng dấu hoa thị theo sau là dấu gạch chéo về phía trước (*/):
fn main() {
This is a block comment that spans multiple lines.
It is often used to describe a larger block of code.
*/
let x = 5;
}
Nhận xét của bạn nên ngắn gọn và dễ hiểu.
Mảng trong Rust
Mảng là tập hợp các phần tử có cùng kiểu dữ liệu có kích thước cố định. Rust phân bổ các mảng trên ngăn xếp theo mặc định.
Đây là cách bạn có thể khai báo mảng trong Rust:
fn main() {
let numbers = [1, 2, 3, 4, 5];
}
Các con số mảng chứa năm mục. Bạn có thể truy cập giá trị tại một vị trí trong mảng bằng cách sử dụng chỉ mục của nó:
fn main() {
let numbers = [1, 2, 3, 4, 5];
let x = numbers[3];
println!("{}", x)
}
Các chủ yếu chức năng in x biến truy cập đến phần tử thứ tư của mảng.
Vector trong Rust
Rust cung cấp các vectơ để che đi những hạn chế của mảng. Các vectơ có kích thước động; chúng có thể phát triển và co lại khi cần thiết.
Đây là cách bạn có thể khai báo các vectơ trong Rust:
fn main() {
let my_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
let x = my_vec[3];
println!("{}", x)
}
Các my_vec vectơ là một vectơ của các số nguyên 32 bit. Các x biến truy cập phần tử thứ tư của vectơ và chủ yếu hàm in giá trị ra bàn điều khiển.
Tuyên bố có điều kiện của Rust
Câu lệnh điều kiện là một trong những cấu trúc điều khiển của Rust để ra quyết định trong chương trình. Bạn có thể dùng nếu như Và khác từ khóa để xử lý các quyết định trong chương trình của bạn.
Đây là một nếu như câu lệnh in một chuỗi ra bàn điều khiển dựa trên sự bằng nhau của hai số nguyên.
fn main() {
let a: i32 = 12; if a == 12 {
println!("a equals twelve");
}
}
Các chủ yếu chức năng in chuỗi với inln! macro vì biến bằng 12.
Bạn có thể dùng khác từ khóa để xử lý các trường hợp trong đó nếu như tuyên bố đánh giá sai:
fn main() {
let a: i32 = 12; if a == 123 {
println!("a equals twelve");
} else {
println!("a does not equal twelve");
}
}
Trong ví dụ này, các khác câu lệnh chạy vì giá trị của a không bằng 123.
Bạn có thể khai báo các câu lệnh đối sánh với cuộc thi đấu từ khóa cho các điều kiện phức tạp:
fn main() {
let age: i32 = 7; match age {
1 => println!("one"),
2 => println!("two"),
3 => println!("three"),
_ => println!("zero"),
}
}
Các chủ yếu chức năng phù hợp với tuổi biến đối với các trường hợp trong cuộc thi đấu câu lệnh và thực thi biểu thức khớp với giá trị. Dấu gạch dưới (_) là câu lệnh mặc định sẽ chạy nếu có giá trị khớp.
Vòng lặp trong Rust
Rust cung cấp các vòng lặp cho các tác vụ lặp đi lặp lại. Rust có ba loại vòng lặp chính: vòng, trong khiVà vì vòng lặp.
Các vòng từ khóa tạo một vòng lặp vô hạn chạy cho đến khi gặp từ khóa break:
fn main() {
loop {
println!("printed repeatedly until break statement is encountered.");
break;
}
}
Các trong khi vòng lặp rất hữu ích khi bạn muốn lặp lại một khối mã miễn là một điều kiện được đánh giá là đúng:
fn main() {
let mut count = 0; while count < 5 {
println!("The count is {}", count);
count += 1;
}
}
MỘT vì vòng lặp phù hợp để lặp qua một tập hợp các mục, chẳng hạn như một mảng:
fn main() {
let numbers = [1, 2, 3, 4, 5]; for item in numbers.iter() {
println!("The current item is {}", item);
}
}
Cái này vì vòng lặp lặp qua con số mảng và in từng mục ra bàn điều khiển.
Khai báo và gọi các hàm Rust
Sử dụng fn từ khóa để khai báo hàm Rust, theo sau là tên hàm, danh sách các tham số và kiểu trả về (nếu có).
Đây là cách bạn có thể khai báo một hàm với các tham số và kiểu trả về:
fn add(a: i32, b: i32) -> i32 {
return a + b;
}
Các thêm vào hàm nhận hai số nguyên 32 bit và trả về một số nguyên 32 bit, tổng của hai tham số.
Để gọi một hàm từ nơi khác trong mã của bạn, chỉ cần chỉ định tên và đối số (nếu có):
fn main() {
let result = add(2, 3);
println!("2 + 3 = {}", result);
}
Các kết quả biến giữ kết quả từ việc gọi thêm vào chức năng. Các chủ yếu chức năng in kết quả ra bàn điều khiển bằng cách sử dụng inln! vĩ mô.
Cấu trúc trong Rust
Rust cung cấp các cấu trúc để xác định các loại dữ liệu tùy chỉnh nhóm các giá trị liên quan. Cấu trúc là bản thiết kế để tạo đối tượng với các thuộc tính cụ thể.
Đây là cách bạn có thể khai báo một cấu trúc:
struct Person {
name: String,
age: u32,
is_male: bool,
}
Các Người struct có ba trường: Chuỗi, số nguyên 32 bit không dấu và boolean.
Sau khi xác định cấu trúc, bạn có thể tạo các phiên bản của cấu trúc đó trong các phần khác của chương trình:
fn main() {
let person1 = Person {
name: String::from("Candace Flynn"),
age: 16,
is_male: false,
};
}
Các người1 biến là một thể hiện của Người cấu trúc. Khi khởi tạo, bạn có thể gán giá trị cho các trường cấu trúc. Bạn có thể tạo bao nhiêu phiên bản của cấu trúc tùy thích.
Bạn có thể triển khai các khái niệm OOP trong Rust
Rust rất linh hoạt và bạn có thể triển khai các khái niệm OOP trong Rust bằng các cấu trúc dữ liệu tích hợp như cấu trúc.
Bạn sẽ sử dụng các cấu trúc thay thế cho các lớp. Với cấu trúc của Rust, bạn có thể xác định bản thiết kế cho loại và triển khai các khái niệm OOP khác nhau với các chức năng mà Rust cung cấp trên cấu trúc.