Nhóm cộng đồng Rust Việt Nam

FB: https://www.facebook.com/groups/546307380433651

Telegram: https://t.me/rust_vn

Nếu có bất gì ý kiến hoặc đóng góp xin gửi đến thùng thư:

Tuan Phung [email protected]

Rất mong nhận được sự đóng góp của cộng đồng để mọi ngôn ngữ Rust trở nên phổ cập hơn và là nguồn tài liệu bổ ích cho những người đã và sẽ yêu thích ngôn ngữ này.

Ngôn ngữ lập trình Rust

Steve Klabnik và Carol Nichols, cùng với sự đóng góp của cộng đồng Rust

Phiên bản của tài liệu sử dụng với Rust 1.59 (ngày ra mắt 2022-02-24) trở lên. Xem phần “Installation” của Chương 1 để cài đặt hoặc cập nhật Rust.

Tài liệu định dạng HTML trực tuyến có sẵn tại https://doc.rust-lang.org/stable/book/ và ngoại tuyến với các bản cài đặt của Rust được thực hiện bởi rustup; chạy câu lệnh rustup docs --book để mở.

Những bản dịch với một số ngôn ngữ có sẵn.

Tài liệu này có sẵn ở paperback and ebook format from No Starch Press.

Lời tựa

Rust không phải là ngôn ngữ quá tường minh và dễ học đối với người mới, nhưng về cơ bản nó sẽ trao quyền - tạo cảm giác làm chủ ngôn ngữ cho người sử dụng: bất kể bạn đang lập trình ngôn ngữ nào hiện tại, Rust sẽ cho phép bạn vươn xa hơn, tự tin lập trình trong nhiều lĩnh vực rộng hơn so với những gì bạn làm trước đây.

Lấy ví dụ đối với lập trình hệ thống, làm việc với ngôn ngữ lập trình bậc thấp trong việc quản lý bộ nhớ, biểu diễn dữ liệu, lập trình song song và đồng thời. Theo truyền thống, lĩnh vực lập trình này được coi là phức tạp, chỉ một số ít người với trình độ chuyên môn cao cùng với đó là sự tận tâm dành nhiều năm nghiên cứu mới tránh được những rủi ro nguy hiểm mà nó đem lại. Và ngay cả với những người học, tiếp cận với nó cũng phải làm việc hết sức thận trọng nếu không mã nguồn của họ có thể dễ dàng bị khai thác, làm hỏng hóc hay phá hủy hệ thống.

Rust phá vỡ những rào cản này bằng việc loại bỏ những rủi ro cũ và cung cấp một bộ công cụ thân thiện, được cải thiện hàng giờ để giúp bạn trong suốt quá trình sử dụng. Các lập trình viên cần đi sâu vào kiểm soát hệ thống cũng có thể làm đối với Rust mà không phải chịu những rủi ro thông thường về sự cố hỏng chương trình, lỗ hổng bảo mật, ... Hơn thế nữa, Rust được thiết kế để hướng dẫn bạn một cách tự nhiên, hiệu quả với mã nguồn đáng tin cậy, hiệu quả về tốc độ và sử dụng bộ nhớ.

Những lập trình viên đã và đang làm việc thuần thục với ngôn ngữ lập trình cấp thấp có thể sử dụng Rust để nâng cao hiệu quả làm việc của họ. Ví dụ đối với lập trình song song (parallelism) trong Rust là công việc rủi ro tương đối thấp: trình biên dịch sẽ bắt các lỗi cổ điển cho bạn. Do đó bạn có thể tối ưu hóa mã nguồn của mình và tự tin rằng sẽ không vô tình tạo ra những sự cố hay lỗ hổng bảo mật mới.

Nhưng Rust không giới hạn trong việc lập trình hệ thống ở mức thấp. Nó đủ đủ khả năng và sự tiện dụng để viết các ứng dụng CLI, máy chủ web và nhiều loại mã thông dụng khác - bạn sẽ tìm thấy trong các ví dụ trong phần sau của cuốn sách. Làm việc với Rust cho phép bạn xây dựng các kỹ năng chuyển đổi giữa các nền tảng; bạn có thể học Rust bằng cách viết một ứng dụng web, sau đó áp dụng các kỹ năng tương tự đó để phát triển tiếp các mục tiêu của bạn.

Cuốn sách này khai thác toàn bộ tiềm năng của Rust để trao quyền kiểm soát và sử dụng cho người dùng. Đây là một tài liệu thân thiện và dễ hiểu, dễ học nhằm giúp bạn nâng cao không chỉ kiến thức về Rust mà còn là về khả năng tiếp cận và sự tự tin của bạn với tư cách là là một lập trình viên nói chung. Vì vậy, hãy tham gia, sẵn sàng học hỏi - và chào mừng bạn đến với cộng đồng Rust!

— Nicholas Matsakis và Aaron Turon

Giới thiệu

Note: This edition of the book is the same as The Rust Programming Language available in print and ebook format from No Starch Press.

Chào mừng bạn đến với The Rust Programming Language, một cuốn sách giới thiệu về Rust. Ngôn ngữ lập trình Rust giúp bạn viết phần mềm nhanh hơn, đáng tin cậy hơn. High-level ergonomics(Thiết kế tối ưu mức cao) and low-level control(Điều khiển mức thấp) thường mâu thuẫn nhau trong thiết kế ngôn ngữ lập trình; Rust thách thức xung đột đó. Thông qua việc cân bằng giữa năng lực kỹ thuật mạnh mẽ và kinh nghiệm tuyệt vời của nhà phát triển, Rust cho bạn tùy chọn để kiểm soát các chi tiết cấp thấp (chẳng hạn như sử dụng bộ nhớ) mà không gặp phải mọi rắc rối truyền thống liên quan đến việc kiểm soát như vậy.

Rust dành cho đối tượng nào ?

Rust là phù hợp cho nhiều mục đích lập trình khác nhau và cho nhiều nhóm đối tượng Hãy xem xét một số nhóm đối tượng chính:

Nhóm các developer

Rust đang chứng tỏ là một công cụ hiệu quả để cộng tác giữa các nhóm developer lớn với các cấp độ khác nhau về kiến thức lập trình hệ thống. Code cấp thấp dễ mắc phải nhiều bugs tinh vi, mà ở hầu hết các ngôn ngữ khác chỉ có thể gặp phải thông qua thử nghiệm rộng rãi và xem xét code cẩn thận những developer có kinh nghiệm. Trong Rust, trình biên dịch đóng vai trò người gác cổng bằng cách từ chối biên dịch code với các bugs khó nắm bắt này, bao gồm các bug đồng thời. Bằng cách làm việc cùng với trình biên dịch, nhóm có thể dành thời gian tập trung vào logic của chương trình hơn là tìm kiếm các bug.

Rust cũng mang các công cụ dành cho nhà phát triển vào thế giới lập trình hệ thống:

• Cargo, công cụ bao gồm việc xây dựng và quản lý dependency, giúp việc thêm, biên dịch và quản lý các dependency trở nên dễ dàng và nhất quán trên toàn bộ hệ sinh thái Rust.
• Rustfmt đảm bảo coding style nhất quán giữa các developer.
• Máy chủ Ngôn ngữ Rust hỗ trợ tích hợp Môi trường Phát triển Tích hợp (Integrated Development Environment, IDE) cho việc hoàn thiện code và thông báo lỗi nội tuyến.

Bằng cách sử dụng những công cụ này và các công cụ khác trong hệ sinh thái Rust, các developer có thể làm việc hiệu quả trong khi viết code cấp hệ thống.

Sinh viên

Rust dành cho sinh viên, những người mà quan tâm tìm hiểu các khái niệm hệ thống. Sử dụng Rust, nhiều người đã học về các chủ đề như phát triển hệ điều hành. Cộng đồng rất hoan nghênh và sẵn lòng trả lời các câu hỏi của các bạn sinh viên. Thông qua những nỗ lực chẳng hạn như quyển sách này, nhóm Rust muốn làm cho các khái niệm hệ thống trở trên dễ tiếp cận hơn với nhiều người, đặc biệt nhất là những người mới lập trình.

Các công ty

Hàng trăm công ty, lớn và nhỏ, sử dụng Rust trong sản xuất cho nhiều nhiệm vụ khác nhau. Những tác vụ đó bao gồm công cụ dòng lệnh, dịch vụ web, DevOps tooling, thiết bị nhúng, phân tích và chuyển mã âm thanh và video, tiền điện tử, bioinformatics, công cụ tìm kiếm, các ứng dụng Internet of Things, machine learning, và thậm chí các phần chính của trình duyệt Firefox.

Các developer mã nguồn mở

Rust dành cho những người muốn xây dựng ngôn ngữ lập trình Rust, cộng đồng, công cụ nhà phát triển, và các thư viện. Chúng tôi muốn bạn đóng góp cho ngôn ngữ Rust.

Những người coi trọng tốc độ và sự ổn định

Rust dành cho những ai khao khát tốc độ và sự ổn định trong một ngôn ngữ. Với tốc độ, chúng tôi muốn nói đến tốc độ của chương trình mà bạn có thể tạo ra bằng Rust và tốc độ mà Rust cho phép bạn viết chúng. Các kiểm tra của trình biên dịch Rust đảm bảo tính ổn định thông qua việc bổ sung tính năng và tái cấu trúc. Điều này trái ngược với the brittle legacy code trong các ngôn ngữ không có các kiểm tra này, mà các developer thường e ngại sửa đổi. Bằng cách cố gắng tạo ra các tính năng cấp cao hơn, trừu tượng không tốn chi phí có thể biên dịch thành code cấp thấp hơn nhanh như code được viết thủ công, Rust cũng nỗ lực làm cho code an toàn trở thành code nhanh.

Ngôn ngữ Rust cũng hi vọng sẽ hỗ trợ nhiều người dùng khác; những người được đề cập ở đây chỉ là một số bên liên quan lớn nhất. Nhìn chung, tham vọng lớn nhất của Rust là loại bỏ những đánh đổi mà các lập trình viên đã chấp nhận trong hàng thập kỷ bằng cách cung cấp sự an toàn và năng suất, tốc độ và ergonomics. Hãy thử Rust và xem liệu các lựa chọn của nó có phù hợp với bạn không.

Cuốn sách này dành cho ai

Cuốn sách này giả định bạn đã viết code bằng một ngôn ngữ lập trình khác nhưng không đưa ra bất kỳ giả định nào về ngôn ngữ lập trình đó là ngôn ngữ nào. Chúng tôi đã cố gắng làm cho tài liệu có thể tiếp cận rộng rãi với những người từ nhiều nền tảng lập trình khác nhau. Chúng tôi không dành nhiều thời gian nói về lập trình là gì hoặc cảm nghĩ về nó. Nếu bạn là hoàn toàn mới về lập trình, bạn sẽ được phục vụ tốt hơn bằng cách đọc một quyển sách giới thiệu cụ thể về lập trình.

Làm thế nào để sử dụng cuốn sách này

Nói chung, cuốn sách này giả định bạn đang đọc nó theo thứ tự từ trước đến sau. Các chương sau xây dựng dựa trên các khái niệm trong các chương trước đó và các chương trước đó có thể không đi sâu vào chi tiết một chủ đề, chúng ta thường xem lại chủ đều trong chương sau.

Bạn sẽ tìm thấy hai loại chương trong quyển sách này: các chương về khái niệm và các chương dự án. Trong các chương khái niệm, bạn sẽ tìm hiểu về một khía cạnh của Rust. Trong các chương dự án, chúng ta sẽ xây dựng các chương trình nhỏ cùng nhau, áp dụng những gì bạn đã được học cho đến nay. Các chương 2, 12 và 20 là các chương về dự án; phần còn lại là các chương về khái niệm.

Chương 1 giải thích cách cài đặt Rust, cách viết chương trình “Hello, world!” và cách sử dụng Cargo, công cụ xây dựng và quản lý package của Rust. Chương 2 là phần giới thiệu thực tế về ngôn ngữ Rust. Ở đây chúng ta đề cập các khái niệm ở cấp độ cao và các chương sau sẽ cung cấp thêm chi tiết. Nếu bạn muốn bẩn tay ngay lập tức, Chương 2 chính là nơi dành cho điều đó. Lúc đầu, bạn thậm chí sẽ muốn bỏ qua Chương 3, bao gồm các tính năng Rust tương tự như các ngôn ngữ lập trình khác và đi thẳng tới Chương 4 để tìm hiểu về hệ thống quyền sở hữu (ownership) của Rust. Tuy nhiên, nếu bạn là một người học đặc biệt tỉ mỉ, thích tìm hiểu mọi chi tiết trước khi chuyển qua phần tiếp theo, bạn có thể bỏ qua Chương 2 và đi thẳng đến Chương 3, trở lại Chương 2 khi bạn muốn làm việc trên một dự án ứng dụng những chi tiết bạn đã được học.

Chương 5 thảo luận về structs và phương thức, và Chương 6 nói về enums, biểu thức match, và cấu trúc control flow if let. Bạn sẽ sử dụng structs và enums để tạo ra các kiểu tùy chọn trong Rust.

Trong Chương 7, bạn sẽ tìm hiểu về hệ thống module của Rust và về các nguyên tắc bảo mật để tổ chức code của bạn và Giao diện Lập trình Ứng dụng (Application Programming Interface, API) công khai của nó. Chương 8 thảo luận về một số cấu trúc dữ liệu collection phổ biến mà thư viện chuẩn cung cấp, như vectors, strings, và hash maps. Chương 9 khám phá triết lý và kỹ thuật xử lý error của Rust.

Chương 10 đào sâu vào generics, traits, và lifetimes, cung cấp cho bạn sức mạnh để định nghĩa code ứng dụng cho nhiều loại dữ liệu. Chương 11 nói về testing, mà ngay cả với các đảm bảo an toàn của Rust cần thiết để đảm bảo logic chương trình của bạn là chính xác. Trong Chương 12, chúng ta sẽ xây dựng cách triển khai của riêng mình với một nhóm chức năng từ công cụ dòng lệnh grep tìm kiếm đoạn text trong file. Đối với điều này, chúng ta sẽ sử dụng các khái niệm mà chúng ta đã thảo luận trong các chương trước.

Chương 13 khám phá về closures và iterators: các tính năng của Rust đến từ ngôn ngữ lập trình chức năng. Trong Chương 14, chúng ta sẽ xem xét Cargo sâu hơn và nói về các phương pháp hay nhất để chia sẻ thư viện của bạn với những người khác. Chương 15 thảo luận về smart pointers mà thư viện chuẩn cung cấp và traits để kích hoạt chức năng của chúng.

Trong Chương 16, chúng ta sẽ đi qua các mô hình lập trình đồng thời khác nhau và nói về cách Rust giúp bạn lập trình đa luồng một cách dễ dàng. Chương 17 xem xét cách Rust idioms so sánh với các nguyên tắc lập trình hướng đối tượng mà bạn có thể quen thuộc.

Chương 18 là tài liệu tham khảo về patterns và pattern matching, đây là các cách mạnh mẽ thể hiện ý tưởng trong suốt chương trình Rust. Chương 19 chứa một loạt các chủ đề nâng cao được quan tâm, bao gồm Rust không an toàn, macros, và nhiều hơn nữa về lifetimes, traits, types, functions và closures.

Trong Chương 20, chúng ta sẽ hoàn thành một dự án trong đó chúng ta sẽ triển khai một máy chủ web đa luồng cấp thấp!

Cuối cùng, một số phụ lục chứa thông tin hữu ích về ngôn ngữ trong một định dạng giống như tham khảo hơn. Phụ lục A bao gồm các từ khóa của Rust, Phụ lục B bao gồm các toán tử và ký hiệu của Rust, Phụ lục C bao gồm các derivable traits được cung cấp bởi thư viện chuẩn, Phụ lục D bao gồm một số công cụ phát triển hữu ích và Phụ lục E giải thích các phiên bản Rust.

Mọi phương pháp đọc cuốn sách này đều đúng: nếu bạn muốn bỏ qua chương nào đó, hãy làm điều đó. Bạn có thể phải quay lại các chương trước đó nếu bạn gặp bất kỳ sự khó hiểu nào. Nhưng hãy làm bất cứ điều gì có ích cho bạn.

Một phần quan trọng của quá trình học Rust là học cách đọc thông báo lỗi mà trình biên dịch hiển thị: chúng sẽ hướng dẫn bạn cách làm việc với code. Do đó, chúng tôi sẽ cung cấp nhiều ví dụ minh họa không biên dịch cùng với thông báo lỗi mà trình biên dịch sẽ hiển thị cho bạn trong mỗi tình huống. Biết rằng nếu bạn nhập và chạy một ví dụ ngẫu nhiên, nó có thể sẽ không biên dịch! Đảm bảo rằng bạn đọc đoạn text xung quanh để xem liệu ví dụ bạn đang cố chạy có bị lỗi hay không. Ferris cũng sẽ giúp bạn phân biệt code không hoạt động:

Ferris	Meaning
	This code does not compile!
	This code panics!
	This code does not produce the desired behavior.

Trong hầu hết các tình huống, chúng tôi sẽ dẫn bạn đến phiên bản chính xác của bất kỳ đoạn code nào không biên dịch được.

Source Code

Bạn có thể tìm thấy các file nguồn mà cuốn sách này được tạo nên trên GitHub.

[]

Thuật ngữ

Chương này không có trong Rust book. Mình tạo ra để mô tả các thuật ngữ để tiện tra cứu:

Bắt đầu

Bắt đầu hành trình vào thế giới của Rust Trong chương này chúng ta sẽ nói về:

• Cài đặt Rust trên Linux, macOs và Windows
• Viết chương trình Hello world bằng Rust
• Sử dụng cargo - hệ thống build và quản lý thư viện của Rust

Cài đặt

Đầu tiên chúng ta phải cài Rust. Cách cài đặt đơn giản là sử dụng rustup - Command line tool quản lý phiên bản Rust và các công cụ liên quan.

Note: Nếu bạn không muốn dùng rustup, hãy truy cập Other Rust Installation Methods page để có xem các lựa chọn khác.

Các bước sau cài phiên bản ổn định mới nhất của trình biên dịch Rust (Rust compiler). Phiên bản ổn định của Rust đảm bảo các ví dụ trong sách có thể biên dịch với phiên bản Rust mới hơn. Tuy nhiên ouput có thể khác 1 chút giữa các phiên bản, bởi vì Rust thường xuyên cải thiện các message lỗi và cảnh báo.

Cài đặt rustup trên Linux và macOS

Nếu bạn đang sử dụng Linux hay macOs, mở terminal và nhập lệnh sau

$ curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

Câu lệnh trên sẽ tải 1 đoạn script và bắt đầu cài đặt rustup, nó cài đặt phiên bản ổn định và mới nhất của Rust. Nếu cài đặt thành công, terminal sẽ hiển thị:

Rust is installed now. Great!

Bạn cũng sẽ cần một linker - một chương trình Rust dùng để ghi complied outputs vào 1 file. Nếu bạn gặp linker errors, bạn nên cài C compiler (đã bao gồm linker). Bên cạnh đó, một số Rust packages được viết bằng ngôn ngữ C và cần C compiler để biên dịch

Trên macOS, bạn có thể cài C compiler bằng lệnh sau:

$ xcode-select --install

Người dùng linux nên cài GCC hoặc Clang

Cài đặt rustup trên Windows

Trên Windows, truy cập https://www.rust-lang.org/tools/install và làm theo hướng dẫn để cài Rust. Bạn cũng sẽ cần C++ build tools cho Visual Studio 2013 hoặc mới hơn. Cách dễ nhất là cài Build Tools for Visual Studio 2019. Hãy đảm bảo “C++ build tools” được chọn.

Cập nhật và gỡ cài đặt

Sau khi cài Rust bằng rustup, bạn có thể cập nhật phiên bản mới nhất bằng lệnh:

$ rustup update

Để gỡ cài đặt Rust và rustup, chạy dòng lệnh:

$ rustup self uninstall

Xử lý sự cố (Troubleshouting)

Để kiểm tra bạn đã cài đặt Rust đúng chưa:

$ rustc --version

Bạn sẽ thấy phiên bản, commit hash, và ngày commit cho phiên bản bạn đã cài đặt

rustc x.y.z (abcabcabc yyyy-mm-dd)

Nếu bạn thấy thông tin trên, bạn đã cài đặt Rust thành công! Nếu không thấy trên Window, hãy kiểm tra Rust đã được thêm trong %PATH% ở system variable hay chưa. Nếu gặp lỗi hãy tham gia nhóm facebook Cộng đồng Rust Việt Nam. Mọi người sẽ nhiệt tình giúp đỡ

Hello, World!

Sau khi cài đặt Rust, hãy viết chương trình Rust đầu tiên hiển thị Hello, world!

Tạo một chương trình - Thư mục chương trình

Bạn sẽ bắt đầu bằng tạo một thư mục để lưu trữ Rust code. Bạn có thể lưu trữ nó ở bất kì đâu, tuy nhiên cho các bài tập trong sách này, bạn nên để đường dẫn ở thư mục home.

Mở terminal và nhập những lệnh sau để tạo thư mục projects và thư mục “Hello, world!” bên trong thư mục projects

Với Linux, macOS, và PowerShell trên Windows:

$ mkdir ~/projects
$ cd ~/projects
$ mkdir hello_world
$ cd hello_world

Với Windows CMD:

> mkdir "%USERPROFILE%\projects"
> cd /d "%USERPROFILE%\projects"
> mkdir hello_world
> cd hello_world

Viết và chạy một chương trình Rust

Tiếp theo, tạo một file tên main.rs. Rust file luôn kết thúc với đuôi .rs. Nếu có hai từ trong tên file, hãy thêm dấu gạch dưới để tách nó. Ví dụ, dùng hello_world.rs thay vì helloworld.rs.

Bây giờ mở file main.rs và nhập đoạn code ở Mục 1-1.

Filename: main.rs

fn main() {
    println!("Hello, world!");
}

Mục 1-1: Chương trình in ra Hello, world!

Lưu file và mở terminal. Trên Linux hoặc macOS, nhập lệnh sau để chạy file:

$ rustc main.rs
$ ./main
Hello, world!

Trên Windows, nhập lệnh .\main.exe thay vì ./main:

> rustc main.rs
> .\main.exe
Hello, world!

Dòng Hello, world! sẽ được in ra ở terminal. Nếu bạn không thấy hãy tham gia nhóm facebook Cộng đồng Rust Việt Nam để được mọi người giúp đỡ.

Phân tích một chương trình Rust

Hãy xem lại chi tiết chương trình “Hello, world!”. Đây là phần đầu tiên:

fn main() {

}

Dòng code khai báo một hàm trong Rust. Hàm main là hàm đặc biệt: nó luôn là đoạn code chạy đầu tiên trong tất cả chương trình Rust. Dòng đầu khai báo một hàm tên main, nó không có tham số truyền vào và không trả về giá trị. Nếu có tham số truyền vào, hãy đặt nó trong ().

Thân hàm được viết trong cặp ngoặc {}. Bạn nên đặt dấu mở ngoặc trên cùng dòng với tên hàm và có dấu cách ở giữa

Nếu bạn muốn format code theo phong cách chuẩn, bạn có thể sử dụng tool format code rustfmt. Tool này đã được cài đặt cùng với rustc.

Trong hàm main có dòng code:

#![allow(unused)]
fn main() {
    println!("Hello, world!");
}

Dòng này in ra một đoạn text trên màn hình. Có 4 điều cần lưu ý:

Thứ nhất, Rust style là thụt lề với bốn dấu cách, không phải là một tab

Thứ hai, println! gọi một Rust macro. Nếu gọi một hàm sẽ là println (không có !). Chúng ta sẽ bàn luận chi tiết về Rust macros trong Chương 19. Bây giờ, bạn chỉ cần biết là sử dụng ! nghĩa là bạn đang gọi một macro thay vì một hàm thông thường.

Thứ ba, bạn thấy chuỗi kí tự "Hello, world!". Chúng ta sẽ truyền chuỗi này như một tham số vào macro println!, và đoạn kí tự sẽ được in ra màn hình.

Thứ tư, chúng ta kết thúc dòng với dấu chấm phẩy (;), nó chỉ ra một expression kết thúc. Hầu hết các dòng code Rust đều kết thúc với dấu chấm phẩy

Biên dịch và Chạy chương trình là hai bước riêng

Bạn vừa mới chạy một chương trình vừa tạo, hãy xem từng bước

Trước khi chạy một chương trình Rust, bạn phải biên dịch bằng Rust compiler với lệnh rustc. Ví dụ:

$ rustc main.rs

Sau khi biên dịch thành công, Rust sinh ra một file binary có thể thực thi

Trên Linux, macOS, và PowerShell trên Windows, bạn có thể thấy file bằng lệnh ls.

Trên Linux và macOS, bạn sẽ thấy 2 file:

$ ls
main  main.rs

Trên Windows bạn sẽ thấy 3 files:

> dir
main.exe
main.pdb
main.rs

Nó bao gồm file source với đuôi .rs, file thực thi(main.exe trên Windows, main trên Linux và MacOS). Và khi sử dụng Windows, có thêm một file bao gồm thông tin debug với đuôi .pdb. Bạn chạy file main hoặc main.exe:

$ ./main # hoặc .\main.exe trên Windows

Nếu main.rs là chương trình “Hello, world!”, terminal sẽ in ra Hello, world!

Rust là ngôn ngữ biên dịch trước, bạn có thể biên dịch 1 chương trình và đưa file thực thi cho người khác, và họ có thể chạy nó mà không cần cài đặt Rust. Nếu bạn đưa người khác một file .rb, .py, hoặc .js họ cần cài Ruby, Python, JavaScript để chạy nó. Đánh đổi lại, các ngôn ngữ đó biên dịch và chạy chỉ với 1 câu lệnh.

Biên dịch với rustc chỉ dành cho chương trình đơn giản. Khi project phát triển, sẽ rất phức tạp khi quản lý các options. Công cụ quản lý package - Cargo sẽ giúp ta việc đó.

Hello, Cargo!

Cargo là hệ thống build và quản lý thư viện của Rust. Hầu hết Rust coder - Rustaceans đều sử dụng Cargo để quản lý project của họ bởi vì Cargo xử lý nhiều tác vụ cho bạn ví dụ như: build code, tải thư viện, và build những thư viện đó. (Chúng ta gọi những thư viện mà code của bạn cần là những dependency)

Những chương trình Rust đơn giản nhất, như ví dụ bạn vừa viết chẳng hạn, không có dependency nào. Nên nếu chúng ta build chương trình “Hello, world!” với Cargo, Cargo sẽ chỉ giúp chúng ta build code. Khi bạn viết những chương trình phức tạp hơn, bạn sẽ cần thêm các dependency. Và nếu bạn bắt đầu chương trình với Cargo, việc thêm các dependency sẽ cực kì dễ dàng.

Bởi vì phần lớn các dự án Rust sử dụng Cargo, phần còn lại của cuốn sách này giả định rằng bạn cũng đang sử dụng Cargo. Cargo được cài đặt cùng với Rust nếu bạn sử dụng bộ cài chính thức đã được nêu ở phần “Cài đặt”. Nếu bạn đã cài Rust theo những cách khác, hãy kiểm tra xem Cargo đã được cài đặt hay chưa bằng cách nhập câu lệnh sau trong terminal:

$ cargo --version

Nếu bạn nhìn thấy số phiên bản, tức là bạn đã cài Cargo! Nếu bạn nhìn thấy lỗi như command not found thì phiên bản Rust bạn đã cài đặt không bao gồm Cargo.

Tạo một project với Cargo

Chúng ta hãy tạo một project mới bằng Cargo và xem nó khác như thế nào so với project “Hello, world!” trước. Vào thư mục projects của bạn (bất cứ thư mục nào mà bạn muốn lưu trữ code). Sau đó chạy những lệnh sau:

$ cargo new hello_cargo
$ cd hello_cargo

Câu lệnh đầu tiên tạo một thư mục mới là hello_cargo. Chúng ta đã đặt tên project của chúng ta là hello_cargo, và Cargo sẽ tạo những file mặc định trong thư mục trên.

Vào thư mục hello_cargo và xem các file được tạo. Bạn sẽ thấy Cargo tạo ra hai file và một thư mục: file Cargo.toml và thư mục src có file main.rs bên trong.

Cargo cũng tạo một Git repository cùng với file .gitignore. Nếu bạn chạy cargo new trong một thư mục đã có Git repository nó sẽ không tạo Git repository mới. Nếu bạn vẫn muốn tạo Git repository mới hãy dùng cargo new --vcs=git.

Note: Git là hệ thống quản lý phiên bản phổ biến. Bạn có thể dùng hệ thống quản lý phiên bản khác với cờ --vcs. Sử dụng cargo new --help để xem những options có thể chọn.

Mở file Cargo.toml. Nó sẽ giống với code ở Listing 1-2.

Filename: Cargo.toml

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2021"

[dependencies]

Listing 1-2: Nội dung file Cargo.toml được tạo bởi cargo new

File này được viết theo chuẩn TOML (Tom’s Obvious, Minimal Language), theo định dạng cấu hình của Cargo

Dòng đầu tiên, [package], là tiêu đề của một đoạn thể hiện rằng những khai báo sau đó đang cấu hình một package. Chúng ta sẽ thêm nhiều thông tin khác cũng như các đoạn khác vào file này.

Ba dòng tiếp theo đặt thông tin cấu hình Cargo cần để biên dịch chương trình: tên, phiên bản, và phiên bản(edition) Rust cần dùng Chúng ta sẽ nói về edition trong phần Appendix E.

Dòng cuối, [dependencies], là bắt đầu của một đoạn liệt kê các dependency của project. Trong Rust, các package được coi như các crate. Chúng ta không cần bất kỳ crate nào cho project này, nhưng chúng ta sẽ cần trong project đầu tiên ở Chương 2, nên chúng ta sẽ sử dùng đoạn khai báo dependencies này sau.

Giờ mở file src/main.rs và xem thử:

Filename: src/main.rs

fn main() {
    println!("Hello, world!");
}

Cargo đã tạo ra một chương trình “Hello, world!” cho bạn, giống như cái chúng ta đã viết trong Listing 1-1! Cho đến giờ, điểm khác biệt giữa project trước và project Cargo tạo ra là Cargo đặt code bên trong thư mục src, và chúng ta có một file cấu hình Cargo.toml ở thư mục ngoài cùng.

Cargo yêu cầu những file mã nguồn của bạn nằm trong thư mục src. Thư mục ngoài cùng của project chỉ để file README, thông tin bản quyền, các file cấu hình, và những thứ không liên quan tới code. Việc sử dụng Cargo giúp bạn tổ chức project khoa học hơn.

Nếu bạn đã tạo một project mà không sử dụng Cargo, như project “Hello, world!”, bạn có thể chuyển nó thành một project sử dụng Cargo. Chuyển code vào trong thư mục src và tạo một file Cargo.toml phù hợp.

Build và chạy một Cargo Project

Giờ hãy nhìn vào sự khác biệt khi bạn build và chạy chương trình “Hello, world!” với Cargo! Từ thư mục hello_cargo của bạn, build project bằng lệnh sau:

$ cargo build
   Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs

Câu lệnh trên tạo một file thực thi trong target/debug/hello_cargo (hoặc target\debug\hello_cargo.exe trên Windows) thay vì thư mục hiện tại của bạn. Bạn có thể chạy file thực thi với lệnh sau:

$ ./target/debug/hello_cargo # hoặc .\target\debug\hello_cargo.exe trên Windows
Hello, world!

Nếu mọi việc thực hiện đúng, Hello, world! sẽ được in ra terminal. Việc chạy cargo build lần đầu tiên cũng làm Cargo tạo ra một file mới ở thư mục ngoài: Cargo.lock. File này chứa thông tin phiên bản của các dependency trong project của bạn. Project này không có dependency nên file này hầu như không có thông tin gì cả. Bạn không cần phải sửa đổi gì ở file này; Cargo sẽ quản lý nội dung của nó cho bạn.

Chúng ta vừa mới build một project với cargo build và chạy nó với ./target/debug/hello_cargo, nhưng chúng ta cũng có thể sử dụng cargo run để biên dịch và chạy trong một lệnh.

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/hello_cargo`
Hello, world!

Lưu ý rằng lần này chúng ta không nhìn thấy output chỉ ra rằng Cargo đang biên dịch hello_cargo. Cargo thấy rằng các file không thay đổi nên nó chỉ thực thi file nhị phân. Nếu bạn đã sửa source code, Cargo sẽ build lại project trước khi chạy nó và bạn sẽ nhìn thấy output này:

$ cargo run
   Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs
     Running `target/debug/hello_cargo`
Hello, world!

Cargo cung cấp một câu lệnh gọi là cargo check. Câu lệnh này nhanh chóng kiểm tra code của bạn để chắc chắn rằng nó biên dịch được nhưng không tạo ra file thực thi:

$ cargo check
   Checking hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs

Sao bạn lại không muốn file thực thi? Thông thường, cargo check nhanh hơn rất nhiều so với cargo build, bởi vì nó bỏ qua bước tạo file thực thi. Nếu bạn liên tục kiểm tra code của bạn trong khi viết, sử dụng cargo check sẽ tăng tốc quá trình làm việc! Như vậy, nhiều Rustacean chạy cargo check thường xuyên khi họ viết chương trình để đảm bảo nó biên dịch được. Sau đó họ chạy cargo build khi họ sẵn sàng sử dụng file thực thi.

Hãy cùng điểm những gì chúng ta đã học được về Cargo cho đến lúc này:

• Chúng ta có thể tạo project với cargo new.
• Chúng ta có thể build một project với cargo build.
• Chúng ta có thể build và chạy một project trong một bước bằng cargo run.
• Chúng ta có thể build project mà không sinh ra file thực thi để kiểm tra lỗi compile bằng cargo check.
• Thay vì lưu kết quả build trong cùng thư mục với code, Cargo lưu nó trong thư mục target/debug.

Một ưu điểm nữa của Cargo là các câu lệnh của nó giống nhau trên các hệ điều hành. Nên từ bây giờ chúng ta sẽ không đưa ra những chỉ dẫn riêng cho Linux và macOS với Windows nữa.

Build bản phát hành

Khi project của bạn sẵn sàng để phát hành, bạn có thể sử dụng cargo build --release để biên dịch nó một các tối ưu. Câu lệnh này sẽ tạo một file thực thi trong target/release thay vì target/debug. Cách này làm code của bạn chạy nhanh hơn, nhưng sẽ biên dịch lâu hơn. Đây là lý do vì sao có hai cấu hình khác nhau: một cho việc phát triển, khi mà bạn muốn build lại nhanh chóng và thường xuyên, và một cái khác cho việc build ra chương trình cuối cùng, thứ mà bạn sẽ đưa cho người dùng, nó sẽ không cần build lại nhiều lần và sẽ chạy nhanh nhất có thể. Nếu bạn đang benchmark thời gian chạy của code, hãy chắc chắn rằng chạy cargo build --release và benchmark với file thực thi trong target/release.

Cargo as Convention

Với những project đơn giản, Cargo không có giá trị nhiều so với sử dụng rustc, nhưng nó sẽ chứng minh giá trị của nó khi chương trình của bạn phức tạp hơn. Với những project phức tạp bao gồm nhiều crate, dùng cargo sẽ thuận tiện hơn rất nhiều.

Mặc dù project hello_cargo rất đơn giản, nhưng nó đã sử dụng những công cụ mà bạn sẽ sử dụng sau này trong công việc của bạn. Thực tế, để tham gia vào project Rust, bạn có thể sử dụng những lệnh sau để clone code từ git và build nó

$ git clone example.org/someproject
$ cd someproject
$ cargo build

Xem thêm tài liệu Cargo để biết nhiều thông tin hơn.

Tổng kết

Bạn đã có một khởi đầu rất tuyệt trong hành trình đến với Rust! Trong chương này, bạn đã học được cách:

• Cài đặt phiên bản ổn định mới nhất của Rust bằng cách sử dụng rustup
• Viết và chạy một chương trình “Hello, world!” với rustc
• Tạo và chạy một project mới bằng Cargo

Đây là thời điểm rất tốt để build một chương trình lớn hơn để làm quen với việc đọc và viết code Rust. Vì thế, trong chương 2, chúng ta sẽ build một chương trình trò chơi đoán số. Nếu bạn muốn bắt đầu học về các khái niệm lập trình phổ biến trong Rust, bạn có thể đọc Chương 3 và quay lại Chương 2 sau.

Lập trình Trò chơi đoán số

Bây giờ, hãy nhảy vào Rust bằng cách bắt tay vào làm một dự án cùng nhau! Chương này sẽ giới thiệu một vài ý tưởng Rust thông thường, Bạn sẽ học về let, match, các phương thức, các hàm liên quan, sử dụng các external crates, và còn nhiều hơn nữa! Trong chương tiếp theo, chúng ta sẽ khám phá những ý tưởng này chi tiết hơn. Trong chương này, bạn sẽ luyện tập được những nguyên tắc cơ bản.

Chúng ta sẽ triển khai một vài vấn đề lập trình cơ bản dành cho người mới: một trò chơi đoán số. Đây là cách nó thực hiện: Chương trình này sẽ khởi tạo một số nguyên ngẫu nhiên trong khoảng 1 đến 100. Nó sẽ yêu cầu người chơi phải đoán. Sau khi người chơi nhập số, chương trình sẽ hiển thị rằng: dự đoán của người chơi quá thấp hoặc quá cao. Nếu dự đoán chính xác, chương trình sẽ in ra thông báo chúc mừng và thoát ra.

Cấu hình một dự án mới

Để cấu hình một dự án mới, đến thư mục project, nơi mà được bạn tạo ra trong chương 1 và tạo mới một dự án mới sử dụng Cargo, ví dụ như sau:

$ cargo new guessing_game
$ cd guessing_game

Câu lệnh đầu tiên, cargo new, đặt tên cho dự án này, (guessing_game) là thông số đầu tiên. Câu lệnh tiếp theo để thay đổi thư mục, đưa bạn tới thư mục của dự án.

Nhìn vào file Cargo.toml đã được khởi tạo trước đó.

Filename: Cargo.toml

[package]
name = "guessing_game"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

Như bạn đã thấy trong Chương 1, cargo new khởi tạo chương trình "Hello, world!" cho bạn. Kiểm tra file src/main.rs:

Filename: src/main.rs

fn main() {
    println!("Hello, world!");
}

Bây giờ, hãy cùng biên dịch chương trình "Hello, world!" và chạy nó, sử dụng câu lệnh cargo run:

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 1.50s
     Running `target/debug/guessing_game`
Hello, world!

Câu lệnh run sẽ có ích khi bạn cần lặp lại nhanh chóng trong một dự án, cũng như cách mà chúng ra thực hiện trong trò chơi này, nhanh chóng kiểm tra từng lần lặp lại trước khi chuyển tới bước tiếp theo.

Mở lại file src/main.rs. Bạn sẽ phải viết lại tất cả code trong file này.

Tiến hành dự đoán

Phần đầu tiên của trò chơi dự đoán này là sẽ hỏi người chơi nhập đầu vào, xử lý đầu vào đó, và kiểm tra đầu vào đó có trong định dạng được kì vọng hay không. Để bắt đầu, chúng ta sẽ cho người chơi nhập vào một đầu vào dự đoán. Nhập đoạn code trong Listing 2-1 vào trong file src/main.rs.

Filename: src/main.rs

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");
}

Listing 2-1: Đoạn mã nhận dự đoán của người dùng và in nó ra

Đoạn code này hàm chứa rất nhiều thông tin, vì vậy hãy cùng nhau giải thích nó từng dòng một. Để lựa chọn đầu vào của người dùng và in kết quả đầu ra, ta cần mang thư viện io input/output vào trong phạm vi này. Thư viện io từ thư viện tiêu chuẩn, được viết tới là std:

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");
}

Trong mặc định, Rust có một tập các items định nghĩa các thư viện tiêu chuẩn được mang vào trong phạm vi của mỗi dự án. Tập này được gọi là prelude, và bạn có thể nhìn thấy tất cả chúng trong tài liệu về thư viện tiêu chuẩn.

Nếu kiểu thư viện bạn muốn không ở trong phần dạo đầu, bạn cần mang nó vào trong một phạm vi rõ ràng với statement use. Sử dụng thư viện std::id cung cấp cho bạn một vài tính năng hữu dụng, bao gồm khả năng chấp nhận đầu vào của người dùng.

Như bạn từng thấy trong Chương 1, hàm main sẽ là điểm vào trong chương trình.

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");
}

Cú pháp fn khai báo hàm mới, dấu ngoặc đơn, (), biểu thị rằng nó không có tham số, và dấu ngoặc nhọn, { bắt đầu phần thân của một hàm.

Như bạn đã từng học trong Chương 1, println! cũng là một macro in ra chuỗi ngoài màn hình.

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");
}

Đoạn code này in ra một lời nhắc đây là trò chơi gì và yêu cầu nhập đầu vào từ người dùng.

Lưu giữ giá trị với biến.

Tiếp theo, chúng ta sẽ tạo một biến để lưu trữ giá trị từ đầu vào của người dùng, như sau:

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");
}

Bây giờ chương trình đang dần thú vị hơn! Có rất nhiều điều xảy ra trong dòng này. Chúng ta sẽ sử dụng câu lệnh let để tạo giá trị. Sau đây là một ví dụ:

let apples = 5;

Dòng code này tạo mới một biến được đặt tên là apples và gắn nó với giá trị là 5. Trong Rust, các biến đều mắc định là bất biến, nghĩa là một khi chúng được đưa một giá trị nhất định, giá trị này sẽ không thay đổi. Chúng ta sẽ bàn đến ý tưởng này chi tiết hơn trong phần "Các biến và tính bất biến" ở chương 3. Để làm cho một biến có thể biến đổi được, ta thêm mut trước tên biến:

let apples = 5; // immutable
let mut bananas = 5; // mutable

Ghi chú: Cú pháp \\ bắt đầu một bình luận kéo dài đến cuối dòng. Rust sẽ bỏ qua tất cả ở trong phần bình luận này. Chúng ta sẽ bàn đến phần bình luận này chi tiết hơn ở trong Chương 3.

Trở về chương trình trò chơi đoán số, bạn biết rằng let mut guess sẽ giới thiệu biến khả biến được đặt tên là guess. Dấu bằng (=) nói với Rust rằng chúng ta muốn gắn gì đó vào biến. Bên phải của dấu bằng là giá trị mà guess được gắn vào, thứ là kết quả của việc gọi String::new, một hàm trả về một instance của String. String là kiểu dữ liệu được cung cấp bởi thư viện tiêu chuẩn, nó có thể phát triển được, UTF-8 encoded bit hoặc text.

Cú pháp :: trong dòng ::new chỉ ra rằng new có liên quá đến hàm của kiểu dữ liệu String. Một hàm liên quan là một hàm được triển khai thực hiện trên một kiểu, trong trường hợp này là String. Hàm new này tạo ra một chuỗi mới và trống. Bạn sẽ tìm được hàm new trong nhiều kiểu dữ liệu, bởi vì nó là cái tên phổ biến cho hàm tạo ra giá trị mới, hoặc đại loại vậy.

Về cụ thể, dòng let mut guess = String::new() đã tạo ra một biến khả biến, nó được gắn liền với một chuỗi mới, trống và là instance của String. Phù!

Nhận dữ liệu đầu vào từ người dùng.

Quay lại với việc chúng ta đã bao gồm chức năng đầu vào/đầu ra từ một thư viện tiêu chuẩn với use std::io; trong dòng đầu tiên của chương trình. Bây giờ chúng ta sẽ gọi hàm stdin từ module io, thứ mà cho phép chúng ta xử lý đầu vào được nhập từ người dùng:

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");
}

Nếu chúng ta chưa bổ sung thư viện io với use std::io ở phần đầu của chương trình, chúng ta vẫn có thể sử dụng hàm bằng cách viết hàm gọi, ví dụ std::io::stdin. Hàm stdin trả về instance của std::io::Stdin, thứ mà đại diện xử lý đầu vào tiêu chuẩn cho terminal của bạn.

Tiếp theo, dòng .read_line(&mut guess) gọi đến phương thức read_line trên chuẩn xử lý đầu vào để lấy đầu vào được nhập từ người dùng. Chúng ta cũng đi qua &mut gues như là một tham số để read_line để chỉ ra rằng chuỗi nào lưu trữ đầu vào của người dùng. Công việc đầy đủ của read_line là nhận lấy bất kỳ kiểu dữ liệu tiêu chuẩn nào của người dùng và nối chúng thành một chuỗi (mà không hề ghi đè nội dung), vì vậy trước khi bỏ qua chuỗi đó như là một tham số. Chuỗi tham số này cần để trở nên khả biến vì vậy phương thức có thể thay đổi nội dung chuỗi.

Ký hiệu & chỉ ra rằng tham số này là một tham chiếu, thứ mà chỉ ra cho bạn cách để nhiều đoạn code của bạn cùng truy cập vào một dùng dữ liệu mà không cần sao chiếu dữ liệu đó vào bộ nhớ nhiều lần. Tham chiếu là một tính năng phức tạo, nhưng và nó là một trong những điểm điểm mạnh của Rust, vô cùng an toàn và dễ dàng để sử dụng tham chiếu trong Rust. Bạn không cần phải biết quá nhiều chi tiết để hoàn thiện chương trình. Bây giờ, tất cả những gì bạn cần phải biết là nó giống với biến, tham chiếu là bất biến trong mặc định. Vì vậy, bạn cần phải ghi &mut guess thay vì &guess để làm nó khả biến. (Chương 4 sẽ giải thích tham chiếu rõ ràng hơn)

Chúng ta vẫn sẽ làm việc trong dòng code này. Giờ đây, ta bàn tiếp về dòng code thứ 3 trong đoạn đó, nhưng ghi chú rằng nó vẫn là một phần của dòng code logic. Phần tiếp theo là phương thức này:

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");
}

Chúng ta có thể ghi dòng code như sau:

io::stdin().read_line(&mut guess).expect("Failed to read line");

Mặc dù vậy, một dòng quá dài thì vô cùng khó để đọc, vì vậy cách tốt nhất là chia nó ra. Thông thường, sẽ khôn ngoan hơn nếu khai báo một dòng code và một khoảng trắng để giúp chia một dòng dài khi bạn gọi một phương thức với cú pháp .method_name(). Bây giờ chúng ta sẽ thảo luận dòng code này làm gì.

Như đã đề cập trước đó, read_line đưa vào bất kỳ dữ liệu đầu vào nào được người dùng nhập vào, nhưng cũng đồng thời trả về giá trị Result. Result là một enumeration, thường xuyên gọi là enum thứ mà kiểu dữ liệu có thể ở một trong nhiều trạng thái có thể. Chúng ta gọi từng trạng thái đó là các biến thể.

Chương 6 sẽ bao hàm enums chi tiết hơn. Mục đích của những kiểu dữ liệu Result là để mã hóa thông tin xử lý lỗi.

Các biến thể của Result là Ok và Err. Biến thể Ok chỉ ra rằng toán tử đã thành công và bên trong Ok là một giá trị được khởi tạo thành công. Biến thể Err có nghĩa rằng toán tử đã thất bại, và Err bao gồm những thông tin về việc tại sao hay bằng cách nào mà toán tử lại thất bại.

Giá trị của kiểu dữ liệu Result giống như nhiều giá trị và kiểu khác, là đều có những phương thức định nghĩa trên chúng. Một instance của Result có expect method mà bạn có thể gọi. Nếu instance này của Result là một giá trị Err, expect sẽ là nguyên nhân tại sao chương trình crash và hiển thị tin nhắn đó, được bạn bỏ qua như là một tham số của expect. Nếu phương thức read_line được trả về như Err, nó sẽ giống như kết quả của một lỗi đến từ hệ điều hành của bạn. Nếu như instance của Result này là một giá trị Ok, expect sẽ nhận giá trị trả về khi Ok đang nắm giữ giá trị và trả về đúng giá trị đó cho bạn để sử dụng. Trong trường hợp này giá trị đó là số của những byte trong đầu vào người dùng.

Nếu bạn không gọi expect, chương trình vẫn sẽ biên dịch nhưng bạn sẽ nhận được cảnh báo:

$ cargo build
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
warning: unused `Result` that must be used
  --> src/main.rs:10:5
   |
10 |     io::stdin().read_line(&mut guess);
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: `#[warn(unused_must_use)]` on by default
   = note: this `Result` may be an `Err` variant, which should be handled

warning: `guessing_game` (bin "guessing_game") generated 1 warning
    Finished dev [unoptimized + debuginfo] target(s) in 0.59s

Rust sẽ cảnh báo bạn vì bạn chưa sử dụng giá trị trả về Result từ read_line, nó chỉ ra tằng chương trình chưa được xử lý những lỗi có thể xảy ra.

Cách phù hợp để giảm cảnh báo thực ra là viết phần xử lý lỗi, nhưng trong trường hợp này chúng ta chỉ muốn crash chương trình khi vấn đề xuất hiện, vì vậy chúng ta sử dùng expect. Bạn sẽ học được cách xử lý lỗi trong Chương 9.

In ra giá trị với trình giữ chỗ println!

Bên cạnh dấu ngoặc nhọn, chỉ còn duy nhất một dòng để bàn về đoạn code đến bây giờ:

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");
}

Dòng này in ra một chuỗi chứa đầu vào được nhập bởi người dùng. Dấu {} là một tập các dấu ngoặc nhọn là một trình giữ chỗ: Hãy liên tưởng {} giống như một chiếc càng cua nhỏ giữ một giá trị đúng chỗ. Bạn có thể in nhiều hơn một giá trị nếu dử dụng dấu ngoặc nhọn: dấu ngoặc nhọn đầu tiên của các dấu ngoặc nhọn giữ giá trị đầu tiên được liệt kê dưới định dạng chuỗi, và cứ thế tiếp tục. In ra nhiều giá trị trong một lần gọi println! sẽ trông như sau:

#![allow(unused)]
fn main() {
let x = 5;
let y = 10;

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

Dòng code này sẽ in ra: x = 5 and y = 10.

Kiểm thử phần đầu tiên

Hãy cùng nhau kiểm thử phần đầu tiên của trò chơi đoán số. Khởi chạy chương trình sử dụng cargo run:

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 6.44s
     Running `target/debug/guessing_game`
Guess the number!
Please input your guess.
6
You guessed: 6

Tính đến thời điểm này, phần đầu tiên của trò chơi đã hoàn tất: chúng ta đã nhận đầu vào được nhập bởi bàn phím người dùng và in ra nó.

Khởi tạo ra một số bí mật

Tiếp theo, chúng ta cần tạo ra một số bí mật để người dùng đoán. Số bí mật sẽ thay đổi sau mỗi lần để trò chơi thêm phần thú vị. Chúng ta sẽ sử dụng một số bí mật nằm giữa 1 và 100 để trò chơi không trở nên quá khó. Rust chưa bao gồm một hàm khởi tạo ngẫu nhiên số bí mật. Nhưng đội ngũ Rust đã cung cấp một thư viện rand crate như chúng ta đã nói.

Sử dụng Crate để lấy thêm chức năng

Hãy nhớ rằng crate là một tập các file source code Rust. Một dự án mà chúng tôi đã từng xây dựng là một binary crate, thứ mà có thể thực thi. Crate rand là một thư viện crate, thứ mà bao gồm đoạn mã được dự định sẽ sử dụng trong chương trình khác và không thể tử thực thi bởi chính nó.

Sự phối hợp của Cargo trong những crate ngoại cảnh là điểm sáng của Cargo. Trước khi chúng ta có thể viết những đoạn code sử dụng rand, chúng ta cần chỉnh sửa file Cargo.toml để bao gồm rand như một dependency. Mở file đó và thêm vào những dòng sau ở bên dưới cùng chỗ [dependencies] trong mục header mà Cargo đã tạo cho bạn.

Filename: Cargo.toml

rand = "0.8.3"

Trong file Cargo.toml, tất cả đều theo phần đầu, đó là mục tiếp theo cho đến khi mục khác bắt đầu. Trong [dependencíe] bạn chỉ ra với Cargo rằng những crates ngoại vi nào phụ thuộc trong dự án của bạn và phiên bản nào của những crate này mà bạn yêu cầu. Trong trường hợp này, chúng ta xác định rằng crate rand về mặt ngữ nghĩa được xác định là phiên bản 0.8.3. Cargo hiểu Semantic Versioning (thi thoảng được gọi là SemVer), là tiêu chuẩn cho viết phiên bản số bao nhiêu. Số 0.8.3 thực ra là tốc ký cho ^0.8.3. Điều này có ý nghĩa rằng phiên bản tối thiểu là 0.8.3 nhưng dưới 0.9.0.

Cargo cho rằng những phiên bản này phải có những APIs công khai, tương thích với phiên bản 0.8.3 và sự chỉ rõ này đảm bảo rằng bạn sẽ nhận bản vá mới nhất được công bố, thứ mà vẫn có thể biên dịch với đoạn code ở trong chương này. Mọi phiên bản 0.9.0 trở lên không được cho phép có cùng API theo như những gì mà ví dụ sau sử dụng.

Bây giờ, thay vì thay đổi bất kỳ phần code nào, hãy xây dựng dự án này, như đã thể hiện trong mục Listing 2-2.

$ cargo build
    Updating crates.io index
  Downloaded rand v0.8.3
  Downloaded libc v0.2.86
  Downloaded getrandom v0.2.2
  Downloaded cfg-if v1.0.0
  Downloaded ppv-lite86 v0.2.10
  Downloaded rand_chacha v0.3.0
  Downloaded rand_core v0.6.2
   Compiling rand_core v0.6.2
   Compiling libc v0.2.86
   Compiling getrandom v0.2.2
   Compiling cfg-if v1.0.0
   Compiling ppv-lite86 v0.2.10
   Compiling rand_chacha v0.3.0
   Compiling rand v0.8.3
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 2.53s

Listing 2-2: Đầu ra sau khi chạy cargo build sau khi thêm crate ngẫu nhiên như một dependency

Bạn có thể thấy sự khác biệt trong số của phiên bản (nhưng chúng sẽ đều tương thích với đoạn code, cảm ơn SemVer!), Những dòng khác nhau (phụ thuộc vào hệ điều hành) và những dòng này code thể ở những trật tự khác nhau.

Khi chúng ta bao hàm những dependency ngoại vi, Cargo sẽ tìm về phiên bản cũ nhất của tất cả những gì mà dependency cần từ registry, đó là một bản sao của dữ liệu từ Crates.io. Crate.io là nơi mà mọi người trong hệ sinh thái Rust có thể đăng những đoạn code Rust mã nguồn mở để mọi người khác có thể sử dụng.

Sau khi cập nhật phần đăng ký, Cargo sẽ kiểm tra mục [dependencies] và tải về bất kỳ crates nào được liệt kệ nhưng chưa được tải xuống. Trong trường hợp này, mặc dù chúng ta mới liệt kê rand như là một dependency, Cargo đồng thời mang những crates khác mà rand cần để hoạt động. Sau khi tải xuống các crate, Rust sẽ biên dịch chúng và sau đó biên dịch dự án với những dependency khả dụng.

Nếu bạn ngay lập tức khởi chạy cargo build lần nữa mà không thay đổi bất kỳ điều gì, bạn sẽ không nhận được bất kỳ đầu ra ngoài nào từ dòng Finished. Cargo biết đó đã sẵn sàng được tải xuống và biên dịch các dependency, và bạn sẽ không cần thay đổi bất kỳ thứ gì trong file Cargo.toml của bạn. Cargo đồng thời biết rằng bạn chưa hề thay đổi bất cứ điều gì trong đoạn code của bạn, vì vậy nó không hề biên dịch lại luôn. Với việc không có gì để làm, nó chỉ đơn giản là thoát ra.

Nếu bạn mở file src/main.rs, thay đổi không đáng kể và sau đó lưu chúng và build lại từ đầu, bạn sẽ nhìn thấy hai dòng đầu ra như sau:

$ cargo build
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs

Những dòng sau cho thấy rằng Cargo chỉ cập những bản build với sự thay đổi nhỏ nhất trong file src/main/rs. Những dependency của bạn không hề thay đổi, vì vậy Cargo biết rằng chúng có thể tái sử dụng những thứ gì đã được tải xuống và biên dịch những thứ đó.

Đảm bảo rằng có thể tái sử dụng những bản Build trong file Cargo.lock

Cargo có một cơ chế để đảm bảo rằng bạn có thể build lại cùng một sản phẩm từng lần, dù bạn hay người khác build code đó: Cargo sẽ chỉ sử dụng những phiên bản của những dependency mà bạn chỉ định đến khi bạn biểu thị cái khác. Lấy ví dụ, phiên bản tiếp theo của 0.8.4 của rand crate được công bố, và phiên bản đó đã bao gồm những lỗi đã được sửa, những nó đồng thời bao gồm sự cấp lại, mà có thể phá hỏng code của bạn. Để xử lý điều này, rust tạo ra file Cargo.lock, lần đầu tiên bạn chạy cargo.build, giờ đây chúng ta có điều này trong thư mục guesing_game

Khi bạn build một project lần đầu, Cargo tìm ra tất cả những phiên bản của các dependency phù hợp với những tiêu chí và rồi ghi chúng vào trong file Cargo.lock tồn tại và sử dụng những phiên bản được chỉ định hơn là làm hết những công việc được tìm ra trong những phiên bản trước đó. Điều này cho bạn khả năng tái sử dụng các bản build một cách tự động. Mặt khác, dự án của bạn sẽ được duy trì ở 0.8.3 đến khi bạn chỉ định cập nhật, cảm ơn file Cargo.lock. Bởi vì file Cargo.lock vô cùng quan trọng cho những bản build có thể tái sử dụng, nó thường xuyên kiếm tra trong trình kiểm soát mã với phần còn lại của đoạn code trong dự án của bạn.

Cập nhật Crate để nhận phiên bản mới hơn

Khi bạn muốn cập nhật một crate, Cargo cung cấp câu lệnh update, thứ mà bỏ qua file Cargo.lock và tìm ra tất cả những phiên bản mới nhất mà phù hợp với chỉ định của bạn trong file Cargo.toml. Cargo khi đó sẽ viết những phiên bản này vào trong file Cargo.lock. Mặt khác, mặc định, Cargo sẽ chỉ khóa những phiên bản lớn hơn 0.8.3 và nhỏ hơn 0.9.0. Nếu crate rand đã được công bố hai phiên bản 0.8.4 và 0.9.0 thì bạn sẽ thấy những dòng sau đây nếu bạn chạy cargo update:

$ cargo update
    Updating crates.io index
    Updating rand v0.8.3 -> v0.8.4

Cargo sẽ bỏ qua phiên bản 0.9.0. Ở thời điểm này, bạn để ý rằng không có thay đổi trong file Cargo.lock của bạn mà những phiên của crate rand của bạn giờ đây sử dụng 0.8.4. Để sử dụng phiên bản 0.9.0 của rand hoặc bất kỳ phiên bản nào khác trong tập 0.9.x, bạn cần cập nhật trong file Cargo.toml để khóa thay vì làm như sau:

[dependencies]
rand = "0.9.0"

Lần tiếp theo bạn chạy cargo build, Cargo sẽ cập nhật bản đăng ký của những crate khả dụng và đánh giá lại yêu cầu rand thay vì phiên bản mới mà bạn chỉ định.

Có nhiều điều để nói về Cargo và its ecosystem thứ mà chúng ta sẽ bàn kỹ hơn trong Chương 14, nhưng không phải bây giờ, đó là tất cả những gì mà bạn cần phải biết. Cargo sẽ làm nó trở nên vô cùng đơn giản để tái sử dụng thư viện, vì vậy những lập trình viên Rust có khả năng viết những dự án nhỏ hơn, những dự án được tập hợp bởi một số lượng các package.

Khởi tạo một số ngẫu nhiên

Hãy bắt đầu sử dụng rand để khởi tạo một số để đoán. Bước tiếp theo là cập nhật src/main.rs được hiển thị trong Listing 2-3.

Filename: src/main.rs

use std::io;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");
}

Listing 2-3: Thêm phần code để khởi tạo ngẫu nhiên

Đầu tiên, chúng ta thêm dòng use rand::Rng. Rnd định nghĩa phương thức mà trình khởi tạo số triển khai, và đặc điểm này cần phải trong phạm vi cho chúng ta có thể sử dụng những phương thức này. Chương 10 sẽ bao gồm những đặc điểm này về chi tiết.

Tiếp theo, chúng ta sẽ thêm hai dòng ở giữa. Trong dòng đầu tiên, chúng ta gọi hàm rand::thread_rng để cho chúng ta một trình khởi tạo số ngẫu nhiên mà sẽ được chúng ta sử dụng: một là từ local đến thread hiện tại của trình thực thi và được seed bởi hệ điều hành. Sau đó chúng. Sau đó chúng ta gọi phương thức gen_rand trên trình khởi tạo số ngẫu nhiên. Phương thức này được định nghĩa bởi Rng mà chúng đã đã mang vào trong phạm vi này trước đó với câu lệnh use rand::Rng. Phương thức gen_rand lấy hai khoảng của biểu thức như là tham số và khởi tạo ra một số trong phạm vi đó. Kiểu của phạm vi biểu thức này chúng ta sử dụng ở đây để nhận mẫu start..=end và nó bao gồm giới hạn thấp và cao, vì vậy chúng ta cần chỉ ra 1..=100 để yêu cầu một số giữa 1 và 100.

Ghi chú: bạn sẽ không thể biết đặc điểm nào được sử dụng và phương thức hay hàm nào được gọi trong crate, vì vậy mỗi crate có một tài liệu cho cách sử dụng. Với tính năng neat khác của Cargo được chạy bởi câu lệnh cargo doc--open sẽ build một tài liệu được cung cấp bởi tất cả các dependency locally và mở nó trong trình duyệt cua bạn. Nếu bạn cảm thấy thú vị với những tính năng này trong crate rand này, ví dụ, chạy cargo doc --open và bấm vào rand bên trái trên thành sidebar.

Dòng thứ hai in ra số bí mật. Nó sẽ vô cùng hữu ích khi mà chúng ta phát triển chương trình để có khả năng kiểm thử nó, nhưng chúng ta sẽ xóa nó ra khỏi phiên bản cuối cùng. Sẽ không có nhiều trò chơi nếu chương trình in ra kết quả ngay khi trò chơi bắt đầu.

Thử chạy chương trình vài lần:

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 2.53s
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 7
Please input your guess.
4
You guessed: 4

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.02s
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 83
Please input your guess.
5
You guessed: 5

Bạn cần nhận được các số ngẫu nhiên khác nhau, và chúng sẽ đều nằm trong khoảng 1 và 100. Làm tốt lắm!

So sánh dự đoán với số bí mật

Bây giờ chúng ta đã có đầu vào của người dùng và một số bí mật, chúng ta có thể so sánh chúng. Đó là bước được hiển thị trong Listing 2-4. Ghi chú rằng đoạn code này chưa được biên dịch, như chúng ta sẽ giải thích.

Filename: src/main.rs

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    // --snip--
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    }
}

Listing 2-4: Xử lý các khả năng của giá trị trả về khi so sánh hai số

Đầu tiên chúng ta thêm câu lệnh use, mang kiểu gọi std::cmp::Ordering vào trong phạm vi từ thư viện tiêu chuẩn. Kiểu Odering là một kiểu enum khác và có giá trị Less, Greater, và Equal. Đây là ba đầu ra khả dụng khi bạn so sánh hai giá trị.

Sau đó thêm năm dòng vào phần cuối sử dụng kiểu Ordering. Phương thức cmp so sánh hai giá trị và có thể được gọi trên bất kỳ thứ gì có thể so sánh được. Có cần tham chiếu tới bất kỳ thứ giá ban muốn để so sánh với: đây là cách so sánh guess với secret_number. Sau đó trả về giá trị của Ordering enum mà chúng ta mang vào trong phạm vi này với câu lệnh use. Chúng ta sử dụng biểu thức match để khai báo những gì cần làm tiếp theo dựa trên những biến nào của Ordering được trả lại từ lời gọi đến hàm cmp với những giá trị trong guess và secret_number.

Biểu thức match được tạo ra bởi arms. Một cánh tay bao gồm những pattern để khớp với, và đoạn code nên được chạy nếu giá trị được cho đến match phù hợp với mô hình cánh tay. Rust nhận những giá trị được cho đến match và nhìn qua từng mô hình cánh tay trong một lượt. Các mô hình và cấu trúc match là những tính năng Rust vô cùng mạnh mẽ cho phép bạn thể hiện một vài những tình huống trong code của bạn có thể gặp và đảm bảo rằng bạn có thể xử lý được hết chúng. Những tính năng này sẽ được bao hàm về chi tiết trong Chương 6 và Chương 18 tương ứng.

Cùng nhau dạo qua một ví dụ với biểu thức match mà chúng ta sử dụng ở đây. Nói rằng người dùng đã đoán 50 lần và số được khởi tạo ngẫu nhiên lần này là 38. Khi mà code so sánh 50 và 38, phương thức cmp sẽ trả về giá trị Orderring::Greater và bắt đầu kiểm tra từng mô hình cánh tay. Nó nhìn đến mô hình cánh tay đầu tiên, Ordering::Less và nhìn thấy giá trị Ordering::Greater không khớp với Ordering::Less, vì vậy nó quả qua đoạn code trong cánh tay đó và chuyển tiếp đến canh tay tiếp theo. Mô hình cánh tay tiếp theo là Ordering::Greater, thứ mà khớp với Ordering::Greater! Sự liên quan trong đoạn code từ cánh tay đó sẽ thực thi và in ra Too big! lên màn hình. Biểu thức khớp sau khi lần khớp thành công đầu tiên, vì vậy nó sẽ không nhìn đến cánh tay cuối trong kịch bản.

Mặc dù, đoạn code trong Listing 2-4 sẽ chưa được biên dịch. Hãy thử điều này

$ cargo build
   Compiling libc v0.2.86
   Compiling getrandom v0.2.2
   Compiling cfg-if v1.0.0
   Compiling ppv-lite86 v0.2.10
   Compiling rand_core v0.6.2
   Compiling rand_chacha v0.3.0
   Compiling rand v0.8.3
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
error[E0308]: mismatched types
  --> src/main.rs:22:21
   |
22 |     match guess.cmp(&secret_number) {
   |                     ^^^^^^^^^^^^^^ expected struct `String`, found integer
   |
   = note: expected reference `&String`
              found reference `&{integer}`

error[E0283]: type annotations needed for `{integer}`
   --> src/main.rs:8:44
    |
8   |     let secret_number = rand::thread_rng().gen_range(1..=100);
    |         -------------                      ^^^^^^^^^ cannot infer type for type `{integer}`
    |         |
    |         consider giving `secret_number` a type
    |
    = note: multiple `impl`s satisfying `{integer}: SampleUniform` found in the `rand` crate:
            - impl SampleUniform for i128;
            - impl SampleUniform for i16;
            - impl SampleUniform for i32;
            - impl SampleUniform for i64;
            and 8 more
note: required by a bound in `gen_range`
   --> /Users/carolnichols/.cargo/registry/src/github.com-1ecc6299db9ec823/rand-0.8.3/src/rng.rs:129:12
    |
129 |         T: SampleUniform,
    |            ^^^^^^^^^^^^^ required by this bound in `gen_range`
help: consider specifying the type arguments in the function call
    |
8   |     let secret_number = rand::thread_rng().gen_range::<T, R>(1..=100);
    |                                                     ++++++++

Some errors have detailed explanations: E0283, E0308.
For more information about an error, try `rustc --explain E0283`.
error: could not compile `guessing_game` due to 2 previous errors

Cốt lõi của trạng thái lỗi là nó có kiểu không khớp. Rust có hệ thống mạnh, tĩnh. Mặc dù thế, nó cũng có sự suy luận. Khi chúng ta viết let mut guess = String::new(), Rust có khả năng suy luận ra guess có thể là kiểu String và không làm chúng ta viết kiểu. Mặt khác, secret_number là kiểu số. Và một vài kiểu số của Rust có thể có giá trị từ 1 đến 100: i32, một số 32 bit; u32, một số không dấu 32 bit; i64, một số 64 bit, giống với các số khác. Trừ khi được chỉ định khác, Rust sẽ mặc định sử dụng i32, đó là kiểu dành cho số secret_number trừ khi bạn thêm thông tin về kiểu khác, điều đó khiển Rust suy luận một kiểu số khác. Lý do cho lỗi này là Rust không thể so sánh một chuỗi với một kiểu số.

Cuối cùng, chúng ta muốn chuyển đổi kiểu chuỗi để chương trình đọc đầu vào thành một số thực, chúng ta có thể so sánh về mặt số học với số bí mật. Chúng ta làm điều đó bằng cách thêm dòng này vào phần thân của hàm main.

Filename: src/main.rs

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    println!("Please input your guess.");

    // --snip--

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    let guess: u32 = guess.trim().parse().expect("Please type a number!");

    println!("You guessed: {guess}");

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    }
}

Dòng đó là:

let guess: u32 = guess.trim().parse().expect("Please type a number!");

Chúng ta tạo ra một biến được đặt tên là guess. Nhưng đợi đã, không chương trình đã có biến tên là guess rồi hay sao? Đúng vậy, nhưng may thay, Rust cho phép chúng ta shadow giá trị trước đó của guess với một biến mới. Shadowing cho phép chúng ta tái sử dụng biến guess thay vì phải tạo ra biến mới, như là guess_str và guess. Chúng ta sẽ bao hàm chi tiết vấn đề này trong Chương 3, nhưng bây giờ chỉ cần biết rằng tính năng này thường xuyên được sử dụng khi bạn muốn chuyển đổi một giá trị sang giá trị khác.

Chúng ta gắn biến này vào biểu thức guess.trim().parse(). guess trong biểu thúc này cho thấy rằng biến guess nguyên bản chứa đầu vào như là một chuỗi. Phương thức trim lên String instance sẽ xóa bỏ bất kỳ khoảng trắng nào ở đầu và cuối chuỗi, chúng ta cần làm vậy để có khả năng so sánh chuỗi với u32, thứ mà chỉ bao gồm dữ liệu số. Người dùng sẽ nhập enter để thõa mãn read_line và nhập dự đoán của họ, thứ mà được thêm một dòng những ký tự mới thành chuỗi. Ví dụ, nếu người dùng nhập 5 và nhấn enter, guess sẽ giống như này 5\n. \n biểu thị dòng mới (Trên windows, nhấn enter kết quả trong toa xe sẽ trả về và một dòng mới \r\n). Phương thức trim sẽ xóa bỏ \n và \r\n, kết quả sẽ chỉ là 5.

parse method on strings sẽ chuyển đổi một chuỗi thành kiểu dữ liệu khác. Ở đây, chúng ta sẽ sử dụng nó để chuyển đối nó từ một chuỗi thành số. Chúng ta cần nói với Rust chính xác kiểu dữ liệu mà chúng ta cần, sử dụng let guess: u32. Dấu hai chấm (:) sau guess nói với Rust rằng chúng ta sẽ chú thích biến ở đây. Rust có một vài kiểu số xây dựng trong; u32 ở đây là một số không dấu, số nguyên 32 bit. Đây là một lựa chọn mặc định tốt dành cho số dương nhỏ. Bạn sẽ học được về kiểu số khác trong Chương 3. Trong điều kiện đó, chú thích u32 trong chương trình ví dụng này và sự so sánh với secret_number có ý nghĩa là Rust sẽ suy luận rằng secret_number sẽ là u32. Giờ đây sự so sánh sẽ là giữa hai giá trị có cùng kiểu.

Phương thức parse sẽ chỉ làm việc trên những ký tự có thể chuyển đổi hợp lý thành số và nó cũng dễ gây ra lỗi. Nếu, ví dụ là, chuỗi chứa A👍%, sẽ không thể nào chuyển đôi nó thành một số được. Vì nó sẽ thất bại, phương thức parse sẽ trả về kiểu Result, giống như phương thức read_line làm (đã được thảo luận trước đó trong “Handling Potential Failure with theResult Type”). Chúng ta sẽ đối xử với Result cùng với cách mà chúng ta sử dụng phương thức expect lần nữa. Nếu parse trả về biến thể Err của Result vì không thể tạo một số từ một chuỗi, lời gọi expect sẽ phá hỏng trò chơi và in tin nhắn mà chúng ta đã đưa cho nó. Nếu parse có thể thành công chuyển đổi chuỗi thành số, nó sẽ trả về biến thể Ok của Result, và expect sẽ trả về số mà chúng ta muốn ở giá trị Ok.

Bây giờ hãy khởi chạy chương trình!

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 0.43s
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 58
Please input your guess.
  76
You guessed: 76
Too big!

Tốt! Kể cả khi khoảng trắng được thêm vào trước dự đoán, chương trình vẫn tìm ra được dự đoán của người dùng là 76. Chạy chương trình vài lần để kiểu tra hành vi khác nhau với những kiểu đầu vào khác nhau: dự đoán số chính xác, dự đoán số quá cao, dự đoán số quá thấp.

Chúng ta đã có gần hết trò chơi bây giờ, nhưng người chơi chỉ có thể đoán một lần. Hãy thay đổi điều đó bằng cách thêm vào môt vòng lặp!

Từ khóa loop tạo ra một vòng lặp vô hạn. Chúng ta sẽ thêm một vòng lặp để cho người dùng có nhiều cơ hội hơn để đoán số:

Filename: src/main.rs

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    // --snip--

    println!("The secret number is: {secret_number}");

    loop {
        println!("Please input your guess.");

        // --snip--


        let mut guess = String::new();

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = guess.trim().parse().expect("Please type a number!");

        println!("You guessed: {guess}");

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => println!("You win!"),
        }
    }
}

Như bạn đã thấy, chúng ta đã chuyển tất cả từ đầu vào người dùng trở đi vào trong vòng lặp. Hãy chắc chắn rằng dòng mới được thụt vào trong với 4 khoảng trắng và chạy lại chương trình lần nữa. Chương trình sẽ hỏi dự đoán mãi mãi, đây là một vấn đề mới. Dường như là người chơi không thể thoát.

Người dùng có thể gián đoạn chương trình bất cứ lúc nào, sử dụng tổ hợp phím: ctrl-c. Nhưng có cách khác để thoát ra, như đã đề cập trước đó ở phần thảo luận parse trong “Comparing the Guess to the Secret Number”: Nếu người chơi nhấn một phím không phải số, chương trình sẽ hỏng. Chúng ta cần tận dụng lợi thế đó để cho phép người chơi thoát, như dưới đây:

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 1.50s
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 59
Please input your guess.
45
You guessed: 45
Too small!
Please input your guess.
60
You guessed: 60
Too big!
Please input your guess.
59
You guessed: 59
You win!
Please input your guess.
quit
thread 'main' panicked at 'Please type a number!: ParseIntError { kind: InvalidDigit }', src/main.rs:28:47
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Gõ quit sẽ thoát trò chơi, nhưng bạn cần chú ý rằng người dùng có thể nhập một ký tự không phải số. Đây là cách không hề tối ưu, ít nhất, chúng ta muốn trò chơi dừng lại khi người chơi dự đoán đúng số.

Thoát sau khi dự đoán đúng

Hãy lập trình một trò chơi khi người chơi thắng bằng cách thêm câu lệnh break:

Filename: src/main.rs

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = guess.trim().parse().expect("Please type a number!");

        println!("You guessed: {guess}");

        // --snip--

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

Thêm dòng break sau You win! làm cho chương trình thoát ra khỏi vòng lặp khi mà người chơi dự đoán đúng. Thoát khỏi vòng lặp đồng nghĩa với việc thoát khỏi chương trình, bởi vì vòng lặp là phần cuối cùng của main.

Xử lý đầu vào không hợp lệ

Để lọc nhiều hơn những hành vi của trò chơi, hơn là chỉ dừng chương trình khi người chơi nhập một ký tự không phải số, hãy làm cho trò chơi bỏ qua ký tự đó để người chơi có thể tiếp tục dự đoán. Chúng là có thể làm được điều đó bằng cách thay đổi dòng sau, nơi mà guess được chuyển đổi từ String thành u32. Được thể hiện trong Listing 2-5;

Filename: src/main.rs

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        // --snip--

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("You guessed: {guess}");

        // --snip--

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

Listing 2-5: Bỏ qua một ký tự không phải số và yêu cầu một dự đoán khác thay vì dừng chương trình

Chúng ta chuyển từ lời gọi expect thành biểu thức match để từ dừng chương trình thành một lỗi có thể xử lý được. Nhớ rằng parse sẽ trả về một kiểu Result là một enum có biến thể Ok và Err. Chúng ta đang sử dụng biểu thức match ở đây, như cách chúng ta đã làm với kết quả Ordering của phương thức cmp.

Nếu parse cho phép chuyển thành công từ chuỗi thành số, nó sẽ trả về giá Ok chứa kết quả số. Giá trị Ok đó sẽ khớp với mô hình cánh tay đầu tiên, và biểu thức match sẽ chỉ trả về giá trị num mà thủ tục parse và trả về bên trong giá trị Ok. Số này sẽ kết thúc ở nơi ta muốn nó ở trong giá trị guess mà chúng ta tạo ra.

Nếu parse không có khả năng để chuyển một chuỗi thành số, nó sẽ trả về giá trị Err hàm chứa nhiều thông tin hơn về lỗi. Giá trị Err không khợp với mẫu Err(_) trong cánh tay match đầu tiên. Dấu gạch dưới _ là một giá trị catchall; Trong ví dụ này, chúng ta nói rằng chúng ta muốn khớp tất cả giá trị Err, không quan trọng thông tin nào mà họ có. Vì thế chương trình sẽ thực thi đoạn mã trong cánh tay thứ hai, continue nói với chương trình đi tới lần lặp tiếp theo của loop và tiếp tục hỏi dự đoán khác. Vì thế, vô cùng hiệu quả, chương trình sẽ bỏ qua tất cả lỗi mà parse có thể gặp!

Giờ đây mọi tính năng trong chương trình cần hoạt động như kì vọng. Hãy chạy thử:

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 4.45s
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 61
Please input your guess.
10
You guessed: 10
Too small!
Please input your guess.
99
You guessed: 99
Too big!
Please input your guess.
foo
Please input your guess.
61
You guessed: 61
You win!

Tuyệt vời! Với một chút chỉnh sửa, chúng ta sẽ kết thúc trò chơi đoán số. Gọi lại chương trình vẫn sẽ in ra số bí mật. Nó hoạt động tốt trong lúc kiểm thử, nhưng nó sẽ phá hỏng trò chơi, Hãy cùng xóa println! mà in ra số bí mật. Listing 2-6 sẽ hiển thị đoạn code chính thức.

Filename: src/main.rs

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("You guessed: {guess}");

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

Listing 2-6: Hoàn thiện đoạn mã của trò chơi đoán số

Tổng kết

Ở thời điểm này, bạn đã thành công xây dựng trò chơi đoán số. Chúc mừng!

Dự án này là cách bắt tay vào để giới thiệu cho bạn những ý tưởng mới trong Rust: các hàm let, match, cách dùng các crate ngoại vi, và nhiều hơn nữa. Trong vài chương tiếp theo, bạn sẽ học được về những ý tưởng này chi tiết hơn. Chương 3 sẽ bao hàm các ý tưởng mà hầu hết các ngôn ngữ lập trình có, ví dụ như biến, kiểu dữ liệu và các hàm, và cho bạn thấy cách để dùng chúng trong Rust. Trong chương 4, chúng ta sẽ khám phá quyền sở hữu, một tính năng khiến Rust trở nên khác biệt so với các ngôn ngữ khác. Chương 5 chúng ta sẽ thảo luận sẽ các cấu trúc và các cú pháp phương thức. Và chương 6 sẽ giải thích enum hoạt động như nào.

Các khái niệm lập trình chung

Chương này bao gồm các khái niệm xuất hiện hầu hết trong mọi ngôn ngữ lập trình và cách chúng hoạt động trong Rust. Nhiều ngôn ngữ lập trình có nhiều điểm chung trong cố lõi của chúng. Không có khái niệm nào trong chương trình là duy nhất đối với Rust nhưng chúng ta sẽ thảo luận về chúng trong ngữ cảnh Rust và giải thích các quy ước xung quanh việc sử dụng các khái niệm này.

Cụ thể, bạn sẽ tìm hiểu về các biến, các kiểu dữ liệu cơ bản, hàm, comment và control flow. Những nền tảng này sẽ có mặt trong mọi chương trình Rust và học chúng sớm sẽ cung cấp cho bạn một nền tảng cốt lõi vững chắc.

Từ khóa

Ngôn ngữ Rust có một tập hợp các từ khóa (keywords) chỉ dành riêng cho ngôn ngữ đó, giống như nhiều ngôn ngữ khác. Hãy nhớ rằng bạn không thể sử dụng các từ khóa này để đặt tên biến hay tên hàm. Hầu hết từ khóa có ý nghĩa đặc biệt và bạn sẽ sử dụng chúng để thực hiện nhiều tác vụ khác nhau trong chương trình Rust; một vài tự khóa hiện tại chưa có chức năng đi kèm với chúng nhưng đã được dành riêng cho các chức năng có thể được thêm vào Rust trong tương lai. Bạn có thể tìm thấy danh sách các từ khóa trong Phụ lục A.

Biến (Variable) và Tính biến đổi (Mutability)

Như đã đề cập trong phần “Sử dụng biến để chứa các giá trị”, các biến mặc định là không thể thay đổi được (bất biến - immutable). Đây là một trong số nhiều khuyến khích mà Rust cung cấp để bạn viết code theo cách tận dụng sự an toàn và đồng thời dễ dàng mà Rust đưa ra. Tuy nhiên, bạn vẫn có tùy chọn để khiến cho biến có thể thay đổi (mutable). Hãy cùng tìm hiểu cách thức và lý do tại sao Rust khuyến khích bạn ưu tiên tính bất biến (immutability) và tại sao đôi khi bạn có thể không muốn thế.

Khi một biến là immutable, bạn không thể thay đổi giá trị đã được gán vào biến đó. Để mô tả điều này, hãy tạo một dự án có tên variables trong thư mục projects bằng cách sử dụng cargo new variables.

Sau đó, trong thư mục variables, mở file src/main.rs và thay code của nó bằng đoạn code bên dưới. Code này sẽ chưa được biên dịch, chúng sẽ kiểm tra lỗi về tính bất biến trước.

Filename: src/main.rs

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
    x = 6;
    println!("The value of x is: {}", x);
}

Lưu lại và chạy chương trình bằng cargo run. Bạn sẽ nhận một thông báo lỗi như được hiển thị trong phần kết quả này:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0384]: cannot assign twice to immutable variable `x`
 --> src/main.rs:4:5
  |
2 |     let x = 5;
  |         -
  |         |
  |         first assignment to `x`
  |         help: consider making this binding mutable: `mut x`
3 |     println!("The value of x is: {}", x);
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable

For more information about this error, try `rustc --explain E0384`.
error: could not compile `variables` due to previous error

Ví dụ này chỉ ra cách mà trình biên dịch giúp bạn tìm ra lỗi trong chương trình. Lỗi trình biên dịch có thể gây khó chịu, nhưng thực sự chúng chỉ có nghĩa rằng chương trình của bạn chưa thực hiện một cách an toàn những gì bạn muốn; chúng không có nghĩa là bạn không phải là một lập trình viên giỏi! Nhiều Rustacean có kinh nghiệm vẫn gặp những lỗi này.

Thông báo lỗi chỉ ra nguyên nhân lỗi là cannot assign twice to immutable variable `x`, bởi vì bạn đã cố gắng gán một giá trị thứ hai vào biến immutable x.

Điều quan trọng là chúng ta gặp lỗi compile-time khi chúng ta cố gắng thay đổi giá trị immutable bởi vì chính tình huống này có thể dẫn tới bugs. Nếu một phần code hoạt động trên giả định rằng một giá trị sẽ không bao giờ bị thay đổi và một phần khác có thể thay đổi giá trị đó thì phần code đầu tiền sẽ không thể thực hiện được như những gì nó được thiết kế. Nguyên nhân của loại bug này có thể khó lần ra trong thực tế, đặc biệt là khi đoạn code thứ hai chỉ đôi khi thay đổi giá trị. Trình biên dịch Rust đảm bảo rằng khi bạn chỉ đinh một giá trị sẽ không thay đổi, nó sẽ thực sự không đổi, vì vậy bạn không cần phải tự mình theo dõi nó. Do đó, code của bạn sẽ dễ dàng lập luận hơn.

Nhưng mutability có thể rất hữu ích và có thể khiến bạn viết code thuận tiện hơn. Các biến chỉ immutable theo mặc định; như bạn đã làm trong Chương 2, bạn có thể làm cho chúng mutable khi thêm mut vào trước tên biến. Việc thêm mut cũng truyền tải ý định đến những người đọc code trong tương lai bằng cách chỉ ra rằng các phần khác của code sẽ thay đổi giá trị của biến này.

Ví dụ, hãy thay đổi file src/main.rs thành như sau:

Filename: src/main.rs

fn main() {
    let mut x = 5;
    println!("The value of x is: {}", x);
    x = 6;
    println!("The value of x is: {}", x);
}

Khi chúng ta chạy chương trình, chúng ta sẽ nhận được như vầy:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/variables`
The value of x is: 5
The value of x is: 6

Chúng ta được phép thay đổi giá trị gán vào x từ 5 thành 6 khi chúng ta dùng mut. Có nhiều sự đánh đổi cần cân nhắc ngoài việc ngăn ngừa bugs. Ví dụ, trong trường hợp bạn đang sử dụng một cấu trúc dữ liệu lớn, việc thay đổi instance tại chỗ có thể sẽ nhanh hơn so với việc sao chép và trả về các instance mới được phân bổ. Với cấu trúc dữ liệu nhỏ hơn, việc tạo instace mới và viết theo phong cách lập trình nhiều chức năng hơn có thể dễ dàng hơn để suy nghĩ, do đó hiệu suất thấp hơn có thể là một hình phạt đáng giá để tăng đạt được sự rõ ràng đó.

Hằng số (Constants)

Giống như các biến immutable, constants là các giá trị được gắn với một cái tên và không được phép thay đổi, nhưng có một vài khác biệt giữa hằng số và biến.

Đầu tiên, bạn không được phép sử dụng mut với hằng số. Hằng số không chỉ immutable theo mặc định - chúng luôn luôn immutable. Bạn khai báo hằng số sử dụng từ khóa const thay vì từ khóa let, và kiểu dữ liệu của giá trị buộc phải được chú thích. Chúng ta sắp đề cập đến kiểu dữ liệu và chú thích kiểu dữ liệu trong phần tiếp theo, “Các kiểu dữ liệu” vì vậy đừng lo lắng về chi tiết lúc này. Chỉ biết rằng bạn phải luôn luôn chú thích kiểu dữ liệu.

Hằng số có thể được khai báo trong bất kì phạm vi nào, bao gồm cả phạm vi toàn cục (global scope), điều này làm hằng số trở nên hữu ích cho các phần của code cần sử dụng giá trị của chúng.

Sự khác biệt cuối cùng là các hằng số chỉ có thể khai báo ở dạng biểu thức hằng, chứ không phải kết quả của một giá trị được tính toán lúc runtime.

Dưới đây là một ví dụ về khai báo hằng:

#![allow(unused)]
fn main() {
const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;
}

Tên của hằng số là THREE_HOURS_IN_SECONDS và giá trị của nó được thiết lập là kết quả của 60 (số giây trong một phút) nhân 60 (số phút trong một giờ) nhân 3 (số giờ chúng ta muốn đếm trong chương trình). Quy ước đặt tên hằng số của Rust là đặt tên với chữ in hoa và phân cách giữa các từ bằng dấu gạch dưới. Trình biên dịch có thể tính toán hạn chế một số phép toán ở thời điểm biên dịch, điều này cho phép chúng ta chọn viết ra giá trị này theo một cách dễ hiểu và dễ xác minh hơn, hơn là để giá trị 10,800 cho hằng số này. Hãy xem Rust Reference’s section on constant evaluation để biết thêm thông tin về những phép toán có thể được dùng khi khai báo hằng số.

Hằng số hợp lệ trong toàn bộ thời gian chương trình chạy, trong phạm vi mà chúng được khai báo. Thuộc tính này làm cho hằng số trở nên hữu ích trong cho các giá trị trong miền ứng dụng của bạn mà nhiều phần của chương trình có thể cần chúng, chẳng hạn như số điểm tối đa mà bất cứ người chơi nào trong game có thể kiếm được hoặc tốc độ ánh sáng.

Đặt tên cho các giá trị được mã hóa cứng được sử dụng trong suốt chương trình của bạn dưới dạng hằng số rất hữu ích trong việc truyền đạt ý nghĩa của giá trị đó đến với những người bảo trì code trong tương lai. Nó cũng hữu ích khi chỉ có một vị trí trong code của bạn mà bạn sẽ cần thay đổi nếu giá trị được mã hóa cứng đó cần được cập nhật trong tương lai.

Phủ bóng (Shadowing)

Như bạn đã thấy trong bài hướng dẫn game đoán số trong Chương 2, bạn có thể khai báo một biến mới với cùng tên gọi như biến trước đó. Rustaceans nói rằng biến đầu tiên bị phủ bóng (shadowed) bởi biến thứ hai, điều này có nghĩa là giá trị của biến thứ hai là giá trị mà chương trình thấy khi biến đó được sử dụng. Chúng ta có thể phủ bóng một biến bằng cách sử dụng tên của biến đó và sử dụng lại từ khóa let như sau:

Filename: src/main.rs

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {}", x);
    }

    println!("The value of x is: {}", x);
}

Đầu tiên, chương trình gán x với giá trị 5. Sau đó phủ bóng x bằng cách lặp lại let x =, lấy giá trị ban đầu và cộng 1 do đó, giá trị của x khi đó là 6. Sau đó, trong phạm vi bên trong, câu lệnh let thứ ba cũng phủ bóng x, nhân giá trị trước đó với 2 để x được giá trị là 12. Khi phạm vi kết thúc, việc phủ bóng ở phạm vi bên trong kết thúc và x trả về giá trị 6. Khi chúng ta chạy chương trình, đầu ra sẽ như sau:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/variables`
The value of x in the inner scope is: 12
The value of x is: 6

Phủ bóng khác với đánh dấu một biến với mut, bởi vì chúng ta sẽ gặp lỗi compile-time nếu chúng ta vô tình cố gắng gán lại cho biến này mà không sử dụng từ khóa let. Bằng cách sử dụng let, chúng ta có thể thực hiện một số phép biến đổi trên một giá trị nhưng biến đó không thể thay đổi được sau khi các phép biến đổi đó hoàn tất.

Sự khác biệt khác giữa mut and shadowing là do chúng ta đang tạo ra một biến mới một cách hiệu quả khi chúng ta sử dụng lại từ khóa let, chúng ta có thể thay đổi kiểu dữ liệu của giá trị nhưng sử dụng lại tên đó. Ví dụ, giả sử chương trình của chúng ta yêu cầu người dùng hiển thị bao nhiêu khoảng cách mà họ muốn giữa một số đoạn text bằng cách nhập các ký tự khoảng trắng và sau đó chúng ta muốn lưu trữ đầu vào đó dưới dạng số:

fn main() {
    let spaces = "   ";
    let spaces = spaces.len();
}

Biến spaces đầu tiên có kiểu string và biến spaces thứ hai có kiểu dữ liệu số. Do đo shadowing giúp chúng ta không cần phải đặt các tên khác nhau như spaces_str và spaces_num; thay vào đó, chúng ta có thể sử dụng lại cái tên đơn giản hơn spaces. Tuy nhiên, nếu chúng ta cố gắng sử dụng mut cho việc này, chúng ta sẽ gặp lỗi compile-time như bên dưới:

fn main() {
    let mut spaces = "   ";
    spaces = spaces.len();
}

Lỗi cho biết chúng ta không được phép thay đổi kiểu dữ liệu của một biến:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0308]: mismatched types
 --> src/main.rs:3:14
  |
2 |     let mut spaces = "   ";
  |                      ----- expected due to this value
3 |     spaces = spaces.len();
  |              ^^^^^^^^^^^^ expected `&str`, found `usize`

For more information about this error, try `rustc --explain E0308`.
error: could not compile `variables` due to previous error

Bây giờ chúng ta đã khám phá cách các biến hoạt động, hãy cùng xem xét thêm các kiểu dữ liệu mà Rust có thể có.

Kiểu dữ liệu

Mọi giá trị trong Rust đều có một kiểu dữ liệu xác định, dựa vào kiểu dữ liệu Rust sẽ biết phải làm việc với dữ liệu đó như thế nào. Chúng ta sẽ xem xét hai tập con của kiểu dữ liệu: vô hướng và kết hợp.

Hãy nhớ rằng Rust là ngôn ngữ định kiểu tĩnh (statically typed), tức là Rust phải biết được kiểu dữ liệu của tất cả các biến tại thời điểm biên dịch. Trình biên dịch thông thường có thể suy luận kiểu dữ liệu mà chúng ta đang dùng dựa trên giá trị và cách chúng ta sử dụng giá trị đó. Trong các trường hợp có nhiều kiểu, chẳng hạn như khi chúng ta chuyển đổi String sang kiểu số bằng cách sử dụng parse trong phần “So sánh số dự đoán với số bí mật” trong Chương 2, chúng ta phải chú thích rõ kiểu dữ liệu như sau:

#![allow(unused)]
fn main() {
let guess: u32 = "42".parse().expect("Not a number!");
}

Nếu chúng ta không thêm chú thích kiểu dữ liệu vào, Rust sẽ hiển thị lỗi như bên dưới, trình biên dịch cần thêm thông tin để biết chúng ta đang sử dụng kiểu dữ liệu nào:

$ cargo build
   Compiling no_type_annotations v0.1.0 (file:///projects/no_type_annotations)
error[E0282]: type annotations needed
 --> src/main.rs:2:9
  |
2 |     let guess = "42".parse().expect("Not a number!");
  |         ^^^^^ consider giving `guess` a type

For more information about this error, try `rustc --explain E0282`.
error: could not compile `no_type_annotations` due to previous error

Các loại dữ liệu khác nhau sẽ chú thích khác nhau.

Kiểu dữ liệu vô hướng

Một kiểu dữ liệu vô hướng (scalar) đại diện cho một giá trị duy nhất. Rust có 4 kiểu vô hướng chính: số nguyên (integers), số thực dấu phẩy động (floating-point numbers), Booleans và ký tự (characters). Bạn có thể thấy chúng quen thuộc ở các ngôn ngữ lập trình khác. Hãy cùng tìm hiểu cách chúng hoạt động trong Rust.

Kiểu số nguyên (interger)

Số nguyên là một số không có phần thập phân. Chúng ta đã sử dụng kiểu số nguyên trong Chương 2, kiểu u32. Việc khai báo kiểu dữ liệu này cho giá trị chỉ ra rằng giá trị được khai báo phải là một số nguyên không dấu chiếm 32 bit (kiểu số nguyên có dấu bắt đầu bằng i, thay vì u). Bảng 3-1 chỉ ra các kiểu số nguyên được xây dựng sẵn trong Rust. Chúng ta có thể sử dụng bất kì variant nào trong này để khai báo kiểu số nguyên.

Bảng 3-1: Các kiểu số nguyên trong Rust

Mỗi variant có thể có dấu hoặc không dấu và có kích thước rõ ràng. Signed và unsigned chỉ ra rằng số đó liệu có thể có giá trị âm hay không, một số có dấu (signed) có thể chứa giá trị âm và dương, trong khi một số không có dấu (unsigned) sẽ chỉ chứa giá trị dương. Giống như việc viết số trên giấy: khi dấu là quan trọng, một số sẽ được ghi kèm với dấu cộng hoặc dấu trừ; tuy nhiên, thông thường khi viết số dương thường không có dấu. Các số có dấu được lưu trữ sử dụng two’s complement representation.

Mỗi signed variant có dấu có thể lưu trữ các số từ -(2^{n - 1}) đến 2^{n - 1} - 1, trong đó n là số bits mà variant sử dụng. Do đó, i8 có thể chứa các số từ -(2⁷) đến 2⁷ - 1, tương ứng từ -128 đến 127. Unsigned variants có thể chứa các số từ 0 đến 2ⁿ - 1, do đó u8 chứa các số từ 0 đến 2⁸ - 1, tương ứng từ 0 đến 255.

Ngoài ra, kiểu isize and usize phụ thuộc vào cấu hình máy tính mà chương trình bạn đang chạy, các kiểu này được ký hiệu trong bảng là “arch”: 64 bits nếu bạn đang dùng máy tính cấu hình 64-bit và 32 bits nếu bạn đang dùng cấu hình 32-bit.

Bạn có thể viết số nguyên ở bất kỳ dạng nào như trong Bảng 3-2. Lưu ý rằng các ký tự số (number literals) có thể là nhiều kiểu số cho phép một hậu tố để chỉ định kiểu dữ liệu, chẳng hạn như 57u8. Number literals cũng có thể sử dụng _ để phân tách số cho dễ đọc hơn, ví dụ 1_000 sẽ có cùng giá trị như khi bạn khai báo 1000.

Bảng 3-2: Integer Literals trong Rust

Vì vậy làm cách nào bạn biết nên sử dụng loại số nguyên nào? Nếu bạn không chắc chắn về điều đó, kiểu dữ liệu mặc định của Rust thường hữu ích: ví dụ, kiểu dữ liệu mặc định của số nguyên trong Rust là i32. Còn isize và usize bạn sẽ sử dụng khi cần lập chỉ mục một số loại collection.

Tràn số nguyên (Integer Overflow)

Giả sử bạn có một biến có kiểu dữ liệu u8 có thể lưu giá trị từ 0 đến 255. Nếu bạn cố gắng thay đổi giá trị của biến vượt ra khỏi phạm vi trên, chẳng hạn như 256, integer overflow sẽ xảy ra có thể dẫn đến một trong hai hành vi. Khi bạn biên dịch ở chế độ debug, Rust sẽ bao gồm các kiểm tra về integer overflow có phải là nguyên nhân khiến chương trình của bạn panic ở thời gian chạy nếu hành vi này xảy ra. Rust sử dụng thuật ngữ panicking khi thoát một chương trình bị lỗi, chúng ta sẽ thảo luận panics sâu hơn trong phần “Các lỗi không thể phục hồi với panic!” trong Chương 9.

Khi bạn biên dịch trong chế độ release với cờ --release, Rust sẽ không bao gồm các kiểm tra về integer overflow. Thay vào đó, nếu overflow xảy ra, Rust thực hiện two’s complement wrapping. Tóm lại, các giá trị lớn hơn giá trị mà kiểu dữ liệu có thể chứa sẽ “wrap around” vào giá trị nhỏ nhất mà kiểu dữ liệu có thể lưu giữ. Trong trường hợp u8, giá trị 256 trở thành 0, giá trị 257 trở thành 1, v..v.. Chương trình sẽ không panic, nhưng biến sẽ có một giá trị mà bạn không mong đợi. Đây được coi là một lỗi.

Để xử lý rõ ràng khả năng overflow, bạn có thể sử dụng các phương thức do thư viện chuẩn cung cấp cho các kiểu số nguyên thủy:

• Wrap trong tất cả các chế độ bằng các phương thức wrapping_*, như wrapping_add
• Trả về giá trị None nếu overflow xảy ra bằng phương thức checked_*
• Trả về giá trị và một boolean cho biết liệu overflow có xảy ra hay không bằng phương thức overflowing_*
• Saturate ở các giá trị tối thiểu hoặc tối đa bằng phương thức saturating_*

Kiểu dấu phẩy động

Rust cũng có hai kiểu dữ liệu nguyên thủy cho số thực dấu phẩy động, các số có dấu phần thập phân. Kiểu dấu phẩy động của Rust là f32 và f64, tương ứng với kích thước 32 bits và 64 bits. Kiểu mặc định trong Rust là f64 bởi vì các CPU hiện đại bây giờ tốc độ giống như f32 nhưng chính xác hơn. Tất cả kiểu dấu phẩy động đều có dấu.

Dưới đây là một ví dụ về sử dụng số thực dấu phẩy động:

Filename: src/main.rs

fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

Số thực dấu phẩy động được biểu diễn theo tiêu chuẩn IEEE-754 standard. Kiểu float f32 có độ chính xác đơn và f64 có độ chính xác gấp đôi.

Các phép toán số học

Rust hỗ trợ tất cả các phép toán cơ bản cho tất cả kiểu số: cộng, trừ, nhân, chia và phần dư. Phép chia số nguyên được làm tròn đến số nguyên gần nhất. Code bên dưới chỉ bạn cách sử dụng mỗi phép toán trong câu lệnh let:

Filename: src/main.rs

fn main() {
    // addition
    let sum = 5 + 10;

    // subtraction
    let difference = 95.5 - 4.3;

    // multiplication
    let product = 4 * 30;

    // division
    let quotient = 56.7 / 32.2;
    let floored = 2 / 3; // Results in 0

    // remainder
    let remainder = 43 % 5;
}

Mỗi biểu thức trong các câu lệnh sử dụng một toán tử toán học và cho ra kết quả là một giá trị đơn được gán vào một biến. Phụ lục B chứa danh sách bao gồm tất cả các toán tử mà Rust cung cấp.

Kiểu Boolean

Như trong hầu hết các ngôn ngữ lập trình khác, kiểu Boolean trong Rust chứa hai giá trị: true và false. Booleans có kích thước 1 byte. Sử dụng bool để chỉ ra kiểu Boolean trong Rust. Ví dụ:

Filename: src/main.rs

fn main() {
    let t = true;

    let f: bool = false; // with explicit type annotation
}

Giá trị Boolean được sử dụng chủ yếu trong các câu điều kiện, chẳng hạn như biểu thức if. Chúng ta sẽ đề cập về biểu thức if được sử dụng như thế nào trong Rust trong phần “Control Flow”.

Kiểu ký tự

Kiểu char trong Rust là kiểu chữ cái nguyên thủy nhất của ngôn ngữ. Sau đây là một vài ví dụ về khai báo giá trị char:

Filename: src/main.rs

fn main() {
    let c = 'z';
    let z = 'ℤ';
    let heart_eyed_cat = '😻';
}

Lưu ý rằng chúng ta chỉ định ký tự char bằng dấu nháy đơn, trong khi ký tự chuỗi sử dụng dấu nháy kép. Kiểu char trong Rust có kích thước 4 bytes và đại diện cho một Giá trị Vô hướng Unicode (Unicode Scalar Value), tức là nó có thể đại diện cho nhiều thứ hơn ASCII. Tấy cả các chữ cái có dấu; chữ Trung Quốc, Nhật Bản và Hàn Quốc; emoji và zero-width spaces đều là giá trị char hợp lệ trong Rust. Unicode Scalar Values nằm trong khoảng từ U+0000 đến U+D7FF và U+E000 đến U+10FFFF. Tuy nhiên, một “ký tự” không thực sự là một khái niệm trong Unicode, vì vậy trực giác của con người về “ký tự” là gì có thể không trùng khớp với char trong Rust. Chúng ta sẽ thảo luận chi tiết về chủ đề này trong “Storing UTF-8 Encoded Text with Strings” ở Chương 8.

Kiểu kết hợp (Compound Types)

Compound types có thể nhóm nhiều giá trị vào một kiểu. Rust có hai kiểu kết hợp nguyên thủy là: tuples và arrays.

Kiểu Tuple

Tuple là cách thông thường nhóm một số giá trị tương ứng với những kiểu dữ liệu khác nhau lại. Tuples có độ dài cố định: một khi được khai báo, chúng ta không thể tăng hoặc giảm kích thước của chúng.

Chúng ta tạo ra tuple bằng cách viết một danh sách các giá trị được phân cách nhau bằng dấu phẩy bên trong dấu ngoặc tròn. Mỗi vị trí trong tuple mang một kiểu dữ liệu và không nhất thiết tất cả các giá trị trong tuple phải có kiểu dữ liệu giống nhau. Chúng tôi đã thêm chú thích kiểu dữ liệu như trong ví dụ sau:

Filename: src/main.rs

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

Toàn bộ tuple được gán cho biến tup , vì một tuple được coi là một phần tử kết hợp đơn lẻ. Để lấy các giá trị riêng lẻ ra khỏi tuple, chúng ta có thể sử dụng pattern matching để destructure giá trị như sau:

Filename: src/main.rs

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {}", y);
}

Chương trình ban đầu tạo ra một a tuple và gán nó vào biến tup. Sau đó sử dụng pattern với let để biến tup trở thành ba biến riêng biệt, x, y và z. Cách làm này được gọi là destructuring, bởi vì nó chia một tuple đơn lẻ thành ba phần riêng biệt. Cuối cùng, chương trình in ra giá trị của y là 6.4.

Chúng ta cũng có thể truy cập trực tiếp vào một tuple bằng cách sử dụng dấu chấm (.) theo sau đó là vị trí của giá trị mà chúng ta muốn truy cập. Ví dụ:

Filename: src/main.rs

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

Chương trình tạo ra một tuple x, sau đó tạo các biến mới cho từng phần tử bằng cách sử dụng chỉ số ứng với chúng. Như với hầu hết các ngôn ngữ lập trình, vị trí đầu tiên trong tuple là 0.

Tuple không chứa bất kì giá trị nào là một kiểu đặc biệt chỉ chứa một giá trị, (). Kiểu này được gọi là unit type và giá trị đó được gọi là unit value. Các biểu thức sẽ trả về unit value nếu chúng không trả về bất kì giá trị nào khác.

Kiểu Mảng (Array)

Một cách khác để có một collection với nhiều giá trị là sử dụng array. Không giống như tuple, mọi phần tử của array phải có kiểu dữ liệu giống nhau. Không giống như array trong các ngôn ngữ khác, các array trong Rust có độ dài cố định.

Chúng ta tạo array bằng cách viết một danh sách các giá trị được phân cách nhau bằng dấu phẩy đặt bên trong dấu ngoặc vuông:

Filename: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];
}

Arrays rất hữu ích khi bạn muốn dữ liệu của mình được phân bổ trên stack hơn là trên heap (chúng ta sẽ thảo luận nhiều hơn về stack và heap trong Chương 4) hoặc khi bạn muốn đảm bảo rằng bạn luôn luôn có số lượng phần tử cố định. Tuy nhiên array không linh hoạt như kiểu vector. Vector là một kiểu collection tương tự như array do thư viện chuẩn cung cấp, vector cho phép bạn tăng hoặc giảm kích thước. Nếu bạn không chắc liệu nên sử dụng array hay vector thì bạn nên sử dụng vector. Chúng ta sẽ thảo luận chi tiết hơn về vector trong Chương 8.

Tuy nhiên, array sẽ hữu ích hơn khi bạn đã biết được số lượng phần tử mà bạn cần. Ví dụ, nếu bạn sử dụng tên của các tháng trong chương trình, bạn nên sử dụng array hơn là vector bởi vì bạn biết chắc chắn rằng nó sẽ luôn luôn chứa 12 phần tử:

#![allow(unused)]
fn main() {
let months = ["January", "February", "March", "April", "May", "June", "July",
              "August", "September", "October", "November", "December"];
}

Bạn viết kiểu array bằng cách sử dụng dấu ngoặc vuông với bên trong là kiểu của phần tử, dấu chấm phẩy và sau đó là số lượng phần tử trong array, như sau:

#![allow(unused)]
fn main() {
let a: [i32; 5] = [1, 2, 3, 4, 5];
}

Ở đây i32 là kiểu dữ liệu của tất cả phần tử. Số 5nằm sau dấu chấm phẩy cho biết rằng array chứ 5 phần tử.

Bạn cũng có thể tạo ra một array chứa các phần tử có cùng giá trị bằng cách chỉ định giá trị ban đầu, theo sau là dấu chấm phẩy và kế đó là độ dài của array, tất cả được đặt bên trong dấu ngoặc vuông như bên dưới:

#![allow(unused)]
fn main() {
let a = [3; 5];
}

Array a sẽ chứa 5 phần tử có cùng giá trị ban đầu là 3. Tương tự như khi chúng ta viết let a = [3, 3, 3, 3, 3]; nhưng ngắn gọn hơn.

Truy cập các phần tử của array

Array là một đoạn bộ nhớ đơn đã biết có kích thước cố định có thể được phân bổ trên stack. Bạn có thể truy cập các phần tử của array bằng cách sử dụng chỉ mục như sau:

Filename: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];

    let first = a[0];
    let second = a[1];
}

Trong ví dụ này, biến first sẽ nhận giá trị 1, bởi vì đó là giá trị tại chỉ mục [0] trong array. Biến second sẽ nhận giá trị 2 từ chỉ mục [1] trong array.

Truy cập phần tử array không hợp lệ

Hãy xem điều gì xảy ra nếu bạn cố gắng truy cập vào một phần tử nằm vượt quá phần cuối của array. Giả sử bạn chạy code này, tương tự như game đoán số trong Chương 2, để nhận chỉ mục array từ người dùng:

Filename: src/main.rs

use std::io;

fn main() {
    let a = [1, 2, 3, 4, 5];

    println!("Please enter an array index.");

    let mut index = String::new();

    io::stdin()
        .read_line(&mut index)
        .expect("Failed to read line");

    let index: usize = index
        .trim()
        .parse()
        .expect("Index entered was not a number");

    let element = a[index];

    println!(
        "The value of the element at index {} is: {}",
        index, element
    );
}

Code này sẽ biên dịch thành công. Nếu bạn chạy cargo run và nhập 0, 1, 2, 3, hoặc 4, chương trình sẽ in ra giá trị tương ứng tại chỉ mục trong array đó. Thay vào đó nếu bạn nhập một số vượt quá phần cuối của array, ví dụ như 10, bạn sẽ thấy đầu ra như sau:

thread 'main' panicked at 'index out of bounds: the len is 5 but the index is 10', src/main.rs:19:19
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Chương trình sẽ dẫn đến lỗi runtime tại điểm mà bạn sử dụng giá trị không hợp lệ trong thao tác lập chỉ mục. Chương trình thoát ra với thông báo lỗi và không thực thi câu lệnh println! cuối cùng. Khi bạn cố gắng truy cập một phần tử sử dụng lập chỉ mục, Rust sẽ kiểm tra xem chỉ mục mà bạn chỉ định có nhỏ đơn độ dài của array hay không. Nếu chỉ mục lớn hơn hoặc bằng chiều dài của array, Rust sẽ panic. Kiểm tra này diễn ra tại thời điểm runtime, nhất là trong trường hợp này, bởi vì trình biên dịch không thể biết người dùng sau đó sẽ nhập giá trị nào khi họ chạy code.

Đây là một ví dụ về nguyên tắc an toàn bộ nhớ của Rust đang hoạt động. Trong nhiều ngôn ngữ cấp thấp, loại kiểm tra này không được thực hiện và khi bạn cung cấp một chỉ mục không chính xác, bộ nhớ không hợp lệ có thể được truy cập. Rust bảo vệ bạn tránh khỏi lỗi này bằng cách thoát chương trình ngay lập tức, thay vì cho phép truy cập bộ nhớ và tiếp tục chạy. Chương 9 sẽ thảo luận nhiều hơn về cách xử lý lỗi của Rust.

Hàm

Hàm phổ biến trong Rust. Bạn đã thấy một trong những hàm quan trọng nhất trong ngôn ngữ này: đó là hàm main. Bạn cũng thấy từ khóa fn giúp cho phép bạn khai báo hàm mới.

Rust sử dụng quy tắc con rắn (snake case) làm quy ước cách đặt tên hàm và biến, trong đó tất cả các chữ cái phải viết thường và phân cách các từ bằng dấu gạch dưới. Bên dưới là một chương trình ví dụ về cách định nghĩa hàm:

Filename: src/main.rs

fn main() {
    println!("Hello, world!");

    another_function();
}

fn another_function() {
    println!("Another function.");
}

Chúng ta định nghĩa hàm trong Rust bằng cách gõ từ khóa fn theo sau là tên của hàm và một cặp dấu ngoặc đơn. Cặp dấu ngoặc nhọn cho trình biên dịch biết vị trí bắt đầu và kết thúc của thân hàm.

Chúng ta có thể gọi bất kỳ hàm nào đã được định nghĩa bằng cách gõ tên hàm theo sau là cặp dấu ngoặc tròn. Do hàm another_function đã được định nghĩa trong chương trình, bạn có thể gọi hàm này từ bên trong hàm main. Lưu ý rằng chúng ta đã định nghĩa hàm another_function sau hàm main trong code; chúng ta cũng có thể định nghĩa nó trước hàm main. Rust không quan tâm bạn định nghĩa hàm ở đâu, Rust chỉ quan tâm hàm đã được định hay chưa.

Hãy bắt đầu một dự án nhị phân có tên functions để khám phá thêm về hàm. Lấy ví dụ hàm another_function cho vào src/main.rs và khởi chạy chương trình. Bạn sẽ thấy kết quả như bên dưới:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished dev [unoptimized + debuginfo] target(s) in 0.28s
     Running `target/debug/functions`
Hello, world!
Another function.

Các dòng thực thi theo thứ tự xuất hiện trong hàm main. Đầu tiên, thông điệp “Hello, world!” được in ra, sau đó gọi hàm another_function và in thông điệp của nó ra.

Tham số

Chúng ta có thể định nghĩa các hàm có các tham số - đây là những biến đặc biệt là một phần của chữ ký hàm. Khi một hàm có tham số đi kèm, bạn có thể cung cấp cho nó các giá trị tham số cụ thể. Về mặt kỹ thuật, các giá trị cụ thể này được gọi là đối số (arguments), nhưng trong giao tiếp thông thường, mọi người có xu hướng sử dụng từ tham số (parameter) và đối số (argument) thay thế cho nhau cho các biến trong định nghĩa hàm hoặc giá trị cụ thể được chuyển vào khi bạn gọi hàm.

Trong phiên bản này của hàm another_function, chúng ta thêm một tham số vào:

Filename: src/main.rs

fn main() {
    another_function(5);
}

fn another_function(x: i32) {
    println!("The value of x is: {}", x);
}

Thử khởi chạy chương trình; bạn sẽ nhận được kết quả sau:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished dev [unoptimized + debuginfo] target(s) in 1.21s
     Running `target/debug/functions`
The value of x is: 5

Khi khai báo hàm another_function, chúng ta có một tham số tên x. Kiểu của x được chỉ định là i32. Khi chúng ta chuyển giá trị 5 vào hàm another_function, println! macro sẽ đặt 5 vào vị trí của cặp dấu ngoặc nhọn để định dạng thành string.

Trong chữ ký hàm, bạn buộc phải khai báo kiểu của mọi tham số. Đây là một quyết định có chủ ý trong thiết kế của Rust: việc yêu cầu chú thích kiểu dữ liệu trong định nghĩa hàm có nghĩa là trình biên dịch sẽ không bao giờ yêu cầu bạn khai báo kiểu dữ liệu ở bất kỳ nơi khác trong code để tìm ra kiểu dữ liệu mà bạn muốn nói đến.

Khi bạn định nghĩa hàm với nhiều tham số, phân cách việc khai báo tham số bằng dấu phẩy như sau:

Filename: src/main.rs

fn main() {
    print_labeled_measurement(5, 'h');
}

fn print_labeled_measurement(value: i32, unit_label: char) {
    println!("The measurement is: {}{}", value, unit_label);
}

Ví dụ này tạo ra một hàm có tên print_labeled_measurement với hai tham số. Tham số thứ nhất có tên value và có kiểu i32. Tham số thứ hai có tên unit_label và có kiểu char. Sau đó hàm in ra đoạn văn bản chứa cả value và unit_label.

Hãy thử khởi chạy code. Thay thế ví dụ vừa rồi vào file src/main.rs của dự án functions và khởi chạy nó với cargo run:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/functions`
The measurement is: 5h

Bởi vì chúng ta đã gọi hàm với giá trị của value là 5 và unit_label là 'h', đầu ra của chương trình sẽ chứa các giá trị đó.

Câu lệnh và Biểu thức

Thân hàm được tạo thành từ một loạt các câu lệnh tùy ý kết thúc bằng một biểu thức. Cho đến bây giờ, các hàm mà chúng ta đã đề cập chưa có hàm nào kết bằng một biểu thức, nhưng bạn đã thấy biểu thức như một phần của câu lệnh. Bởi vì Rust là một ngôn ngữ dựa trên biểu thức, bạn cần hiểu về sự phân biệt quan trọng này. Những ngôn ngữ khác không có sự phân biệt giống như vậy, vì vậy hãy xem xét câu lệnh và biểu thức là gì và sự khác biệt của chúng ảnh hưởng như thế nào đến nội dung của hàm.

Câu lệnh (Statements) là các hướng dẫn thực hiện một số hành động và không trả về giá trị. Biểu thức (Expressions) tính toán để đưa ra một giá trị kết quả. Hãy xem xét một vài ví dụ.

Chúng ta đã thực sự sử dụng câu lệnh và biểu thức. Tạo một biến và gán một giá trị cho nó với từ khóa let là một câu lệnh. Trong Listing 3-1, let y = 6; là một câu lệnh.

Filename: src/main.rs

fn main() {
    let y = 6;
}

Listing 3-1: A main function declaration containing one statement

Việc định nghĩa một hàm cũng là một câu lệnh; toàn bộ ví dụ trước là một câu lệnh.

Câu lệnh không trả về giá trị. Do đó, bạn không thể gán một câu lệnh let statement vào một biến khác, bạn sẽ gặp lỗi nếu cố gắng làm như đoạn code bên dưới:

Filename: src/main.rs

fn main() {
    let x = (let y = 6);
}

Khi bạn chạy chương trình, bạn sẽ bắt gặp lỗi như thế này:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
error: expected expression, found statement (`let`)
 --> src/main.rs:2:14
  |
2 |     let x = (let y = 6);
  |              ^^^^^^^^^
  |
  = note: variable declaration using `let` is a statement

error[E0658]: `let` expressions in this position are experimental
 --> src/main.rs:2:14
  |
2 |     let x = (let y = 6);
  |              ^^^^^^^^^
  |
  = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
  = help: you can write `matches!(<expr>, <pattern>)` instead of `let <pattern> = <expr>`

warning: unnecessary parentheses around assigned value
 --> src/main.rs:2:13
  |
2 |     let x = (let y = 6);
  |             ^         ^
  |
  = note: `#[warn(unused_parens)]` on by default
help: remove these parentheses
  |
2 -     let x = (let y = 6);
2 +     let x = let y = 6;
  | 

For more information about this error, try `rustc --explain E0658`.
warning: `functions` (bin "functions") generated 1 warning
error: could not compile `functions` due to 2 previous errors; 1 warning emitted

Câu lệnh let y = 6 không trả về một giá trị, do đó không có bất kỳ giá trị nào được gán cho x. Điều này khác biệt với những gì xảy ra trong các ngôn ngữ khác, như C và Ruby, trong đó phép gán trả về giá trị của phép gán đó. Trong những ngôn ngữ này, bạn có thể viết x = y = 6, cả x và y đều sẽ có giá trị là 6; nhưng Rust thì không hiểu như vậy.

Biểu thức tính toán đưa ra một giá trị và tạo nên gần như toàn bộ phần còn lại của code mà bạn viết bằng Rust. Xét về một phép toán số học như 5 + 6, đó là một biểu thức sẽ đưa ra kết quả là 11. Biểu thức có thể là một phần của câu lệnh: trong Listing 3-1, giá trị 6 trong câu lệnh let y = 6; là một biểu thức đưa ra giá trị là 6. Việc gọi một hàm cũng là một biểu thức. Gọi một macro là một biểu thức. Một khối phạm vi mới được tạo ra bằng dấu ngoặc nhọn là một biểu thức, ví dụ:

Filename: src/main.rs

fn main() {
    let y = {
        let x = 3;
        x + 1
    };

    println!("The value of y is: {}", y);
}

Biểu thức này:

{
    let x = 3;
    x + 1
}

trong trường hợp này là một khối sẽ đưa ra giá trị là 4. Giá trị đó được gán vào y như một phần của câu lệnh let. Lưu ý rằng dòng x + 1 không có dấu chấm phẩy ở cuối câu, không giống như hầu hết các dòng code bạn đã thấy cho đến nay. Các biểu thức không kết thúc bằng dấu chấm phẩy. Nếu bạn thêm dấu chấm phẩy vào cuối biểu thức, nó sẽ trở thành một câu lệnh và câu lệnh thì không trả về giá trị. Hãy nhớ điều này khi bạn tìm hiểu về các hàm trả về giá trị và biểu thức ở phần kế tiếp.

Hàm trả về giá trị

Hàm có thể trả về các giá trị cho code khi chúng được gọi. Chúng ta không đặt tên giá trị trả về, nhưng chúng ta buộc phải khai báo kiểu dữ liệu của chúng sau dấu mũi tên (->). Trong Rust, giá trị trả về của hàm đồng nghĩa với giá trị của biểu thức cuối cùng trong phần thân hàm. Bạn có thể trả về sớm giá trị của hàm bằng việc sử dụng từ khóa return và chỉ định giá trị trả về, nhưng trong hầu hết các hàm sẽ ngầm định trả về biểu thức cuối cùng. Dưới đây là một ví dụ về một hàm trả về giá trị:

Filename: src/main.rs

fn five() -> i32 {
    5
}

fn main() {
    let x = five();

    println!("The value of x is: {}", x);
}

Không có gọi hàm, macros, hay thậm chí câu lệnh let trong hàm five — chỉ có duy nhất số 5. Đó là một hàm hợp lệ trong Rust. Lưu ý rằng phải biết được kiểu dữ liệu trả về của hàm như -> i32. Hãy khởi chạy code này; đầu ra sẽ như thế này:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/functions`
The value of x is: 5

Số 5 trong hàm five là giá trị trả về của hàm, đó là lý do tại sao kiểu dữ liệu trả về là i32. Hãy xem xét điều này chi tiết hơn. Có 2 bits quan trọng: đầu tiên, dòng lệnh let x = five(); cho biết rằng bạn đang sử dụng giá trị trả về của hàm để khởi tạo ra một biến. Bởi vì hàm five trả về giá trị 5, dòng lệnh đó tương đương với dòng lệnh bên dưới:

#![allow(unused)]
fn main() {
let x = 5;
}

Thứ hai, hàm five không có tham số và hàm xác định kiểu dữ liệu của giá trị trả về, nhưng trong phần thân hàm chỉ có số 5 không có dấu chấm phẩy bởi vì nó là một biểu thức chứa giá trị mà chúng ta muốn trả về.

Hãy xem xét một ví dụ khác:

Filename: src/main.rs

fn main() {
    let x = plus_one(5);

    println!("The value of x is: {}", x);
}

fn plus_one(x: i32) -> i32 {
    x + 1
}

Code này sẽ in ra The value of x is: 6. Nhưng nếu chúng ta đặt dấu chấm phẩy vào cuối dòng chứa x + 1, nó sẽ từ biểu thức chuyển thành câu lệnh, chúng ta sẽ gặp lỗi ngay.

Filename: src/main.rs

fn main() {
    let x = plus_one(5);

    println!("The value of x is: {}", x);
}

fn plus_one(x: i32) -> i32 {
    x + 1;
}

Biên dịch code này sẽ gây ra lỗi như sau:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
error[E0308]: mismatched types
 --> src/main.rs:7:24
  |
7 | fn plus_one(x: i32) -> i32 {
  |    --------            ^^^ expected `i32`, found `()`
  |    |
  |    implicitly returns `()` as its body has no tail or `return` expression
8 |     x + 1;
  |          - help: consider removing this semicolon

For more information about this error, try `rustc --explain E0308`.
error: could not compile `functions` due to previous error

Thông báo lỗi chính, “mismatched types,” cho thấy vấn đề cốt lõi trong code. Định nghĩa hàm plus_one nói rằng nó sẽ trả về một giá trị i32, nhưng câu lệnh không trả về giá trị được biểu thị bằng (), unit type. Do đó, không có gì để trả về, điều này mẫu thuẫn với định nghĩa của hàm và dẫn đến lỗi. Trong đầu ra này, Rust đưa ra một thông báo để có thể giúp khắc phục vấn đề này: Rust đề xuất loại bỏ dấu chấm phẩy để khắc phục lỗi.

Chú thích (Comments)

Tất cả lập trình viên đều cố gắng làm cho code dễ hiểu, nhưng đôi khi cần những lời giải thích thêm. Trong các trường hợp này, lập trình viên sẽ để lại comments trong code, trình biên dịch sẽ bỏ qua các comment này nhưng chúng lại có thể có ích cho những ai đọc code.

Đây là một comment đơn giản:

#![allow(unused)]
fn main() {
// hello, world
}

Trong Rust, comment bắt đầu với hai dấu gạch chéo và kéo dài cho đến cuối dòng. Đối với các comment vượt quá một dòng, bạn sẽ cần viết thêm // ở mỗi dòng như thế này:

#![allow(unused)]
fn main() {
// So we’re doing something complicated here, long enough that we need
// multiple lines of comments to do it! Whew! Hopefully, this comment will
// explain what’s going on.
}

Comments cũng có thể được đặt ở cuối dòng chứa mã code:

Filename: src/main.rs

fn main() {
    let lucky_number = 7; // I’m feeling lucky today
}

Nhưng bạn sẽ thường xuyên thấy chúng ở định dạng comment ở trên một dòng riêng biệt với code cần chú thích:

Filename: src/main.rs

fn main() {
    // I’m feeling lucky today
    let lucky_number = 7;
}

Rust cũng có một loại comment khác, documentation comments, chúng ta sẽ thảo luận về nó trong phần “Publishing a Crate to Crates.io” ở Chương 14.

Luồng điều khiển (Control Flow)

Luồng điều khiển sẽ quyết định cách code của chúng ta được hoạt động như thế nào. Các cấu trúc phổ biến nhất cho phép bạn kiểm soát luồng thực thi code của Rust là biểu thức if và vòng lặp (loops).

Biểu thức if

Biểu thức if cho phép bạn phân nhánh code phụ thuộc vào các điều kiện. Bạn đưa ra một điều kiện, sau đó yêu cầu: “Nếu thỏa mãn điều kiện này, hãy chạy code này. Nếu điều kiện này không thỏa mãn, không chạy code này.”

Khởi tạo một dự án mới có tên branches trong thư mực projects của bạn để tìm hiểu về biểu thức if. Trong file src/main.rs, hãy nhập code như bên dưới:

Filename: src/main.rs

fn main() {
    let number = 3;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

Tất cả biểu thức if bắt đầu với từ khóa if, theo sau là một điều kiện. Trong trường hợp này, điều kiện sẽ kiểm tra xem liệu biến number có giá trị nhỏ hơn 5 hay không. Ngay sau điều kiện, bên trong cặp dấu ngoặc nhọn, chúng ta viết code cần thực thi nếu điều kiện đúng. Đoạn code liên kết với điều kiện trong biểu thức if thường được gọi là nhánh (arms), giống như arms trong biểu thức match mà chúng ta đã đề cập trong phần “So sánh số dự đoán với số bí mật” ở Chương 2.

Chúng ta cũng có thể tùy ý bao gồm thêm biểu thức else, như chúng ta đã làm ở đây, để cung cấp cho chương trình một đoạn code thay thế khác để thực thi nếu điều kiện sai. Nếu bạn không cung cấp biểu thức else và điều kiện không thỏa mãn, chương trình sẽ bỏ qua đoạn code chứa if và chuyển sang đoạn code tiếp theo.

Hãy thử chạy code này; bạn sẽ nhận được kết quả như sau:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
condition was true

Hãy thử thay đổi giá trị của biến number thành một giá trị làm cho điều kiện sai để xem điều gì xảy ra:

fn main() {
    let number = 7;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

Chạy chương trình một lần nữa và xem kết quả:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
condition was false

Cũng cần lưu ý rằng điều kiện trong code phải là bool. Nếu điều kiện không phải là bool, chúng ta sẽ gặp lỗi. Ví dụ, bạn hãy thử chạy đoạn code sau đây:

Filename: src/main.rs

fn main() {
    let number = 3;

    if number {
        println!("number was three");
    }
}

Lần này điều kiện if có giá trị là 3 và Rust đưa ra lỗi:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
error[E0308]: mismatched types
 --> src/main.rs:4:8
  |
4 |     if number {
  |        ^^^^^^ expected `bool`, found integer

For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches` due to previous error

Lỗi chỉ ra rằng Rust mong đợi bool nhưng lại nhận được số nguyên. Không giống như các ngôn ngữ khác như Ruby và JavaScript, Rust sẽ không tự động chuyển đổi các kiểu dữ liệu không phải Boolean sang Boolean. Bạn phải rõ ràng và luôn luôn cung cấp Boolean cho câu điều kiện if. Ví dụ, nếu bạn muốn đoạn code if chỉ chạy khi một số khác 0, chúng ta có thể thay đổi biểu thức if như sau:

Filename: src/main.rs

fn main() {
    let number = 3;

    if number != 0 {
        println!("number was something other than zero");
    }
}

Khởi chạy đoạn code này sẽ in ra number was something other than zero.

Xử lý nhiều điều kiện với else if

Bạn có thể so sánh nhiều điều kiện bằng cách kết hợp if và else trong biểu thức else if Ví dụ như:

Filename: src/main.rs

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else if number % 2 == 0 {
        println!("number is divisible by 2");
    } else {
        println!("number is not divisible by 4, 3, or 2");
    }
}

Chương trình này có 4 điều kiện có thể thực hiện. Sau khi chạy code, bạn sẽ thấy kết quả như bên dưới:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
number is divisible by 3

Khi thực thi chương trình, Rust sẽ kiểm tra lần lượt mỗi biểu thức if và thực thi đoạn code đầu tiên mà điều kiện thỏa mãn. Lưu ý rằng 6 chia hết cho 2, chúng ta không thấy kết quả đầu ra là đoạn text number is divisible by 2 cũng như đoạn text number is not divisible by 4, 3, or 2 từ else. Bởi vì Rust chỉ thực thi đoạn code cho điều kiện đúng đầu tiên và nó sẽ bỏ qua phần code còn lại.

Sử dụng quá nhiều biểu thức else if có thể làm lộn xộn code của bạn, vì vậy nếu bạn có nhiều hơn một biểu thức, bạn có thể cần tái cấu trúc lại code của mình. Chương 6 giới thiệu một cấu trúc phân nhánh mạnh mẽ, match, cho các trường hợp này.

Sử dụng if trong câu lệnh let

Bởi vì if là một biểu thức, chúng ta có thể sử dụng nó bên phải câu lệnh let để giá kết quả cho biến, như trong Listing 3-2.

Filename: src/main.rs

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

    println!("The value of number is: {}", number);
}

Listing 3-2: Gán kết quả của biểu thức if cho một biến

Biến number sẽ được gán với giá trị dựa vào kết quả của biểu thức if. Hãy chạy đoạn code này để xem điều gì xảy ra:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/branches`
The value of number is: 5

Hãy nhớ rằng đoạn code đánh giá đến biểu thức cuối cùng và các số cũng bản thân nó
cũng là biểu thức. Trong trường hợp này, giá trị của toàn bộ biểu thức if phụ thuộc vào đoạn code mà nó thực thi. Điều này có nghĩa là các giá trị của mỗi nhánh if phải có kiểu dữ liệu giống nhau; trong Listing 3-2, kết quả từ cả nhánh if và nhánh else đều là số nguyên i32. Nếu kiểu dữ liệu không khớp, bạn sẽ gặp lỗi như trong ví dụ dưới đây:

Filename: src/main.rs

fn main() {
    let condition = true;

    let number = if condition { 5 } else { "six" };

    println!("The value of number is: {}", number);
}

Khi bạn biên dịch code này, bạn sẽ gặp lỗi. Nhánh if và else có kiểu giá trị không tương thích và Rust chỉ ra chính xác vị trí vấn đề trong chương trình:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
error[E0308]: `if` and `else` have incompatible types
 --> src/main.rs:4:44
  |
4 |     let number = if condition { 5 } else { "six" };
  |                                 -          ^^^^^ expected integer, found `&str`
  |                                 |
  |                                 expected because of this

For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches` due to previous error

Biểu thức trong khối if đưa ra một số nguyên và biểu thức trong khối else đưa ra một string. Điều này sẽ không thực hiện được bởi vì các biến phải có một kiểu duy nhất và Rust cần biết tại thời điểm biên dịch biến number có kiểu gì. Biết được kiểu của number cho phép trình biên dịch xác minh kiểu đó hợp lệ ở mọi chỗ khi chúng ta sử dụng number. Rust không thể làm điều đó nếu kiểu của number chỉ được xác định tại thời điểm runtime; trình biên dịch sẽ phức tạp hơn và sẽ ít đảm bảo hơn về code nếu nó phải theo dõi nhiều kiểu giả định cho bất kỳ biến nào.

Lặp lại với các vòng lặp (Loops)

Việc thực thi một đoạn code nhiều lần sẽ rất hữu ích. Để làm điều này, Rust cung cấp một số vòng lặp (loop), vòng lặp này sẽ chạy code bên trong thân của vòng lặp từ đầu đến cuối và sau đó ngay lập tức bắt đầu lại từ đầu. Để trải nghiệm với vòng lặp, hãy khởi tạo một dự án mới có tên loops.

Rust có 3 loại vòng lặp: loop, while, và for. Hãy thử từng loại.

Lặp lại code với loop

Từ khóa loop yêu cầu Rust thực thi một đoạn code lặp đi lặp lại mãi mãi hoặc cho đến khi bạn yêu cầu nó dừng lại.

Ví dụ, thay đổi file src/main.rs trong thư mục loops như bên dưới:

Filename: src/main.rs

fn main() {
    loop {
        println!("again!");
    }
}

Khi bạn chạy chương trình này, bạn sẽ thấy kết quả again! được in liên tục cho đến khi chúng ta dừng chương trình một cách thủ công. Hầu hết terminal hỗ trợ phím tắt ctrl-c để ngắt một chương trình bị mắc kẹt trong một vòng lặp liên tục. Hãy thử một lần:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished dev [unoptimized + debuginfo] target(s) in 0.29s
     Running `target/debug/loops`
again!
again!
again!
again!
^Cagain!

Ký hiệu ^C thể hiện vị trí bạn nhấn ctrl-c . Bạn có thể gặp lại từ again! này hoặc không được in ra sau ^C, phụ thuộc vào vị trí của code trong vòng lặp khi nó nhận được tín hiệu ngắt.

May mắn thay, Rust cũng cung cấp một cách để thoát khỏi vòng lặp bằng cách sử dụng code. Bạn có thể đặt từ khóa break trong vòng lặp để cho chương trình biết khi nào nên dừng thực hiện vòng lặp. Chúng ta đã làm điều này trong trò chơi đoán số trong phần “Thoát ra sau khi đoán đúng” ở Chương 2 để thoát khỏi chương trình khi người dùng đoán đúng con số bí mật.

Chúng ta cũng đã dùng continue trong trò chơi đoán số, trong vòng lặp continue sẽ yêu cầu chương trình bỏ qua đoạn code còn lại trong lần lặp này của vòng lặp và đi đến vòng lặp tiếp theo.

Nếu bạn có vòng lặp lồng bên trong vòng lặp, break và continue áp dụng cho vòng lặp trong cùng tại điểm đó. Bạn có thể tùy chọn chỉ định gắn nhãn cho vòng lặp, chúng ta có thể sử dụng break hoặc continue để chỉ định rằng các từ khóa đó sẽ áp dụng cho vòng lặp nào được gắn nhãn thay vì vòng lặp trong cùng. Dưới đây là một ví dụ về hai vòng lặp lồng nhau:

fn main() {
    let mut count = 0;
    'counting_up: loop {
        println!("count = {}", count);
        let mut remaining = 10;

        loop {
            println!("remaining = {}", remaining);
            if remaining == 9 {
                break;
            }
            if count == 2 {
                break 'counting_up;
            }
            remaining -= 1;
        }

        count += 1;
    }
    println!("End count = {}", count);
}

Vòng lặp bên ngoài có nhãn 'counting_up và nó sẽ đếm từ 0 đến 2. Vòng lặp bên trong không có nhãn đếm ngược từ 10 đến 9. Câu lệnhbreak đầu tiên không chỉ định nhãn của vòng lặp nên sẽ chỉ thoát khỏi vòng lặp bên trong. Câu lệnh break 'counting_up; sẽ thoát khỏi vòng lặp ngoài. Code này sẽ in ra:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished dev [unoptimized + debuginfo] target(s) in 0.58s
     Running `target/debug/loops`
count = 0
remaining = 10
remaining = 9
count = 1
remaining = 10
remaining = 9
count = 2
remaining = 10
End count = 2

Trả về giá trị từ vòng lặp

Một trong các cách sử dụng vòng lặp là thử một phép toán mà bạn biết có thể nó sẽ thất bại, chẳng hạn như kiểm tra xem một luồng có hoàn thành công việc hay không. Bạn cũng có thể cần chuyển kết quả của phép toán đó ra khỏi vòng lặp đến phần còn lại của code. Để làm điều này, bạn có thể thêm giá trị bạn muốn trả về sau biểu thức break mà bạn sử dụng để dừng vòng lặp; giá trị đó sẽ được trả về khỏi vòng lặp và do đó bạn có thể sử dụng giá trị đó như được hiển thị ở đây:

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {}", result);
}

Trước vòng lặp, chúng ta khai báo một biến có tên counter và gán cho nó giá trị 0. Sau đó chúng ta khai báo một biến có tên result để chứa giá trị mà vòng lặp trả về. Trên mỗi lần lặp của vòng lặp, chúng ta cộng 1 vào biến counter và sau đó kiểm tra xem liệu counter bằng 10 hay không. Khi nó thỏa mãn điều kiện, chúng ta sử dụng từ khóa break với counter * 2. Sau vòng lặp, chúng ta sử dụng dấu chấm phẩy để kết thúc câu lệnh gán giá trị vào biến result. Cuối cùng, chúng ta in ra giá trị của result, trong trường hợp này là 20.

Vòng lặp có điều kiện với while

Một chương trình sẽ thường cần đánh giá một điều kiện bên trong vòng lặp. Trong khi điều kiện là đúng, vòng lặp sẽ chạy. Khi điều kiện không còn đúng nữa, chương trình sẽ gọi break để dừng vòng lặp. Có thể triển khai hành vi như vậy bằng cách sử dụng kết hợp loop, if, else và break; bạn có thể thử điều đó trong một chương trình ngay nếu bạn muốn. Tùy nhiên, mẫu này phổ biến đến mức Rust đã xây dựng một cấu trúc cho nó gọi là vòng lặp while. Trong Listing 3-3, chúng ta sử dụng while để lặp lại chương trình ba lần, mỗi lần lặp đếm ngược, in ra một thông báo và thoát

Filename: src/main.rs

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{}!", number);

        number -= 1;
    }

    println!("LIFTOFF!!!");
}

Listing 3-3: Sử dụng vòng lặp while để chạy code trong khi điều kiện đúng

Cấu trúc này loại bỏ nhiều lồng ghép cần thiết nếu bạn sử dụng loop, if, else và break và nó rõ ràng hơn nhiều. Trong khi một điều kiện đúng, code sẽ hoạt động; nếu không nó sẽ thoát vòng lặp.

Vòng lặp cho Collection với for

Bạn có thể sử dụng cấu trúc while để lặp qua các phần tử của một collection, chẳng hạn như array. Ví dụ, vòng lặp trong Listing 3-4 in ra từng phần tử trong array a.

Filename: src/main.rs

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    while index < 5 {
        println!("the value is: {}", a[index]);

        index += 1;
    }
}

Listing 3-4: Lặp qua từng phần tử của một collection sử dụng vòng lặp while

Ở đây, code sẽ đếm lên thông qua các phần tử trong array. Nó bắt đầu ở chỉ mục 0 và sau đó lặp lại cho đến chỉ mục cuối cùng trong array (đó là khi index < 5 không còn đúng nữa). Khởi chạy code này, nó sẽ in ra mọi phần tử trong array:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished dev [unoptimized + debuginfo] target(s) in 0.32s
     Running `target/debug/loops`
the value is: 10
the value is: 20
the value is: 30
the value is: 40
the value is: 50

Tất cả năm giá trị của array đều xuất hiện trong terminal như mong đợi. Mặc dù index sẽ đạt giá trị 5 tại một số thời điểm , vòng lặp dừng thực thi trước khi cố gắng tìm nạp giá trị thứ sáu từ array.

Tuy nhiên, các tiếp cận này dễ xảy ra lỗi; chúng ta có thể làm chương trình panic nếu giá trị chỉ mục hoặc điều kiện kiểm tra không đúng. Ví dụ nếu bạn thay đổi định nghĩa của array a chỉ có bốn phần tử nhưng quên cập nhật điều kiện thành while index < 4, code khi đó sẽ panic. Nó cũng chậm bởi vì trình biên dịch thêm runtime code để thực hiện kiểm tra có điều kiện liệu chỉ mục có nằm trong giới hạn của array trên mỗi lần lặp qua vòng lặp hay không.

Để thay thế ngắn gọn hơn, bạn có thể sử dụng vòng lặp for và thực thi code cho mỗi item trong collection. Vòng lặp for trong giống như code trong Listing 3-5.

Filename: src/main.rs

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("the value is: {}", element);
    }
}

Listing 3-5: Lặp qua từng phần tử của collection sử dụng vòng lặp for

Khi chúng ta sử dụng đoạn code này, chúng ta sẽ nhận được kết quả giống hệt như trong Listing 3-4. Quan trọng hơn, chúng ta có thể tăng tính an toàn của code và loại bỏ khả năng lỗi từ việc vượt qua phần tử cuối của array hoặc lặp không hết và thiếu sót một vài item.

Sử dụng vòng lặp for, bạn sẽ không cần phải thay đổi code nếu bạn thay đổi số lượng phần tử của array như với phương pháp mà bạn sử dụng trong Listing 3-4.

Tính an toàn và độ ngắn gọn của vòng lặp for khiến chúng trở thành cấu trúc vòng lặp được sử dụng phổ biến trong Rust. Ngay cả trong các tình huống bạn muốn chạy code một số lần nhất định, như ví dụ đếm ngược đã sử dụng vòng lặp while trong Listing 3-3, phần lớn Rustaceans sẽ sử dụng vòng lặp for. Các để làm điều đó là sử dụng phạm vi (Range), được cung cấp bởi thư viện chuẩn, tạo ra tất cả các số theo thứ tự bắt đầu từ một số và kết thúc trước một số khác.

Dưới đây là cách đếm ngược sử dụng vòng lặp for và một phương thức khác mà chúng ta chưa đề cập đến, rev, để đảo ngược phạm vi:

Filename: src/main.rs

fn main() {
    for number in (1..4).rev() {
        println!("{}!", number);
    }
    println!("LIFTOFF!!!");
}

Code này đẹp hơn một chút rồi phải không?

Tóm tắt

Bạn đã làm được! Đây là một chương khá lớn: bạn đã học về biến, kiểu dữ liệu vô hướng và kết hợp, hàm, comments, biểu thức if và vòng lặp! Để thực hành các khái niệm này, hãy thử xây dựng chương trình để thực hiện những điều sau:

• Chuyển đổi nhiệt độ giữa Fahrenheit và Celsius.
• Tạo ra số Fibonacci thứ n.
• In lời bài hát mừng Giáng sinh “The Twelve Days of Christmas,” tận dụng sự lặp lại trong bài hát.

Khi bạn đã sẵn sàng để tiếp tục, chúng ta sẽ nói về một khái niệm trong Rust không thường tồn tại trong các ngôn ngữ lập trình khác: quyền sở hữu (ownership).

Understanding Ownership

Ownership (Quyền sở hữu) là tính năng độc đáo nhất của Rust và có ý nghĩa sâu sắc đối với phần còn lại của ngôn ngữ. Nó cho phép Rust đảm bảo an toàn cho bộ nhớ mà không cần bộ thu gom rác (garbage collector), vì vậy điều quan trọng là phải hiểu cách thức hoạt động của Ownership. Chúng ta sẽ nói về ownership cũng như một số tính năng liên quan: borrowing (nguyên lý mư mượn), slices (chuỗi các thành phần liên tiếp trong bộ nhớ), và cách Rust đưa dữ liệu ra ngoài trong bộ nhớ.

What Is Ownership?

Một số thuật ngữ:

• ownership:
• scope: phạm vi, tầm vực
• stack và heap: vùng bộ nhớ trong máy tính lưu trữ biến

Ownership là một tập hợp các quy tắc chi phối cách một chương trình Rust quản lý bộ nhớ. Tất cả các chương trình phải quản lý cách chúng sử dụng bộ nhớ của máy tính khi chạy. Một số ngôn ngữ có garbage collection (bộ thu thập rác) liên tục tìm kiếm bộ nhớ không còn được sử dụng khi chương trình chạy; trong các ngôn ngữ khác, lập trình viên phải cấp phát và giải phóng bộ nhớ một cách rõ ràng. Rust sử dụng cách tiếp cận thứ ba: bộ nhớ được quản lý thông qua một hệ thống sở hữu (system of ownership) với một tập hợp các quy tắc mà trình biên dịch kiểm tra khi biên dịch. Nếu bất kỳ quy tắc nào bị vi phạm, chương trình sẽ không biên dịch. Không có tính năng nào của ownership sẽ làm chậm chương trình của bạn khi nó đang chạy.

Vì ownership là một khái niệm mới đối với nhiều lập trình viên, nên nó cần một chút thời gian để làm quen. Tin tốt là bạn càng có nhiều kinh nghiệm hơn với Rust và các quy tắc của hệ thống sở hữu (ownership system) hơn, bạn càng thấy dễ dàng hơn khi phát triển code an toàn và hiệu quả một cách tự nhiên. Hãy kiên trì!

Khi bạn hiểu ownership, bạn sẽ có một nền tảng vững chắc để hiểu các tính năng làm cho Rust trở nên độc đáo. Trong chương này, bạn sẽ học ownership bằng cách làm việc thông qua một số ví dụ tập trung vào cấu trúc dữ liệu rất phổ biến: chuỗi (strings).

Stack và Heap

Nhiều ngôn ngữ lập trình không yêu cầu bạn phải nghĩ về stack và heap thường xuyên. Nhưng trong một ngôn ngữ lập trình hệ thống như Rust, việc một giá trị nằm trên stack hoặc sẽ ảnh hưởng đến cách ngôn ngữ hoạt động và tại sao bạn phải đưa ra những quyết định nhất định. Các phần của ownership sẽ được mô tả liên quan đến stack và heap ở phần sau của chương này, vì vậy đây là một lời giải thích ngắn gọn trong quá trình chuẩn bị.

Cả stack và heap đều là những phần bộ nhớ có sẵn cho code của bạn để sử dụng trong runtime, nhưng chúng được cấu trúc theo những cách khác nhau. Stack lưu trữ lưu trữ các giá trị theo thứ tự mà nó nhận được và xóa các giá trị theo thứ tự ngược lại. Điều này được gọi là last in, first out (Vào sau, ra trước). Hãy nghĩ về một chồng đĩa: Khi bạn thêm nhiều đĩa, bạn đặt chúng lên trên đầu và khi bạn cần một chiếc đĩa, bạn lấy một cái trên đầu ra. Thêm hoặc xóa các đĩa ở giữa hoặc dưới cùng cũng sẽ không hoạt động! Thêm dữ liệu được gọi là pushing onto the stack, và xóa dữ liệu được gọi là popping off the stack. Tất cả dữ liệu được lưu trữ trên stack phải có kích thước cố định (fixed size), đã biết. Thay vào đó dữ liệu có kích thước không xác định (unknown size) tại thời điểm biên dịch hoặc kích thước có thể thay đổi phải được lưu trữ trên heap.

Heap ít được tổ chức hơn: khi bạn đặt dữ liệu trên heap, bạn gửi yêu cầu một khoảng trống nhất định trong bộ nhớ. Bộ cấp phát bộ nhớ tìm thấy một chỗ trống trên heap đủ lớn, đánh dấu nó là đang được sử dụng, và trả về một con trỏ, đó là địa chỉ cuả vị trí đó. Quá trình này được gọi là allocating on the heap (cấp phát trên heap) và đôi khi được viết tắt là allocating (việc đẩy các giá trị vào stack không được coi là cấp phát). Vì con trỏ tới heap có kích thước cố định (fixed size) và đã biết, bạn có thể lưu trữ con trỏ trên stack, nhưng khi bạn muốn dữ liệu thực sự, bạn phải đi theo con trỏ. Hãy nghĩ đến việc tìm chỗ ngồi tại một nhà hàng. Khi bạn tới đó, bạn sẽ cần nói số người trong nhóm của bạn, và nhần viên sẽ tìm một bàn trống đủ chỗ cho mọi người và dẫn bạn tới đó. Nếu ai đó trong nhóm của bạn đến muộn, họ có thể hỏi chỗ ngồi của bạn ở đâu để tìm.

Đẩy dữ liệu vào stack nhanh hơn là cấp phát trên heap vì bộ cấp phát không bao giờ phải tìm kiếm một nơi để lưu dữ liệu mới; vị trí đó luôn ở trên cùng của stack. Tương tự, việc phân bổ không gian trên heap đòi hỏi nhiều công việc hơn, bởi vì bộ cấp phát trước tiên phải tìm một không gian đủ lớn để chứa dữ liệu sau đó thực hiện ghi sổ (bookkeeping) để chuẩn bị cho đợt cấp phát tiếp theo.

Truy cập dữ liệu trong heap chậm hơn so với truy cập dữ liệu trên stack vì bạn phải đi theo một con trỏ để đến đó. Các bộ xử lý hiện đại nhanh hơn nếu chúng ít nhảy qua lại bộ nhớ hơn. Tiếp tục tương tự, hãy xem xét một máy chủ tại một nhà hàng nhận các orders từ nhiều bàn. Cách hiệu quả nhất là nhận tất cả các orders tại một bàn trước khi chuyển sang bàn tiếp theo. Nhận một order từ bàn A, sau đó một order từ bàn B, sau đó lại một từ bàn A lần nữa, và sau đó lại một từ B sẽ là một quá trình chậm hơn nhiều. Cũng vì lẽ ấy, một bộ xử lý có thể thực hiện công việc của nó tốt hơn nếu nó làm việc với các dữ liệu gần nhau (như trên stack) thay vì các dữ liệu xa nhau (như trên heap). Việc phân bổ một lượng lớn không gian trên heap cũng có thể mất thời gian.

Khi code của bạn gọi một hàm, các giá trị đã được truyền vào hàm (có thể bao gồm cả con trỏ đến dữ liệu trên heap) và các biến cục bộ của hàm được đẩy lên stack. Khi hàm kết thúc, những giá trị đó bị lấy ra khỏi stack.

Theo dõi những phần code nào đang sử dụng dữ liệu nào trên heap, giảm thiểu số lượng dữ liệu trùng lặp trên heap, và dọn dẹp dữ liệu không sử dụng trên heap do đó bạn không cạn kiệt khoảng trống là tất cả những vấn đề mà ownership giải quyết. Khi bạn hiểu về ownership, bạn không cần phải suy nghĩ về stack và heap thường xuyên, nhưng biết được mục đích chính của ownership là để quản lý dữ liệu heap có thể giúp giải thích được tại sao nó hoạt động như vậy.

Các quy tắc của Ownership

Trước tiên, hãy xem các quy tắc ownership. Hãy ghi nhớ những quy tắc này khi chúng ta xem thông qua các ví dụ minh họa chúng:

• Mỗi giá trị trong Rust có một biến gọi là owner của nó.
• Chỉ có thể có một owner tại một thời điểm.
• Khi owner ra khỏi phạm vi (scope) của nó, giá trị sẽ bị bỏ đi.

Phạm vi biến

Bây giờ chúng ta đã qua cú pháp Rust cơ bản, chúng ta sẽ không viết tất cả các dòng fn main() { trong ví dụ nữa, vì vậy khi bạn theo dõi các ví dụ hãy chắc chắn đã tự đặt các ví dụ bên trong hàm main một cách thủ công. Vì vậy, các ví dụ của chúng ta trông sẽ ngắn gọn hơn một chút, cho phép chúng ta tập trung vào những chi tiết hơn là các đoạn mã soạn sẵn.

Trong ví dụ đầu tiên, chúng ta sẽ nói về phạm vi (scope) của một số biến. Scope là phạm vi trong một chương trình mà một item có giá trị. Giả sử ta có biến sau:

#![allow(unused)]
fn main() {
let s = "hello";
}

Biến s đề cập tới một chuỗi kí tự (string literal), nơi mà giá trị của chuỗi được gán cứng (hardcoded) vào một văn bản trong chương trình. Biến có giá trị tại thời điểm mà nó được khai báo cho đến khi kết thúc scope hiện tại. Trong Listing 4-1 bên dưới có các comment chỉ ra nơi biến s hợp lệ

fn main() {
    {                      // s không hợp lệ ở đây, nó chưa được khai báo
        let s = "hello";   // s có giá trị từ thời điểm này trở đi

        // nơi làm những thứ với s
    }                      // scope này hiện đã kết thúc và s không còn hợp lệ
}

Listing 4-1: Một biến và phạm vi mà nó hợp lệ

Nói cách khác, có hai điểm quan trọng về thời gian ở đây:

• Khi s đi vào scope, nó có giá trị.
• Nó vẫn có giá trị cho tới khi nó đi ra khỏi scope.

Tại thời điểm này, mối quan hệ giữa phạm vi và thời điểm các biến có giá trị tương tự như trong các ngôn ngữ lập trình khác. Bây giờ dựa trên hiểu biết này bây giờ chúng tôi sẽ giới thiệu về kiểu String.

Kiểu String

Để minh họa các quy tắc về ownership, chúng ta cần một kiểu dữ liệu phức tạp hơn những kiểu mà chúng ta đã đề cập trong phần “Data Types” ở chương 3. Các loại được đề cập trước đây đều có kích thước đã biết, có thể được lưu trữ trên stack và bị đẩy ra khỏi stack khi phạm vi của chúng kết thúc, và có thể được sao chép nhanh chóng và đơn để tạo ra một cái mới trong trường hợp độc lập nếu một phần khác của code cần sử dụng cùng một giá trị trong một phạm vi khác. Nhưng chúng ta muốn xem xét dữ liệu được lưu trữ trên heap và khám phá cách Rust biết khi nào cần dọn dẹp dữ liệu đó, và kiểu String là một ví dụ tuyệt vời.

Chúng ta sẽ tập trung vào các phần của String liên quan đến ownership. Các khía cạnh này cũng áp dụng cho các kiểu dữ liệu phức tạp khác, cho dù chúng được cung cấp bởi thư viện chuẩn hay do bạn tạo. Chúng ta sẽ thảo luận về String sâu hơn ở Chapter 8.

Chúng ta đã nhìn thấy những chuỗi kí tự (string literals) có giá trị được gán cứng (hardcoded) trong chương trình. Các ký tự kiểu chuỗi rất tiện lợi, nhưng chúng không phù hợp với mọi tình huống mà chúng ta có thể muốn sử dụng văn bản. Một lý do là chúng không thay đổi. Một điều khác là không phải mọi giá trị chuỗi đều có thể được biết khi chúng ta viết mã của mình, ví dụ: nếu chúng ta muốn lấy dữ liệu đầu vào của người dùng và lưu trữ nó thì sao? Trong tình huống này, Rust có một kiểu chuỗi thứ hai, String. Kiểu dữ liệu này được phân bổ trên heap, như thế nó có thể lưu trữ một khối lượng văn bản không biết trước ở thời điểm biên dịch. Bạn có thể tạo một String từ một string literal bằng cách sử dụng hàm from, như sau:

#![allow(unused)]
fn main() {
let s = String::from("hello");
}

Dấu hai chấm :: là một toán tử cho phép chúng ta gọi hàm (namespace) from với kiểu String thay vì sử dụng một số loại tên như string_from. Chúng ta sẽ thảo luận về cú pháp này nhiều hơn trong phần “Method Syntax” chương 5 và khi chúng ta nói về namespacing với module ở phần “Paths for Referring to an Item in the Module Tree” trong chương 7.

Kiểu chuỗi này cũng có thể biến đổi giá trị (mutated):

fn main() {
    let mut s = String::from("hello");

    s.push_str(", world!"); // push_str() nối một ký tự vào một chuỗi

    println!("{}", s); // Điều này sẽ in ra `hello, world! '
}

Vậy, sự khác biệt ở đây là gì? Tại sao String có thể biến đổi trong khi chuỗi kí tự (string literals) thì không? Sự khác biệt là cách hai loại này tương tác với bộ nhớ.

Memory and Allocation (Bộ nhớ và cấp phát)

Trong trường hợp một chuỗi kí tự (string literal), chúng ta biết nội dung tại thời điểm biên dịch, vì vậy văn bản được gán cứng (hardcoded) trực tiếp vào tệp thực thi cuối cùng. Đây là lý do tại sao các ký tự chuỗi (string literals) nhanh và hiệu quả. Nhưng những thuộc tính này chỉ đến từ tính bất biến của chuỗi ký tự. Thật không may, chúng ta không thể đặt một blob memory vào hệ nhị phân cho mỗi đoạn văn bản có kích thước không xác định tại thời điểm biên dịch và kích thước của chúng có thể thay đổi trong khi chạy chương trình.

Với kiểu String, để hỗ trợ một đoạn văn bản có thể thay đổi, có thể phát triển, chúng ta cần phân bổ một lượng bộ nhớ trên heap, không xác định tại thời điểm biên dịch, để giữ nội dung. Điều này có nghĩa là:

• Bộ nhớ phải được yêu cầu từ bộ cấp phát bộ nhớ trong thời gian chạy (runtime).
• Chúng ta cần một cách để trả lại bộ nhớ này cho bộ cấp phát khi chúng ta hoàn thành String.

Phần đầu tiên do chúng ta thực hiện: khi chúng ta gọi String::from, việc triển khai của nó yêu cầu bộ nhớ mà nó cần. Điều này khá phổ biến trong các ngôn ngữ lập trình.

Tuy nhiên, phần thứ hai thì khác. Trong các ngôn ngữ có garbage collector(GC), theo dõi và dọn dẹp bộ nhớ không còn được sử dụng nữa và chúng ta không cần phải suy nghĩ về điều đó. Trong hầu hết các ngôn ngữ không có GC, chúng ta có trách nhiệm xác định khi nào bộ nhớ không còn được sử dụng và dùng code để trả lại bộ nhớ một cách rõ ràng, giống như chúng ta đã làm để yêu cầu nó. Trong lịch sử để thực hiện điều này một cách chính xác là một vấn đề khó khăn của lập trình. Nếu chúng ta quên, chúng ta sẽ lãng phí bộ nhớ. Nếu chúng ta làm điều đó quá sớm, chúng ta sẽ có một biến không hợp lệ. Nếu chúng tôi làm điều đó hai lần, đó cũng là một lỗi. Chúng ta cần ghép chính xác một allocate với một free.

Rust đi theo một con đường khác: bộ nhớ sẽ tự động được trả về khi biến sở hữu nó vượt ra khỏi phạm vi (scope). Dưới đây là một phiên bản của ví dụ về scope từ Listing 4-1 sử dụng một String thay vì một chuỗi kí tự (string literal):

fn main() {
    {
        let s = String::from("hello"); // s có giá trị từ thời điểm này trở đi

        // do stuff with s
    }                                  // phạm vi này hiện đã kết thúc và không  
                                       // còn giá trị
}

Có một điểm tự nhiên mà chúng ta có thể trả lại vùng nhớ String của chúng ta cho bộ cấp phát: khi s đi ra khỏi scope. Khi một biến vượt ra ngoài scope, Rust gọi một hàm đặc biệt cho chúng ta. Hàm này được gọi là drop, và nó là nơi mà tác giả của String có thể đặt code để trả lại bộ nhớ. Rust gọi drop tự động tại nơi dấu đóng ngoặc nhọn.

Note: Lưu ý: Trong C ++, kiểu phân bổ tài nguyên này ở cuối vòng đời của một item đôi khi được gọi là Resource Acquisition Is Initialization (RAII). Hàm drop trong Rust sẽ quen thuộc hơn với bạn nếu bạn từng dùng mô hình RAII.

Mô hình này có tác động sâu sắc đến cách viết code của Rust. Nó có vẻ đơn giản ngay bây giờ, nhưng hành vi của code có thể không mong muốn trong các tình huống phức tạp hơn khi chúng ta muốn có nhiều biến sử dụng dữ liệu chúng ta đã phân bổ trên heap. Bây giờ chúng ta hãy khám phá một số tình huống đó.

Cách các biến và dữ liệu tương tác: Move

Nhiều biến có thể tương tác với cùng một dữ liệu theo những cách khác nhau trong Rust. Hãy xem một ví dụ sử dụng một số nguyên trong Listing 4-2.

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

Listing 4-2: Gán giá trị nguyên của biến x vào y

Chúng ta có thể đoán được đoạn code này đang thể hiện gì: “gán giá trị 5 vào x; sau đó tạo một bản sao của giá trị của x và gán nó bằng y.” Bây giờ chúng ta có hai biến, x và y, cả 2 đều bằng 5. Đây thực sự là những gì đang xảy ra, bởi vì số nguyên là các giá trị đơn giản có giá trị cố định, đã biết, và hai giá trị 5 này được đẩy vào stack.

Giờ hãy cùng nhìn vào phiên bản String:

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;
}

Điều này trông rất giống nhau, vì vậy chúng tôi có thể giả định rằng cách nó hoạt động sẽ giống nhau: nghĩa là, dòng thứ hai sẽ tạo một bản sao của giá trị trong s1 và gán nó cho s2. Nhưng đây không phải là điều sẽ diễn ra.

Hãy xem Hình 4-1 để xem điều gì đang xảy ra với String trong thực tế. String được tạo thành từ ba phần, hiển thị ở bên trái: một con trỏ tới bộ nhớ chứa nội dung của string, một độ dài, và một dung lượng (capacity). Nhóm dữ liệu này được lưu trữ trên stack. Ở bên phải là bộ nhớ trên heap chứa nội dung.

Hình 4-1: Biểu diễn trong bộ nhớ của một String giữ giá trị "hello" gán cho s1

Độ dài là lượng bộ nhớ, tính bằng byte, mà nội dung của String đang sử dụng. Dung lượng (capacity) là tổng dung lượng bộ nhớ, tính bằng byte mà String đã nhận được từ bộ cấp phát. Có sự khác biệt giữa độ dài và dung lượng (capacity), nhưng không phải trong bối cảnh này, vì vậy hiện tại, bạn có thể bỏ qua dung lượng (capacity).

Khi chúng ta gán s1 cho s2, dữ liệu String được sao chép, có nghĩa là chúng ta sao chép con trỏ, độ dài và dung lượng trên stack. Chúng ta không sao chép dữ liệu trên heap mà con trỏ chỉ tới. Nói cách khác, dữ liệu được biểu diễn trong bộ nhớ như Hình 4-2.

Hình 4-2: Biểu diễn trong bộ nhớ của biến s2 chứa bản sao của con trỏ, độ dài và dung lượng của s1

Biểu diễn trên Hình 4-2 không giống như Hình 4-3, đó là bộ nhớ sẽ trông như thế nào nếu thay vào đó Rust cũng sao chép dữ liệu heap. Nếu Rust đã làm điều này, s2 = s1 có thể rất tốn kém về hiệu suất thời gian chạy nếu dữ liệu trên heap lớn.

Hình 4-3: Một khả năng khác cho những gì s2 = s1 có thể làm nếu Rust cũng sao chép dữ liệu heap

Trước đó, chúng tôi đã nói rằng khi một biến vượt ra ngoài scope, Rust tự động gọi hàm drop và dọn dẹp bộ nhớ heap cho biến đó. Nhưng Hình 4-2 hiển thị cả hai con trỏ dữ liệu trỏ đến cùng một vị trí. Đây là một vấn đề: khi s2 và s1 vượt ra ngoài scope, cả hai sẽ cố gắng giải phóng cùng một bộ nhớ. Điều này được gọi là lỗi double free và là một trong những lỗi an toàn bộ nhớ mà chúng tôi đã đề cập trước đây. Giải phóng bộ nhớ hai lần có thể dẫn đến hỏng bộ nhớ, có thể dẫn đến lỗ hổng bảo mật.

Để đảm bảo an toàn cho bộ nhớ, sau dòng let s2 = s1, Rust coi s1 không còn giá trị nữa. Do đó, Rust không cần giải phóng bất cứ thứ gì khi khi s1 đi ra khỏi scope. Kiểm tra những gì sẽ xảy ra khi bạn cố gắng sử dụng s1 sau khi s2 được tạo ra; nó sẽ không hoạt động:

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;

    println!("{}, world!", s1);
}

Bạn sẽ gặp lỗi như thế này vì Rust ngăn bạn sử dụng tham chiếu không hợp lệ:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0382]: borrow of moved value: `s1`
 --> src/main.rs:5:28
  |
2 |     let s1 = String::from("hello");
  |         -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
3 |     let s2 = s1;
  |              -- value moved here
4 | 
5 |     println!("{}, world!", s1);
  |                            ^^ value borrowed here after move
  |
  = note: this error originates in the macro `$crate::format_args_nl` (in Nightly builds, run with -Z macro-backtrace for more info)

For more information about this error, try `rustc --explain E0382`.
error: could not compile `ownership` due to previous error

Nếu bạn đã nghe về thuật ngữ sao chép cạn (shallow copy) và sao chép sâu (deep copy) trong khi làm việc với các ngôn ngữ khác, khái niệm sao chép con trỏ, độ dài và dung lượng mà không sao chép dữ liệu có thể nghe giống như tạo một sao chép cạn. Nhưng vì Rust cũng làm mất hiệu lực của biến đầu tiên, thay vì gọi nó là một sao chép cạn, nó được gọi là một move (di chuyển). Trong ví dụ này, chúng ta sẽ nói rằng s1 đã được moved vào s2. Những gì thực sự xảy ra được thể hiện trong Hình 4-4.

Hình 4-4: Biểu diễn trong bộ nhớ sau khi s1 đã bị vô hiệu

Điều đó giải quyết vấn đề của chúng tôi! Chỉ với s2 còn giá trị và khi nó vượt ra ngoài scope, chỉ nó sẽ giải phóng bộ nhớ và chúng ta đã hoàn tất.

Ngoài ra, có một lựa chọn thiết kế được ngụ ý bởi điều này: Rust sẽ không bao giờ tự động tạo các bản sao "sâu" (deep copy) dữ liệu của bạn. Do đó, bất kỳ tự động sao chép nào cũng có thể được coi là không tốn kém về hiệu suất runtime.

Cách tương tác giữa các biến và dữ liệu: Clone

Nếu chúng tôi muốn sao chép sâu dữ liệu heap của String, không chỉ là dữ liệu stack, chúng ta có thể sử dụng một phương thức (method) phổ biến được gọi là clone. Chúng ta sẽ thảo luận về cú pháp của method trong Chương 5, nhưng vì các method là một tính năng phổ biến trong nhiều ngôn ngữ lập trình, nên có thể bạn đã từng thấy chúng trước đây.

Đây là một ví dụ của method clone:

fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone();

    println!("s1 = {}, s2 = {}", s1, s2);
}

Đoạn code hoạt động tốt và rõ ràng tạo ra hành vi được hiển thị trong Hình 4-3, nơi dữ liệu heap được sao chép.

Khi bạn thấy một lệnh gọi clone, bạn biết rằng đoạn code nào đó đang được thực thi và code đó có thể khá tốn tài nguyên. Đó là một chỉ báo trực quan cho thấy điều gì đó khác thường đang diễn ra.

Dữ liệu chỉ trên Stack (Stack-Only Data): Copy

Có một vấn đề khác mà chúng ta chưa nói đến. Đoạn code này sử dụng số nguyên – một phần trong số đó đã được hiển thị trong Listing 4-2 – hoạt động và hợp lệ:

fn main() {
    let x = 5;
    let y = x;

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

Nhưng mã này có vẻ mâu thuẫn với những gì chúng ta vừa học được: chúng ta không gọi lệnh clone, nhưng x vẫn còn hiệu lực và chưa được move vào y.

Lý do là các loại như số nguyên có kích thước đã biết tại thời điểm biên dịch được lưu trữ hoàn toàn trên stack, vì vậy các bản sao của các giá trị thực tế được tạo ra nhanh chóng. Điều đó có nghĩa là không có lý do gì chúng tôi muốn ngăn chặn x không còn hợp lệ sau khi chúng tôi tạo biến y. Nói cách khác, không có sự khác biệt giữa sao chép sâu và sao chép cạn ở đây, vì vậy việc gọi clone sẽ không làm gì khác so với cách sao chép cạn thông thường và chúng ta có thể bỏ nó đi.

Rust có một chú thích (annotation) đặc biệt gọi là Copy trait chúng ta có thể đặt nó trên những kiểu được lưu trữ trên stack như integer (chúng ta sẽ nói thêm về trait trong Chương 10). Nếu một kiểu thực hiện Copy trait, một biến vẫn hợp lệ sau khi gán cho một biến khác. Rust không cho phép chúng ta chú thích một kiểu với Copy nếu kiểu của nó, hoặc bất kì phần nào của nó, đã thực thi Drop trait. Nếu kiểu cần một cái gì đó đặc biệt để xảy ra khi giá trị vượt ra ngoài scope và chúng ta thêm Copy annotation vào kiểu đó, chúng ta sẽ gặp lỗi biên dịch. Để tìm hiểu về cách thêm Copy annotation vào kiểu của bạn để triển khai trait, hãy xem “Derivable Traits” trong Phụ lục C.

Vậy, những loại nào triển khai Copy trait? Bạn có thể kiểm tra tài liệu về loại đã cho để chắc chắn, nhưng theo quy tắc chung, bất kỳ nhóm giá trị vô hướng đơn giản nào cũng có thể triển khai Copy, và không có kiểu nào yêu cầu allocation hoặc là một dạng của resource có thể triển khai Copy. Dưới đây là một số kiểu có thể triển khai Copy:

• Tất cả các kiểu số nguyên, chẳng hạn như u32.
• Kiểu Boolean, bool, với giá trị true và false.
• Tất cả các kiểu dấu phẩy động, chẳng hạn như f64.
• Kiểu ký tự, char.
• Tuples, nếu chúng chỉ chứa những kiểu có thể triển khai Copy. Ví dụ, (i32, i32) có thể triển khai Copy, nhưng (i32, String) thì không.

Ownership và Hàm

Ý nghĩa cho việc truyền một giá trị tới một hàm tương tự việc gán một giá trị vào một biến. Truyền một biến cho một hàm sẽ di chuyển hoặc sao chép, giống như phép gán. Listing 4-3 có một ví dụ với một số chú thích hiển thị nơi các biến đi vào và ra khỏi scope.

Filename: src/main.rs

fn main() {
    let s = String::from("hello");  // s đi vào scope

    takes_ownership(s);             // giá trị của s di chuyển vào hàm...
                                    // ... và như vậy không còn giá trị ở đây

    let x = 5;                      // x đi vào scope

    makes_copy(x);                  // x sẽ di chuyển vào hàm,
                                    // nhưng i32 là Copy, vì vậy vẫn hoàn toàn có thể
                                    // sử dụng x sau đó

} // Tại đây, x đi ra khỏi scope, sau đó là s. Nhưng vì giá trị của s đã được move, nên không có gì 
  // đặc biệt xảy ra.

fn takes_ownership(some_string: String) { // some_string đi vào scope
    println!("{}", some_string);
} // Tại đây, some_string đi ra khỏi scope và `drop` được gọi. Bộ nhớ được giải phóng.

fn makes_copy(some_integer: i32) { // some_integer đi vào scope
    println!("{}", some_integer);
} // Tại đây, some_integer đi ra khỏi scope. Không có gì đặc biệt xảy ra.

Listing 4-3: Hàm với ownership và scope được chú thích

Nếu chúng ta cố gắng sử dụng s sau khi gọi takes_ownership, Rust sẽ báo lỗi biên dịch. Những kiểm tra tĩnh này bảo vệ chúng ta khỏi những sai lầm. Thử thêm code vào main sử dụng s và x để xem bạn có thể sử dụng chúng ở đâu và các quy tắc ownership ngăn bạn làm điều đó ở đâu.

Trả về giá trị và (Tầm vực - Phạm vi) Scope

Giá trị trả về cũng có thể chuyển giao ownership. Listing 4-4 hiển thị một ví dụ về một hàm trả về một số giá trị, với các chú thích tương tự như trong Listing 4-3.

Filename: src/main.rs

fn main() {
    let s1 = gives_ownership();         // gives_ownership di chuyển giá trị trả về của nó
                                        // vào s1

    let s2 = String::from("hello");     // s2 đi vào scope

    let s3 = takes_and_gives_back(s2);  // s2 is được di chuyển vào
                                        // takes_and_gives_back, và 
                                        // giá trị trả về của nó được di chuyển vào s3
} // Tại đây, s3 đi ra khỏi scope và bị drop. s2 đã bị di chuyển, vậy nên không có gì
  // xảy ra. s1 đi ra khỏi scope và bị drop.

fn gives_ownership() -> String {             // gives_ownership sẽ di chuyển 
                                             // giá trị trả về của nó nó vào hàm gọi nó
                                             
    let some_string = String::from("yours"); // some_string đi vào scope

    some_string                              // some_string được trả về và
                                             // chuyển sang hàm gọi
                          
}

// Hàm này nhận một a String trả về một string
fn takes_and_gives_back(a_string: String) -> String { // a_string đi vào
                                                      // scope

    a_string  // a_string được trả về và chuyển sang hàm gọi
}

Listing 4-4: Chuyển ownership của giá trị trả về

Ownership của một biến luôn tuân theo cùng một mẫu: việc gán một giá trị cho một biến khác sẽ di chuyển nó. Khi một biến bao gồm dữ liệu trên heap vượt ra khỏi scope, giá trị sẽ được xóa bởi drop trừ khi ownership của dữ liệu đã được chuyển sang một biến khác.

Việc lấy ownership và sau đó trả về ownership với mọi hàm có một chút tẻ nhạt. Điều gì sẽ xảy ra nếu chúng ta muốn cho một hàm sử dụng một giá trị nhưng không có ownership? Điều khá khó chịu là bất kỳ thứ gì chúng ta truyền đi cũng cần phải được truyền lại nếu chúng ta muốn sử dụng lại nó, thêm cả bất kỳ dữ liệu nào đến từ phần thân của hàm mà chúng ta có thể muốn trả về.

Rust cho phép chúng ta trả về nhiều giá trị bằng cách sử dụng một bộ tuple, như được hiển thị trong Listing 4-5.

Filename: src/main.rs

fn main() {
    let s1 = String::from("hello");

    let (s2, len) = calculate_length(s1);

    println!("The length of '{}' is {}.", s2, len);
}

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len(); // len() trả về độ dài của một String

    (s, length)
}

Listing 4-5: Returning ownership of parameters

Nhưng đây là quá nhiều thao tác và rất nhiều công việc đối với một khái niệm nên phổ biến. May mắn cho chúng ta, Rust có một tính năng để sử dụng một giá trị mà không cần chuyển ownership, được gọi là references.

Tham chiếu và nguyên lý mượn - borrowing (References và Borrowing)

Data races: Chạy đua dữ liệu, chỉ hiện tượng các đoạn code khác nhau cùng đòi quyền sử dụng một biến hay một vùng bộ nhớ

Vấn đề với tuple trong Listing 4-5 là chúng ta phải trả lại String cho hàm gọi vì vậy chúng ta vẫn có thể sử dụng String sau khi gọi calculate_length, vì String đã được chuyển đến calculate_length. Thay vào đó, chúng ta có thể cung cấp một tham chiếu (reference) đến giá trị của String. Một tham chiếu (reference) giống như một con trỏ ở chỗ đó là một địa chỉ mà chúng ta có thể đi theo để truy cập vào dữ liệu được lưu trữ tại địa chỉ thuộc sở hữu của một số biến khác. Không giống như một con trỏ, một tham chiếu được đảm bảo trỏ đến một giá trị hợp lệ của một kiểu cụ thể. Đây là cách bạn sẽ xác định và sử dụng một hàm calculate_length có tham chiếu đến một đối tượng dưới dạng tham số thay vì dùng ownership để có quyền sở hữu giá trị:

Filename: src/main.rs

fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1);

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

Đầu tiên, hãy lưu ý rằng tất cả tuple trong khai báo biến và giá trị trả về của hàm đã biến mất. Thứ hai, lưu ý rằng chúng tôi chuyển &s1 vào calculate_length và, theo định nghĩa của nó, chúng tôi lấy &String thay vì String. Các ký hiệu & này đại diện cho các tham chiếu (references), và chúng cho phép bạn tham chiếu đến một số giá trị mà không cần lấy ownership của nó. Hình 4-5 mô tả khái niệm này.

Figure 4-5: Một sơ đồ của &String s trỏ vào String s1

Lưu ý: Ngược lại với tham chiếu bằng cách sử dụng & is dereferencing, được thực hiện với toán tử dereference, *. Chúng ta sẽ thấy một số cách sử dụng của toán tử dereference trong Chương 8 và thảo luận chi tiết về dereferencing trong Chương 15.

Chúng ta hãy xem xét kỹ hơn lệnh gọi hàm tại đây:

fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1);

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

&s1 cú pháp cho phép chúng ta tạo một tham chiếu đề cập đến giá trị của s1 nhưng không sở hữu nó. Bởi vì nó không sở hữu nó, giá trị nó trỏ đến sẽ không bị drop khi tham chiếu ngừng được sử dụng.

Tương tự như vậy, chữ ký hàm (signature of the function) sử dụng uses & để chỉ ra rằng kiểu tham số s là một tham chiếu. Hãy xem một số chú thích để giải thích cho việc này:

fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1);

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize { //s là một tham chiếu đến một String
    s.len()
} // Tại đây, s đi ra khỏi scope. Nhưng vì nó không có quyền sở hữu của String nó đề cập đến, 
  // nên không có gì xảy ra.

Phạm vi mà biến s có giá trị giống như phạm vi của bất kỳ thông số hàm nào, nhưng giá trị được trỏ đến bởi tham chiếu không bị drop khi s được dừng sử dụng vì s không có ownership. Khi các hàm có tham chiếu dưới dạng tham số thay vì giá trị thực, chúng ta sẽ không cần trả lại giá trị để trả lại ownership vì chúng ta chưa bao giờ có ownership.

Chúng tôi gọi hành động tạo tham chiếu là borrowing. Như trong cuộc sống thực, nếu một người sở hữu một thứ gì đó, bạn có thể mượn nó từ họ. Khi bạn làm xong, bạn phải trả lại nó. Bạn không sở hữu nó.

Vậy điều gì sẽ xảy ra nếu chúng ta cố gắng sửa đổi thứ mà chúng ta đang vay mượn (borrowing)? Hãy thử code trong Listing 4-6. Spoiler cảnh báo: nó không hoạt động!

Filename: src/main.rs

fn main() {
    let s = String::from("hello");

    change(&s);
}

fn change(some_string: &String) {
    some_string.push_str(", world");
}

Listing 4-6: Attempting to modify a borrowed value

Here’s the error:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` reference
 --> src/main.rs:8:5
  |
7 | fn change(some_string: &String) {
  |                        ------- help: consider changing this to be a mutable reference: `&mut String`
8 |     some_string.push_str(", world");
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable

For more information about this error, try `rustc --explain E0596`.
error: could not compile `ownership` due to previous error

Cũng giống như các biến là bất biến theo mặc định, các tham chiếu cũng vậy. Chúng tôi không được phép sửa đổi điều gì đó mà chúng tôi có tham chiếu đến.

Tham chiếu (References) có thể thay đổi

Chúng ta có thể sửa code từ Listing 4-6 để cho phép chúng ta sửa đổi một giá trị đã mượn chỉ với một vài chỉnh sửa nhỏ, bằng cách sử dụng tham chiếu có thể thay đổi (mutable reference):

Filename: src/main.rs

fn main() {
    let mut s = String::from("hello");

    change(&mut s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

Đầu tiên, chúng ta thay đổi s s thành mut để có thể thay đổi. Sau đó, chúng tôi tạo một tham chiếu có thể thay đổi với &muts nơi chúng ta gọi hàm change, và cập nhật chữ ký hàm (function signature) để chấp nhận một tham chiếu có thể thay đổi với some_string: &mut String. Điều này làm cho nó rất rõ ràng rằng hàm change sẽ thay đổi giá trị mà nó vay.

Tham chiếu có thể thay đổi có một hạn chế lớn: bạn chỉ có thể có một tham chiếu có thể thay đổi cho một phần dữ liệu cụ thể tại một thời điểm. Code này cố gắng tạo hai tham chiếu có thể thay đổi cho s sẽ không thành công:

Filename: src/main.rs

fn main() {
    let mut s = String::from("hello");

    let r1 = &mut s;
    let r2 = &mut s;

    println!("{}, {}", r1, r2);
}

Đây là lỗi:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0499]: cannot borrow `s` as mutable more than once at a time
 --> src/main.rs:5:14
  |
4 |     let r1 = &mut s;
  |              ------ first mutable borrow occurs here
5 |     let r2 = &mut s;
  |              ^^^^^^ second mutable borrow occurs here
6 | 
7 |     println!("{}, {}", r1, r2);
  |                        -- first borrow later used here

For more information about this error, try `rustc --explain E0499`.
error: could not compile `ownership` due to previous error

Lỗi này cho biết rằng code không hợp lệ vì chúng ta không thể mượn (borrow) s có thể thay đổi nhiều lần tại một thời điểm. Đầu tiên là tại s1 r1 và nó kéo dài cho tới khi sử dụng println!, nhưng giữa chừng, chúng ta đã cố gắng tạo một tham chiếu có thể thay đổi khác tại r2 mượn cùng một dữ liệu như r1.

Hạn chế ngăn nhiều tham chiếu có thể thay đổi đến cùng một dữ liệu cùng một lúc cho phép tạo ra đột biến nhưng theo cách rất được kiểm soát. Đó là điều mà những Rustaceans mới gặp khó khăn vì hầu hết các ngôn ngữ đều cho phép bạn thay đổi bất cứ khi nào bạn muốn. Lợi ích của việc hạn chế này là Rust có thể ngăn chặn hiện tượng data race tại thời điểm biên dịch. Một data race tương tự như một race condition và xảy ra khi ba hành vi này xảy ra:

• Hai hoặc nhiều con trỏ truy cập cùng một dữ liệu cùng một lúc.
• Ít nhất một trong các con trỏ đang được sử dụng để ghi vào dữ liệu.
• Không có cơ chế nào được sử dụng để đồng bộ hóa quyền truy cập vào dữ liệu.

Chạy đua dữ liệu (Data races) gây ra hành vi không xác định (undefined behavior) và có thể khó chẩn đoán và khắc phục khi bạn đang cố gắng theo dõi chúng trong runtime; Rust ngăn chặn vấn đề này bằng cách từ chối biên dịch code với data races!

Như mọi khi, chúng ta có thể sử dụng dấu ngoặc nhọn để tạo một phạm vi mới, cho phép nhiều tham chiếu có thể thay đổi, chỉ là những tham chiếu không được xảy ra đồng thời:

fn main() {
    let mut s = String::from("hello");

    {
        let r1 = &mut s;
    } // r1 đi ra khỏi scope tại đây, vì vậy chúng ta có thể tạo một 
      //tham chiếu mới mà không gặp vấn đề gì.

    let r2 = &mut s;
}

Rust thực thi một quy tắc tương tự để kết hợp các tham chiếu có thể thay đổi và bất biến. Code này dẫn đến lỗi:

fn main() {
    let mut s = String::from("hello");

    let r1 = &s; // no problem
    let r2 = &s; // no problem
    let r3 = &mut s; // BIG PROBLEM

    println!("{}, {}, and {}", r1, r2, r3);
}

Here’s the error:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
 --> src/main.rs:6:14
  |
4 |     let r1 = &s; // no problem
  |              -- immutable borrow occurs here
5 |     let r2 = &s; // no problem
6 |     let r3 = &mut s; // BIG PROBLEM
  |              ^^^^^^ mutable borrow occurs here
7 | 
8 |     println!("{}, {}, and {}", r1, r2, r3);
  |                                -- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` due to previous error

Chà! Chúng ta cũng không thể có một tham chiếu có thể thay đổi (mutable reference) trong khi chúng ta có một tham chiếu bất biến (immutable reference) với cùng một giá trị. Người dùng tham chiếu bất biến không mong đợi giá trị đột ngột thay đổi! Tuy nhiên, việc sử dụng nhiều tham chiếu bất biến thì được cho phép vì không ảnh hưởng đến việc đọc dữ liệu của bất kỳ ai khác.

Lưu ý rằng phạm vi của tham chiếu bắt đầu từ nơi nó tạo ra và tiếp tục cho đến lần cuối cùng tham chiếu đó được sử dụng. Ví dụ: code này vẫn sẽ biên dịch vì nơi sử dụng cuối cùng của các tham chiếu bất biến tại println!, xảy ra trước khi tham chiếu có thể thay đổi được tạo ra:

fn main() {
    let mut s = String::from("hello");

    let r1 = &s; // no problem
    let r2 = &s; // no problem
    println!("{} and {}", r1, r2);
    // biến r1 và r2 sẽ không được sử dụng sau thời điểm này 

    let r3 = &mut s; // no problem
    println!("{}", r3);
}

Phạm vi của các tham chiếu bất biến r1 và r2 kết thúc sau println! nơi chúng được sử dụng lần cuối, trước tham chiếu có thể thay đổi r3 được tạo ra. Các phạm vi này không trùng lặp, vì vậy code này được phép sử dụng. Khả năng của trình biên dịch để thông báo rằng một tham chiếu không còn được sử dụng tại một điểm trước khi kết thúc phạm vi được gọi là Non-Lexical Lifetimes (viết tắt là NLL), và bạn có thể đọc thêm về nó trong The Edition Guide.

Mặc dù đôi khi lỗi borrowing có thể khiến bạn bực bội, hãy nhớ rằng đó là trình biên dịch Rust chỉ ra một lỗi tiềm ẩn sớm (tại tại thời điểm biên dịch thay vì tại runtime) và cho bạn thấy chính xác vấn đề nằm ở đâu. Sau đó, bạn không phải theo dõi lý do tại sao dữ liệu của bạn không giống như bạn nghĩ nữa.

Tham chiếu treo (Hoặc Tham chiếu lạc) (Dangling References)

Trong các ngôn ngữ có con trỏ, rất dễ tạo sai một con trỏ treo (dangling pointer)--một con trỏ tham chiếu đến một vị trí trong bộ nhớ có thể đã được cấp cho người khác--bằng cách giải phóng một số bộ nhớ trong khi vẫn bảo toàn con trỏ tới bộ nhớ đó. Ngược lại, trong Rust, trình biên dịch đảm bảo rằng các tham chiếu sẽ không bao giờ là tham chiếu treo (dangling references): nếu bạn có tham chiếu đến một số dữ liệu, trình biên dịch sẽ đảm bảo rằng dữ liệu sẽ không vượt ra khỏi phạm vi trước khi tham chiếu đến dữ liệu đó.

Hãy thử tạo một tham chiếu treo (dangling references) để xem cách Rust ngăn chặn chúng với lỗi biên dịch:

Filename: src/main.rs

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String {
    let s = String::from("hello");

    &s
}

Here’s the error:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0106]: missing lifetime specifier
 --> src/main.rs:5:16
  |
5 | fn dangle() -> &String {
  |                ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime
  |
5 | fn dangle() -> &'static String {
  |                ~~~~~~~~

For more information about this error, try `rustc --explain E0106`.
error: could not compile `ownership` due to previous error

Thông báo lỗi này đề cập đến một tính năng mà chúng tôi chưa đề cập đến: lifetimes. Chúng ta sẽ thảo luận về lifetimes chi tiết trong Chương 10. Tuy nhiên, nếu bạn chưa nắm rõ về lifetimes thì thông báo vẫn có chỉ ra tại sao code này lại đang có vấn đề:

this function's return type contains a borrowed value, but there is no value
for it to be borrowed from
(kiểu trả về của hàm này chứa giá trị được borrow, nhưng không có giá trị nào cho nó được borrow)

Chúng ta hãy xem xét kỹ hơn chính xác những gì đang xảy ra ở mỗi giai đoạn trong code:

Filename: src/main.rs

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String { // trả về một tham chiếu đến một String

    let s = String::from("hello"); // s là một String mới

    &s // chúng ta trả về một tham chiếu đến  String, s
} // Tại đây, s đi ra khỏi scope, và bị dropped. Bộ nhớ của nó đã bị mất đi.
  // Nguy hiểm!

Bởi vì s được tạo ra bên trong dangle, khi code của dangle đã hoàn thành, s sẽ được phân bổ. Nhưng chúng ta đã cố gắng trả về một tham chiếu đến nó. Điều đó có nghĩa là tham chiếu này sẽ trỏ đến một String không còn giá trị. Điều đó không tốt! Rust sẽ không để chúng ta làm điều này.

Giải pháp ở đây là trả về String trực tiếp:

fn main() {
    let string = no_dangle();
}

fn no_dangle() -> String {
    let s = String::from("hello");

    s
}

Điều này hoạt động mà không có bất kỳ vấn đề gì. Ownership đã được chuyển ra ngoài, và không có gì được phân bổ.

Các quy tắc của References

Hãy tóm tắt lại những gì chúng ta đã thảo luận về tham chiếu (references):

• Tại một thời điểm, bạn chỉ có thể có một tham chiếu có thể thay đổi (mutable reference) và có thể có nhiều tham chiếu bất biến (immutable references).
• Tham chiếu phải luôn có giá trị.

Tiếp theo, chúng ta sẽ xem xét một loại tham chiếu khác: slices.

Kiểu Slice

Slices cho phép bạn tham chiếu một chuỗi các phần tử liền nhau trong một tập hợp thay vì toàn bộ tập hợp. Một slice là một loại tham chiếu, vì vậy nó không có ownership.

Có một vấn đề nhỏ trong lập trình: viết một hàm nhận một chuỗi (String) và trả về từ đầu tiên mà nó tìm thấy trong chuỗi đó. Nếu hàm không tìm thấy khoảng trắng trong chuỗi, thì toàn bộ chuỗi phải là một từ, do đó, toàn bộ chuỗi phải được trả về.

Hãy cùng tìm hiểu về cách chúng ta viết chữ ký của hàm (signature of function) mà không cần sử dụng các slice, để hiểu vấn đề mà các slice sẽ giải quyết:

fn first_word(s: &String) -> ?

Hàm first_word có một &String là một tham số. Chúng ta không muốn sử dụng ownership, vì vậy điều này không sao cả. Nhưng chúng ta nên return lại cái gì? Chúng ta thực sự không có cách nào để nói về một phần của một string. Tuy nhiên, chúng ta có thể trả về index ở cuối từ, nếu nó là một khoảng trắng. Hẫy thử điều đó trong Listing 4-7.

Filename: src/main.rs

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Listing 4-7: Hàm first_word trả về một giá trị index dạng byte vào tham số String

Bởi vì chúng ta cần đi qua phần tử của String theo từng phần tử và kiểm tra xem một giá trị có phải là khoảng trắng hay không, chúng ta sẽ chuyển đổi String thành một mảng byte bằng method as_bytes:

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Tiếp theo, chúng ta tạo một trình lặp trên mảng byte bằng method iter:

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Chúng ta sẽ thảo luận chi tiết hơn về trình lặp trong Chương 13. Bây giờ, hãy biết rằng iter là một method that trả về từng phần tử trong một tập hợp và enumerate sẽ bao bọc kết quả của iter và trả về từng phần tử dưới dạng một phần của một tuple. Phần tử đầu tiên của tuple được trả về từ enumerate là index,và phần tử thứ hai là một tham chiếu đến phần tử. Điều này thuận tiện hơn một chút so với việc tự tính toán index.

Bởi vì method enumerate một tuple,chúng ta có thể sử dụng các patterns để cấu trúc bộ tuple đó. Chúng ta sẽ thảo luận thêm về patterns trong Chương 6. Trong vòng lặp for, chúng ta xác định một pattern có i là index trong tuple và &item cho single byte trong tuple. Bởi vì chúng ta nhận được một tham chiếu đến phần tử từ .iter().enumerate() nên chúng ta sử dụng & trong pattern.

Trong vòng lặp for, chúng ta tìm kiếm byte đại diện cho khoảng trắng bằng cách sử dụng cú pháp ký tự byte. Nếu chúng ta tìm thấy một khoảng trắng, chúng ta sẽ trả về vị trí của nó. Nếu không, chúng ta trả về độ dài của chuỗi bằng cách sử dụng s.len():

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Bây giờ chúng ta có một cách để tìm ra index của cuối từ đầu tiên trong chuỗi, nhưng có một vấn đề. Chúng ta đang trả lại một usize của riêng nó, nhưng nó chỉ là một con số có ý nghĩa trong ngữ cảnh của &String. Nói cách khác, bởi vì nó là một giá trị riêng biệt với String, không có gì đảm bảo rằng nó sẽ vẫn có giá trị trong tương lai. Xem xét chương trình trong Listing 4-8 sử dụng hàm first_word từ Listing 4-7.

Filename: src/main.rs

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s); // word sẽ nhận được giá trị 5

    s.clear(); // ở đây chúng ta làm trống String, làm cho nó bằng ""

    // word vẫn có giá trị 5 ở đây, nhưng không còn String nào mà chúng ta có thể sử dụng
    // một cách có ý nghĩa với giá trị 5 này nên word bây giờ hoàn toàn không có giá trị sử dụng!
}

Listing 4-8: Lưu trữ kết quả trả về khi gọi hàm first_word function và sau đó thay đổi nội dung của String

Chương trình này biên dịch mà không có bất kỳ lỗi nào và cũng như vậy nếu chúng ta sử dụng word sau khi gọi s.clear(). Vì word hoàn toàn không kết nối với trạng thái của s, word vẫn chứa giá trị 5. Nếu chúng ta sử dụng giá trị 5 với biến s để trích xuất từ ​​đầu tiên, nhưng đây sẽ là một lỗi vì nội dung của s đã thay đổi kể từ khi chúng ta lưu 5 trong word.

Việc phải lo lắng về việc index trong word không đồng bộ với dữ liệu trong s thật tẻ nhạt và dễ xảy ra lỗi! Việc quản lý các chỉ số này thậm chí còn khó khăn hơn nếu chúng ta viết một hàm second_word. Chữ ký hàm của nó sẽ phải trông như thế này:

fn second_word(s: &String) -> (usize, usize) {

Bây giờ chúng ta đang theo dõi index nơi bắt đầu và nơi kết thúc, và chúng ta có nhiều giá trị hơn được tính toán từ dữ liệu ở một trạng thái cụ thể nhưng hoàn toàn không bị ràng buộc với trạng thái đó. Chúng tôi có tới ba biến không liên quan đang trôi nổi cần được đồng bộ hóa.

May mắn thay, Rust có một giải pháp cho vấn đề này: string slices.

String Slices

Một string slice là một tham chiếu đến một phần của một String, và nó trông như thế này:

fn main() {
    let s = String::from("hello world");

    let hello = &s[0..5];
    let world = &s[6..11];
}

Thay vì tham chiếu đến toàn bộ String, hello là một tham chiếu đến một phần của String, được xác định trong [0..5] bit. Chúng ta tạo các lát cắt (slices) bằng cách sử dụng một phạm vi trong dấu ngoặc bằng cách chỉ định [starting_index..ending_index], starting_index là vị trí đầu tiên trong slice và ending_index nhiều hơn một so với vị trí cuối cùng trong slice. Bên trong, cấu trúc dữ liệu slice lưu trữ vị trí bắt đầu và độ dài của slice, tương ứng với ending_index trừ đi starting_index. Vì vậy, trong trường hợp của let world = &s[6..11];, world là một slice chứa một con trỏ đến byte tại index 6 của s với giá trị độ dài là 5.

Figure 4-6 cho thấy điều này trong một sơ đồ.

Figure 4-6: String slice tham chiếu đến một phần của một String

Với .. là cú pháp phạm vi của Rust, nếu bạn muốn bắt đầu từ index 0, bạn có thể viết theo 2 cách sau, chúng tương đương nhau:

#![allow(unused)]
fn main() {
let s = String::from("hello");

let slice = &s[0..2];
let slice = &s[..2];
}

Tương tự, nếu slice của bạn bao gồm byte cuối cùng của String, bạn có thể bỏ len ở sau cùng. 2 cách viết dưới đây tương đương nhau:

#![allow(unused)]
fn main() {
let s = String::from("hello");

let len = s.len();

let slice = &s[3..len];
let slice = &s[3..];
}

Bạn cũng có thể bỏ cả hai giá trị để lấy một slice của toàn bộ chuỗi:

#![allow(unused)]
fn main() {
let s = String::from("hello");

let len = s.len();

let slice = &s[0..len];
let slice = &s[..];
}

Lưu ý: chỉ số phạm vi của String slice phải nằm trong ranh giới ký tự UTF-8 hợp lệ. Nếu bạn cố gắng tạo một string slice ở giữa một ký tự nhiều byte, chương trình của bạn sẽ thoát ra với một lỗi. Với mục đích giới thiệu string slices, chúng tôi chỉ giả định ASCII trong phần này; một cuộc thảo luận kỹ lưỡng hơn về việc xử lý UTF-8 có trong phần “Storing UTF-8 Encoded Text with Strings” ở chương 8.

Với tất cả thông tin này, chúng ta hãy viết lại first_word để return một slice. Kiểu biểu thị“string slice” được viết là &str:

Filename: src/main.rs

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {}

Chúng ta nhận được index cho cuối từ theo cách giống như chúng tôi đã làm trong Listing 4-7, bằng cách tìm kiếm sự xuất hiện đầu tiên của một khoảng trắng. Khi chúng tôi tìm thấy một khoảng trắng, chúng ta trả về một string slice sử dụng nơi bắt đầu của string và index của khoảng trắng làm chỉ số bắt đầu và kết thúc.

Bây giờ khi chúng ta gọi first_word, chúng ta nhận lại một giá trị duy nhất được liên kết với dữ liệu cơ bản. Giá trị được tạo thành từ tham chiếu đến điểm bắt đầu của slice và số phần tử trong slice.

Trả lại một slice cũng sẽ hoạt động cho một hàm second_word:

fn second_word(s: &String) -> &str {

Giờ đây, chúng tôi có một API đơn giản và khó bị xáo trộn hơn nhiều, vì trình biên dịch sẽ đảm bảo các tham chiếu vào String vẫn hợp lệ. Hãy nhớ lỗi trong chương trình trong Listing 4-8, khi chúng ta nhận được index của cuối từ đầu tiên nhưng sau đó xóa chuỗi nên index của chúng ta không hợp lệ? Code đó không chính xác về mặt logic nhưng không hiển thị bất kỳ lỗi nào ngay lập tức. Các vấn đề sẽ xuất hiện sau đó nếu chúng tôi tiếp tục cố gắng sử dụng index của từ đầu tiên với một chuỗi trống. Slices khiến lỗi này không thể xảy ra và cho chúng ta biết rằng chúng ta gặp sự cố với code của mình sớm hơn nhiều. Sử dụng phiên bản slice của first_word wsẽ gây ra lỗi biên dịch:

Filename: src/main.rs

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s);

    s.clear(); // error!

    println!("the first word is: {}", word);
}

Here’s the compiler error:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
  --> src/main.rs:18:5
   |
16 |     let word = first_word(&s);
   |                           -- immutable borrow occurs here
17 | 
18 |     s.clear(); // error!
   |     ^^^^^^^^^ mutable borrow occurs here
19 | 
20 |     println!("the first word is: {}", word);
   |                                       ---- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` due to previous error

Hãy nhớ lại các quy tắc borrowing rằng nếu chúng ta có một tham chiếu bất biến đến một cái gì đó, chúng ta cũng không thể lấy một tham chiếu có thể thay đổi được. Vì clear cần phải cắt bớt String, nó cần nhận được một tham chiếu có thể thay đổi. println! sau lệnh gọi clear sử dụng tham chiếu trong word, vì vậy tham chiếu bất biến phải vẫn hoạt động tại thời điểm đó. Rust không cho phép tham chiếu có thể thay đổi trong clear và tham chiếu bất biến trong word tồn tại cùng một lúc, và biên dịch không thành công. Rust không chỉ làm cho API của chúng ta dễ sử dụng hơn mà còn loại bỏ toàn bộ lớp lỗi tại thời điểm biên dịch!

String Literals là Slices

Nhớ lại rằng chúng ta đã nói về string literals .được lưu trữ bên trong tệp nhị phân. Bây giờ chúng ta biết về slices, chúng ta có thể hiểu đúng về string literals:

#![allow(unused)]
fn main() {
let s = "Hello, world!";
}

Kiểu của s ở đây là &str: nó là một slice chỉ đến điểm cụ thể của tệp nhị phân. Đây cũng là lý do tại sao string literals là bất biến; &str là một tham chiếu bất biến.

String Slices như là các tham số (String Slices as Parameters)

Biết rằng bạn có thể lấy slices trong tập hợp các chữ và giá trị String dẫn chúng ta đến một cải tiến nữa trên first_word, và đó là signature của nó:

fn first_word(s: &String) -> &str {

Một Rustacean có kinh nghiệm hơn sẽ viết signature trong Listing 4-9 vì nó cho phép chúng ta sử dụng cùng một hàm trên cả giá trị &String và giá trị &str.

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let my_string = String::from("hello world");

    // `first_word` works on slices of `String`s, whether partial or whole
    let word = first_word(&my_string[0..6]);
    let word = first_word(&my_string[..]);
    // `first_word` also works on references to `String`s, which are equivalent
    // to whole slices of `String`s
    let word = first_word(&my_string);

    let my_string_literal = "hello world";

    // `first_word` works on slices of string literals, whether partial or whole
    let word = first_word(&my_string_literal[0..6]);
    let word = first_word(&my_string_literal[..]);

    // Because string literals *are* string slices already,
    // this works too, without the slice syntax!
    let word = first_word(my_string_literal);
}

Listing 4-9: Cải tiến hàm first_word bằng cách sử dụng một string slice cho kiểu của tham số s

Nếu chúng ta có một string slice, chúng ta có thể truyền vào trực tiếp. Nếu chúng ta có một String, chúng ta có thể truyền một slice của String hoặc một tham chiếu đến String. Sự linh hoạt này tận dụng lợi thế của deref coercions, một tính năng chúng ta sẽ đề cập trong phần “Implicit Deref Coercions with Functions and Methods” của Chương 15. Việc xác định một hàm để lấy một string slice thay vì tham chiếu đến một String làm cho API của chúng ta trở nên tổng quát và hữu ích hơn mà không làm mất bất kỳ chức năng nào:

Filename: src/main.rs

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let my_string = String::from("hello world");

    // `first_word` works on slices of `String`s, whether partial or whole
    let word = first_word(&my_string[0..6]);
    let word = first_word(&my_string[..]);
    // `first_word` also works on references to `String`s, which are equivalent
    // to whole slices of `String`s
    let word = first_word(&my_string);

    let my_string_literal = "hello world";

    // `first_word` works on slices of string literals, whether partial or whole
    let word = first_word(&my_string_literal[0..6]);
    let word = first_word(&my_string_literal[..]);

    // Because string literals *are* string slices already,
    // this works too, without the slice syntax!
    let word = first_word(my_string_literal);
}

Kiểu Slices khác (Other Slices)

String slices, như bạn có thể tưởng tượng, dành riêng cho chuỗi. Nhưng cũng có một kiểu slice chung chung hơn. Hãy xem xét mảng này:

#![allow(unused)]
fn main() {
let a = [1, 2, 3, 4, 5];
}

Cũng giống như chúng ta có thể muốn tham chiếu đến một phần của chuỗi, chúng ta có thể muốn tham chiếu đến một phần của mảng. Chúng tôi sẽ làm như thế này:

#![allow(unused)]
fn main() {
let a = [1, 2, 3, 4, 5];

let slice = &a[1..3];

assert_eq!(slice, &[2, 3]);
}

Slice này có kiểu &[i32]. Nó hoạt động theo cách tương tự như string slices, bằng cách lưu trữ một tham chiếu đến phần tử đầu tiên và độ dài. Bạn sẽ sử dụng loại slice này cho tất cả các loại tập hợp khác. Chúng ta sẽ thảo luận chi tiết về các tập hợp này khi chúng ta nói về vectơ trong Chương 8.

Summary

Các khái niệm về ownership, borrowing, và slices đảm bảo an toàn cho bộ nhớ trong các chương trình Rust tại thời điểm biên dịch. Ngôn ngữ Rust cho phép bạn kiểm soát việc sử dụng bộ nhớ của mình giống như các ngôn ngữ lập trình hệ thống khác, nhưng có tự động xóa dữ liệu đó khi owner vượt ra khỏi scope có nghĩa là bạn không phải viết và gỡ lỗi thêm code để có được quyền kiểm soát này.

Ownership aảnh hưởng đến cách hoạt động của nhiều phần khác của Rust, vì vậy, chúng ta sẽ nói thêm về những khái niệm này trong suốt phần còn lại của cuốn sách. Hãy chuyển sang Chương 5 và xem xét việc nhóm các phần dữ liệu lại với nhau trong struct.

Sử dụng Structs để "đóng gói" các trường dữ liệu có liên quan

Một struct, hay structure, có thể coi là một kiểu dữ liệu mà lập trình viên tự định nghĩa, được tạo ra để nhóm các giá trị có mối liên hệ với nhau và tạo thành một tập giá trị có ý nghĩa. Nếu bạn đã quen thuộc với lập trình hướng đối tượng (object-oriented language - OOP), struct giống như khái niệm object ở trong đó. Trong chương này, chúng ta sẽ so sánh struct trong Rust và kiểu struct mà bạn đã biết, khi nào nên sử dụng struct, làm cách nào để định nghĩa và khởi tạo một struct, hay làm sao để tạo ra một associated function (một trong những associated function phổ biến đó chính là method). Method trong Rust cũng tương tự như trong OOP, dùng để mô tả một hành vi (behavior) cụ thể của một struct. Structs và enums (trong chương 6) là một trong những cách tạo kiểu dữ liệu mới mà có thể tận dụng tối đa tính năng kiểm tra kiểu dữ liệu (type checking) tại thời điểm biên dịch (compile time).

Định nghĩa và khởi tạo Structs

Một số thuật ngữ:

• instance: thực thể
• mutable: có thể thay đổi được

Structs tương tự như tuples (trình bày tại phần "The Tuple Type"), đó là chúng đều giữ các giá trị có mối liên hệ với nhau. Một điểm chung nữa đó là các thành phần bên trong struct và tuple có thể khác kiểu dữ liệu. Tuy nhiên, sự khác nhau cơ bản ở đây là các phần tử trong struct sẽ được đặt tên tương ứng cho từng trường, làm cho struct sẽ có ý nghĩa rõ ràng hơn so với tuple. Có thể gán tên đồng nghĩa với việc struct sẽ linh hoạt hơn tuple: ví dụ, bạn sẽ không phải dựa vào thứ tự của các phân tử để truy cập giá trị.

Để định nghĩa một struct, chúng ta sử dụng từ khóa struct kèm theo tên struct đó. Tên của struct nên đặt một cách gợi nhớ và có ý nghĩa. Sau đó, bên trong cặp ngoặc nhọn, ta sẽ định nghĩa tên và kiểu dữ liệu cho từng phần tử , hay "trường dữ liệu" (được gọi là field) trong struct đó. Ví dụ, mục 5-1 thể hiện một struct lưu trữ thông tin về một tài khoản của người dùng.

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {}

Listing 5-1: Định nghĩa một struct có tên User

Để sử dụng struct sau khi đã định nghĩa, chúng ta sẽ tạo ra một instance của struct đó bằng cách đặt giá trị cho từng trường. Một instance được tạo ra bắt đầu bằng tên struct, bên trong cặp ngoặc nhọn sẽ chứa các cặp khóa: giá trị (key: value), trong đó keys đại diện cho tên của từng trường và value thể hiện cho giá trị cần lưu của trường đó trong struct. Nói một cách khác, struct như một bản mẫu chung cho kiểu dữ liệu, còn instances sẽ hoàn thiện struct đó bằng cách điền các giá trị vào mẫu chung đó. Ví dụ, ta có thể khởi tạo một user cụ thể như sau.

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    let user1 = User {
        email: String::from("[email protected]"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };
}

Listing 5-2: Tạo một instance "User"

Để lấy giá trị của các trường trong struct, ta sử dụng dấu chấm. Nếu bạn muốn lấy ra địa chỉ email của user, có thể dùng user1.email. Nếu instance có thể thay đổi được (mutable), ta có thể thay đổi giá trị của bất kì trường nào mà mình muốn. Listing 5-3 cho ta thấy làm sao để thay đổi email trong instance User.

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    let mut user1 = User {
        email: String::from("[email protected]"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

    user1.email = String::from("[email protected]");
}

Listing 5-3: Thay đổi email trong instance "User"

Chú ý rằng instance(thực thể) này phải thay đổi được (mutable); Rust không cho phép chúng ta đánh dấu mutable cho các trường dữ liệu bên trong struct. Ta cũng có thể tạo ra một instance và đặt nó ở cuối của thân hàm (last expression) để ngầm định giá trị trả về cho hàm đó.

Listing 5-4 cho ta thấy một hàm build_user trả về một User instance với email và username. Trường active có giá trị true và trường sign_in_count có giá trị 1.

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn build_user(email: String, username: String) -> User {
    User {
        email: email,
        username: username,
        active: true,
        sign_in_count: 1,
    }
}

fn main() {
    let user1 = build_user(
        String::from("[email protected]"),
        String::from("someusername123"),
    );
}

Listing 5-4: Hàm build_user trả về User instance với email và username

Đặt tên các tham số truyền vào của hàm trùng với tên của các trường trong struct sẽ giúp chương trình dễ đọc hơn, tuy nhiên việc này sẽ khiến ta cảm thấy hơi "khó chịu" nếu gặp một struct phức tạp. May mắn thay, ta đã có một cách thuận tiện hơn!

Khởi tạo vắn tắt (Field Init Shorthand)

Nếu tham số truyền vào trùng tên với tên trường dữ liệu, ta có thể sử dụng cú pháp vắn tắt (field init shorthand) để viết lại như sau.

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn build_user(email: String, username: String) -> User {
    User {
        email,
        username,
        active: true,
        sign_in_count: 1,
    }
}

fn main() {
    let user1 = build_user(
        String::from("[email protected]"),
        String::from("someusername123"),
    );
}

Listing 5-5: Hàm build_user sử dụng cách khởi tạo mới bởi vì email và username ở tham số truyền vào trùng tên với tên trường dữ liệu struct

Ở đây, chúng ta tạo mới một instance của User struct, có trường email. Ta cũng muốn gán giá trị của trường email bởi giá trị của tham số email truyền vào hàm build_user. Do chúng đều có cùng tên, nên ta chỉ cần viết email thay vì email:email.

Tạo Instances từ Instances khác với Struct Update Syntax

Việc tạo ra một instance từ một instance khác gần giống nó là một việc làm rất phổ biến trong lập trình. Với Rust, bạn có thể sử dụng struct update syntax.

Đầu tiên, Listing 5-6 sẽ cho ta thấy cách tạo User instance một cách thông thường, không sử dụng update syntax. Ta sẽ gán giá trị mới cho trường email, còn các trường còn lại sẽ giữ nguyên như ở user1 trong Listing 5-2.

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    // --snip--

    let user1 = User {
        email: String::from("[email protected]"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        active: user1.active,
        username: user1.username,
        email: String::from("[email protected]"),
        sign_in_count: user1.sign_in_count,
    };
}

Listing 5-6: Tạo mới User instance sử dụng lại một vài giá trị của user1

Sử dụng struct syntax update, ta có thể có kết quả tương tự nhưng với ít dòng code hơn, như ở Listing 5-7. Cú pháp .. chú thích rằng các trường còn lại không được khai báo một cách tường minh sẽ có cùng một giá trị với instance cho trước.

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    // --snip--

    let user1 = User {
        email: String::from("[email protected]"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        email: String::from("[email protected]"),
        ..user1
    };
}

Listing 5-7: Sử dụng struct update syntax để gán giá trị cho email của User instance nhưng sử dụng các giá trị còn lại từ user1

Đoạn code ở Listing 5-7 tạo ra instance user2 khác email nhưng lại giống username, active và sign_in_count với user1. Cú pháp ..user1 phải được đặt ở cuối để thể hiện rằng các giá trị còn lại sẽ phải bằng với các trường tương ứng của user1.

Chú ý rằng struct update syntax sử dụng = như một phép gán; điều này có đươc là bởi vì nó đã chuyển quyền sở hữu dữ liệu (move), như chúng ta đã biết trong phần “Ways Variables and Data Interact: Move”. Ở trong ví dụ này, ta không thể sử dung user1 sau khi đã tạo user2 vì String trong trường username của user1 đã chuyển quyền sở hữu (move) vào trong user2. Do đó, ta chỉ có thể sử dụng active và sign_in_count từ user1. Kiểu dữ liệu của active và sign_in_count là những kiểu đã implement Copy trait, các bạn có thể xem thêm phần “Stack-Only Data: Copy” để hiểu hơn.

Sử dụng Tuple Structs

Rust cũng hỗ trợ tạo structs trông giống như tuples, được gọi là tuple struct. Tuple structs không có tên của các trường dữ liệu trong struct đó; chúng chỉ có các kiểu dữ liệu. Tuple structs rất hữu dụng khi bạn muốn tạo cho tuple đó một cái tên và khiến cho chúng nổi bật hơn so với những tuples còn lại.

Để định nghĩa một tuple struct, hãy bắt đầu với từ khóa struct và tên của struct, sau đó đến kiểu dữ liệu trong tuple. Ví dụ, hãy tạo hai tuple structs có tên là Color và Point:

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
}

Chú ý rằng black và origin có kiểu dữ liệu khác nhau. Mỗi struct bạn định nghĩa đều có kiểu riêng của nó, kể cả khi các trường trong struct đó có chung một kiểu dữ liệu. Ví dụ, một hàm truyền tham số kiểu Color không thể nhận tham số truyền vào kiểu Point, kể cả khi chúng đều có chung kiểu dữ liệu của từng trường (là i32). Mặt khác, instance của tuple struct có thể sự dụng như một tuple: bạn có thể tách chúng thành nhiều phần bằng cách sử dụng . để truy cập đến từng trường.

Unit-like Structs

Bạn có thể định nghĩa một struct mà không hề có bất kì một trường dữ liệu nào! Những kiểu structs này được gọi là unit-like structs vì chúng tương tự như (), là một kiểu dữ liệu được đề cập trong phần “The Tuple Type”. Unit-like structs rất thích hợp khi bạn muốn implement một trait và không có bất kì dữ liệu nào cần lưu trữ. Ta sẽ bàn thêm về trait ở chương 10. Sau đây là ví dụ về việc tạo unit struct có tên là AlwaysEqual.

struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}

Để định nghĩa AlwaysEqual, ta sử dụng từ khóa struct đi kèm với tên mình muốn, kết thúc bởi dấu chấm phẩy và không cần có ngoặc nhọn hay ngoặc đơn đi kèm! Khi đó ta có thể tạo ra một instance của AlwaysEqual là subject.

Ownership of Struct Data

User struct định nghĩa ở Listing 5-1 dùng kiểu String thay vì dùng &str. Việc này là có chủ ý vì ta muốn struct sở hữu toàn bộ dữ liệu bên trong nó, như vậy vòng đời của dữ liệu sẽ ngang bằng với vòng đời của struct.

Struct hoàn toàn có thể lưu trữ các tham chiếu, nhưng để làm được điều đó thì cần sử dụng tới lifetimes, một tính năng của Rust sẽ được đề cập đến trong chương 10. Lifetimes sẽ đảm bảo rằng dữ liệu trong struct sẽ có vòng đời ít nhất là ngang với vòng đời của chính struct đó. Nếu bạn làm như ví dụ sau, lỗi sẽ xảy ra:

Filename: src/main.rs

struct User {
    active: bool,
    username: &str,
    email: &str,
    sign_in_count: u64,
}

fn main() {
    let user1 = User {
        email: "[email protected]",
        username: "someusername123",
        active: true,
        sign_in_count: 1,
    };
}

Compiler sẽ nói rằng bạn cần dùng lifetime:

p

$ cargo run
   Compiling structs v0.1.0 (file:///projects/structs)
error[E0106]: missing lifetime specifier
 --> src/main.rs:3:15
  |
3 |     username: &str,
  |               ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct User<'a> {
2 |     active: bool,
3 ~     username: &'a str,
  |

error[E0106]: missing lifetime specifier
 --> src/main.rs:4:12
  |
4 |     email: &str,
  |            ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct User<'a> {
2 |     active: bool,
3 |     username: &str,
4 ~     email: &'a str,
  |

For more information about this error, try `rustc --explain E0106`.
error: could not compile `structs` due to 2 previous errors

Trong chương 10, ta sẽ tìm hiểu cách để sửa lỗi trên. Còn hiện tại, hãy cứ sử dụng String thay vì &str.

Một vài ví dụ khi sử dụng Structs

Để hiểu khi nào ta nên dùng structs, hãy cùng đến với một ví dụ về chương trình tính toán diện tích hình chữ nhật. Ta sẽ bắt đầu với việc sử dụng các biến đơn, sau đó sẽ thay thế bằng struct để so sánh.

Đầu tiền, tạo một binary project với Cargo đặt tên là rectangles, có đầu vào là chiều dài và chiều rộng của một hình chữ nhật cụ thể và sau đó tính toán ra diện tích của hình chữ nhật đó. Listing 5-8 cho ta thấy một đoạn code mẫu cho chương trình trên.

Filename: src/main.rs

fn main() {
    let width1 = 30;
    let height1 = 50;

    println!(
        "The area of the rectangle is {} square pixels.",
        area(width1, height1)
    );
}

fn area(width: u32, height: u32) -> u32 {
    width * height
}

Listing 5-8: Tính diện tích của hình chữ nhật với chiều dài và chiều rộng cho trước

Chạy chương trình với cargo run:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished dev [unoptimized + debuginfo] target(s) in 0.42s
     Running `target/debug/rectangles`
The area of the rectangle is 1500 square pixels.

Ta có thể chỉnh sửa một chút để code rõ ràng và dễ đọc hơn...

fn main() {
    let width1 = 30;
    let height1 = 50;

    println!(
        "The area of the rectangle is {} square pixels.",
        area(width1, height1)
    );
}

fn area(width: u32, height: u32) -> u32 {
    width * height
}

Hàm area tính toán diện tích của một hình chữ nhật, sử dụng 2 tham số, như vậy chương trình sẽ không rõ ràng và ta không thấy được mối quan hệ giữa các tham số. Để cải thiện điều này, có thể nhóm 2 tham số này lại với nhau. Ở phần “The Tuple Type” của chương 3, việc sử dụng tuple sẽ giúp ích trong trường hợp này.

Chỉnh sửa code với Tuples

Listing 5-9 là một cách làm khác sử dụng tuples.

Filename: src/main.rs

fn main() {
    let rect1 = (30, 50);

    println!(
        "The area of the rectangle is {} square pixels.",
        area(rect1)
    );
}

fn area(dimensions: (u32, u32)) -> u32 {
    dimensions.0 * dimensions.1
}

Listing 5-9: Nhóm chiều dài và chiều rộng của hình chữ nhật vào trong tuple

Chương trình này cũng có điểm tốt và chưa tốt. Điểm tốt ở chỗ các tham số đã được nhóm lại và trông có cấu trúc hơn, hàm lúc này chỉ cần nhận một tham số. Tuy nhiên, điểm trừ là tuple sẽ không rõ ràng tên các tham số, ta không biết đâu là chiều dài và đâu là chiều rộng.

Việc lẫn lộn giữa chiều dài và chiều rộng sẽ không phải vấn đề trong trường hợp tính diện tích, nhưng giả sử yêu cầu bài toán là vẽ hình chữ nhật, lúc này sẽ có vấn đề xảy ra! Bạn có thể nhớ trong đầu rằng phần tử 0 là chiều dài và phần tử 1 là chiều rộng. Tuy nhiên sẽ gây khó khăn cho người khác nếu họ sử dụng code của bạn.

Chỉnh sửa code dùng struct: làm rõ nghĩa chương trình

Ta sử dụng structs để gán nhãn cho dữ liệu, làm chúng dễ đọc hơn. Sử dụng struct cho bài toán trên như sau.

Filename: src/main.rs

struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
        "The area of the rectangle is {} square pixels.",
        area(&rect1)
    );
}

fn area(rectangle: &Rectangle) -> u32 {
    rectangle.width * rectangle.height
}

Listing 5-10: Định nghĩa một Rectangle struct

Ta sẽ tạo ra một struct có tên Rectangle. Bên trong có 2 trường width và height đều có kiểu u32. Trong hàm main, một instance sẽ được tạo ra với chiều dài bằng 50 và chiều rộng bằng 30.

Hàm area bây giờ chỉ có một tham số duy nhất có tên rectangle. Như đã đề cập trong chương 4, ta nên mượn (borrow) struct hơn là lấy quyền sở hữu của nó, main lúc này sẽ giữ lại quyền sở hữu của rect1.

Thêm các chức năng hữu dụng khác với Derived Traits

Sẽ rất tuyệt với nếu ta có thể in ra màn hình cả một struct trong khi debug. Listing 5-11 sử dụng println! macro mà chúng ta thường dùng trong các chương trước. Tuy nhiên, sẽ xảy ra lỗi.

Filename: src/main.rs

struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!("rect1 is {}", rect1);
}

Listing 5-11: In Rectangle instance ra console

Khi biên dịch đoạn code này, lỗi sẽ xảy ra với message:

error[E0277]: `Rectangle` doesn't implement `std::fmt::Display`

Macro println! có thể dùng cho rất nhiều định dạng, mặc định, cặp ngoặc nhọn {} sẽ chỉ dẫn cho println! sử dụng một loại định dạng có tên là Display. Các kiểu dữ liệu nguyên thủy (primitive types) đều implement Display. Nhưng với structs, mọi thứ sẽ khác, do có rất nhiều cách để thể hiện một struct: có dùng dấu phẩy hay không, có muốn in dấu ngoặc nhọn hay không, ... Vì vậy mặc định structs sẽ không implement Display.

Nếu bạn để ý lỗi in ra màn hình, bạn có thể tìm được giải pháp:

   = help: the trait `std::fmt::Display` is not implemented for `Rectangle`
   = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead

Hãy thử cách này! Macro println! sẽ sử dụng {:?}. Cách này giúp cho macro println! sử dụng kiểu định dạng có tên là Debug. Debug cho phép ta in một struct ra console, rất thuận tiền trong quá trình debug code.

Biên dịch chương trình với cách mới. Ta vẫn sẽ gặp lỗi:

error[E0277]: `Rectangle` doesn't implement `Debug`

Nhưng một lần nữa, compiler lại cho ta một gợi ý:

   = help: the trait `Debug` is not implemented for `Rectangle`
   = note: add `#[derive(Debug)]` to `Rectangle` or manually `impl Debug for Rectangle`

Ta phải khai báo tường minh một outer attribute #[derive(Debug)] ngay trên phần định nghĩa struct, như Listing 5-12.

Filename: src/main.rs

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!("rect1 is {:?}", rect1);
}

Listing 5-12: Thêm attribute để sử dụng Debug trait và in ra màn hình Rectangle instance

Chạy chương trình, ta sẽ nhận được kết quả:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished dev [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/rectangles`
rect1 is Rectangle { width: 30, height: 50 }

Tuyệt! Output này chưa dễ nhìn lắm, tuy nhiên nó đã đáp ứng được việc thể hiện ra tất cả các trường dữ liệu. Ngoài ra, có thể sử dụng {:#?} để in ra dễ nhìn hơn.

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished dev [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/rectangles`
rect1 is Rectangle {
    width: 30,
    height: 50,
}

Một cách khác để có thể in struct ra màn hình là sử dụng macro dbg!macro, chiếm quyền sở hữu, in ra tên file, số dòng mà dbg! được gọi cùng với kết quả mong muốn, trả lại quyền sở hữu (ownership).

Chú ý: Macro dbg! sử dụng chuẩn stderr (StandardError) để in ra màn hình, khác với println! sử dụng stdout (StandardOutput). Ta sẽ bàn rõ hơn về stderr và stdout ở phần “Writing Error Messages to Standard Error Instead of StandardOutput” trong chương 12.

Dưới đây là một ví dụ về việc in giá trị của width cũng như của struct rect1 ra màn hình:

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let scale = 2;
    let rect1 = Rectangle {
        width: dbg!(30 * scale),
        height: 50,
    };

    dbg!(&rect1);
}

Ta có thể đặt 30 * scale vào trong dbg!, vì dbg! ngay sau đó sẽ trả về quyền sở hữu của giá trị truyền vào, trường width vẫn sẽ có cùng giá trị ngay cả khi có dbg! hay không. Macro dgb! không nên chiếm quyền sở hữu (ownership) của rect1, vì vậy ta sẽ dùng tham chiều trong trường hợp này:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished dev [unoptimized + debuginfo] target(s) in 0.61s
     Running `target/debug/rectangles`
[src/main.rs:10] 30 * scale = 60
[src/main.rs:14] &rect1 = Rectangle {
    width: 60,
    height: 50,
}

Nhìn vào dòng số 10, ta sẽ nhận được 30 * scale và sau đó nó sẽ trả về giá trị là 60 (Debug implement cho kiểu integers sẽ chỉ in ra giá trị mà thôi). Dòng số 14 sẽ in ra toàn bộ struct rect1. Tóm lại, macro dbg! sẽ hữu dụng khi bạn muốn tìm hiểu xem đoạn code này đang làm gì!

Ngoài kiểu trait là Debug, Rust cung cấp rất nhiều các traits khác để sử dụng với derive attribute giúp lập trình viên có thể tùy chỉnh rất nhiều thứ theo ý muốn. Traits và cách sử dụng chúng được nói trong phần Appendix C. Ta sẽ bàn về việc làm sao để implement traits theo ý muốn ở chương 10. Ngoài derive, ta còn có rất nhiều các attributes khác; tất cả có trong phần the “Attributes” section of the Rust Reference.

Hàm area được tạo ra ở đây với mục đích rất cụ thể: tính toán diện hình chữ nhật. Vì vậy, nếu ta khiến cho hàm này trở nên "gần gũi" hơn với struct Rectangle, code khi đó sẽ rõ ràng hơn bởi area không sử dụng được với kiểu dữ liệu khác ngoài Rectangle. Bài sau sẽ giới thiệu một cách tiếp cận khác: chuyển từ hàm (function) area thành phương thức (method) area của kiểu Rectangle.

Phương thức (method)

Các thuật ngữ:

• block: Khối lệnh {}
• Asscociated Functions: Hàm liên kết
• Method: Phương thức

Method (phương thức) khá tương đồng với functions (hàm) ở điểm: đều sử dụng từ khóa fn kèm theo tên, đều có tham số truyền vào và giá trị trả về, đều chứa các đoạn code để thực thi khi được gọi trong chương trình. Điểm khác biệt với functions ở chỗ, methods được định nghĩa ở bên trong struct (có thể là enum hoặc trait, ta sẽ đi sâu hơn trong chương 6 và 17); tham số đầu tiên của method luôn là self, đại diện cho instance của struct đó.

Định nghĩa phương thức

Biến đổi hàm area thành phương thức area như sau:

Filename: src/main.rs

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area()
    );
}

Listing 5-13: Định nghĩa một phương thức area thuộc struct Rectangle

Để định nghĩa các phương thức của Rectangle, ta sẽ sử dụng từ khóa impl (implementation) kèm theo một cú pháp {} (block) của Rectangle. Mọi thứ ở trong impl block sẽ thuộc về Rectangle. Tiếp theo, đưa hàm area vào bên trong impl block và thêm self vào làm tham số đầu tiên của hàm đó. Trong hàm main, sử dụng method syntax để gọi phương thức area của Rectangle instance. Cú pháp ở đây được sử dụng bằng cách thêm dấu chấm sau khi gọi instance.

Phần khai báo của area, ta sử dụng &self thay vì rectangle: &Rectangle, &self là viết tắt của self: &Self. Ở trong impl block, Self đại diện cho kiểu dữ liệu mà nó được implement. Method phải có tham số self ở đầu tiên, vì vậy Rust giúp ta viết thuận tiện hơn với việc chỉ cần &self thay vì self: &Self. Để ý rằng vẫn cần có & ở trước self để báo hiệu việc mượn instance. Method có thể chiếm quyền sở hữu của self, vì vậy ta cần cân nhắc khi sử dụng.

Sử dụng &self bởi cũng giống như &Rectangle: ta không muốn chiếm quyền sở hữu của biến, chỉ cần mượn để đọc. Nếu muốn thay đổi giá trị của instance, hãy sử dụng &mut self làm tham số đầu tiên của method. Method chiếm quyền sở hữu của instance bằng cách dùng self rất ít khi được dùng; kĩ thuật này chỉ được sử dụng khi ta không muốn người gọi phương thức có thể sử dụng tiếp instance này sau khi gọi mà thôi.

Mục đích chính của việc sử dụng method thay vì function đó là: có thể nhóm mọi thứ liên quan đến instance của một kiểu dữ liệu vào với nhau, giúp cho việc quản lí code cũng như bảo trì code sau này trở nên dễ dàng hơn.

Chú ý rằng ta có thể đặt tên method trùng với tên trường của struct. Ví dụ, method width của Rectangle: Filename: src/main.rs

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn width(&self) -> bool {
        self.width > 0
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    if rect1.width() {
        println!("The rectangle has a nonzero width; it is {}", rect1.width);
    }
}

Ở đây, phương thức width sẽ trả về true nếu giá trị của width lớn hơn 0, và false nếu trong trường hợp còn lại. Trong hàm main, nếu sử dụng rect1.width(), Rust sẽ hiểu đây là method width, nếu không có cặp ngoặc tròn (), Rust sẽ hiểu đây là trường width.

Thông thường, ta sẽ đặt tên method trùng với tên trường nếu chỉ muốn trả về giá trị của chính trường đó. Những method dạng này được gọi là getters, Rust không implement chúng một cách tự động như những ngôn ngữ khác. Getters rất hữu dụng vì bạn có thể điều khiển được quyền truy cập biến, trường trong struct; cho phép trường đó có thể được thay đổi hay không, hay chỉ có quyền đọc mà thôi. Chủ đề về quyền truy cập (public và private) sẽ được nói đến trong chương 7.

Toán tử ->

Trong C và C++, có hai toán tử được dùng để gọi method: dùng . nếu bạn đang dùng trực tiếp object để gọi method, dùng -> nếu gọi method dùng con trỏ trỏ đến object đó.

Rust không hỗ trợ toán tử ->; thay vào đó, Rust cung cấp tính năng được gọi là automatic referencing and dereferencing.

Đây là cách hoạt động: mỗi khi bạn gọi một method như object.something(), Rust sẽ tự động thêm &, &mut hay * vào object. Xem xét ví dụ sau:

#![allow(unused)]
fn main() {
#[derive(Debug,Copy,Clone)]
struct Point {
    x: f64,
    y: f64,
}

impl Point {
   fn distance(&self, other: &Point) -> f64 {
       let x_squared = f64::powi(other.x - self.x, 2);
       let y_squared = f64::powi(other.y - self.y, 2);

       f64::sqrt(x_squared + y_squared)
   }
}
let p1 = Point { x: 0.0, y: 0.0 };
let p2 = Point { x: 5.0, y: 6.5 };
p1.distance(&p2);
(&p1).distance(&p2);
}

Cách gọi method p1.distance phía trên sẽ dễ nhìn hơn cách phía dưới. Rust sẽ tự động thêm tham chiếu cho p1, ngoài ra Rust có thể kiểm tra được khi nào method chỉ được đọc (&self), có thể thay đổi đươc (&mut self) hay consuming (self). Đây là một cơ chế khá hay mà Rust hỗ trợ cho chúng ta trong quá trình lập trình.

Methods nhiều tham số

Lần này ta sẽ thử implement thêm method thứ 2 của Rectangle struct. Method này có nhiệm vụ kiểm tra xem hình chữ nhật truyền vào có đặt vừa vào bên trong hình chữ nhật cho trước hay không. Method này sẽ có tên là can_hold với kiểu trả về là bool:

Filename: src/main.rs

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };
    let rect2 = Rectangle {
        width: 10,
        height: 40,
    };
    let rect3 = Rectangle {
        width: 60,
        height: 45,
    };

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}

Listing 5-14: Sử dụng can_hold method

Output sẽ trông giống như bên dưới, vì cả 2 chiều của rect2 đều nhỏ hơn rect1 còn rect3 thì lớn hơn rect1:

Can rect1 hold rect2? true
Can rect1 hold rect3? false

Method mới này cũng sẽ được đặt trong impl Rectangle block. Đặt tên cho method là can_hold, có tham số truyền vào là một Rectangle khác. Như đoạn code dưới đây:

Filename: src/main.rs

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }

    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };
    let rect2 = Rectangle {
        width: 10,
        height: 40,
    };
    let rect3 = Rectangle {
        width: 60,
        height: 45,
    };

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}

Listing 5-15: Implementing can_hold method của struct Rectangle

Hàm liên kết (Associated Functions)

Tất cả các hàm được định nghĩa bên trong impl đều được gọi là associated functions vì chúng đều có liên quan đến struct được impl. Ta có thể định nghĩa associated functions mà không có self làm tham số truyền vào (do đó không gọi là methods) vì chúng không cần instance của struct đó để hoạt động. Ví dụ như hàm from trong String::from là một associated function.

Những associated functions mà không phải là method thường được dùng để khởi tạo instance cho struct.

Filename: src/main.rs

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn square(size: u32) -> Rectangle {
        Rectangle {
            width: size,
            height: size,
        }
    }
}

fn main() {
    let sq = Rectangle::square(3);
}

Để gọi một associated function, sử dụng dấu :: với tên của struct; let sq = Rectangle::square(3); là một ví dụ. Cú pháp :: được sử dụng cho cả associated functions và namespaces để khởi tạo modules. Ta sẽ bàn thêm trong chương 7.

Multiple impl Blocks

Mỗi struct có thể có nhiều impl blocks. Ví dụ , Listing 5-15 cũng tương đương với Listing 5-16, đều sở hữu các method như nhau.

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

impl Rectangle {
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };
    let rect2 = Rectangle {
        width: 10,
        height: 40,
    };
    let rect3 = Rectangle {
        width: 60,
        height: 45,
    };

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}

Listing 5-16: Viết lại Listing 5-15 sử dụng multiple impl blocks

Không có mục đích cụ thể nào cho việc tạo nhiều impl blocks cả, chỉ đơn giản là cú pháp này được chấp nhận trong Rust. Tuy nhiên đôi khi nó cũng khá hữu dụng, xem thêm chương 10 phần generic types và traits.

Tổng kết

Structs giúp bạn có thể tạo ra một kiểu dữ liệu mà mình mong muốn. Sử dụng structs, ta có thể nhóm các hàm, biến có mối liên hệ với nhau và làm cho code rõ ràng, dễ hiểu hơn. Khi impl blocks, có 2 loại hàm là associated functions và method (một dạng đặc biệt của asscociated functions), giúp bạn thể hiện các hành vi (behavior) của instance đó.

Structs không phải là cách duy nhất để tạo một kiểu dữ liệu mới: hãy xem thêm kiểu enum trong Rust.

Enums và Mẫu Matching

Trong chương này chúng ta sẽ tìm hiểu về enumerations, còn được gọi là enums. Enums cho phép bạn có thể định nghĩa một kiểu dữ liệu bằng cách liệt kê các kiểu dữ liệu của nó. Đầu tiên, chúng ta sẽ định nghĩa và sử dụng một enum để chỉ cách một enum có thể mã hoá ý nghĩa cùng với dữ liệu. Tiếp theo, chúng ta sẽ khá phá một enum đặc biệt hữu ích, được sử dụng rất nhiều trong Rust, đó là Option, điều này thể hiện một giá trị có thể có giá trị nào đó hoặc không. Sau đó chúng ta sẽ cách sử dụng match với enum giúp bạn dễ dàng chạy các đoạn code khác nhau cho những giá trị khác nhau của một enum. Cuối cùng, chúng ta sẽ đề cập đến cách sử dung if let để xử lý các enum trong code của bạn

Enums là một tính năng được sử dụng trong nhiều ngôn ngữ lập trình, nhưng khả năng sử dụng của chúng khác nhau trong mỗi ngôn ngữ. Enum của Rust giống kiểu dữ liệu đại số trong ngôn ngữ lập trình chức năng, như là F#, OCaml và Haskell

Định nghĩa một Enum

Enums là định nghĩa một kiểu dữ liệu tuỳ chỉnh khác với structs. Hãy xem xét một tình huống chúng ta phải diễn đạt trong code và xem tại sao enums lại hữu ích và phù hợp hơn struct trong trường hợp này. Giả sử chúng ta làm việc với các địa chỉ IP. Hiện tại, 2 tiêu chuẩn chính được sử dụng cho địa chỉ IP là: Ipv4 và Ipv6. Bởi vì đây là khả năng duy nhất cho 1 địa chỉ IP mà chương trình của chúng ta sẽ bắt gặp, chúng ta có thể sử dụng enumerate để liệt kê hết các biến có thể có, which is where enumeration gets its name.

Bất kì địa chỉ IP nào cũng có thể là Ipv4 hoặc Ipv6, nhưng không phải cả 2 tại 1 thời điểm. Thuộc tính trên làm cho cấu trúc của enum thích hợp để sử dụng cho trường hợp này, bởi vì một enum chỉ có thể lấy 1 giá trị trong các loại của nó. Cả Ipv4 và Ipv6 về cơ bản vẫn là một địa chỉ IP, vì vậy nên chúng được coi là 1 loại giá trị khi đoạn code áp dụng cho bất kì loại địa chỉ IP nào.

Chúng ta có thể thực hành khái niệm trên trong code bằng cách khai báo 1 *enum" IpAddrKind và liệt kê các loại địa chỉ IP có thể có: V4 và V6. Bên dưới là các loại của enum

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

IpAddrKind là một kiểu dữ liệu tuỳ chỉnh mà ta có thể sử dụng ở những nơi khác nhau trong code của mình.

Enum Values

Chúng ta có thể tạo ra từng biến cho 2 loại IpAddrKind giống như thế này:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

Lưu ý rằng các loại của enum có thể đặt tên dưới định dang của nó, và chúng ta sử dụng 2 dấu 2 chấm (::) để phân tách. Điều này rất có ích vì cả 2 giá trị IpAddrKind::V4 và IpAddrKind::V6 đều có kiểu giá trị: IpAddrKind. Chúng ta có thể định một hàm xử dụng bất kì IpAddrKind nào:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

Và chúng ta có thể gọi hàm này với 1 trong 2 loại enum

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

Sử dụng enum thậm chí còn nhiều điểm mạnh hơn. Chúng tôi suy nghĩ thêm về địa IP, hiện tại chúng tôi không có cách nào để lưu trữ dữ liệu thực tế của địa chỉ IP; chúng tôi chỉ biết chúng là kiểu dữ liệu nào. Bạn mới học về cấu struct ở chương 5, bạn có thể giải quyết vấn đề này với truct như trong Listing 6-1.

fn main() {
    enum IpAddrKind {
        V4,
        V6,
    }

    struct IpAddr {
        kind: IpAddrKind,
        address: String,
    }

    let home = IpAddr {
        kind: IpAddrKind::V4,
        address: String::from("127.0.0.1"),
    };

    let loopback = IpAddr {
        kind: IpAddrKind::V6,
        address: String::from("::1"),
    };
}

Listing 6-1: Lưu trữ dữ liệu IpAddrKind bằng cách sử dụng struct an IP address using a struct

Ở đây, chúng tôi dã định nghĩa một struct IpAddr có 2 trường: trường kind có kiểu dữ liệu là IpAddrKind (enum chúng ta đã định nghĩa trước đó) và một trường là address có kiểu dữ liệu String. Chúng ta có 2 trường hợp của struct này. Đầu tiên là home, và nó có giá trị IpAddrKind::V4 như là kind với địa chỉ của dữ liệu là 127.0.0.1. Trường hợp thứ 2 là loopback. Nó là một trường hợp khác của IpAddrKind giá trị kind là V6, và có địa chỉ ::1 liên kết với nó. Chúng ta sử dụng 1 struct để nhóm giá trị kind và address với nhau, vì vậy hiện giờ biến thể được thể liên kết với nhau.

Tuy nhiên, đại diện cho cùng 1 khái niệm dùng một enum là ngắn gọn hơn: hơn là 1 enum bên trong 1 struct , chúng ta có thể đưa dữ liệu trực tiếp vào từng trường hợp của enum. Định nghĩa mới này của enum IpAddr cho biết rằng cả 2 giá trị V4 and V6 sẽ có các giá trị String:

fn main() {
    enum IpAddr {
        V4(String),
        V6(String),
    }

    let home = IpAddr::V4(String::from("127.0.0.1"));

    let loopback = IpAddr::V6(String::from("::1"));
}

Chúng ta gán giá trị trực tiếp vào cho mỗi trường hợp enum, vì vậy nên không cần thêm cấu trúc. Tại đây, bạn cũng có thể dễ dàng xem một chi tiết khác về cách hoạt động của enum: tên của mỗi trường hợp enum mà chúng ta định nghĩa đã trở thành một hàm tạo của enum. Đó là, IpAddr::V4() là một hàm sử dụng 1 String là tham số và trả về một instance của kiểu IpAddr. Chúng tự động định nghĩa hàm khởi tạo này như là kết quả của định nghĩa một enum.

Có một lợi thế khác khi sử dụng enum thay vì cấu trúc: mỗi trường hợp trong enum có thể có các loại dữ liệu khác nhau. Địa chỉ IP của V4 sẽ luôn có bốn thành phần số sẽ có giá trị từ 0 đến 255. Nếu chúng tôi muốn lưu trữ địa chỉ V4 dưới dạng bốn giá trị u8 nhưng vẫn diễn đạt được địa chỉ V6 là một giá trị String, điều này không thể với struct. Enums xử lý trường hợp này một cách dễ dàng:

fn main() {
    enum IpAddr {
        V4(u8, u8, u8, u8),
        V6(String),
    }

    let home = IpAddr::V4(127, 0, 0, 1);

    let loopback = IpAddr::V6(String::from("::1"));
}

Chúng tôi đã chỉ ra một số cách khác nhau để xác định cấu trúc dữ liệu để lưu trữ địa chỉ IP V4 và V6. Tuy nhiên, hóa ra, muốn lưu trữ địa chỉ IP và mã hóa loại nào chúng rất phổ biến nên Rust định nghĩa một thư viện chuẩn mà chúng ta có thể sử dụng! Hãy xem cách thư viện chuẩn định nghĩa IpAddr: nó có enum chính xác và các trường hợp mà chúng ta định nghĩa và sử dụng, nhưng nó nhúng dữ liệu địa chỉ bên trong các trường hợp enum dưới dạng hai cấu trúc khác nhau, được định nghĩa khác nhau cho từng trường hợp:

#![allow(unused)]
fn main() {
struct Ipv4Addr {
    // --snip--
}

struct Ipv6Addr {
    // --snip--
}

enum IpAddr {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}
}

Đoạn mã này minh họa rằng bạn có thể đặt bất kỳ loại dữ liệu nào bên trong một trường hợp của enum: strings, numeric, hay struct... ví dụ. Thậm chí có thể chứa cả một enum khác! Ngoài ra, các loại thư viện chuẩn thường không phức tạp hơn nhiều so với những gì mà bạn có thể nghĩ ra.

Lưu ý rằng mặc dù thư viện chuẩn có chứa định nghĩa cho IpAddr, chúng ta vẫn có thể tạo và sử dụng định nghĩa riêng của chúng ta mà không bị xung đột bởi vì chúng ta không đưa thư viện chuẩn vào trong phạm vi sử dụng của chúng ta. Chúng ta sẽ nói nhiều hơn về việc đưa các loại vào trong phạm vi sử dụng ở Chương 7.

Hã xem một ví dụ khác về enum trong Listing 6-2: cái này có nhiều loại dữ liệu được định nghĩa trong các trường hợp enum:

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {}

Listing 6-2: Một enum Message mà mỗi trường hợp của nó khác nhau về số lượng và kiểu dữ liệu

Enum này có 4 trường hợp với 4 loại khác nhau:

• Quit không có chứa dữ liệu nào cả.
• Move giống như một struct.
• Write bao gồm 1 String.
• ChangeColor chứa 3 giá trị i32.

Định nghĩa 1 enum với các trường hợp như trong Listing 6-2 tương tự như việc xác định các loại định nghĩa struct khác nhau, trừ trường hợp enum không sử dụng từ khoá struct và tất cả các trường hợp trong nhóm lại với nhau bên dưới kiểu Message. Các struct có thể chứa cùng một dữ liệu mà các trường hợp của enum trước đó giữ:

struct QuitMessage; // unit struct
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // tuple struct
struct ChangeColorMessage(i32, i32, i32); // tuple struct

fn main() {}

Nhưng nếu chúng ta sử dụng các struct khác nhau, mỗi struct có kiểu riêng của chúng, chúng ta không thể dễ dàng định nghĩa một hàm để nhận bất kì một thông báo nào như chúng ta có thể làm với enum Message được định nghĩa ở Listing 6-2, một kiểu duy nhất.

Có một điểm tương đồng nữa giữa enum và struct:: chúng đều định nghĩa các phương thức sử dụng impl. Đây là một phương thức call, chúng ta có thể định nghĩa trong enum Message:

fn main() {
    enum Message {
        Quit,
        Move { x: i32, y: i32 },
        Write(String),
        ChangeColor(i32, i32, i32),
    }

    impl Message {
        fn call(&self) {
            // method body would be defined here
        }
    }

    let m = Message::Write(String::from("hello"));
    m.call();
}

Phần thân của phương thức sẽ sử dụng self để lấy giá trị mà chúng ta đã gọi phương thức trên. Trong ví dụ này, chúng tôi đã tạo một biến m có giá trị là Message::Write(String::from("hello")), và đó là những gì self sẽ ở trong phần thân hàm call khi m.call() chạy.

Chúng ta hãy xem xét một enum khác trong thư viện chuẩn rất phổ biến và hữu ích: Option.

Option Enum và ưu điểm của nó so với giá trị Null

Trong phần này chúng ta sẽ khám phá 1 trường hợp điển hình của Enum là Option, là một enum khác được định nghĩa bởi thư viện tiêu chuẩn. Option là 1 loại mã hóa rất phổ biến trong đó giá trị có thể là một cái gì đó hoặc nó có thể không là gì cả. Ví dụ, nếu bạn yêu cầu phần tử đầu tiên của một danh sách chứa những mục, bạn sẽ nhận một giá trị. Nếu bạn yêu cầu phần tử đầu tiên của một danh sách rỗng, bạn không nhận được gì. Diễn đạt khái niệm này theo kiểu hệ thống có nghĩa là trình biên dịch có thể kiểm tra xem bạn đã xử lý tất cả các trường hợp cần xử lý chưa; chức năng này có thể ngăn chặn các lỗi rất phổ biến trong các ngôn ngữ lập trình khác.

Thiết kế ngôn ngữ lập trình thường được xem xét về các tính năng bạn bao gồm những tính năng nào, nhưng các tính năng bạn loại trừ cũng quan trọng. Rust không có giá trị rỗng mà nhiều ngôn ngữ khác có. Null là một giá trị có nghĩa là không có giá trị nào ở đó. Trong các ngôn ngữ có null, các biến luôn có thể ở một trong hai trạng thái: null hoặc not-null.

Trong bài thuyết trình năm 2009 của anh ấy “Null References: The Billion Dollar Mistake,” Tony Hoare, người phát minh ra null, có điều này để nói:

Tôi gọi đó là sai lầm hàng tỷ đô la của mình. At that time, Vào thời điểm đó, tôi đang thiết kế hệ thống đầu tiên cho các tham chiếu bằng ngôn ngữ hướng đối tượng. Mục tiêu của tôi là đảm bảo rằng tất cả việc sử dụng các tham chiếu phải an toàn tuyệt đối, với việc kiểm tra được thực hiện tự động bởi trình biên dịch. Nhưng tôi không thể cưỡng lại sự cám dỗ để đưa vào một tham chiếu rỗng, đơn giản vì nó rất dễ thực hiện. Điều này đã dẫn đến vô số lỗi, lỗ hổng bảo mật và sự cố hệ thống mà có lẽ đã gây ra đau đớn và thiệt hại hàng tỷ đô la trong bốn mươi năm qua.

Vấn đề với giá trị null là nếu bạn cố gắng sử dụng giá trị null làm giá trị không null, bạn sẽ gặp một lỗi nào đó. Bởi vì thuộc tính null hoặc not-null này là phổ biến, rất dễ mắc phải loại lỗi này.

Tuy nhiên, khái niệm null đang cố gắng diễn đạt vẫn hữu ích: null là một giá trị hiện không hợp lệ hoặc vắng mặt vì lý do nào đó.

Vấn đề không thực sự nằm ở khái niệm mà là ở cách triển khai cụ thể. Như vậy, Rust không có null, nhưng nó có một enum có thể mã hóa khái niệm giá trị hiện diện hoặc vắng mặt. Enum này là Option<T>, và nó là defined by the standard library như sau:

#![allow(unused)]
fn main() {
enum Option<T> {
    None,
    Some(T),
}
}

Option<T> enum hữu ích đến mức chứa phần báo trước; bạn không cần phải đưa nó vào phạm vi một cách rõ ràng. Các biến thể của nó cũng được bao gồm trong phần mở đầu: bạn có thể sử dụng Some và None trực tiếp mà không có tiền tố Option::. Option<T> enum vẫn là 1 enum bình thường, và Some(T) và None cũng là các biến thể trong kiểu Option<T>.

Cú pháp <T> là một tính năng của Rust mà chúng tôi chưa nói đến. Nó là 1 kiểu generic, và chúng tôi sẽ trình bày chi tiết hơn trong Chương 10. Hiện tại, tất cả những gì bạn cần biết là <T> nghĩa là Some là biến thể Option enum có thể chứa bất kì loại dữ liệu nào, và mỗi loại dữ liệu cụ thể được sử dụng thay cho T làm cho loại Option<T> trở thành một loại khác. Dưới đây là một số ví dụ về việc sử dụng giá trị Option để lưu các loại số và loại chuỗi:

fn main() {
    let some_number = Some(5);
    let some_string = Some("a string");

    let absent_number: Option<i32> = None;
}

Kiểu some_number là Option<i32>. Kiểu some_string là Option<&str>, đó là một loại kiểu khác . Rust có thể suy ra các loại này bởi vì chúng tôi đã chỉ định một giá trị bên trong biến thể Some. Đối với absent_number, Rust yêu cầu chúng tôi chú thích loại Option: trình biên dịch không thể suy ra loại mà tương ứng Some đang lưu trữ là giá trị None. Ở đây, chúng tôi nói với Rust rằng ý của chúng tôi là để absent_number có kiểu Option<i32>.

khi Some có một giá trị nào đó, chúng tôi biết rằng một giá trị hiện diện và giá trị được giữ trong Some. Khi chúng tôi cố 1 giá trị None, theo một nghĩa nào đó, nó có nghĩa giống như là null: chúng tôi không có giá trị hợp lệ. Vậy tại sao có Option<T> lại tốt hơn là null?

Nói ngắn gọn, bởi vì Option<T> và T (T có thể là bất kì một kiểu nào) là những loại khác nhau , trình biên dịch sẽ không cho phép chúng tôi sử dụng một giá trị Option<T> nếu như nó không phải một giá trị hợp lệ. Ví dụ: mã này sẽ không biên dịch vì nó đang cố gắng sử dụng phép cộng một i8 với một Option<i8>:

fn main() {
    let x: i8 = 5;
    let y: Option<i8> = Some(5);

    let sum = x + y;
}

Nếu chúng tôi chạy mã này, chúng tôi nhận được thông báo lỗi như sau:

$ cargo run
   Compiling enums v0.1.0 (file:///projects/enums)
error[E0277]: cannot add `Option<i8>` to `i8`
 --> src/main.rs:5:17
  |
5 |     let sum = x + y;
  |                 ^ no implementation for `i8 + Option<i8>`
  |
  = help: the trait `Add<Option<i8>>` is not implemented for `i8`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `enums` due to previous error

Mãnh liệt! Thực tế, thông báo lỗi này có nghĩa là Rust không hiểu làm cách nào cộng một i8 với một Option<i8>, bởi vì chúng là những loại khác nhau. Khi chúng ta có một giá trị kiểu i8 trong Rust, trình biên dịch sẽ chắc chắn chúng ta có một giá trị hợp lệ. Chúng ta có thể tiến hành một cách tự tin mà không cần phải kiểm tra null trước khi sử dụng giá trị đó . Chỉ khi chúng ta có một Option<i8> (hoặc bất kỳ loại giá trị nào mà chúng ta đang làm việc) chúng ta phải lo lắng về việc có thể không có giá trị, và trình biên dịch sẽ đảm bảo rằng chúng tôi xử lý trường hợp đó trước khi sử dụng giá trị đó.

Nói cách khác, bạn phải chuyển một kiểu Option<T> thành một kiểu T trước khi bạn thực hiện bất kì thao tác nào với nó. Nói chung, điều này giúp khắc phục một trong những vấn đề phổ biến nhất với null: giả sử rằng một cái gì đó không phải là null khi nó thực sự là như vậy.

Loại bỏ rủi ro giả định không chính xác giá trị không phải là null giúp bạn tin hơn vào mã của mình. Để có một giá trị có thể là null, bạn phải chọn một cách rõ ràng bằng cách đặt loại giá trị đó là Option<T>. Sau đó, khi bạn sử dụng giá trị đó, bạn được yêu cầu xử lý rõ ràng trường hợp khi giá trị là null. Ở mọi nơi mà một giá trị có một loại không phải là Option<T>, bạn có thể an toàn giả định rằng giá trị không phải là null. Đây là một quyết định thiết kế có chủ ý của Rust để hạn chế lỗi phổ biến của null và tăng độ an toàn của mã Rust.

Vì vậy, làm thế nào để bạn có được giá trị T từ một kiểu Some khi bạn có một giá trị thuộc loại Option<T> để bạn có thể sử dụng giá trị đó? Option<T> enum có một số lượng lớn các phương pháp hữu ích trong nhiều tình huống khác nhau; bạn có thể kiểm tra chúng tại its documentation. Làm quen với các phương pháp trên Option<T> sẽ cực kỳ hữu ích trong hành trình của bạn với Rust.

Nói chung, để sử dụng một giá trị Option<T>, bạn muốn có mã sẽ xử lý từng biến thể. Bạn muốn một số mã sẽ chỉ chạy khi bạn có một giá trị Some(T), và mã này được phép sử dụng bên trong T. Bạn muốn một số mã khác chạy nếu bạn có một giá trị None, và mã đó không có sẵn giá trị T. Biểu thức match là một cấu trúc luồng điều khiển thực hiện điều này khi được sử dụng với enums: nó sẽ chạy mã khác nhau tùy thuộc vào biến thể của enum mà nó có, và mã đó có thể sử dụng dữ liệu bên trong giá trị phù hợp.

The match Control Flow Construct

Rust có một cấu trúc luồng điều khiển cực kỳ mạnh mẽ được gọi là match cho phép bạn so sánh một giá trị với một loạt các mẫu và sau đó thực thi mã dựa trên mẫu nào phù hợp. Các mẫu có thể được tạo thành từ các giá trị chữ, tên biến, ký tự đại diện và nhiều thứ khác; Chương 18 bao gồm tất cả các loại mẫu khác nhau và những gì chúng làm. Sức mạnh của match đxuất phát từ sự biểu đạt của các mẫu và thực tế là trình biên dịch xác nhận rằng tất cả các trường hợp có thể xảy ra đều được xử lý.

Hãy nghĩ về một biểu thức match như là giống như một cỗ máy phân loại tiền xu: đồng xu trượt xuống một đường ray với các lỗ có kích thước khác nhau dọc theo nó, và mỗi đồng xu rơi qua lỗ đầu tiên mà nó gặp phải mà nó vừa vào. Theo cách tương tự, các giá trị đi qua từng mẫu trong một match, và ở mẫu đầu tiên, giá trị "phù hợp", giá trị rơi vào khối mã liên kết sẽ được sử dụng trong quá trình thực thi Nói về tiền xu, hãy sử dụng chúng làm ví dụ bằng cách sử dụng match! Chúng ta có thể viết một hàm lấy một đồng xu Hoa Kỳ không xác định và, theo cách tương tự như máy đếm, xác định đó là đồng xu nào và trả về giá trị của nó bằng xu, như được hiển thị ở đây trong Listing 6-3.

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

fn main() {}

Listing 6-3: Một enum và một biểu thức so khớp có các biến thể của enum là các mẫu của nó

Hãy chia nhỏ match trong hàm value_in_cents. Đầu tiên, chúng ta liệt kê từ khoá match là một biểu thức, trong trường hợp này là coin. Điều này có vẻ rất giống với một biểu thức được sử dụng với if, nhưng có một sự khác biệt lớn: với if, biểu thức cần trả về giá trị Boolean, nhưng ở đây, nó có thể trả về bất kỳ loại nào. Kiểu của coin trong ví dụ này là một enum Coin mà chúng ta đã định nghĩa ở dòng đầu tiên.

Tiếp theo là các nhánh match. Một nhánh gồm 2 phần: mẫu và code. Nhánh đầu tiên ở đây có một mẫu là giá trị Coin::Penny và sau đó toán tử => phân tách mẫu và code để chạy. Code trong trường hợp này nhận giá trị là 1. Mỗi nhánh được ngăn cách với nhánh tiếp theo bằng dấu phẩy.

Khi biểu thức match thực thi, nó so sánh giá trị kết quả với mẫu của mỗi nhánh, theo thứ tự. Nếu một mẫu khớp với giá trị, code với mẫu đó sẽ được thực thi. Nếu mẫu đó không khớp với giá trị, thì việc thực thi sẽ tiếp tục cho nhánh tiếp theo, giống như trong một máy phân loại tiền xu. Chúng ta có thể có nhiều nhánh như chúng ta cần: trong Listing 6-3, match của chúng ta có 4 nhánh.

Code được liên kết với mỗi nhánh là một biểu thức, và giá trị kết quả của biểu thức trong nhánh phù hợp là giá trị được trả về cho toàn bộ biểu thức match.

Chúng ta thường không sử dụng dấu ngoặc nhọn nếu mã nhánh đối sánh ngắn, như là trong Listing 6-3 trong đó mỗi nhánh chỉ trả về một giá trị. Nếu bạn muốn chạy nhiều dòng mã trong một nhánh, bạn phải sử dụng dấu ngoặc nhọn. Ví dụ, mã sau in “Lucky penny!” mỗi khi phương thức được gọi tới một Coin::Penny, nhưng vẫn trả về giá trị cuối cùng của block, 1:

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => {
            println!("Lucky penny!");
            1
        }
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

fn main() {}

Các mẫu ràng buộc với giá trị

Một tính năng hữu ích khác của các nhánh match là chúng có thể liên kết với các phần của giá trị khớp với mẫu. Đây là cách chúng tôi có thể trích xuất các giá trị từ các trường hợp của enum.

Như ví dụ dưới, hãy thay đổi một trong các biến thể enum của chúng tôi để giữ dữ liệu bên trong nó. Từ năm 1999 đến năm 2008, Hoa Kỳ đúc đồng 25 xu với các thiết kế khác nhau cho mỗi bên trong số 50 tiểu bang. Không có đồng xu nào khác có thiết kế trạng thái, vì vậy chỉ các đồng 25 xu có giá trị bổ sung này. Chúng ta có thể thêm thông tin này vào enum bằng cách thay đổi trường hợp Quarter có chứa 1 giá trị UsState được lưu trữ bên trong nó, mà chúng ta đã làm ở đây trong Listing 6-4.

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {}

Listing 6-4: Một enum Coin trong đó trường hợp Quarter chứa 1 giá trị UsState

Hãy tưởng tượng rằng một người bạn đang cố gắng thu thập tất cả 50 đồng 25 xu của các tiểu bang. Trong khi chúng ta phân loại tiền lẻ của mình theo loại tiền xu, chúng tôi cũng sẽ gọi ra tên của tiểu bang được liên kết với mỗi đồng 25 xu vì vậy nếu đó là một trong những người bạn của chúng tôi không có, họ có thể thêm nó vào bộ sưu tập của họ.

Trong biểu thức match cho code này, chúng tôi thêm một biến được gọi là state vào mẫu phù hợp với các giá trị của trường hợp Coin::Quarter. Khi một Coin::Quarter khớp, biến state sẽ liên kết với giá trị của trạng thái của đồng 25 xu đó. Sau đó, chúng ta có thể sử dụng state trong code cho nhánh này, giống như bên dưới:

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter from {:?}!", state);
            25
        }
    }
}

fn main() {
    value_in_cents(Coin::Quarter(UsState::Alaska));
}

Nếu chúng ta gọi value_in_cents(Coin::Quarter(UsState::Alaska)), coin sẽ là Coin::Quarter(UsState::Alaska). Khi chúng tôi so sánh giá trị đó với từng nhánh, không ai trong số chúng phù hợp cho đến khi chúng tôi đạt được Coin::Quarter(state).Tại thời điểm đó, ràng buộc đối với state sẽ là giá trị UsState::Alaska. Chúng tôi có thể sử dụng ràng buộc đó trong câu lệnh println!, do đó nhận được giá trị trạng thái bên trong của giá trị Coin cho Quarter.

Matching với Option<T>

Trong phần trước, chúng ta muốn có được bên trong giá trị T của Sometrường hợp khi sử dụng Option<T>; chúng ta cũng có thể xử lý Option<T> sử dung match như là chúng ta đã làm với Coin! Thay vì so sánh tiền xu, chúng tôi sẽ so sánh các trường hợp của Option<T>, nhưng cách thức hoạt động của biểu thức match vẫn giống nhau.

Giả sử chúng tôi muốn viết một hàm sử dụng Option<i32>, nếu có một giá trị bên trong, hãy thêm 1 vào giá trị đó. Nếu không có giá trị bên trong, hàm sẽ trả về giá trị None và không cố gắng thực hiện bất kỳ hoạt động nào.

Hàm này rất dễ viết, nhờ match, và sẽ trông như Listing 6-5.

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

Listing 6-5: Một hàm sử dụng biểu thức matchh trên Option<i32>

Chúng ta hãy kiểm tra việc thực hiện đầu tiên của plus_one chi tiết hơn. Khi chúng ta gọi plus_one(five), biến x trong thân hàm plus_one sẽ có giá trị Some(5). Sau đó, chúng tôi so sánh điều đó với từng nhánh match.

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

Giá trị Some(5) không khớp với mẫu None,vì vậy chúng ta tiếp tục đến nhánh tiếp theo.

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

Some(5) có khớp với Some(i)? Tại sao lại có nó! Chúng ta có cùng một trường hợp. i liên kết với giá trị chứa trong Some, vì vậy i nhận giá trị 5. Sau đó, đoạn code trong nhánh match được thực thi, vì vậy chúng ta cộng thêm 1 vào giá trị của i và tạo ra một giá trị mới Some với tổng là 6.

Bây giờ chúng ta hãy xem xét lời gọi hàm thứ hai của plus_one trong Listing 6-5, trong đó x là None. Chúng ta nhập match và so sánh giá trị ở nhánh đầu tiên.

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

Nó phù hợp! Không có giá trị nào để thêm vào, vì vậy chương trình dừng và trả về giá trị None ở phía bên phải của =>. Bởi vì nhánh đầu tiên khớp với nhau, nên không có nhánh nào khác được so sánh.

Kết hợp match và enum rất hữu ích trong nhiều trường hợp. Bạn sẽ thấy mẫu này rất nhiều trong mã Rust: match chống lại một enum, liên kết một biến với dữ liệu bên trong, và sau đó thực thi mã dựa trên nó. Lúc đầu hơi phức tạp, nhưng một khi bạn đã quen với nó, bạn sẽ ước bạn có nó trong tất cả các ngôn ngữ. Nó luôn là một sự yêu thích của người dùng.

Matches là đầy đủ

Có một khía cạnh khác của match chúng ta cần thảo luận. Hãy xem xét phiên bản hàm plus_one này của chúng ta có một lỗi và sẽ không biên dịch:

fn main() {
    fn plus_one(x: Option<i32>) -> Option<i32> {
        match x {
            Some(i) => Some(i + 1),
        }
    }

    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

Chúng ta không xử lý trường hợp None, vì vậy mã này sẽ gây ra lỗi. May mắn thay, đó là một lỗi mà Rust biết cách bắt. Nếu chúng ta cố gắng biên dịch mã này, chúng ta sẽ gặp lỗi sau:

$ cargo run
   Compiling enums v0.1.0 (file:///projects/enums)
error[E0004]: non-exhaustive patterns: `None` not covered
   --> src/main.rs:3:15
    |
3   |         match x {
    |               ^ pattern `None` not covered
    |
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
    = note: the matched value is of type `Option<i32>`

For more information about this error, try `rustc --explain E0004`.
error: could not compile `enums` due to previous error

Rust biết rằng chúng ta không bao gồm trường hợp nào có thể xảy ra và thậm chí biết chúng ta đã quên mẫu nào! Matches trong Rust là đầy đủ: chúng ta phải sử dụng hết mọi khả năng để mã có hiệu lực. Đặc biệt là trong trường hợp của Option<T>, khi Rust ngăn chúng ta quên xử lý rõ ràng trường hợp None, nó bảo vệ chúng ta khỏi giả định rằng chúng ta có một giá trị khi chúng ta có thể có null, do đó làm cho sai lầm hàng tỷ đô la đã được thảo luận trước đó là không thể.

Catch-all Patterns and the _ Placeholder

Sử dụng enum, chúng ta cũng có thể thực hiện các hành động đặc biệt đối với một số giá trị cụ thể, nhưng đối với tất cả các giá trị khác thì thực hiện một hành động mặc định. Hãy tưởng tượng chúng tôi đang triển khai một trò chơi trong đó, nếu bạn tung một con xúc xắc là 3, người chơi sẽ không di chuyển, nhưng thay vào đó nhận được một chiếc mũ mới nhiều màu sắc. Nếu bạn tung ra 7, người chơi sẽ mất một chiếc mũ. Đối với tất cả các giá trị khác, người chơi của bạn di chuyển số khoảng trắng đó trên bảng trò chơi. Đây là một triển khai logic match, với kết quả của cuộn xúc xắc được mã hóa cứng chứ không phải là một giá trị ngẫu nhiên, và tất cả các logic khác được đại diện bởi các hàm không có phần thân bởi vì thực sự việc triển khai chúng nằm ngoài phạm vi của ví dụ này:

fn main() {
    let dice_roll = 9;
    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        other => move_player(other),
    }

    fn add_fancy_hat() {}
    fn remove_fancy_hat() {}
    fn move_player(num_spaces: u8) {}
}

Đối với hai nhánh đầu tiên, các mẫu là các giá trị 3 và 7. Đối với nhánh cuối cùng bao gồm mọi giá trị có thể có khác, biến chúng ta đã chọn để đặt tên other. Mã chạy cho nhánh other sử dụng biến bằng cách chuyển nó đến hàm move_player.

Biên dịch đoạn code này, mặc dù chúng tôi chưa liệt kê tất cả các giá trị có thể có của một u8, vì mẫu cuối cùng sẽ khớp với tất cả các giá trị không được liệt kê cụ thể. Mẫu tổng hợp này đáp ứng yêu cầu rằng match phải đầy đủ. Lưu ý rằng chúng ta phải đặt nhánh thu thập tất cả cuối cùng vì các mẫu được đánh giá theo thứ tự. Rust sẽ cảnh báo chúng ta nếu chúng ta thêm nhánh nào đó sau khi bắt được tất cả vì những nhánh sau đó sẽ không bao giờ khớp với nhau!

Rust cũng có một mẫu mà chúng ta có thể sử dụng khi không muốn sử dụng giá trị trong mẫu tổng hợp: _, là một mẫu đặc biệt phù hợp với bất kỳ giá trị nào và không liên kết với giá trị đó. Điều này cho Rust biết rằng chúng ta sẽ không sử dụng giá trị, vì vậy Rust sẽ không cảnh báo chúng ta về một biến không được sử dụng.

Hãy thay đổi quy tắc của trò chơi thành nếu bạn tung bất kỳ thứ gì khác ngoài số 3 hoặc số 7, bạn sẽ phải tung lại. Chúng ta không cần sử dụng giá trị trong trường hợp đó, vì vậy chúng ta có thể thay đổi mã của mình để sử dụng _ thay vì biến có tên other:

fn main() {
    let dice_roll = 9;
    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        _ => reroll(),
    }

    fn add_fancy_hat() {}
    fn remove_fancy_hat() {}
    fn reroll() {}
}

Ví dụ này cũng đáp ứng yêu cầu đầy đủ vì chúng ta đang bỏ qua tất cả các giá trị khác trong nhánh cuối cùng; chúng ta đã không quên bất cứ điều gì.

Nếu chúng tôi thay đổi các quy tắc của trò chơi một lần nữa, để không có gì khác xảy ra trong lượt của bạn nếu bạn tung bất kỳ thứ gì khác ngoài con 3 hoặc con 7, chúng ta có thể thể hiện điều đó bằng cách sử dụng giá trị đơn vị (loại tuple trống mà chúng tôi đã đề cập trong phần “The Tuple Type”) như mã đi với nhánh _:

fn main() {
    let dice_roll = 9;
    match dice_roll {
        3 => add_fancy_hat(),
        7 => remove_fancy_hat(),
        _ => (),
    }

    fn add_fancy_hat() {}
    fn remove_fancy_hat() {}
}

Ở đây, chúng ta đang nói với Rust một cách rõ ràng rằng chúng ta sẽ không sử dụng bất kỳ giá trị nào khác không khớp với một mẫu trong nhánh trước đó, và chúng tôi không muốn chạy bất kỳ mã nào trong trường hợp này.

Có nhiều thông tin hơn về các mẫu và matchings mà chúng ta sẽ đề cập đến ở Chapter 18. Bây giờ, chúng ta sẽ chuyển sang cú pháp if let, có thể hữu ích trong các tình huống mà match diễn đạt hơi dài dòng.

Cú pháp kiểm tra biến với if let

Cú pháp if let cho phép bạn kết hợp if và let thành một cách ít dài dòng hơn để xử lý các giá trị khớp với một mẫu trong khi bỏ qua phần còn lại. Xem xét chương trình trong Listing 6-6 phù hợp với một giá trị Option<u8> trong config_max nhưng chỉ muốn thực thi mã nếu giá trị là trường hợp Some.

fn main() {
    let config_max = Some(3u8);
    match config_max {
        Some(max) => println!("The maximum is configured to be {}", max),
        _ => (),
    }
}

Listing 6-6: match chỉ quan tâm đến việc thực thi mã khi giá trị là Some

Nếu giá trị là Some, chúng ta in ra giá trị Some bằng cách liên kết giá trị với biến max trong mẫu. Chúng ta không muốn làm bất cứ điều gì với giá trị None. Để đáp ứng biểu thức match, chúng ta phải thêm _ => () sau khi chỉ xử lý một trường hợp, đó là đoạn mã khó chịu để thêm vào.

Thay vào đó, chúng ta có thể viết điều này theo cách ngắn hơn bằng cách sử dụng if let. Đoạn mã sau hoạt động giống như match trong Listing 6-6:

fn main() {
    let config_max = Some(3u8);
    if let Some(max) = config_max {
        println!("The maximum is configured to be {}", max);
    }
}

Cú pháp if let nhận một mẫu và một biểu thức được phân tách bằng dấu bằng. Nó hoạt động giống như cách một matchmà trong đó biểu thức được đưa ra cho match và mẫu là nhánh đầu tiên. Trong trường hợp này, mẫu là Some(max), và giá trị max liên kết với giá trị bên trong Some. Sau đó chúng ta có thể sử dụng max trong phần thân của khối if let theo cách tương tự như chúng tôi đã sử dụng max in tương ứng nhánh match. Đoạn mã trong khối if let sẽ không chạy nếu giá trị không khớp với mẫu.

Sử dụng if let có nghĩa là ít nhập hơn, ít thụt lề hơn và ít mã mẫu hơn. Tuy nhiên, bạn sẽ matts đi sự kiểm tra đầy đủ mà một match được thực thi. Lựa chọn giữa match và if let phụ thuộc vào những gì bạn đang làm trong tình huống cụ thể của bạn và và liệu việc đạt được sự ngắn gọn có phải là một sự đánh đổi thích hợp để đánh mất việc kiểm tra đầy đủ hay không.

Nói cách khác, bạn có thể nghĩ về if let như là cú pháp ngọt ngào cho một match chạy mã khi giá trị khớp với một mẫu và sau đó bỏ qua tất cả các giá trị khác.

Chúng tôi có thể bao gồm một else với một if let. Khối code đó sẽ đi với else giống như khối mã sẽ đi với trường hợp _ casetrong biểu thức match điều đó tương đương với if let và else. Nhớ lại định nghĩa enum Coin ở Listing 6-4, trường hợp Quarter cũng có giá trị là một UsState. Nếu chúng ta muốn đếm tất cả các đồng tiền không phải đồng 25 xu mà chúng ta thấy đồng thời thông báo trạng thái của đồng 25 xu, chúng tôi có thể làm điều đó với một biểu thức match như thế này:

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {
    let coin = Coin::Penny;
    let mut count = 0;
    match coin {
        Coin::Quarter(state) => println!("State quarter from {:?}!", state),
        _ => count += 1,
    }
}

Hoặc chúng ta có thể sử dụng một biểu thức if let và else như thế này:

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {
    let coin = Coin::Penny;
    let mut count = 0;
    if let Coin::Quarter(state) = coin {
        println!("State quarter from {:?}!", state);
    } else {
        count += 1;
    }
}

Nếu bạn gặp tình huống trong đó chương trình của bạn có logic quá dài dòng để diễn đạt bằng cách sử dụng match, nhớ rằng that if let cũng có trong hộp công cụ Rust của bạn.

Tóm tắt

Bây giờ chúng ta đã đề cập đến cách sử dụng enum để tạo các loại tùy chỉnh có thể là một trong tập hợp các giá trị được liệt kê. Chúng tôi đã chỉ ra cách thư viện tiêu chuẩn Option<T> loại giúp bạn sử dụng hệ thống loại để ngăn ngừa lỗi. Khi các giá trị enum có dữ liệu bên trong chúng, bạn có thể sử dụng match hoặc if let để trích xuất và sử dụng các giá trị đó, tùy thuộc vào số lượng trường hợp bạn cần xử lý.

Các chương trình Rust của bạn hiện có thể diễn đạt các khái niệm trong miền của bạn bằng cách sử dụng cấu trúc và enum. Tạo các loại tùy chỉnh để sử dụng trong API của bạn đảm bảo an toàn cho loại: trình biên dịch sẽ đảm bảo các hàm của bạn chỉ nhận các giá trị kiểu mà mỗi hàm mong đợi.

Để cung cấp một API được tổ chức tốt cho người dùng của bạn, dễ sử dụng và chỉ hiển thị chính xác những gì người dùng của bạn sẽ cần, bây giờ hãy chuyển sang các mô-đun của Rust.

Quản lý các dự án lớn với Packages, Crates, and Modules

Khi bạn viết các chương trình lớn, tổ chức code của bạn sẽ rất quan trọng vì theo dõi toàn bộ chương trình của bạn trong đầu sẽ trở nên không thể. Bằng cách nhóm chức năng liên quan và phân tách code với các tính năng riêng biệt, bạn sẽ làm rõ nơi tìm code thực hiện một tính năng cụ thể và nơi để thay đổi cách thức hoạt động của một tính năng.

Các chương trình chúng tôi đã viết cho đến nay đã có trong một mô-đun trong một file. Là một dự án phát triển, bạn có thể tổ chức code bằng cách chia nó thành nhiều mô-đun và sau đó nhiều file. Một package có thể chứa nhiều binary crates và tùy chọn một library crate. Như một package phát triển, bạn có thể chia nhỏ các phần vào các crates, những crates này trở thành external dependencies. Chương này bao gồm tất cả các kỹ thuật trên. Đối với các dự án rất lớn của một tập hợp các package có liên quan đến nhau, Cargo cung cấp workspaces, chúng tôi sẽ đề cập trong phần “Cargo Workspaces”trong Chương 14.

Ngoài chức năng nhóm, triển khai tính đóng gói chi tiết cho phép bạn sử dụng lại code ở mức cao: khi bạn triển khai một hành động, các đoạn code khác sẽ gọi code đó thông qua public interface mà không cần biết cách triển khai hoạt động. Các mà bạn viết code xác định phần nào public để đoạn code khác sử dụng và phần nào private để bạn có thể tuỳ chỉnh khi cần. Đây là một cách khác để hạn chế số lượng tổ chức code mà bạn phải nhớ

Một khái niệm liên quan nữa là scope: ngữ cảnh mà code được viết lồng nhau trong đó một tập hợp các tên được định nghĩa là “in scope.” Khi đọc, viết và biên dịch code, các lập trình viên và trình biên dịch cần biết tại một thời điểm cụ thể đề cập tới một biến, function, struct, enum, module, constant hoặc các item khác và các item đó có nghĩa là gì. Bạn có thể tạo ra phạm vi và thay đổi cái tên nào trong hoặc ngoài phạm vi. Bạn không thể có hai item có cùng tên trong cùng phạm vi; tools có sẵn để giải quyết xung đột tên.

Rust có một số tính năng cho phép bạn quản lý tổ chức code của mình, bao gồm cả chi tiết nào được công khai, chi tiết nào là private và tên nào trong mỗi phạm vi trong các chương trình của bạn. Những tính năng này, đôi khi được gọi chung là module system, bao gồm:

• Packages: Một tính năng Cargo cho phép bạn build, test, and chia sẻ crates
• Crates: Một cây của modules tạo ta một lib hoặc thực thi
• Modules and use: để bạn kiểm soát tổ chức (dự án), phạm vi và quyền riêng tư của các đường dẫn
• Paths: một cách để đặt tên một item, chẳng hạn như một struct, function hoặc module

Trong chương này, chúng ta sẽ đề cập tới tất cả các tính năng trên, bàn luận về cách chúng tương tác và giải thích cách sử dụng chúng để quản lý phạm vi. Cuối cùng, bạn nên có một sự hiểu biết vững chắc về phân chia module để có thể làm việc một cách hiệu quả.

Packages and Crates

Các phần đầu tiên của module system chúng ta sẽ bao gồm packages và crates.

Một package là một hoặc nhiều crates cung cấp một loạt các chức năng. Một package chứa một file Cargo.toml mô tả cách build các crate của package đó.

Một crate có thể là một binary crate hoặc một library crate. Binary crates là các chương trình bạn có thể biên dịch và thực thi để chạy, chẳng hạn như một command-line program hoặc một server. Chúng ta cần có một function được gọi là main, function này xác định điều gì xảy ra khi chạy thực thi. Tất cả các crates được tạo ra thường là binary crates.

Library crates không có main function, và chúng không được biên dịch để thực thi. Chúng định nghĩa các chức năng dự định để chia sẻ với nhiều projects. Ví dụ, crate rand chúng tôi sử dụng trong Chapter 2 cung cấp chức năng tạo các số ngẫu nhiên.

crate root là một file mà nguồn mà trình biên dịch Rust bắt đầu và tạo thành các root module (chúng tôi sẽ giải thích về module sâu hơn trong phần “Defining Modules to Control Scope and Privacy”).

Một số quy tắc xác định những gì mà một package có thể chứa. Một package có thể chứa nhiều nhất một library crate. Nó có thể chứa bao nhiêu binary crates tùy thích, nhưng nó phải chứa ít nhất một crate (hoặc là library hoặc binary).

Hãy xem điều gì xảy ra khi chúng ta tạo ra một package. Đầu tiên chúng ta gõ lệnh cargo new:

$ cargo new my-project
     Created binary (application) `my-project` package
$ ls my-project
Cargo.toml
src
$ ls my-project/src
main.rs

Khi chúng ta nhập lệnh, Cargo tạo một file Cargo.toml , cho chúng ta một package. Nhìn vào nội dung của Cargo.toml, Không đề cập đến src/main.rs bởi vì Cargo tuân theo một quy ước rằng src/main.rs là crate root của một binary crate cùng tên với package. Hơn nữa, Cargo biết rằng nếu thư mục package chứa src/lib.rs, package chứa một library crate có cùng tên với package, và src/lib.rs là crate root của nó. Cargo đưa các file crate root tới rustc để build the library or binary.

Ở đây chúng ta có một package chỉ chứa src/main.rs, có nghĩa là nó chỉ chứa một binary crate tên là my-project. Nếu một package chứa src/main.rs và src/lib.rs, nó có 2 crates: một binary và một library, cả hai đều cùng tên với package. Một package có thể chứa nhiều binary crates bằng cách đặt các files trong thư mục src/bin : mỗi file sẽ là một binary crate riêng biệt.

Định nghĩa module với chính sách và phạm vi truy cập (privacy)

Trong phần này, chúng ta sẽ nói về modules và các phần khác của module system, cụ thể là paths cho phép bạn đặt tên cho các mục; từ khóa use đưa ra một đường dẫn tới scope; và từ khóa pub làm cho các mục public. Chúng ta sẽ thảo luận về từ khóa as, external packages, và toán tử toàn cục.

Đầu tiên, chúng ta sẽ bắt đầu với một danh sách các quy tắc để dễ dàng tham khảo. Khi bạn tổ chức code của mình trong tương lai. Sau đó, chúng tôi sẽ giải thích chi tiết từng quy tắc.

Tham chiếu tới module một cách ngắn gọn (Modules Quick Reference)

Đây là cách mà modules, paths, từ khóa use, và từ khóa pub hoạt động trong trình biên dịch, và làm thế nào hầu hết các developer tổ chức code của họ. Chúng ta sẽ trải qua các ví dụ về từng quy tắc này, nhưng đây là một nơi tuyệt vời để tìm kiếm trong tương lai như một lời nhắc nhở về cách các module hoạt động.

• Bắt đầu từ crate root: Khi biên dịch một crate, Trình biên dịch sẽ nhìn vào file crate root đầu tiên (thường là src/lib.rs cho một library crate hoặc src/main.rs cho một binary crate).
• Khai báo modules: Trong file crate root, bạn có thể khai báo một module mới có tên gọi là “garden”, với cú pháp mod garden;. Trình biên dịch sẽ tìm kiếm code bên trong module tại đây:
  • Trong cùng 1 dòng, trực tiếp viết mod garden, trong dấu ngoặc nhọn thay vì dấu chấm phẩy.
  • Trong file src/garden.rs
  • Trong file src/garden/mod.rs
• Khái báo submodules: Trong bất kì file nào khác crate root, được biên dịch như là một phần của crate (ví dụ, src/garden.rs), bạn cần khai báo submodules (ví dụ, mod vegetables;). Trình biên dịch sẽ tìm kiếm trong dòng code submodules ở những nơi trong thư mục được đặt tên theo module cha:
  • Trong cùng 1 dòng, trực tiếp viết mod vegetables, trong dấu ngoặc nhọn thay vì dấu chấm phẩy.
  • Trong file src/garden/vegetables.rs
  • Trong file src/garden/vegetables/mod.rs
• Đừng dẫn đến code trong modules: Khi một module đang được biên dịch là một phần crate của bạn, bạn có thể tham khảo code trong module đó (ví dụ, một loại Asparagus(măng tây) trong module garden) từ bất cứ nơi nào khác trong crate này bằng cách sử dụng đường dẫn crate::garden::vegetables::Asparagus miễn là các quy tắc bảo mật cho phép.
• Private vs public: Code trong một module là private từ các modules cha theo mặc định. Để làm cho một module public, khai báo nới với từ khóa pub mod thay vì mod là tốt nhất, sử dụng pub trước khi khai báo.
• **Từ khóause **: Trong phạm vi, từ khóa use Tạo các lối tắt cho các mục để giảm sự lặp lại của các đường dẫn dài. Trong bất kỳ phạm vi nào có thể tham khảo crate::garden::vegetables::Asparagus, bạn có thể tạo một lối tắt với use crate::garden::vegetables::Asparagus; và sau đó chỉ cần viết Asparagus để sử dụng loại đó trong phạm vi.

Đây là một binary crate được đặt tên là backyard minh họa cho những quy tắc này. Thư mục của crates, cũng được đặt tên là backyard, chứa các file và thư mục này:

backyard
├── Cargo.lock
├── Cargo.toml
└── src
    ├── garden
    │   └── vegetables.rs
    ├── garden.rs
    └── main.rs

File crate root, trong trường hợp này src/main.rs, chứa:

Filename: src/main.rs

use crate::garden::vegetables::Asparagus;

pub mod garden;

fn main() {
    let plant = Asparagus {};
    println!("I'm growing {:?}!", plant);
}

The pub mod garden; means the compiler includes the code it finds in src/garden.rs, which is:

Filename: src/garden.rs

pub mod vegetables;

Và pub mod vegetables; có nghĩa là code trong src/garden/vegetables.rs cũng được bao gồm:

#[derive(Debug)]
pub struct Asparagus {}

Bây giờ, hãy cùng tìm hiểu chi tiết về các quy tắc này và chứng minh chúng trong thực tế!

Nhóm code liên quan thành một modules (Grouping Related Code in Modules)

Modules hãy tổ chức code của bạn trong một crate thành các group để dễ dàng đọc và sử dụng lại. Các module cũng kiểm soát privacy của các mục, đó là một mục có thể sử dụng bởi code bên ngoài (public) hoặc là một triển khai nội bộ chi tiết và không có sẵn để sử dụng bên ngoài (private).

Ví dụ: hãy viết một library crate cung cấp chức năng của một nhà hàng. Chúng tôi xác định chữ kí hàm nhưng phần thân để trống để tập trung vào việc tổ chức code, thay vì thực sự thực hiện một nhà hàng trong code. Chữ ký của một hàm mô tả:

• tên của nó
• đối số của nó
• kết quả của nó
• trong trường hợp của các chức năng chung, các tham số chung của nó, với các giới hạn cụ thể có khả năng Ví dụ: nếu bạn xác định:

fn hello(s: &str) {
 println!("Hello {}", s);
}

• Chữ ký hàm là fn hello(&str).

Trong ngành nhà hàng, Một số phần của một nhà hàng được gọi là Trước nhà và những cái khác như là Sau nhà. Phía trước nhà là nơi khách hàng ; Đây là nơi khách hàng ngồi, servers nhận đơn đặt hàng và thanh toán, và người pha chế làm đồ uống. Phía sau nhà là nơi các đầu bếp làm việc trong bếp, máy rửa chén rửa chén, và các nhà quản lý làm công việc hành chính Để cấu trúc crate cũng giống như cách mà nhà hàng hoạt động, Chúng ta có thể tổ chức các functions vào các modules lồng nhau. Tạo mới một library đặt tên làrestaurant bằng cách chạy cargo new --lib restaurant; Sau đó đặt mã vào Listing 7-1 vào src/lib.rs để xác định một số modules and chữ kí hàm.

Filename: src/lib.rs

mod front_of_house {
    mod hosting {
        fn add_to_waitlist() {}

        fn seat_at_table() {}
    }

    mod serving {
        fn take_order() {}

        fn serve_order() {}

        fn take_payment() {}
    }
}

Listing 7-1: Một front_of_house module chứa các module khác sau đó chứa các function

Chúng ta định nghĩa một module với từ khóa mod và sau đó chỉ định tên module (trong trường hợp này là front_of_house) và đặt dấu ngoặc nhọn bao quanh phần thân của module. Bên trong module, chúng ta cần có các module khác, trong trường hợp này là với các module hosting và serving. Các module cũng có thể chứa các định nghĩa cho những mục khác, như là structs, enums, constants, traits, hoặc như trong Listing 7-1—functions.

Bằng cách sử dụng các module, chúng tôi có thể nhóm các định nghĩa có liên quan lại với nhau và đặt tên cho lý do tại sao chúng có liên quan. Các lập trình viên sử dụng code này sẽ có thời gian dễ dàng hơn trong việc tìm các định nghĩa mà họ muốn sử dụng vì họ có thể điều hướng code dựa trên các nhóm thay vì phải đọc qua tất cả các định nghĩa. Các lập trình viên thêm chức năng mới vào mã này sẽ biết nơi đặt code để giữ cho chương trình có tổ chức.

Trước đó, chúng tôi đã đề cập rằng src/main.rs và src/lib.rs được gọi là crate roots. Lý do cho tên của chúng là vì nội dung của một trong hai tệp này tạo thành một module có tên crate ở cấu trúc root crate module, được gọi là module tree.

Listing 7-2 hiển thị cây module cho cấu trúc trong Listing 7-1.

crate
 └── front_of_house
     ├── hosting
     │   ├── add_to_waitlist
     │   └── seat_at_table
     └── serving
         ├── take_order
         ├── serve_order
         └── take_payment

Listing 7-2: Cây module cho code trong Listing 7-1

Cây này cho thấy cách một số module lồng vào nhau(Ví dụ, hosting lồng bên trong front_of_house). Cây cũng cho thấy rằng một số module là anh chị em với nhau, nghĩa là chúng được xác định trong cùng một module (hosting và serving được xác định trong front_of_house).Tiếp tục phép ẩn dụ về gia đình, Nếu module A được chứa bên trong module B, chúng tôi nói rằng module A là con của module B và module B là cha của module Lưu ý rằng toàn bộ cây module được bắt nguồn từ module ngầm định có tên crate.

Cây module có thể nhắc bạn về cây thư mục của hệ thống tệp trên máy tính của bạn; đây là một so sánh rất phù hợp! Cũng giống như các thư mục trong hệ thống tệp, bạn sử dụng các module để tổ chức mã của mình. Và cũng giống như các tệp trong thư mục, chúng ta cần một cách để tìm các module của mình.

Đường dẫn tham chiếu đến một mục trong cây module

Để chỉ cho Rust nơi tìm một mục trong cây module, chúng tôi sử dụng một đường dẫn giống như cách chúng ta sử dụng một đường dẫn khi điều hướng một hệ thống tệp. Nếu chúng ta muốn gọi một hàm, chúng ta cần biết đường dẫn của nó.

Một đường dẫn có thể có 2 dạng:

• Một đường dẫn tuyệt đối bắt đầu từ một crate bằng cách sử dụng tên một crate (đối với mã từ external crate) hoặc theo nghĩa đen crate (cho code từ crate hiện tại).
• Một đường dẫn tương đối bắt đầu từ module hiện tại và sử dụng self, super, hoặc một mã định danh trong module hiện tại.

Cả hai đường dẫn tuyệt đối và tương đối đều được theo sau bởi một hoặc nhiều định danh được phân tách bằng dấu hai chấm kép(::).

Hãy quay lại ví dụ trong Listing 7-1. Làm thế nào để chúng tôi gọi hàm add_to_waitlist? Điều này cũng giống như yêu cầu, đừng dẫn của function là gì add_to_waitlist ? Listing 7-3 chứa Listing 7-1 với một số module và hàm bị loại bỏ. Chúng tôi sẽ chỉ ra hai cách để gọi hàm add_to_waitlist từ một hàm mới eat_at_restaurant được định nghĩa trong crate root. Hàm eat_at_restaurant là một phần của public API trong thư viện crate của chúng ta , vì vậy chúng ta đánh dấu nó với từ khóa pub. Trong phần “Exposing Paths with the pub Keyword”, Chúng ta sẽ đi vào chi tiết hơn về pub.Lưu ý rằng ví dụ này sẽ chưa biên dịch; chúng tôi sẽ giải thích một chút lý do tại sao.

Filename: src/lib.rs

mod front_of_house {
    mod hosting {
        fn add_to_waitlist() {}
    }
}

pub fn eat_at_restaurant() {
    // Absolute path
    crate::front_of_house::hosting::add_to_waitlist();

    // Relative path
    front_of_house::hosting::add_to_waitlist();
}

Listing 7-3: Gọi hàm add_to_waitlistsử dụng các đường dẫn tuyệt đối và tương đối

Lần đầu tiên chúng ta gọi hàm add_to_waitlist trong eat_at_restaurant, chúng tôi sử dụng một đường dẫn tuyệt đối. Hàm add_to_waitlistđược xác định trong cùng một crate như eat_at_restaurant, có nghĩa là chúng ta có thể sử dụng từ khóa crate để bắt đầu một đường dẫn tuyệt đối.

Sau crate, chúng tôi bao gồm từng module kế tiếp nhau cho đến khi chúng ta thực hiện theo cách add_to_waitlist.Bạn có thể tưởng tượng một hệ thống tệp có cấu trúc giống nhau, và chúng tôi sẽ chỉ định đường dẫn /front_of_house/hosting/add_to_waitlist để chạy chương trình add_to_waitlist ; sử dụng tên crate để bắt đầu từ crate root giống như sử dụng / để bắt đầu từ gốc hệ thống tệp trong shell của bạn.

Lần thứ hai chúng ta gọi add_to_waitlist trong eat_at_restaurant, chúng ta sử dụng đường dẫn tương đối. Đường dẫn bắt đầu với front_of_house, tên của module được xác định ở cùng cấp của cây module như eat_at_restaurant. Ở đây hệ thống tệp tương đương sẽ sử dụng đường dẫn front_of_house/hosting/add_to_waitlist. Bắt đầu bằng một cái tên có nghĩa là đường dẫn đó là tương đối.

Việc chọn sử dụng đường dẫn tương đối hay đường dẫn tuyệt đối là quyết định bạn sẽ thực hiện dựa trên dự án của mình. Quyết định sẽ phụ thuộc vào việc bạn có nhiều khả năng di chuyển các mục code được xác định riêng biệt hoặc cùng với code sử dụng các mục hay không. Ví dụ, nếu chúng ta di chuyển module front_of_house và hàmeat_at_restaurant vào một module được đặt tên customer_experience, chúng tôi cần cập nhật đường dẫn tuyệt đối đếnadd_to_waitlist, nhưng đường dẫn tương đối sẽ vẫn hợp lệ. Tuy nhiên, nếu chúng ta di chuyển hàm eat_at_restaurant riêng biệt thành một module có tên dining,đường dẫn tuyệt đối dẫn đến add_to_waitlist cuộc gọi sẽ giữ nguyên, nhưng đường dẫn tương đối sẽ cần được cập nhật. Sở thích của chúng tôi là chỉ định đường dẫn tuyệt đối vì có nhiều khả năng chúng tôi muốn di chuyển các định nghĩa code và lệnh gọi các mục độc lập với nhau.

Hãy thử biên dịch Listing 7-3 và tìm hiểu lý do tại sao nó vẫn chưa được biên dịch! Lỗi chúng tôi gặp phải được hiển thị trong Listing 7-4.

$ cargo build
   Compiling restaurant v0.1.0 (file:///projects/restaurant)
error[E0603]: module `hosting` is private
 --> src/lib.rs:9:28
  |
9 |     crate::front_of_house::hosting::add_to_waitlist();
  |                            ^^^^^^^ private module
  |
note: the module `hosting` is defined here
 --> src/lib.rs:2:5
  |
2 |     mod hosting {
  |     ^^^^^^^^^^^

error[E0603]: module `hosting` is private
  --> src/lib.rs:12:21
   |
12 |     front_of_house::hosting::add_to_waitlist();
   |                     ^^^^^^^ private module
   |
note: the module `hosting` is defined here
  --> src/lib.rs:2:5
   |
2  |     mod hosting {
   |     ^^^^^^^^^^^

For more information about this error, try `rustc --explain E0603`.
error: could not compile `restaurant` due to 2 previous errors

Listing 7-4: Lỗi trình biên dịch khi xây dựng code trong Listing 7-3

Các thông báo lỗi cho biết module hosting là private. Nói cách khác, chúng tôi có các đường dẫn chính xác cho module hosting và hàm add_to_waitlist,nhưng Rust sẽ không cho phép chúng tôi sử dụng chúng vì nó không có quyền truy cập vào các phần private.

Các module không chỉ hữu ích cho việc tổ chức code của bạn. Chúng cũng định nghĩa Rust’s privacy boundary: bao gồm chi tiết triển khai code bên ngoài không được phép biết, gọi hoặc phụ thuộc vào. Vì vậy, nếu bạn muốn đặt một mục như function hoặc structs ở chế độ private, bạn đặt nó trong một module.

Cách thức hoạt động của quyền riêng tư trong Rust là tất cả các mục (functions, methods, structs, enums, modules, and constants) là private theo mặc định. Các mục ở module cha không thể sử dụng các mục private bên trong các module con,nhưng các mục trong module con có thể sử dụng các mục trong module tổ tiên của chúng. Lý do là các module con bao bọc và ẩn triển khai chi tiết của chúng, nhưng các module con có thể thấy ngữ cảnh mà chúng được xác định. Để tiếp tục với phép ẩn dụ về nhà hàng, hãy nghĩ về các quy tắc bảo mật giống như văn phòng phía sau của một nhà hàng: những gì diễn ra trong đó là riêng tư đối với khách hàng của nhà hàng, nhưng những người quản lý văn phòng có thể thấy và làm mọi thứ trong nhà hàng mà họ điều hành.

Rust đã chọn để hệ thống module hoạt động theo cách này để ẩn các chi tiết triển khai bên trong là mặc định. Bằng cách đó, bạn biết những phần nào của code bên trong mà bạn có thể thay đổi mà không cần phá vỡ mã bên ngoài. Nhưng bạn có thể hiển thị các phần bên trong của code module con cho các module tổ tiên bên ngoài bằng cách sử dụng từ khóa pub để đặt một mục ở chế độ public.

Hiển thị các Đường dẫn với Từ khoá pub

Hãy quay lại lỗi trong Listing 7-4 Hãy quay lại lỗi trong module hosting là private.Chúng ta muốn function eat_at_restaurant trong module cha để có quyền truy cập vào functionadd_to_waitlist trong module con, vì vậy chúng ta đánh dấu module hosting với từ khóa pub, như được hiển thị trong Listing 7-5.

Filename: src/lib.rs

mod front_of_house {
    pub mod hosting {
        fn add_to_waitlist() {}
    }
}

pub fn eat_at_restaurant() {
    // Absolute path
    crate::front_of_house::hosting::add_to_waitlist();

    // Relative path
    front_of_house::hosting::add_to_waitlist();
}

Listing 7-5: Khai báo module hosting như pub sử dụng nó từ eat_at_restaurant

Thật không may, mã trong Listing 7-5 vẫn dẫn đến lỗi, như được hiển thị trong Listing 7-6.

$ cargo build
   Compiling restaurant v0.1.0 (file:///projects/restaurant)
error[E0603]: function `add_to_waitlist` is private
 --> src/lib.rs:9:37
  |
9 |     crate::front_of_house::hosting::add_to_waitlist();
  |                                     ^^^^^^^^^^^^^^^ private function
  |
note: the function `add_to_waitlist` is defined here
 --> src/lib.rs:3:9
  |
3 |         fn add_to_waitlist() {}
  |         ^^^^^^^^^^^^^^^^^^^^

error[E0603]: function `add_to_waitlist` is private
  --> src/lib.rs:12:30
   |
12 |     front_of_house::hosting::add_to_waitlist();
   |                              ^^^^^^^^^^^^^^^ private function
   |
note: the function `add_to_waitlist` is defined here
  --> src/lib.rs:3:9
   |
3  |         fn add_to_waitlist() {}
   |         ^^^^^^^^^^^^^^^^^^^^

For more information about this error, try `rustc --explain E0603`.
error: could not compile `restaurant` due to 2 previous errors

Listing 7-6:Lỗi trình biên dịch khi xây dựng mã trong Listing 7-5

Chuyện gì đã xảy ra? Thêm từ khóa pub vào trước mod hosting đặt module ở chế độ public. Với sự thay đổi này, nếu chúng ta có thể truy cập front_of_house, chúng ta có thể truy cập hosting. Nhưng nội dung của hosting vẫn còn private; đặt module ở chế độ public không làm public nội dung của module. Từ khóa pub trên một module chỉ cho phép code trong các module tổ tiên của nó tham chiếu đến nó.

Các lỗi trong Listing 7-6 nói rằng function add_to_waitlist là private. Các quy tắc bảo mật áp dụng cho structs, enums, functions, and methods cũng như các module.

Hãy cũng làm cho function add_to_waitlist public bằng cách thêm từ khóa pub trước định nghĩa của nó, như trong Listing 7-7.

Filename: src/lib.rs

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

pub fn eat_at_restaurant() {
    // Absolute path
    crate::front_of_house::hosting::add_to_waitlist();

    // Relative path
    front_of_house::hosting::add_to_waitlist();
}

Listing 7-7: Thêm từ khóa pub vào mod hosting và fn add_to_waitlist cho phép chúng tôi gọi hàm từ eat_at_restaurant

Bây giờ code sẽ biên dịch!Hãy xem xét đường dẫn tuyệt đối và đường dẫn tương đối và kiểm tra kỹ lý do tại sao lại thêm từ khóa pub cho phép chúng tôi sử dụng những đường dẫn này trong add_to_waitlist đối với các quy tắc bảo mật.

Trong đường dẫn tuyệt đối, chúng ta bắt đầu với crate, root của cây crate’s module . Sau đó module front_of_houseđược định nghĩa trong crate root. module front_of_house không là public, nhưng bởi vì function eat_at_restaurant được định nghĩa trong cùng một module như front_of_house (đó là, eat_at_restaurant và front_of_house là chị em), chúng ta có thể tham khảo front_of_house từ eat_at_restaurant.Tiếp theo là module hosting được đánh dấu với pub. Chúng ta có thể truy cập module cha của hosting, vì vậy chúng ta có thể truy cập hosting.Cuối cùng function add_to_waitlist được đánh dấu với pub và chúng tôi có thể truy cập module cha của nó, vì vậy lệnh gọi hàm này hoạt động!

Trong đường dẫn tương đối, logic giống như đường dẫn tuyệt đối ngoại trừ bước đầu tiên: thay vì bắt đầu từ crate root, đường dẫn bắt đầu từ front_of_house. Module front_of_house được định nghĩa trong cùng một module như eat_at_restaurant, vì vậy đường dẫn tương đối bắt đầu từ module trong đó eat_at_restaurant là việc định nghĩa. Sau đó,bởi vì hosting và add_to_waitlist được đánh dấu với pub, phần còn lại của đường dẫn hoạt động và lệnh gọi hàm này hợp lệ!

Nếu bạn định chia sẻ library crate của mình để các dự án khác có thể sử dụng code của bạn, Public API của bạn là hợp đồng của bạn với người dùng trong crate về cách họ tương tác với mã của bạn. Có nhiều cân nhắc xung quanh việc quản lý các thay đổi đối với public API của bạn để giúp mọi người phụ thuộc vào crate của bạn dễ dàng hơn. Những cân nhắc này nằm ngoài phạm vi của cuốn sách này; nếu bạn quan tâm đến chủ đề này, hãy xem The Rust API Guidelines.

Các phương pháp hay nhất cho các package có một Binary và a Library

Chúng tôi đã đề cập đến một package có thể chứa cả hai src/main.rs binary crate root giống như một src/lib.rs library crate root, và cả crates sẽ có tên package theo mặc định. hông thường, các package có mẫu này sẽ chỉ có đủ code trong binary crate để bắt đầu một tệp thực thi gọi code bằng library crate. Điều này cho phép các project khác được hưởng lợi nhiều nhất chức năng mà package cung cấp, vì code của library crate có thể được chia sẻ.

Cây module nên được định nghĩa trong src/lib.rs. Sau đó, bất kỳ mục public nào có thể được sử dụng trong binary crate bằng cách bắt đầu các đường dẫn với tên của package. Binary crate trở thành người dùng của library crate giống như một crate bên ngoài sẽ sử dụng library crate: nó chỉ có thể sử dụng public API. Điều này giúp bạn thiết kế một API tốt; bạn không chỉ là tác giả, bạn còn là client!

In Chapter 12,chúng ta sẽ chứng minh tổ chức này thực hành với một command-line program sẽ chứa cả một binary crate và một library crate.

Bắt đầu Đường dẫn tương đối với super

Chúng tôi cũng có thể xây dựng các đường dẫn tương đối bắt đầu trong module cha bằng cách sử dụng super ở đầu đường dẫn. Điều này giống như bắt đầu một đường dẫn hệ thống tệp với cú pháp ... Tại sao chúng tôi muốn làm điều này?

Hãy xem xét đoạn mã trong Listing 7-8 mô hình hóa tình huống trong đó đầu bếp sửa một đơn hàng không chính xác và đích thân mang món đó ra cho khách hàng.Chức năng fix_incorrect_order được định nghĩa trong module back_of_house gọi hàm deliver_order được định nghĩa trong module cha bằng cách chỉ định đường dẫn đến deliver_order bắt đầu với super:

Filename: src/lib.rs

fn deliver_order() {}

mod back_of_house {
    fn fix_incorrect_order() {
        cook_order();
        super::deliver_order();
    }

    fn cook_order() {}
}

Listing 7-8: Calling a function using a relative path starting with super

Hàm fix_incorrect_order nằm trong module back_of_house, vì vậy chúng ta có thể sử dụng super để chuyển đến module cha của back_of_house, trong trường hợp này là crate root. Từ đó, chúng tôi tìm kiếm delivery_order và tìm thấy nó. Thành công! Chúng tôi nghĩ rằng module back_of_house và hàm delivery_order có thể giữ nguyên mối quan hệ với nhau và được di chuyển cùng nhau nếu chúng tôi quyết định tổ chức lại cây module của crate. Do đó, chúng tôi đã sử dụng super nên chúng tôi sẽ có ít nơi để cập nhật mã hơn trong tương lai nếu mã này được chuyển sang một module khác.

Làm cho Structs và Enums Public

Chúng ta cũng có thể sử dụng pub để chỉ định các struct và enums là public, nhưng có một số chi tiết bổ sung. Nếu chúng ta sử dụng pub trước định nghĩa struct, chúng ta đặt struct ở chế độ public, nhưng các trường của struct sẽ vẫn ở chế độ riêng tư. Chúng tôi có thể public từng trường hoặc không tùy từng trường hợp cụ thể. Trong Listing 7-9, chúng tôi đã xác định cấu trúc back_of_house :: Breakfast public với trường toast public nhưng là trường season_fruit riêng. Điều này mô tả trường hợp trong một nhà hàng, nơi khách hàng có thể chọn loại bánh mì đi kèm với bữa ăn, nhưng đầu bếp quyết định loại trái cây nào đi kèm với bữa ăn dựa trên những gì đang có trong mùa và trong kho. Trái cây có sẵn thay đổi nhanh chóng, vì vậy khách hàng không thể chọn trái cây hoặc thậm chí không thể xem họ sẽ lấy trái cây nào.

Filename: src/lib.rs

mod back_of_house {
    pub struct Breakfast {
        pub toast: String,
        seasonal_fruit: String,
    }

    impl Breakfast {
        pub fn summer(toast: &str) -> Breakfast {
            Breakfast {
                toast: String::from(toast),
                seasonal_fruit: String::from("peaches"),
            }
        }
    }
}

pub fn eat_at_restaurant() {
    // Order a breakfast in the summer with Rye toast
    let mut meal = back_of_house::Breakfast::summer("Rye");
    // Change our mind about what bread we'd like
    meal.toast = String::from("Wheat");
    println!("I'd like {} toast please", meal.toast);

    // The next line won't compile if we uncomment it; we're not allowed
    // to see or modify the seasonal fruit that comes with the meal
    // meal.seasonal_fruit = String::from("blueberries");
}

Listing 7-9:Một struct với một số trường public và một số trường riêng tư

Vì trường toast trong struct back_of_house :: Breakfast là public nên trong eat_at_restaurant, chúng ta có thể viết và đọc trường toast bằng ký hiệu :: . Xin lưu ý rằng chúng ta không thể sử dụng trường season_fruit trong eat_at_restaurant bởi vì season_fruit là private. Hãy thử bỏ ghi chú dòng sửa đổi giá trị trường season_fruit để xem bạn gặp lỗi gì!

Ngoài ra, hãy lưu ý rằng vì back_of_house :: Breakfast có một trường private, nên struct cần cung cấp một hàm liên kết public để tạo một phiên bản của Breakfast (chúng tôi đã đặt tên nó là summer ở đây). Nếu Breakfast không có chức năng như vậy, chúng tôi không thể tạo phiên bản của Breakfast trong eat_at_restaurant vì chúng tôi không thể đặt giá trị của trường private theo seasonal_fruit trong eat_at_restaurant.

Ngược lại, nếu chúng ta public enum, thì tất cả các biến thể của nó sẽ được public. Chúng tôi chỉ cần pub trước từ khóa enum, như được hiển thị trong Listing 7-10.

Filename: src/lib.rs

mod back_of_house {
    pub enum Appetizer {
        Soup,
        Salad,
    }
}

pub fn eat_at_restaurant() {
    let order1 = back_of_house::Appetizer::Soup;
    let order2 = back_of_house::Appetizer::Salad;
}

Listing 7-10:Việc chỉ định một enum là public làm cho tất cả các biến thể của nó ở chế độ public

Vì chúng tôi đã đặt enum Appetizer ở chế độ public nên chúng tôi có thể sử dụng các biến thể Soup và Salad trong eat_at_restaurant. Enums không hữu ích lắm trừ khi các biến thể của chúng được public; sẽ rất khó chịu khi phải chú thích tất cả các biến thể enum bằng pub trong mọi trường hợp, vì vậy mặc định cho các biến thể enum là public. Các struct thường hữu ích mà không cần trường của chúng là public, vì vậy, các trường của struct tuân theo quy tắc chung là mọi thứ là private theo mặc định trừ khi được chú thích bằng pub.

Còn một trường hợp nữa liên quan đến pub mà chúng tôi chưa đề cập đến và đó là tính năng hệ thống public cuối cùng của chúng tôi: từ khóa use. Trước tiên, chúng tôi sẽ đề cập đến vấn đề use, sau đó chúng tôi sẽ chỉ ra cách kết hợp giữa pub và use.

Định nghĩa phạm vi sử dụng cho đường dẫn với từ khoá use

Có vẻ như các đường dẫn mà chúng tôi đã viết để gọi các hàm cho đến nay là dài và lặp đi lặp lại một cách bất tiện. Ví dụ: trong Listing 7-7, cho dù chúng ta chọn đường dẫn tuyệt đối hay tương đối đến hàm add_to_waitlist, mỗi khi chúng ta muốn gọi add_to_waitlist, chúng ta cũng phải chỉ định front_of_house và hosting. May mắn thay, có một cách để đơn giản hóa quy trình này. Chúng ta có thể tạo một lối tắt đến một đường dẫn với từ khóa use một lần, sau đó sử dụng tên ngắn hơn ở mọi nơi khác trong scope.

Trong Listing 7-11, chúng ta đưa module crate :: front_of_house :: hosting vào scope của hàm eat_at_restaurant vì vậy chúng tôi chỉ phải chỉ định hosting :: add_to_waitlist để gọi hàm add_to_waitlist trong eat_at_restaurant.

Filename: src/lib.rs

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

Listing 7-11: Đưa một module vào scope với use

Thêm use và một đường dẫn trong một scope tương tự như tạo một liên kết tượng trưng trong hệ thống tệp. Bằng cách thêm use crate :: front_of_house :: hosting trong crate root, hosting bây giờ là một tên hợp lệ trong scope đó, giống như module hosting đã được xác định trong crate root. Các đường dẫn được đưa vào scope với use cũng kiểm tra quyền riêng tư, giống như bất kỳ đường dẫn nào khác.

Lưu ý rằng use chỉ tạo lối tắt cho scope cụ thể mà use xảy ra. Listing 7-12 di chuyển hàm eat_at_restaurant vào một module con mới có tên là customer, sau đó là một scope khác với câu lệnh use và thân hàm sẽ không biên dịch:

Filename: src/lib.rs

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

use crate::front_of_house::hosting;

mod customer {
    pub fn eat_at_restaurant() {
        hosting::add_to_waitlist();
    }
}

Listing 7-12: Câu lệnh use chỉ áp dụng trong scope mà nó nằm trong

Lỗi trình biên dịch cho thấy rằng phím tắt không còn áp dụng trong module customer:

$ cargo build
   Compiling restaurant v0.1.0 (file:///projects/restaurant)
error[E0433]: failed to resolve: use of undeclared crate or module `hosting`
  --> src/lib.rs:11:9
   |
11 |         hosting::add_to_waitlist();
   |         ^^^^^^^ use of undeclared crate or module `hosting`

warning: unused import: `crate::front_of_house::hosting`
 --> src/lib.rs:7:5
  |
7 | use crate::front_of_house::hosting;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

For more information about this error, try `rustc --explain E0433`.
warning: `restaurant` (lib) generated 1 warning
error: could not compile `restaurant` due to previous error; 1 warning emitted

Lưu ý rằng cũng có một cảnh báo rằng use không còn được sử dụng trong scope của nó nữa! Để khắc phục sự cố này, hãy di chuyển luôn cả use trong module customer hoặc tham chiếu lối tắt trong module cha với super :: hosting trong module con customer.

Tạo các đường dẫn use theo kiểu Idiomatic

Trong Listing 7-11, bạn có thể thắc mắc tại sao chúng tôi chỉ định use crate :: front_of_house :: hosting và sau đó gọi là hosting :: add_to_waitlist trong eat_at_restaurant thay vì chỉ định đường dẫn use đến tận hàm add_to_waitlist để đạt được kết quả tương tự, như trong Listing 7-13.

Filename: src/lib.rs

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

use crate::front_of_house::hosting::add_to_waitlist;

pub fn eat_at_restaurant() {
    add_to_waitlist();
}

Listing 7-13: Đưa hàm add_to_waitlist vào scope với use, đó là unidiomatic

Mặc dù cả Listing 7-11 và 7-13 đều hoàn thành cùng một nhiệm vụ, nhưng Listing 7-11 là cách theo khuôn mẫu để đưa một hàm vào scope với use. Đưa module cha của hàm vào scope với use có nghĩa là chúng ta phải chỉ định module cha khi gọi hàm. Việc chỉ định module cha khi gọi hàm làm rõ rằng hàm không được xác định cục bộ trong khi vẫn giảm thiểu sự lặp lại của đường dẫn đầy đủ. Mã trong Listing 7-13 không rõ ràng về nơi mà add_to_waitlist được định nghĩa.

Mặt khác, khi nhập các structs, enums, và các item khác với use, it’s khuôn mẫu để chỉ định đường dẫn đầy đủ. Listing 7-14 cho thấy một cách theo khuôn mẫu để đưa cấu trúc HashMap của thư viện tiêu chuẩn vào scope của binary crate.

Filename: src/main.rs

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert(1, 2);
}

Listing 7-14: Đưa HashMap vào scope một cách theo khuôn mẫu/span>

Không có lý do chính đáng nào đằng sau mẫu này: đó chỉ là quy ước đã xuất hiện và mọi người đã quen với việc đọc và viết mã Rust theo cách này.

Ngoại lệ cho khuôn mẫu này là nếu chúng ta đưa hai mục có cùng tên vào scope với câu lệnh use, bởi vì Rust không cho phép điều đó. Listing 7-15 cho thấy cách đưa hai kiểu Result vào scope có cùng tên nhưng khác module cha và cách tham chiếu đến chúng.

Filename: src/lib.rs

use std::fmt;
use std::io;

fn function1() -> fmt::Result {
    // --snip--
    Ok(())
}

fn function2() -> io::Result<()> {
    // --snip--
    Ok(())
}

Listing 7-15: Đưa hai kiểu có cùng tên vào cùng một scope yêu cầu sử dụng module cha của chúng

Như bạn có thể thấy, việc sử dụng các module cha sẽ phân biệt hai kiểu Result. Nếu thay vào đó, chúng tôi chỉ định use std :: fmt :: Result và use std :: io :: Result, chúng tôi sẽ có hai loại Result trong cùng một scope và Rust sẽ không biết chúng tôi muốn nói đến loại nào khi chúng tôi đã sử dụng Result

Cung cấp Tên Mới với Từ khoá as

Có một giải pháp khác cho vấn đề đưa hai kiểu tên giống nhau vào cùng một scope với use: sau đường dẫn, chúng ta có thể chỉ định as và một tên cục bộ mới hoặc bí danh cho kiểu đó. Listing 7-16 chỉ ra một cách khác để viết mã trong Listing 7-15 bằng cách đổi tên một trong hai kiểu Result bằng cách sử dụng as.

Filename: src/lib.rs

use std::fmt::Result;
use std::io::Result as IoResult;

fn function1() -> Result {
    // --snip--
    Ok(())
}

fn function2() -> IoResult<()> {
    // --snip--
    Ok(())
}

Listing 7-16: Đổi tên một loại khi nó được đưa vào scope với từ khóa as

Trong câu lệnh use thứ hai, chúng tôi đã chọn tên mới IoResult cho kiểu std :: io :: Result, sẽ không xung đột với Result từ std :: fmt mà chúng tôi có cũng được đưa vào scope. Listing 7-15 và Listing 7-16 được coi là theo khuôn mẫu, vì vậy sự lựa chọn là tùy thuộc vào bạn!

Re-exporting tên với pub use

Khi chúng tôi đưa một tên vào scope với từ khóa use, tên có sẵn trong scope mới là private. Để cho phép code gọi code của chúng tôi tham chiếu đến tên đó như thể nó đã được xác định trong scope của code đó, chúng tôi có thể kết hợp pub và use. Kỹ thuật này được gọi là re-exporting vì chúng tôi đang đưa một item
vào scope nhưng cũng làm cho item đó khả dụng để những người khác đưa vào scope của họ.

Listing 7-17 hiển thị code trong Listing 7-11 với use trong module root được thay đổi thành pub use.

Filename: src/lib.rs

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

pub use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

Listing 7-17: Tạo một tên khả dụng cho bất kỳ code nào để sử dụng từ một scope mới với pub use

Trước thay đổi này, external code sẽ phải gọi hàm add_to_waitlist bằng cách sử dụng đường dẫnrestaurant :: front_of_house :: hosting :: add_to_waitlist (). Bây giờ, pub use này đã re-exported lại module hosting từ module root, external code hiện có thể sử dụng đường dẫnrestaurant :: hosting :: add_to_waitlist ()để thay thế.

Re-exporting hữu ích khi cấu trúc bên trong của code của bạn khác với cách các lập trình viên gọi code của bạn sẽ nghĩ về domain. Ví dụ, trong phép ẩn dụ về nhà hàng này, những người điều hành nhà hàng nghĩ về “front of house” và “back of house”. Nhưng khách hàng đến thăm một nhà hàng có thể sẽ không nghĩ về các bộ phận của nhà hàng theo những thuật ngữ đó. Với pub use, chúng ta có thể viết code của mình với một cấu trúc nhưng hiển thị một cấu trúc khác. Làm như vậy làm cho thư viện của chúng tôi được tổ chức tốt cho các lập trình viên làm việc trên thư viện và các lập trình viên gọi thư viện. Chúng ta sẽ xem xét một ví dụ khác về pub use và cách nó ảnh hưởng đến crate’s documentation của bạn trong phần “Exporting a Convenient Public API with pub use” của Chapter 14.

Sử dụng External Packages

Trong Chương 2, chúng tôi đã lập trình một guessing game project sử dụng một external package gọi là rand để lấy số ngẫu nhiên. Để sử dụng rand trong project của bạn, chúng tôi đã thêm dùng này vào Cargo.toml:

Filename: Cargo.toml

rand = "0.8.3"

Thêm rand như là một dependency trong Cargo.toml yêu cầu Cargo tải xuống gói rand và bất kỳ dependencies từ crates.io và cung cấp rand cho project của chúng tôi.

Sau đó, để đưa các định nghĩa rand vào scope của package của chúng tôi, chúng tôi đã thêm một dòng use bắt đầu bằng tên của crate, rand, và liệt kê các mục chúng tôi muốn đưa vào scope.Nhớ lại rằng trong phần “Generating a Random Number” trong Chương 2,chúng tôi đã đưa đặc điểm Rng vào scope và gọi hàm rand :: thread_rng:

use std::io;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");
}

Các thành viên của cộng đồng Rust đã cung cấp nhiều package tại crates.io, và pull bất kỳ trong số chúng vào package của bạn bao gồm các bước tương tự: liệt kê chúng trong file package’s Cargo.toml và sử dụng use đưa các item từ crate của chúng vào scope.

Note that the standard library (std) is also a crate that’s external to our package. Because the standard library is shipped with the Rust language, we don’t need to change Cargo.toml to include std. But we do need to refer to it with use to bring items from there into our package’s scope. For example, with HashMap we would use this line:

#![allow(unused)]
fn main() {
use std::collections::HashMap;
}

Đây là một đường dẫn tuyệt đối bắt đầu bằng std, tên của library crate tiêu chuẩn.

Sử dụng các đường dẫn lồng nhau để clear up danh sách use lớn

Nếu chúng tôi đang sử dụng nhiều item được xác định trong cùng một crate hoặc cùng một module, thì việc liệt kê từng item trên một dòng riêng có thể chiếm nhiều không gian theo chiều dọc trong file của chúng tôi. Ví dụ: hai câu lệnh use mà chúng ta có trong Guessing Game trong Listing 2-4 đưa các item từ std vào scope:

Filename: src/main.rs

use rand::Rng;
// --snip--
use std::cmp::Ordering;
use std::io;
// --snip--

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    }
}

Thay vào đó, chúng ta có thể sử dụng các đường dẫn lồng nhau để đưa các item giống nhau vào scope trong một dòng. Chúng tôi thực hiện điều này bằng cách chỉ định phần chung của đường dẫn, theo sau là hai dấu hai chấm, sau đó là dấu ngoặc nhọn xung quanh danh sách các phần khác nhau của đường dẫn, như được hiển thị trong Listing 7-18.

Filename: src/main.rs

use rand::Rng;
// --snip--
use std::{cmp::Ordering, io};
// --snip--

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    let guess: u32 = guess.trim().parse().expect("Please type a number!");

    println!("You guessed: {guess}");

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    }
}

Listing 7-18: Chỉ định một đường dẫn lồng nhau để đưa nhiều item có cùng tiền tố vào scope

Trong các chương trình lớn hơn, đưa nhiều item vào scope từ cùng một crate hoặc module bằng cách sử dụng các đường dẫn lồng nhau có thể làm giảm số lượng các câu lệnh use riêng biệt cần thiết đi rất nhiều!

Chúng ta có thể sử dụng một đường dẫn lồng nhau ở bất kỳ mức nào trong một đường dẫn, điều này rất hữu ích khi kết hợp hai câu lệnh use dùng chung một đường dẫn con. Ví dụ: Listing 7-19 hiển thị hai câu lệnh use: một câu đưa std :: io vào scope và một câu đưa std :: io :: Write vào scope.

Filename: src/lib.rs

use std::io;
use std::io::Write;

Listing 7-19: Two use statements where one is a subpath of the other

Phần chung của hai đường dẫn này là std :: io và đó là đường dẫn đầu tiên hoàn chỉnh. Để hợp nhất hai đường dẫn này thành một câu lệnh use, chúng ta có thể sử dụng self trong đường dẫn lồng nhau, như được hiển thị trong Listing 7-20.

Filename: src/lib.rs

use std::io::{self, Write};

Listing 7-20: Kết hợp các đường dẫn trong Listing 7-19 thành một câu lệnh use

Dòng này đưa std :: io và std :: io :: Write vào scope.

Toán tử Glob

Nếu chúng ta muốn đưa tất cả các item public được xác định trong một đường dẫn vào scope, chúng ta có thể chỉ định đường dẫn đó theo sau là *, toán tử Glob:

#![allow(unused)]
fn main() {
use std::collections::*;
}

Câu lệnh use này đưa tất cả các item public được định nghĩa trong std :: collection vào scope hiện tại. Hãy cẩn thận khi sử dụng toán tử cầu! Glob có thể khiến việc phân biệt những tên nào trong scope và nơi tên được sử dụng trong chương trình của bạn được xác định là khó hơn.

Toán tử glob thường được sử dụng khi kiểm tra để đưa mọi thứ đang được kiểm tra vào module tests; chúng ta sẽ nói về điều đó trong phần “How to Write Tests” trong chương 11.Toán tử glob đôi khi cũng được sử dụng như một phần của mẫu dạo đầu: xem the standard library documentation để biết thêm thông tin về mẫu đó.

Tách các module thành các file khác nhau

Cho đến nay, tất cả các ví dụ trong chương này đều xác định nhiều module trong một file. Khi các module trở nên lớn, bạn có thể muốn chuyển định nghĩa của chúng sang một file riêng biệt để làm cho code điều hướng dễ dàng hơn.

Ví dụ: hãy bắt đầu từ code trong Listing 7-17 và trích xuất các module vào các file thay vì xác định tất cả các module trong file crate root. Trong trường hợp này,file crate root là src/lib.rs, nhưng quy trình này cũng hoạt động với các binary crate có file crate root là src/main.rs.

Đầu tiên, chúng tôi sẽ giải nén module front_of_house vào file nó sở hữu. Xóa code bên trong dấu ngoặc nhọn cho module front_of_house, chỉ để lại khai báomod front_of_house;, để src/lib.rs chứa code được hiển thị trong Listing 7-21. Lưu ý rằng điều này sẽ không được biên dịch cho đến khi chúng tôi tạo tệp src/front_of_house.rs trong Listing 7-22.

Filename: src/lib.rs

mod front_of_house;

pub use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

Listing 7-21: Khai báo module front_of_house có phần thân sẽ nằm trong src/front_of_house.rs

Tiếp theo, đặt code nằm trong dấu ngoặc nhọn vào một tệp mới có tên src/front_of_house.rs, như được hiển thị trong Listing 7-22. Trình biên dịch biết tìm kiếm trong file này vì khai báo module mà nó tìm thấy trong crate root với tên front_of_house.

Filename: src/front_of_house.rs

pub mod hosting {
    pub fn add_to_waitlist() {}
}

Listing 7-22: Các định nghĩa bên trong module front_of_house trong src/front_of_house.rs

Lưu ý rằng bạn chỉ cần tải nội dung của file bằng cách sử dụng mod khai báo một lần ở đâu đó trong cây module của bạn. Sau khi trình biên dịch biết file là một phần của dự án (và biết mã nằm ở đâu trong cây module vì nơi bạn đã đặt câu lệnh mod), các file khác trong dự án của bạn nên tham chiếu đến code trong file đó bằng cách sử dụng đường dẫn đến nơi nó được khai báo như được đề cập trong phần “Paths for Referring to an Item in the Module Tree”. Nói cách khác, mod không phải là một hoạt động “bao gồm ”mà các ngôn ngữ lập trình khác có.

Tiếp theo, chúng tôi cũng sẽ giải nén module hosting vào file nó sở hữu. Quá trình này hơi khác một chút vì hosting là một module con của front_of_house, không phải của root module. Tệp cho hosting sẽ nằm trong một thư mục được đặt tên cho vị trí của nó trong cây module.

Để bắt đầu di chuyển hosting, chúng tôi thay đổi src/front_of_house.rs để chỉ chứa phần khai báo của module hosting:

Filename: src/front_of_house.rs

pub mod hosting;

Sau đó, chúng tôi tạo một thư mục src/front_of_house và một file src/front_of_house/hosting.rs để chứa các định nghĩa được thực hiện trong module hosting:

Filename: src/front_of_house/hosting.rs

pub fn add_to_waitlist() {}

Thay vào đó, nếu chúng tôi đặt hosting.rs trong thư mục src, trình biên dịch sẽ mong đợi code đó nằm trong module hosting được khai báo trong crate root, không phải là phần tử con của module front_of_house. Các quy tắc mà trình biên dịch tuân theo để biết những file nào cần tìm cho code của module có nghĩa là các thư mục và tệp phù hợp hơn với cây module.

Đường dẫn tệp thay thế

Phần này bao gồm các đường dẫn file khuôn mẫu nhất mà trình biên dịch Rust sử dụng; nhưng một đường dẫn file cũ hơn cũng vẫn được hỗ trợ.

Đối với module có tên front_of_house được khai báo trong crate root, trình biên dịch sẽ tìm thấy code của module trong:

• src/front_of_house.rs (những gì chúng tôi đã đề cập)
• src/front_of_house/mod.rs (đường dẫn cũ hơn, vẫn được hỗ trợ)

Đối với một module có tên là hosting là một module con của front_of_house, trình biên dịch sẽ tìm kiếm code của module trong:

• src/front_of_house/hosting.rs (những gì chúng tôi đã đề cập)
• src/front_of_house/hosting/mod.rs (đường dẫn cũ hơn, vẫn được hỗ trợ)

Nếu bạn sử dụng cả hai cho cùng một module, bạn sẽ gặp lỗi trình biên dịch.Sử dụng cho phép các kiểu khác nhau cho các module khác nhau trong cùng một dự án,nhưng có thể gây nhầm lẫn cho những người đang điều hướng dự án của bạn.

Nhược điểm chính của kiểu sử dụng file có tên mod.rs là dự án có thể kết thúc với nhiều file có tên mod.rs, điều này có thể gây nhầm lẫn khi bạn mở chúng trong editor của mình cùng một lúc.

Việc chuyển code của từng module sang một file riêng biệt hiện đã hoàn tất và cây module vẫn giữ nguyên. Các lệnh gọi hàm trong eat_at_restaurant sẽ hoạt động mà không có bất kỳ sửa đổi nào, mặc dù các định nghĩa nằm trong các file khác nhau. Kỹ thuật này cho phép bạn di chuyển các module sang các file mới khi chúng phát triển về kích thước.

Lưu ý rằng câu lệnh pub use crate :: front_of_house :: hosting trong src/lib.rs cũng không thay đổi, cũng như use không có bất kỳ tác động nào đến những file nào được biên dịch như một phần của crate. Từ khóa mod khai báo các module và Rust tìm kiếm trong một file có cùng tên với module cho code đi vào module đó.

Tổng kết

Rust cho phép bạn chia một package thành nhiều crate và một crate thành các module để bạn có thể tham chiếu đến các item được xác định trong một module từ một module khác. Bạn có thể làm điều này bằng cách chỉ định các đường dẫn tuyệt đối hoặc tương đối. Các đường dẫn này có thể được đưa vào scope bằng câu lệnh use để bạn có thể sử dụng đường dẫn ngắn hơn cho nhiều mục đích sử dụng trong scope đó. Code module là private theo mặc định, nhưng bạn có thể đặt định nghĩa ở chế độ public bằng cách thêm từ khóa pub.

Trong chương tiếp theo, chúng ta sẽ xem xét một số cấu trúc dữ liệu thu thập trong thư viện chuẩn mà bạn có thể sử dụng trong code được sắp xếp gọn gàng của mình.

Các collections phổ biến

collections: Bộ sưu tập, tập hợp, chỉ cấu trúc dữ liệu lưu trữ nhiều thành phần thành một tập hợp có đặc tính chung nào đó

Thư viện tiêu chuẩn của Rust bao gồm một số cấu trúc dữ liệu rất hữu ích được gọi là collections. Hầu hết các kiểu dữ liệu khác đại diện cho một giá trị cụ thể, nhưng các collections có thể chứa nhiều giá trị. Không giống như các loại array(mảng) và tuple(bộ) được tích hợp sẵn, dữ liệu mà các collections này trỏ tới được lưu trữ trên vùng heap, có nghĩa là lượng dữ liệu không cần biết tại thời điểm biên dịch và có thể tăng lên hoặc thu nhỏ khi chương trình chạy. Mỗi loại collections có tính năng và giá (cost) khác nhau, và chọn một tính năng thích hợp cho tình huống hiện tại của bạn là một tính năng bạn sẽ phát triển theo thời gian. Trong chương này, chúng ta sẽ thảo luận về ba collections được sử dụng rất thường xuyên trong các chương trình Rust:

• Vector cho phép bạn lưu trữ một số lượng giá trị bên cạnh nhau.
• String là một tập hợp các ký tự. Trước đây chúng ta đã đề cập đến kiểu String, nhưng trong chương này chúng ta sẽ nói sâu hơn về nó.
• Hash map cho phép bạn liên kết giá trị với một khóa cụ thể. Đó là một triển khai cụ thể của cấu trúc dữ liệu chung hơn gọi là một map.

Để tìm hiểu về các loại collections khác được cung cấp bởi thư viện tiêu chuẩn, hãy xem the documentation.

Chúng ta sẽ thảo luận về cách tạo và cập nhật vectors, strings, and hash maps, cũng như những gì làm cho mỗi thứ trở nên đặc biệt.

Lưu trữ danh sách các giá trị với Vectors

Cho tới nay chúng ta đã nhìn thấy kiểu danh sách là Vec<T> - đọc là vector. xwVector cho phép chúng ta lưu trữ
nhiều các giá trị cùng kiểu bằng cách đặt chúng cạnh nhau trong bộ nhớ. Vector chỉ cho phép lưu trữ các giá trị cùng kiểu dữ liệu. Eg: Cùng kiểu i32, i64, str, u8... Chúng hưu dụng khi chúng ta có danh sách các đối tượng, giống như mỗi dòng text trong một file hoặc giá của các items trong một giỏ hàng.

Cách tạo một vector

Để tạo một vector mới và rỗng, chúng ta gọi hàm Vec::new, xem ví dụ Listing 8-1

fn main() {
    let v: Vec<i32> = Vec::new();
}

Listing 8-1: Tạo một vector mới, rỗng, kiểu dữ liệu i32

Chú ý rằng, chúng thêm ký hiệu ở đây. Bởi vì, chúng ta đã không chèn bất kỳ giá trị nào vào vector này, Rust sẽ không biết kiểu dữ liệu nào chúng ta định lưu trữ. Điều này khá là quan trọng. Bởi vì Vector đã thực hiện sử dụng kiểu dữ liệu tổng quát (generics). Chúng ta sẽ xem xét cách để sử dụng generics với kiểu dữ liệu mà bạn muốn trong Chương 10. Hiện tại, Kiểu Vec<T> được cung cấp bởi thư viện chuẩn và có thể lưu trữ bất kỳ giá tị nào. Khi chúng tạo một vector để lưu trữ một kiểu cụ thể, chúng ta có thể chi tiết kiểu trong dấu <>. Trong 9-1, chúng ta đã nói rằng Vec<T> trong đó v sẽ giữ thành phần với kiểu dữ liệu i32

Thường xuyên hơn, bạn sẽ tạo một Vec<T> với giá trị khởi tạo và Rust sẽ tự ngầm hiểu(infer)) kiểu mà bạn muốn lưu trữ, do đó hiếm bạn cần ký hiệu cho kiểu dữ liệu. Rust cũng cấp một macro vec! mà sẽ tạo một vector mới mà sẽ giữ các giá trị mà bạn truyền vào. Listing 8-2 tạo một Vec<i32 và dữ giá tị 1,2, và 3. Kiểu số nguyên là i32 bởi vì nó là kiểu số nguyên mặc định (4 bytes). Điều này chúng ta đã thảo luận trong “Data types” Chương 3

fn main() {
    let v = vec![1, 2, 3];
}

Listing 8-2: Tạo một vectỏ mới bao gồm các giá trị Bởi vì chúng ta khởi tạo các giá trị i32, Rust có thể ngầm hiểu kiểu của v là Vec<i32>, và ký hiệu cho kiểu là không cần thiết. Tiêp theo, chúng ta sẽ xem xét cách để thay đổi một vector

Cập nhật một Vector

Để tạo một vector và sau đó thêm các thành phần tới chúng, chúng ta sử dụng phương thức push như được chỉ ra trong Listing 8-3

fn main() {
    let mut v = Vec::new();

    v.push(5);
    v.push(6);
    v.push(7);
    v.push(8);
}

Listing 8-3: Sử dụng phương thức push để thêm các giá trị tới một vector Bởi vì với bất kỳ biến nào, nếu bạn muôn có thể thay đổi giá trị của chúng, bạn cũng sẽ cần làm cho nó mutable (có thể thay đổi được) bằng cách sử dụng từ khoá mut, như đã nói đến trong Chương 3. Số chúng đặt trong vector là kiểu i32, và Rust ngầm hiểu từ dữ liệu, do đó chúng ta không thực sự cần ký hiệu Vec<i32>

Huỷ thành phần trong một vector

Giống như bất kỳ kiếu struct nào, một vector được giải phóng khi nó ra ngoài phạm vi của nó xem Listing 8-4.

fn main() {
    {
        let v = vec![1, 2, 3, 4];

        // do stuff with v
    } // <- v goes out of scope and is freed here
}

Listing 8-4: Nơi vector và các giá trị của nó bị huỷ

Khi vector bị huỷ, tất cả nội dung trong nó sẽ bị huỷ, nghĩa rằng tất cả số nguyên nó giữ sẽ bị xoá sạch. Điều này có vẻ dường như đơn giản nhưng nếu như chúng ta bắt đầu học về tham chiếu (reference) tới các thành phần của một vector, chắc chắn nó không còn dễ hiểu như vậy nữa

Đọc thành phần (elements) trong Vector

Có 2 cách để tham chiếu một giá trị lưu trong một vector: thông qua index (chỉ số) hoặc sử dụng phương thức get. Trong ví dụ dưới đây, chúng ta ký hiệu kiểu của các giá trị mà được trở về từ các hàm trên cho mục địch phân làm rõ hơn.

Listing 8-5 chỉ ra cả 2 phương thức truy xuất một giá trị trong một vector, một sử dụng chỉ số, một sử dụng phương thức get

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    let third: &i32 = &v[2];
    println!("The third element is {}", third);

    match v.get(2) {
        Some(third) => println!("The third element is {}", third),
        None => println!("There is no third element."),
    }
}

Listing 8-5: Sử dụng cú pháp chỉ số hoặc phương thức get để truy xuất một đối tượng trong một vector

Chú ý có 2 chi tiết ở đây. Đầu tiên, chúng ta sử dụng giá trị chỉ số 2 để lấy phần tử thứ 3 bởi vì vector được đánh chỉ số bắt đầu từ 0. Thứ hai, chúng ta lấy phần tử thứ 3 bởi sử dụng & hoặc [], mà đưa chúng ta một tham chiếu hoặc sử dụng phương thức get với chỉ số truyền vào như tham số, kết quả là Option<&T>

Lý do Rust cung cấp 2 cách để tham chiếu một thành phần là bạn có thể chọn cách chương trình hành xử (behaves) khi bạn cố gắng để sử dụng một giá trị ngoài dãy các thành phần xác định. Ví dụ, xem xét chuyện gì xảy ra khi chúng ta có một vector với chỉ 5 thành phần và bạn lại luốn truy xuất tới thành phần có index 100. Xem xét Listing 8-6.

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    let does_not_exist = &v[100];
    let does_not_exist = v.get(100);
}

Listing 8-6: Attempting to access the element at index 100 in a vector containing five elements

Khi bạn chạy đoạn code này, phương thức đầu tiên [] sẽ gây chương trình panic(ngắt) bởi vì nó tham chiếu tới một thành phần không tồn tại. Điều này là tốt khi bạn muốn chương trình crash nếu như bạn không muốn có sự truy xuất tới thành phần ngoài vector (Ví dụ như 1 số chương trình cố gắn truy nhập ô nhớ sau vector đề biết nhiều thông tin hơn chẳng hạn)

Khi phương thức get được sử dụng với chỉ số nằm ngoài một vector, nó trở về None ngoài trừ panicking (ngắt). Bạn sẽ sử dụng phương thức này nếu truy xuất một thành phần vược ra ngoài khoảng của vector có thể xảy ra thường xuyên trong một số trường hợp. Code của bạn sẽ có logic để xử lý hoặc là Some(&element) hoặc None như đã thảo luận trong chương 6.Ví dụ, chỉ số có thể đến từ một người nhập vào một số. Nếu họ vô tình nhập một số mà quá lớn, chương trình sẽ có giá trị None, bạn có thể nói người dùng bao nhiều items trong vector hiện tại, và đưa cho họ một cơ hội khác với giá trị nhập vào hợp lý hơn. Điều này là nhiều thân thiện hơn là ngắt chương trình chỉ vì một lỗi nhập số ngớ ngẩn.

Khi chương trình có một tham chiếu hợp lệ, chương trình borrow checker (bộ kiểm tra nguyên lý mượn) thực thi luật quyền sở hữu (ownership) và nguyên lý borrowing (đã nói trong chương 4) để đảm bảo các tham chiếu và bất kỳ tham chiếu khác tới nội dung của vector còn lại hợp lệ. Nhắc lại luật này, bạn không thể có cùng lúc tham chiếu mutable và immutable trong cùng phạm vi (scope - Ví dụ cùng 1 hàm). Luật này áp dụng trong Listing 8-7, nơi chúng ta giữ một tham chiếu immutable(không thay đổi được) tới thành phần đầu tiên của vector và cố gắn thêm một thành phần tới cuối cùng. Chương trình này sẽ không chạy nếu chúng ta cố gắng tham chiếu tới thành phần đó trong hàm.

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];

    let first = &v[0];

    v.push(6);

    println!("The first element is: {}", first);
}

Listing 8-7: Cố gắng thêm một thành phần tới một vector trong khi giữ một tham chiếu tới một thành phần

Biên dịch code này sẽ lỗi:

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
 --> src/main.rs:6:5
  |
4 |     let first = &v[0];
  |                  - immutable borrow occurs here
5 | 
6 |     v.push(6);
  |     ^^^^^^^^^ mutable borrow occurs here
7 | 
8 |     println!("The first element is: {}", first);
  |                                          ----- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `collections` due to previous error

Code trong Listing 8-7 thoạt nhìn không có gì sai: Tại sao một tham chiếu tới thành phần đầu tiên quan tâm tới sự thay đổi tại thành phần cuối của một vector? Lỗi này là bởi vì cách vector hoạt động: bởi vì vectors đặt các giá trị cạnh trong trong bộ nhớ, thêm một thanh phần mới vào cuối của vector có thể yêu cầu cấp phát bộ nhớ và copy các thành phần của tới không gian mới này, nếu không đủ bộ nhớ để đặt tất cả các thành phần cạnh nhau nơi vector được lưu trữ hiện tại. Trong trường hợp này, tham chiếu tới thành phần đầu tiên trỏ tới bộ nhớ được thu hồi (deallocated memory). Luật borrowing ngăn chặn chương trình rơi vào tình huống này.

Chú ý: Cho nhiều thông tin chi tiết thực hiện kiểu Vec<T> , xem cuốn “The Rustonomicon”.

Duyệt qua các giá trị trong một Vector

Để truy xuất mỗi thành phàn trong một vector lần lượt, chúng ta có thể duyệt qua (iterate) tất các thành phần hhown là sử dụng chỉ thị để truy xuất mỗi thành phần. Listing 8-8 chỉ cách để sử dụng for lặp để có tham chiếu immutable tới mỗi thành phần trong một Vector i32 và in chúng

fn main() {
    let v = vec![100, 32, 57];
    for i in &v {
        println!("{}", i);
    }
}

Listing 8-8: In mỗi thành phần trong một Vector bởi duyệt qua các thành phần sử dụng vòng lặp for

Chúng ta cũng có thể duyệt qua tham chiếu mutable tới mỗi thành phần trong một vector mutable lần lượt để thay đổi tất cả thành phần. Vòng lặp for trong Listing 8-9 sẽ cộng thêm 50 tới mỗi thành phần

fn main() {
    let mut v = vec![100, 32, 57];
    for i in &mut v {
        *i += 50;
    }
}

Listing 8-9: Duyệt qua các tham chiếu mutable trỏ tới các thành phần trong một vector

Để thay đổi giá trị mà một tham chiếu mutable trỏ tới, chúng ta có thể sử toàn tử * (gọi là dereference operator) để lấy giá trị trong i trước khi chúng ta có thể sử dụng toán tử +=. Chúng ta sẽ nói nhiều về toán tử derefence này “Toán từ Dereference như một con trỏ tới một giá trị” trong chương 15

Sử dụng Enum để lưu trữ nhiều kiểu dữ liệu

Vectors có thể chỉ lưu trữ các giá trị mà có cùng kiểu. Điều này có thể hơi bất tiện; rõ ràng có trường hợp cho cần dể lưu trữ một danh sách các phần tử của kiểu khác nhau May mắn thay, biến thể của một enum định nghĩa dưới cùng kiểu enum, nên khi chúng ta cần 1 kiểu để thể hiện các thành phần của kiểu khác nhau, chúng ta có thể sử dụng enum! Ví dụ, chúng ta muốn lấy gái trị từ một dòng trong 1 spreadsheet (tài liệu) nơi một số cột trong hàng bao gồm số nguyên dượng, một vài sốt thực, và một số string. Chúng ta có thể định nghĩa một enum mà các biến của nó sẽ giữ kiểu khác nhau, và tất các biến enum sẽ được xem là cùng một kiểu: kiểu enum. Sau đó chúng ta có thể tạo một vector để lưu trữ enum và do đó không giới giạn lưu trữ kiểu dữ liệu khác nhau. Chúng ta sẽ trình bày điều này trong Listing 8-10

fn main() {
    enum SpreadsheetCell {
        Int(i32),
        Float(f64),
        Text(String),
    }

    let row = vec![
        SpreadsheetCell::Int(3),
        SpreadsheetCell::Text(String::from("blue")),
        SpreadsheetCell::Float(10.12),
    ];
}

Listing 8-10: Định nghĩa enum để lưu trữ giá trị của kiểu khác nhau trong một vector

Rust cần để biết kiểu dữ liệu nào sẽ trong một Vector tại lúc biên dịch do đó nó biết trình chính xác bao nhiều bộ nhớ trong vùng heap sẽ được cần để lưu trữ mỗi thành phần. Chúng ta cũng phải chính xác về kiểu dữ liệu nào được cho phép trong vector này. Nếu Rust cho phép một vector để lưu trữ bất kỳ kiểu nào, sẽ có lúc rằng một hoặc nhiều kiểu sẽ gây lỗi với điều khiển thực hiện trong thành phần của Vector. Sử dụng enum với match cú pháp nghĩa rằng Rust sẽ đảm bảo tại lúc biên dịch mõi trường hợp có thể xảy ra sẽ được xử lý, bởi như đã nói ở Chương 6. Nếu bạn không biết tập hợp kiểu có thể của kiểu dữ liệu mà một chương trình tại lúc runtime (lúc chạy chương trình) lưu giữ trong một Vector, công nghệ enum sẽ áp dụng được. Thay vào đó, bạn có thể sử dụng trait object (đối tuợng trait), mà chúng ta sẽ học trong Chương 17

Nào, chúng ta đã thảo luận một số cách thông thường để sử dụng Vector, xem lại the API documentation để tất cả các phương thức hữu dụng định nghĩa trong Vec<T> trong thư viện chuẩn. Ví dụ, trong hàm push, phương thức pop xoá và trả về giá trị cuối cùng. Tiếp theo, cùng xem xét kiểu collection String

Lưu trữ UTF-8 Encoded Text (Chữ định dạng UTF-8) với kiểu Strings

Chúng ta đã nói về string trong chương 4, nhưng chúng sẽ xem xét kỹ lưỡng chúng bây giờ. Một Rustaceans mới thường gặp rắc rối với string khi kết hợp 3 thứ sau: Biểu thị lỗi trong string, cấu trúc dữ liệu phức tạp của string và thứ 3: Mã hoá dạng UTF-8. Ba nhân tố này kết hợp thành thứ mà dường như khó khi bạn đến từ một ngôn ngữ khác.

Chúng ta thảo luận string trong ngữ cảnh collections bởi vì strings được coi như một tập hợp của các bytes, vài phương thức thêm vào cung cấp chức năng hữu dụng khi bytes của nó được coi như là text. Trong chương này, chúng ta sẽ nói về những điều khiển trong String (kiểu dữ liệu) mà mọi kiểu collection có, giống như điều khiển thông thường như tạo, cập nhật, và đọc. Chúng ta cũng sẽ bàn về việc String là đôi chút khác với các kiểu collection khác, và việc indexing thành một String là phức tạp bởi có sự khác nhau giữa cách người và máy tính giải thích kiểu String;

String là gì?

Đầu tiên, Chúng ta sẽ định nghĩa thuật ngữ string. Rust chỉ có một kiểu string trong ngôn ngữ, nơi nó là dạng slice str mà thường được coi biểu thị trong &str (mượn). Trong chương 4, chúng ta đã nói về string slices, mà là tham chiếu tới dữ liệu text định dạng UTF-8. String, bản chất ví dụ, là được lưu trữ trong tệp nhị phân và do đó là string slices

Kiểu String, nơi được cung cấp bởi thư viện chuẩn của Rust hơn là được lập trình thành ngôn ngữ core, là một kiểu chuỗi (string) có thể mở rộng, thay đổi, owned, định dạng UTF8. Khi lập trình viên Rust (Rustaceans) tham chiếu "string" trong Rust, họ có thể đang tham chiếu tới kiểu String hoặc kiểu &str, hoặc không phải một trong 2 kiểu trên. Mặc dù chương này mục đích chính là về String, cả 2 kiểu là được sử dụng nhiều trong thư viện chuẩn Rust, và cả String và slices là dưới dạng UTF8-encoded

Thư viện chuẩn Rust cũng bao gồm một số kiểu string khác, giống như OsString, OsStr, CString, và CStr. Những thư viện crates có thể cung cấp cả nhiều lựa chọn cho việc lưu trữ dữ liệu dạng string. Nhìn cách kiểu kia đều kết thức với String hoặc Str?. Chúng tahm chiếu tới biến hoặc sở hữu hoặc mượn, cũng giống String và str bạn đã nhìn thầy trước đó. Các kiểu string này có thể lưu trữ text trong định dạng mã hoá khác nhau hoặc được thể hiện trong bộ nhớ theo một cách nào đó. Ví dụ, Chúng ta sẽ không thảo luận các kiểu dữ liệu này trong chương này; xem tài liệu của chúng nhiều hơn hoặc cách sử dụng để biết cách khi nào sử dụng chúng một cách thích hợp.

Tạo một String

Nhiều thao tác với Vec<T> cũng được sử dụng với String, ví dụ hàm new để tạo một string, xem Listing 8-11

fn main() {
    let mut s = String::new();
}

Listing 8-11: Tạo mới một String rỗng

Dòng này tạo một mới một string rỗng và gán tới s. Thông thường, chúng ta sẽ khởi tạo với một giá trị mà chúng ta muốn Để làm điều này, chúng ta có thể sử dụng phương thức to_string, mà nó có trong tất cả các kiểu mà thực hiện trait Display, và string cũng thế. Listing 8-12 xem xét 2 ví dụ

fn main() {
    let data = "initial contents";

    let s = data.to_string();

    // the method also works on a literal directly:
    let s = "initial contents".to_string();
}

Listing 8-12: Using the to_string method to create a String from a string literal

This code creates a string containing initial contents.

We can also use the function String::from to create a String from a string literal. The code in Listing 8-13 is equivalent to the code from Listing 8-12 that uses to_string.

fn main() {
    let s = String::from("initial contents");
}

Listing 8-13: Sử dụng hàm String::from để tạo String từ một chuỗi Bởi vì chuỗi được sử dụng cho nhiều thứ, chúng ta có thể sử dụng generic khác nhau cho chuỗi, cho phép chúng ta nhiều lựa chọn. Một trong số đó dường như hơi thừa thãi, nhưng không sao cả. Trong trường hợp này, String::from và to_string cùng hành động giống nhau, do đó bạn có thể chọn phương thức nào cũng được phụ thuộc vào bạn. Nhớ rằng strings là có định dạng mã hoá UTF-8, do dó chúng có bao gồm bất kỳ dữ liệu mã hoá trong đó, Listing 8-14 là ví dụ

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שָׁלוֹם");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

Listing 8-14: Lưu trữ câu lời chào trong các ngôn ngữ khác nhau

Tất cả chúng là giá trị String hợp lệ

Cập nhật một String

Nếu bạn đẩy nhiều dữ liệu, một String có thể tự tăng kích thước, và nội dụng sẽ thay đổi, giống nội dụng của một Vec<T>. Thêm vào đó, bạn có thể sử dụng toán tử + hoặc macro format! để hợp nhất 2 giá trị String

Thêm dữ liệu tới một String sử dụng push_str và push

Chúng ta thêm dữ liệu vào String bởi sử dụng phương thức push_str và kích thước String sẽ tăng lên. Xem Listing 5-15

fn main() {
    let mut s = String::from("foo");
    s.push_str("bar");
}

Listing 8-15: Thêm một string slice vào một String sử dụng phương thức push_str

Sau 2 dòng trên, s sẽ là foobar. Phương thức push_str nhận tham số là string sclie bởi vì chúng ta không cần thiết truyền vào tham số với một ownership. Ví dụ, trong code Listing 8-16, chúng ta muốn sử dụng s2 sau khi thêm nội dung nó tới s1.(Nếu truyền ownership vào hàm push_str rồi thì s2 không dùng được nữa - đó là điều chúng ta không muốn)

fn main() {
    let mut s1 = String::from("foo");
    let s2 = "bar";
    s1.push_str(s2);
    println!("s2 is {}", s2);
}

Listing 8-16: Sử dụng string slice sau khi thêm nội dung của nó tới một String

Nếu push_str lấy quyền sở hữu của s2, chúng sẽ không thể in được giá trị của nó ở dòng cuối, Tuy nhiên, dòng code này cũng sẽ chạy được như kỳ vọng

Phương thức push nhân một ký tự đơn như một tham số và thêm nó tới String. Listing 8-17 thêm ký tự "l" tới một String sử dụng phương thức push

fn main() {
    let mut s = String::from("lo");
    s.push('l');
}

Listing 8-17: Thêm một ký tự tới String sử dụng `push

Kết quả là s sẽ bao gồm chuỗi lol As a result, s will contain lol.

Gộp 2 chuỗi với toán tử + hoặc sử dụng macro format!

Thông thương, bạn sẽ muốn kết hợp 2 chuỗi với nhau. Một cách để làm điều này là sử dụng toán tử +,Listing 8-18

fn main() {
    let s1 = String::from("Hello, ");
    let s2 = String::from("world!");
    let s3 = s1 + &s2; // note s1 has been moved here and can no longer be used
}

Listing 8-18: Sử dụng toán tử + để kết hợp 2 String thành một String mới

Chuỗi s3 sẽ bao gồm Hello, world!. Lý do s1 là không còn tồn tại (valid) sau thêm vào và lý do chúng ta đã sử dụng một tham chiếu đến s2, là bởi vì Rust đối cử toán tử + như sử dụng phương thức add mà trông giống như sau:

fn add(self, s: &str) -> String {

Trong thư viện chuẩn, bạn sẽ nhìn thấy định nghĩa add sử dụng generic. Ở đây, chúng ta đã thay thế kiểu cụ thể cho generic nơi mà chúng ta gọi hàm này với String. Chúng ta sẽ thảo luận về generic trong chương 10. Hàm chữ ký cho toán tử + sẽ giúp chúng ta có ý niệm để hiểu một chút cách + hoạt động

Đầu tiên, s2 có &, nghĩa là chúng ta thêm một tham chiếu (reference) của chuỗi thứ 2 tới chuỗi thứ nhất. Điều này bởi vì tham số s trong hàm add: chúng ta có thể chi thêm &str tới một String; Chúng ta không có thể cộng 2 String cùng nhau. Nhưng khoan, kiểu của &s2 là '&String, không phải là &str` mà. Nhưng tại sao Listing 8-18 lại vẫn có thể biên dịch?

Lý do là chúng ta có thể sử dụng &s2 trong lời gọi hàm tới add là rằng, trình biên dịch có thể ép buộc (coere) &String thành một &str. Khi chúng ta gọi phương thức add, Rust sử dụng một sự ép buộc deref (deref coercion) nơi mà nó biến &s2 thành &s2[..]. Chúng ta sẽ nói về ép buộc deref sâu hơn trong chương 15 Bởi vì hàm add không nhận quyền sở hữu của tham số s, s2 sẽ có thể được dùng tiêp sau điều khiển này.

Thứ hai, chúng ta có thể nhìn thấy trong chữ của hàm add nhận quyền sở hữu của self, bởi vì self không có &. Điều này nghĩa là s1 trong Listing 8-18 sẽ được move vào lời gọi hàm add và sẽ không còn valid nữa. Do đó, mặc dù let s3 = s1 + &s2; trông như nó sẽ copy cả 2 strings và tạo một string nmoiws, câu lệnh này thật sự lấy ownership của s1 thêm một bản sao nội dung s2 và trở về một sỡ hữu của kết quả. Nói một cách khác, nó làm nhiều việc và hiểu quả hơn là chỉ copy. Nếu chúng ta cần gộp nhiều chuỗi, hành vi của toán tử + sẽ hơi rườm rà và không hiệu quả(unwieldy)

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");

    let s = s1 + "-" + &s2 + "-" + &s3;
}

Tại điểm này, s sẽ có giá trị là tic-tac-toe. Với tất cả ký tự + và ", nó sẽ khó để nhìn thấy thế nào. Cho việc kết hợp nhiều chuỗi phức tạp, chúng ta sử dụng macro format! thay vì.

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");

    let s = format!("{}-{}-{}", s1, s2, s3);
}

Đoạn code này cũng biến s thành tic-tac-toe. Macro format! làm việc giống như macro println!, nhưng thay vì in đầu ra tới màn hình, nó trở về một String với nội dung. Phiên bản này sử dụng format! là dễ để đọc và code được tạo bởi macro format! sử dụng tham chiếu. Do đó, lời gọi hàm này không thay đổi bất kỳ quyền sở hữu của các tham số truyền vào.

Chỉ số trong String (Indexing into String)

Trong nhiều ngôn ngữ lập trình khác, truy cập ký tự riêng rec trong một chuỗi bởi tham chiếu đến chúng thông của chỉ số (index). Tuy nhiên nếu bạn cố gắng truy xuất phần của String sử dụng cú pháp chỉ số trong Rust, bạn sẽ nhận về một lỗi. Xem xét đoạn code không đúng sau trong Listing 8-19

fn main() {
    let s1 = String::from("hello");
    let h = s1[0];
}

Listing 8-19: Cố gắng để sử dụng chỉ số để truy cập trong String

Đoạn code này sẽ nhận về một lỗi sau:

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
error[E0277]: the type `String` cannot be indexed by `{integer}`
 --> src/main.rs:3:13
  |
3 |     let h = s1[0];
  |             ^^^^^ `String` cannot be indexed by `{integer}`
  |
  = help: the trait `Index<{integer}>` is not implemented for `String`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `collections` due to previous error

Lỗi này nói với chúng ta một thứ: Chuỗi trong Rust không hỗ trợ indexing (chỉ số). Nhưng tại sao không? Để trả lời được câu hỏi này, chúng ta cần hiểu cách Rust lưu trữ strings trong bộ nhớ.

Biểu thị bộ nhớ bên trong của String

Một String là một đối tượng chứa (wrapper) một kiểu Vec<u8>. Cùng xem chuỗi ví dụ mã hoá UTF-8 từ Listing 8-14. Đầu tiền, điều này:

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שָׁלוֹם");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

Trong trường hợp này, hàm len là 4, nghĩa vector đang giữ chuỗi "Hola" (độ dài 4 bytes). Mỗi một ký tự chúng chiếm 1 byte khi được mã hoá trong UTF-8. Theo đoạn code trên, có thể làm cho bạn bất ngờ. (Chú ý rằng chuỗi bắt đầu với chũ cái Cyrillic Ze, không phải số 3 Ả rập)

fn main() {
    let hello = String::from("السلام عليكم");
    let hello = String::from("Dobrý den");
    let hello = String::from("Hello");
    let hello = String::from("שָׁלוֹם");
    let hello = String::from("नमस्ते");
    let hello = String::from("こんにちは");
    let hello = String::from("안녕하세요");
    let hello = String::from("你好");
    let hello = String::from("Olá");
    let hello = String::from("Здравствуйте");
    let hello = String::from("Hola");
}

Câu hỏi là chuỗi kia chiếm mấy bytes, bạn có thể nói là 12. Sự thật, Câu trả lời là 24: Số bytes nó chiếm để mã hoá chuỗi “Здравствуйте” trong UTF-8, bởi mỗi giá trị scalar Unicode trong chuỗi chiếm 2 bytes lưu trữ. Do đó, một chỉ số trong string sẽ không tương quan tới giá trị scalar Unicode. Để minh hoạ, xem đoạn code không đúng sau:

let hello = "Здравствуйте";
let answer = &hello[0];

Bạn cũng đã biết rằng câu trả lời sẽ không phải là 3, ký tự đầu tiên. Với mã hoá UTF-8, byte đầu tiên của 3 là 208 và byte thứ 2 là 151, nhưng 208 không phải là ký tự hợp lệ. Trở về 208 là không giống những gì một người dùng muốn nếu họ hỏi về ký tự đầu tiên của chuỗi; tuy nhiên, điều này dữ liệu mà Rust có tại chỉ số index 0. Người dùng một cách tổng quát không muốn sử dụng giá trị byte trở về, dù nếu chuỗi bao gồm chỉ ký tự Latin : Nếu &"hello"[0] là code hợp lệ mà trở về giá trị byte, nó sẽ trở về 104 chứ không phải h

Câu trả lời là để tránh trở về một giá trị không kỳ vọng và gây lỗi, Rust không biên dịch đoạn code này và ngăn chặn hiểu nhầm một cách sớm nhất trong quá trình viết code.

Bytes và Scalar Values và Grapheme Clusters! Oh My!

Một điểm khác về UTF-8 là rằng có 3 cách thực sự liên quan để quan niệm chuỗi trong Rust: Như là mảng bytes, các giá trị scalar và biểu đồ cụm (grapheme clusters) (thứ tưởng tượng gần như là các ký tự (letters))

Nếu bạn nhìn vào chữ Hindi “नमस्ते” được viết trong Devanagari script, nó sẽ được lưu trữ trong một vector của u8 trông giống như sau:

[224, 164, 168, 224, 164, 174, 224, 164, 184, 224, 165, 141, 224, 164, 164,
224, 165, 135]

Đó là 18 bytes cách mà máy tính lưu trữ dữ liệu của chúng ta. Nếu chúng ta nhìn chúng như giá trị Unicode scalar, Giả trị char trong Rust sẽ là

['न', 'म', 'स', '्', 'त', 'े']

Có 6 giá trị char ở đay, nhưng kí tự thứ 4' (्') và thứ 6('े') không phải là từ, chúng là những dấu mà không có ý nghĩa gì cả. Cuối cùng, nếu chúng ta nhìn chúng như biểu đồ cụm, chúng ta get 4 ký tự trong chữ Hindi

["न", "म", "स्", "ते"]

Rust cung cấp những cách khác nhau để thông dịch những dữ liệu chuỗi thô mà máy tính lưu trữ mà mỗi chương trình có thể lựa chọn thông dịch nó cần, bất kể dữ liệu được lưu trữ trong ngôn ngữ nào.

Một lý do cuối cùng, Rust không cho phép chúng ta sử dụng index trong một String để lấy ký tự là rằng điều khiển indexing là được kỳ vọng để lấy với thời gian độ phức tạp O(1). Nhưng điều này không có thể khả năng để đảm bảo hiệu năng với String, bởi vì Rust phải duyệt qua nội dung từ đầu tới chỉ số để xem xét có bao nhiêu ký tự hợp lệ

Slicing Strings (Phần của String/ Dạng lát cắt String)

Chỉ số trong string thường ý tưởng tồi bởi nếu không biết chính xác kiểu trả về: một giá trị byte, một ký tự, một cụm hoặc một string sclie. Nếu bạn thật sự cần để sử chỉ số để tạo ra phần của string, do đo, Rust sẽ hỏi bạn chi tiết hơn.

Thay vì sử dụng chỉ số với [] với một số, bạn có thể sử dụng []` với một dãy để tạo một string slice bao gồm các bytes cụ thể

#![allow(unused)]
fn main() {
let hello = "Здравствуйте";

let s = &hello[0..4];
}

Ở đây, s sẽ là một &str mà bao gồm 4 bytes của 1 string. Trước đây, chúng ta đã đề cập mỗi một ký tự là 2 bytes, nghĩa là s sẽ là Зд

Nếu như chúng ta cố gắng tạo một phần của slice như sau &hello[0..1], Rust sẽ panic tại lục run time bởi vì sử dụng chỉ số không xác định để truy xuất trong 1 vector

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
    Finished dev [unoptimized + debuginfo] target(s) in 0.43s
     Running `target/debug/collections`
thread 'main' panicked at 'byte index 1 is not a char boundary; it is inside 'З' (bytes 0..2) of `Здравствуйте`', src/main.rs:4:14
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Bạn nên sử dụng dãy để tạo một string sclice với sự cẩn trọng, bởi vì có thể làm crash chương trình của bạn

Các phương thức để duyệt qua một String

Cách tốt nhất để điều khiên một phần của strings là biết được bạn muốn ký tự hoặc bytes. Cho giá trị Unicode scalar, sử dụng phương thức chars. Gọi hàm chars trong “नमस्ते” chia tách và trở về 6 giá trị của char, và bạn có thể duyệt qua kết quả để truy xuất tới mỗi thành phần:

#![allow(unused)]
fn main() {
for c in "नमस्ते".chars() {
    println!("{}", c);
}
}

Đoạn code sẽ in ra như sau

न
म
स
्
त
े

Một cách thay thế, phương thức bytes trở về mỗi byte raw, mà có thể chính xác ý muốn chúng ta hơn:

#![allow(unused)]
fn main() {
for b in "नमस्ते".bytes() {
    println!("{}", b);
}
}

Đoạn code này in 18 bytes tạo nên String này:

224
164
// --snip--
165
135

Nhưng đảm bảo luôn nhớ rằng, giá trị Unicode scalar hợp lệ có thể được tạo thành nhiều hơn 1 byte

Grapheme Clusters của strings là phức tạp, do đó chức năng này không được cung cấp bởi thư viện chuẩn. Tìm kiếm trong crates.io nếu bạn cần chức năng này

String là không đơn giản

Tổng quát, strings là phức tạp. Ngôn ngữ lập trình khác nhau chọn cách khác nhau để thể hiện sử phức tạp này đến lập trình viên. Rust đã chọn String cho xử lý tới tất cả chương trình Rust, nghĩa là lập trình viện phải suy nghĩa cách xử lý UTF-8 trước. Sự đánh đổi này tiết lộ nhiều sự phức tạp của strings hơn các nông ngữ khác, nhưng nó ngăn chặn bạn tránh khỏi việc xử lý lỗi liên quan tới ký tự không phải ASCII sớm trong vòng đời phát triển.

Cùng chuyển tới một thứ phức tạp ít một chút là: Hash Maps

Lưu trữ key/value trong Hash Maps

Phần cuối của các collections phổ biến là hash map. Kiểu HashMap<K,V> lưu trữ một liên kết giữa các Key có kiểu K tới giá trị của nó với kiểu V sử dụng một hàm hashing (hashing function). Nhiều ngôn ngữ lập trình hỗ trợ cấu trúc dữ liệu này nhưng chúng thường sử dụng tên khác như hash, map (trong Go), hash table, dictionary, hoặc associative array... Kiểu Hash maps là hữu dụng khi bạn muốn to tìm kiềm dữ liệu với một key với dữ liệu bất ký, không phải sử dụng index giống bạn làm với Vector. Ví dụ: trong một game, bạn có thể giữ dấu vết của điểm mỗi đội trong một hash map nơi mỗi Key là tên của mỗi đội, và giá trị của nó là điểm của mỗi đội. Khi biết tên của đội, bạn có thể truy vấn điểm của đội đó.

Chúng ta sẽ đi qua những hàm cơ bản của hash maps trong chương này, nhưng nhiều thứ là ẩn đấu trong những hàm được định nghĩa `HashMap<K,V> bởi thư viện chuẩn. Kiểm tra tài liệu thư viện chuẩn bất cứ khi nào bạn muốn tìm kiếm nhiều thông tin hơn.

Tạo mới một Hash Map

Một cách để tạo một Hash Map rỗng là sử dụng hàm new và thêm thành với mới bằng hàm insert. Trong Listing 8-20, chúng sẽ theo dấu của 2 dội nơi tên của họ là Blue và Yellow. Đội Blue bắt đầu với 10 điểm, và đội Yellow bắt đầu với 50

fn main() {
    use std::collections::HashMap;

    let mut scores = HashMap::new();

    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);
}

Listing 8-20: Tạo mới một Hash Map và chèn một keys/values

Chú ý rằng, Đầu tiên chúng ta cần sử dụng HashMap từ phần trong collections của bộ thư viện chuẩn. Trong 3 collections phổ biến, thì đây là một cấu trúc ít được dùng nhất. Nó không bao gồm nhiều tính năng lúc đầu Hashmap cũng có ít hỗ trợ trong thư viện chuẩn, không có kiều macro built-in (macro sẵn) để tạo chúng.

Cũng giống như Vector, Hash Map lưu trữ dữ liệu trong vùng heap. HashMap có các keys của String và giá trị là kiểu i32. Giống như vector, hash map là đồng nhất, nghĩa là tất cả keys phải có cùng một kiểu dữ liệu giống nhau và giá trị của chúng cũng phải như vậy

Một cách khác để khởi tạo một hash map là sử dụng iterators (bộ duyệt) và phương thức collect một vector của tuples, nơi mà mỗi tuple bao gồm một key và giá trị của nó. Chúng ta sẽ chi tiết về iterators và các phương thức liên kết của nó trong ”Xử lý items với Iterator” trong chương 13 Phương thức collect thu thập dữ liệu thành một số kiểu collections bao gồm trong đó có HashMap. Ví dụ, nếu chúng có tên team, và giá trị điểm khởi tạo trong 2 vector riêng rẽ, chúng ta có thể sử dụng hàm zip để tạo một iterator của tupple nơi "Blue" là liên kết với 10, và ngược lại. Sau đó, chúng ta có thể sử dụng phương thức collect to biến iterator của tupple thành hash map như chỉ ra trong Listing 8-21

fn main() {
    use std::collections::HashMap;

    let teams = vec![String::from("Blue"), String::from("Yellow")];
    let initial_scores = vec![10, 50];

    let mut scores: HashMap<_, _> =
        teams.into_iter().zip(initial_scores.into_iter()).collect();
}

Listing 8-21: Tạo một hash map từ danh sách team và danh sach các điểm

Ký hiệu HashMap<_, _> là cần thiết ở đây bởi nó có khả năng để collect thành nhiều cấu trúc dữ liệu khác nhau và Rust không biết kiểu mà chúngt a muốn trừ khi chúng ta chi tiết nó. Cho tham số key và giá trị, tuy hiên, chúng ta có thể sử dụng ký tự "_" và Rust có thể ngầm hiểu kiểu mà Hash map bao gồm dựa trên kiểu cảu dữ liệu trong Vector. Trong Listing 8-21, Kiểu dữ liệu key là String và kiểu giá trị là i32, như trong Listing 8-20

Hash Map và Quyền sở hữu (Hash Maps and Ownership)

Cho những kiểu mà thực hiện Copy trait, giống như i32, các giá trị được copy vào thành hash map. Cho giá trị có quyền sở hữu (owned) giống như String, giá trị sẽ được chuyển và hashmap sẽ là owner của các giá trị này, như demo trong Listing 8-22

fn main() {
    use std::collections::HashMap;

    let field_name = String::from("Favorite color");
    let field_value = String::from("Blue");

    let mut map = HashMap::new();
    map.insert(field_name, field_value);
    // field_name and field_value are invalid at this point, try using them and
    // see what compiler error you get!
}

Listing 8-22: Key và gía trị là được sở hữu bởi hash map khi chúng được chèn

Chúng ta đã không có thể sử dụng biến field_name và field_value sau khi chúng ta đã chuyển vào hash map với lời gọi hàm insert.

Nếu chúng ta chèn các tham chiếu tới giá trị trong hash map, các giá trị sẽ không bị chuyển vào hash map. Giá trị mà các tham chiếu trỏ tới phải hợp lệ ít nhất miễn là hash map là hợp lệ. Chúng ta sẽ nói nhiều về vấn đề trong chương "Validate tham chiếu với Lifetimes" mục trong chương 10.

Truy xuất giá trị trong Hash Map

Chúng ta có thể lấy một gía trị từ hash map by cung cấp key tới hàm get, như chỉ ra trong Listing 8-23

fn main() {
    use std::collections::HashMap;

    let mut scores = HashMap::new();

    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);

    let team_name = String::from("Blue");
    let score = scores.get(&team_name);
}

Listing 8-23: Truy xuất tới điểm số của đội Blue trong hash map

Ở đây, score sẽ có giá trị mà đã liên với Blue team, và kết quả sẽ trả về Some(&10). Kết quả là được bọc trong Some bởi get trở lên Options<&V>; nếu không có giá trị cho key này trong hash map get sẽ trở về None. Chương trình sẽ cần để xử lý Option một trong các cách chúng ta đã bao qua trong Chương 6.

Chúng ta có thể duyệt qua mỗi cặp key/value trong một hash map tương tự giống như trong Vector sử dụng for:

fn main() {
    use std::collections::HashMap;

    let mut scores = HashMap::new();

    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);

    for (key, value) in &scores {
        println!("{}: {}", key, value);
    }
}

Đoạn code này sẽ in ra mỗi cặp trong thứ tự tuỳ ý:

Yellow: 50
Blue: 10

Cập nhật một HashMap

Mặc dù số key và gía trị là có thể nhiều vô hạn, mỗi key chỉ có một giá trị liên với nó tại một thời điểm. Khi bạn muốn thay đổi dữ liệu trong một hahs map, bạn phải quyết định cách để xử lý khi một key đã có một giá trị liên kết. Bạn có thể thay thế giá trị cũ với giá trị mới bất kể giá trị cũ. Bạn có thể giữ giá trị cũ và tránh giá trị mới, chỉ thêm giá trị mới nếu key là không tồn tại. Hoặc bạn có thể kết hợp giá trị cũ vf giá trị mới.

Ghi đè một gía trị

Nếu chúng ta chèn một key và giá trị vào một hash map và sau đó chèn cũng key đó với giá trị khác, giá trị liên kết với key này sẽ được thay thế. Mặc dù code trong Listing 8-23 gọi insert 2 lần, hash map sẽ chỉ bao gồm 1 cặp key/value bởi vì chúng đang chèn giá chỉ cho Blue team 2 lần.

fn main() {
    use std::collections::HashMap;

    let mut scores = HashMap::new();

    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Blue"), 25);

    println!("{:?}", scores);
}

Listing 8-24: Thay thế một giá trị lưu trữ với key cụ thể

Đoạn code này sẽ in {"Blue": 25}. Giá trị gốc 10 sẽ bị ghi đề.

Chỉ chèn một giá trị nếu key không tồn tại

Thônng thường để check liệu một key cụ thể có giá trị hay không để chúng ta chèn nó. Hash map có một API cụ thể cho nó gọi là entry mà nhận key mà bạn muốn để kiểm tra. Giá trị trả về của phương thức entry là một enum gọi là Entry mà thể hiện giá trị có thể có hoặc không?

Nếu chúng ta muốn kiểm tra key cho đội Yello có giá trị liên kết đến nó không. Nếu không, chúng ta muốn chen giá trị 50. Sử dụng entry API. Sử dụng entry API, code sẽ giống Listing 8-25

fn main() {
    use std::collections::HashMap;

    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);

    scores.entry(String::from("Yellow")).or_insert(50);
    scores.entry(String::from("Blue")).or_insert(50);

    println!("{:?}", scores);
}

Listing 8-25: Sử dụng phương thức entry để chỉ chèn nếu key là chưa có giá trị liên kết tới

Phương thức or_insert trong Entry là được định nghĩa để trả về một tham chiếu mutable (có thể thay đổi) tới giá trị tương ứng Entry key nếu key này tồn tại, hoặc nếu không, chèn tham số như giá trị mới tới key và trở v về một tham chiếu mutable tới giá trị mới này. Kỹ thuật này là rõ ràng hơn viết logic, thêm vào đó, chúng ta có borrow checker (một chương trình kiểm tra luật mượn) hỗ trợ.

Chạy code trong Listing 8-25 sẽ in ra {"Yellow": 50, "Blue": 10}. Lời gọi hàm đầu tiên entry sẽ chèn key cho Yellow team với giá trị 50 bởi vì Yellow team khong có giá trị trước đó. Lời gọi thứ 2 entry sẽ không thay đổi hash map bởi vì Blue team đã có giá trị 10.

Cập nhật giá trị dựa trên giá trị cũ

Một cách khác cho hash map là tìm kiếm giá trị của một key và sau đó cập nhật giá trị này, Ví dụ, Listing 8-26 đếm số lần mỗi từ xuất hiện trong text. Chúng ta sử dụng hash map với các từ như là các key và giá trị liên kết với key đó là số lần từ đó xuất hiện. Nếu là lần đầu tiên chúng ta nhìn thấy từ, chúng ta sẽ chèn nó với giá trị là 1.

fn main() {
    use std::collections::HashMap;

    let text = "hello world wonderful world";

    let mut map = HashMap::new();

    for word in text.split_whitespace() {
        let count = map.entry(word).or_insert(0);
        *count += 1;
    }

    println!("{:?}", map);
}

Listing 8-26: Đếm số lần xảy ra của các từ sử dụng hash map

Đoạn code này sẽ in ra {"world": 2, "hello": 1, "wonderful": 1}. Phương thức split_whitespace duyệt qua tất các slice con, chia chúng ra bằng khoảng trắng. Phương thức or_insert trở về một tham chiếu mutable (&mut V) tới giá trị key đó. Ở đây, chúng ta lưu trữ tham chiếu mutable trong biến count, nên, để có thể gán tới giá trị này, chúng ta phải dereference (lấy giá trị) count sử dụng ký hiệu (*). Tham chiếu mutable vượt sẽ ra ngoài phạm vị khi kết thúc hàm for, do đó tất cả sự thay đổi là an toàn và được cho phép bởi luật borrowing

Hàm Băm (Hashing Functions)

Bởi mặc định, HashMap sử dụng một hàm Hashing (hàm Băm) gọi là SipHash mà có thể cung cấp trở ngại tới những tấn công như DoS(Denial of Service) liên quan tới bảng băm ¹. Điều này không phải là thuật toán băm nhanh nhất, nhưng đánh đổi hiệu năng cho bảo mật tốt hơn là đáng. Nếu bạn xem xét thời gian xử lý code, và thấy rằng hàm băm mặc định là qúa chậm cho mục đích của bạn, bạn có thể thay đổi hàm khác bải chi tiết một hasher khác. Một hasher là một kiểu mà thực hiện một BuildHasher trait. Chúng ta sẽ nói về trait và cách để thực hiện chúng trong Chương 10. Bạn không cần thiết phải thực hiện hasher của mình trừ đầu. Nhớ rằng thư viện thực hiện có thể tìm thấy trong crates crates.io

Tổng kết

Vector, String, và hash maps sẽ cung cấp một số lượng lớn chức năng cần thiết trong chương trình khi bạn cần để lưu trữ, truy xuất, và chỉnh sửa dữ liệu. Có một số ví dụ bài tập bạn nên trang bị để giải quyết:

• Danh sách số nguyên, sử dụng một vector và trở về thành phần ở chính giữa the (media) và mode(giá trị mà thường xuất hiện nhiều nhất - hash map có thể giải quyết

• Biến đổi strings tới latin pig. Phụ âm đầu của mỗi từ là chuyển tới cuối và thêm "ay", do đó, "first" trở thành "irst-fay". Những từ bắt đầu với một nguyên âm sẽ thêm "hay" tới cuối (Ví dụ: "apple" sẽ thành "apple-hay"). Nhớ rằng UTF-8

• Sử dụng một hash map và vector, tạo một giao diện cho phép người dùng có thể thêm tên nhân viên tới một phòng ban trong công ty. Ví dụ "Add Sally tới Engineering" hoặc "Thêm Amir tới Sales". Sau đó để người dùng lays một danh sách tất cả người trong một phòng bạn hoặc tất cả người trong công ty bởi phòng ban sắp xếp theo thứ alphabet

Tài liệu API của thư viện chuẩn mô tả các phương thức mà vectors, string và hash maps có và sẽ hữu ích cho bài tập này.

Chúng ta đang đi sâu vào chương trình phức tạp, nơi các điều khiển có thể lỗi, do đó, giờ là lúc thao thuận nhiều về xử lý lỗi. Chúng ta sẽ làm điều này trong chương tiếp theo

Xử lý lỗi (Error Handling)

Lỗi là cái gì đó thực tế của cuộc sống trong phần mềm, do đó Rust có một số tính năng cho xử lý các tình huống này nơi mà một thứ gì đó là lỗi. Trong nhiều trường hợp, Rust yêu cầu bạn kiến thức về lỗi ấy và hành động trước khi code được biên dịch. Yêu cầu này làm cho chương trình của bạn nhiều thống nhất bởi đảm bảo rằng bạn sẽ khám phá lỗi và xử lý chúng một cách chính các trước khi bạn có triển khai code tới môi trường production!

Rust nhóm các lỗi thành 2 loại chính: recoverable (có thể phục hồi) và unrecoverable (không thể phục hồi) Cho một lỗi có thể phục hồi, giống như a file not found (không tìm thấy file), chúng hầu như chỉ muốn thông báo vấn đề với người dùng và thử lại điều khiển. Các lỗi không thể phục hồi là luôn luôn dấu hiêu cảu bugs, giống như cố gắng truy xuất một vị trí vượt quá một mảng, và do đó bạn muốn dừng chương trình ngay lập tức.

Hầu hết các ngôn ngữ không phân biết giữa 2 kiểu lỗi và xử lý chúng trong cùng một cách, sử dụng nguyên lý ngoại lệ (exceptions). Rust không có exceptions. Thay vào đó, nó có kiểu Result<T, E> cho lỗi có thể phục hồi và macro panic! cho lỗi dừng xử lý khi chương tình trạm chán lỗi không thể phục hồi. Chương này sẽ bao quát panic! trước và sau đó sẽ nói về giá trị trở `Result<T, E>. Thêm vào đó, chúng ta sẽ khám phá cân nhắc khi quyết định liệu cố để phục hồi lại từ một lỗi hay là dừng xử lý lại.

Lỗi không thể phục hồi với panic!

Thỉnh thoảng, một lỗi xảy ra trong code của bạn và không thể làm gì với nó. Trong những case này, Rust có panic! macro để xử lý. Khi macro panic! xử lý, chương trình sẽ in ra thông điệp lỗi, unwind và dọn dẹp lại stack, và sau đó thoạt. Chúng ta sẽ gọi một panic khi một bug của kiểu này được tìm thấy và chúng ta không rõ ràng cách để xử lý vấn đề lúc đó.

Phục hồi (Unwinding) stack hoặc huỷ bỏ phản hồi dùng Panic

Bởi mặc định, khi một panic xảy ra, chương trình sẽ bắt đầu unwinding, nghĩa là Rust sẽ phục hồi stack và dọn dẹp dữ liệu từ mỗi hàm nó chạm trán. Tuy nhiên, phục hồi và dọn dẹp này là nhiều thứ. Rust, do đó, cho phép bạn để chọn sử thay đổi của huỷ ngay lập tức (aborting), và kết thúc chương trình ngoài sự dọn dẹp. Bộ nhớ mà chương trình là đang Memory that the program was using sử dụng và cần được don dẹp bởi hệ điều hành. Nếu trong dự án bạn cần để tạo binary kết quả nhỏ nhất có thể, bạn có thể chuyển từ unwinding to huỷ bo (aborting) trong panic bởi thêm panic = 'abort' tới mục t[profile] trong file Cargo.toml. Ví dụ, nếu như bạn muốn huỷ (abort) trong panic trong chết độ release, thêm điều này:

[profile.release]
panic = 'abort'

Cố gắng gọi panic! trong một chương trình đơn giản sau:

Filename: src/main.rs

fn main() {
    panic!("crash and burn");
}

Khi bạn chạy chương trình, bạn sẽ nhìn thấy như sau:

$ cargo run
   Compiling panic v0.1.0 (file:///projects/panic)
    Finished dev [unoptimized + debuginfo] target(s) in 0.25s
     Running `target/debug/panic`
thread 'main' panicked at 'crash and burn', src/main.rs:2:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Lời gọi tới panic! có một thông điệp lỗi ở 2 dòng cuối. Dòng đầu tiên chỉ ra thông điệp lỗi panic của chúng ta và thay thế code chúng ta nới panic xảy ra src/main.rs:2:5 và dòng 2, ký tự thứ 5 của file src/main.rs

Trong trường hợp này,những đoạn thống báo trên đã tiết lộ vấn đề của chúng ta và nếu chúng ta viết như vậy, macro panic! sẽ được gọi, Trong một số trường hợp khác, panic! có thể trong code mà chúng ta gọi, tên file và tên dòng được thông báo trong thông điệp lỗi là code của một ai đó (ví dụ sử dụng thư viện - mà trong code đó có panic! được gọi) - không phải là dòng của code chúng ta gây nên panic, nhưng code trong thư viện gây panic. Chúng ta có thể sử dụng backtrace (thông tin các hàm được gọi cho đến vị trí code này) để biết phần nào của code chúng ta đang gây nên lỗi. Chúng ta sẽ thảo luận nhiều về backtrace trong phần tiếp theo

Sử dụng backtrace của một panic!

Cùng xem xét một ví dụ khác để nhìn thấy khi một panic! được gọi từ một thư viện bởi một bug trong code của chúng ta thay vì từ việc chúng ta trực tiếp gọi macro panic!. Listing 9-1 có một số đoạn code mà cố gắng để truy xuất tại một chỉ số trong một vector mà vượt quá dãy các chỉ số hợp lệ.

Filename: src/main.rs

fn main() {
    let v = vec![1, 2, 3];

    v[99];
}

Listing 9-1: Attempting to access an element beyond the end of a vector, which will cause a call to panic!

Ở đây, chúng ta cố gắng truy xuất tới phần tử thứ 100 của vector(chỉ số là 99 vì chỉ số bắt đầu bởi 0), nhưng một vector của chúng ta chỉ có 3 phần tử. Trong trường hợp này, Rust sẽ panic. Sử dụng [] sẽ trở về một phần tử, nhưng nếu bạn truyền vào một chỉ số không hợp lệ, không có phần tử nào, Rust có thể không trả về.

Trong C, cố gắng để đọc vượt quá cấu trúc dữ liệu là hành vi không xác định (undefined). Bạn có thể nhận bất kỳ tại vị trí trong bộ nhớ tương ứng phần tử trong cấu trúc dữ liệu, dù bộ nhớ không thuộc structure. Điều này gọi là buffer overread và có thể dẫn tới lỗ hổng bao mật nếu một người tấn công là có thể thao túng chỉ số trong cách để đọc dữ liêu mà họ không được cho phép. Để bảo vệ chương trình của bạn từ lỗ hỗng này, nếu bạn cố đọc một phần tử tại một chỉ số mà không tồn tại, Rust sẽ dừng execution (xử lý) và từ chối để tiếp tục. Cùng thử và nhìn đoạn code sau:

$ cargo run
   Compiling panic v0.1.0 (file:///projects/panic)
    Finished dev [unoptimized + debuginfo] target(s) in 0.27s
     Running `target/debug/panic`
thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', src/main.rs:4:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Lỗi này chỉ ra tại dòng 4 của main.rs nới chúng ta cố gắng để truy xuất chỉ số 99. Dòng tiếp theo nói với chúng ta rằng chúng ta có thể thiết lập biến môi trường RUST_BACKTRACE đẻ nhận một thông tin backtrace của gì đang xảy ra và gây nên lỗi. Một backtrace là môt danh sách của tất cả các mà được gọi cho đến điểm này. Backtrace trong Rust làm việc giống như chúng làm trong các ngôn ngữ khác: Chìa khóa để đọc một backtrace là bắt tại trên cùng và đọc đến khi bạn nhìn thấy files bạn viết. Đó là điểm nơi vấn đề khởi nguồn. Những dòng code nằm trên tại điểm mà code của bạn được gọi; hoặc những dòng code ở dưới điểm mà bạn được gọi đều tiết lộ nhiều thông tin. Những dòng trước và sau này có thể bao gồm code Rust core, code của thư viện chuẩn, hoặc crates mà bạn đang sử dụng. Cùng cố để lấy thông tin backtrace bởi thiết lập biên môi trường tới bất kỳ giá trị nào trừ 0. Listing 9-21 chỉ ra đầu ra tương tự những gì chúng ta nhìn thấy.

$ RUST_BACKTRACE=1 cargo run
thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', src/main.rs:4:5
stack backtrace:
   0: rust_begin_unwind
             at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/std/src/panicking.rs:483
   1: core::panicking::panic_fmt
             at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/core/src/panicking.rs:85
   2: core::panicking::panic_bounds_check
             at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/core/src/panicking.rs:62
   3: <usize as core::slice::index::SliceIndex<[T]>>::index
             at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/core/src/slice/index.rs:255
   4: core::slice::index::<impl core::ops::index::Index<I> for [T]>::index
             at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/core/src/slice/index.rs:15
   5: <alloc::vec::Vec<T> as core::ops::index::Index<I>>::index
             at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/alloc/src/vec.rs:1982
   6: panic::main
             at ./src/main.rs:4
   7: core::ops::function::FnOnce::call_once
             at /rustc/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/library/core/src/ops/function.rs:227
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

Listing 9-2: The backtrace generated by a call to panic! displayed when the environment variable RUST_BACKTRACE is set

Nhiều dòng được in ra hơn. Thông điệp chính xác bạn nhìn thấy có thể khác phụ thuộc vào hệ điều hành của bạn và phiên bản Rust bạn đang dùng. Để lấy thông tin backtrace, chế độ debug phải được cho phép. Chế độ debug được cho phép bởi mặc định khi bạn sử dụng cargo build hoặc cargo run ngoài trừ cờ --release

Trong thông điệp ở Listing 9-2, dòng 6 của backtrace chỉ tới dòng của project của chúng ta mà đang gây nên lỗi: Dòng 4 của src/main.rs. Nếu chúng ta không muốn chương trình panic, chúng ta nên bắt đầu tìm hiểu tại dòng được chỉ ra bởi dòng đầu tiên đề cập một file chúng ta đã viết. Trong Listing 9-1, nơi chúng viết code mà có panic, cách để sửa một panic là không truy xuất thành phần mà vượt quá dãy của chỉ số vector. Khi code của bạn panic trong tương lại, bạn sẽ cần để tìm hiểu code bạn là đang làm gì với giá trị gây nên panic và code nên làm thế nào để không bị.

Chúng ta sẽ quay trở lại panic! và khi bàn về việc nên hay không không sử dụng panic! để xử lý một số điều kiện lỗi trong phần "To panic! or Not to panic!" phần sau của chương này. Tiếp theo, chúng ta sẽ nhìn lại cách để khôi phục từ một lỗi sử dụng Result

Lỗi có thể khôi phục với Result

Hầu hết các lỗi không nghiêm trọng lắm thường không yêu cầu chương trình chúng ta dừng lại.

Thỉnh thoảng, khi một hàm nào đó gặp lỗi vì một vài lý do nào đó mà bạn có thể dễ dàng giải thích và xử lý nó. Ví dụ, nếu bạn cố gắng mở một file và điều khiển đó bị lỗi bởi vì file không tồn tại, bạn có thể muốn tạo file thay vì kết thúc.

Nhắc lại từ “Handling Potential Failure with the Result Type” trong chương 2 mà Result enum là được định nghĩa như có 2 biến thể : Ok hoặc Err như sau:

#![allow(unused)]
fn main() {
enum Result<T, E> {
    Ok(T),
    Err(E),
}
}

T và E là các tham số với kiểu dữ liệu tổng quát (generic), chúng ta sẽ thảo luận về generic chi tiết hơn trong chương 10. Gì chúng ta biết về nó đến này là T thể hiện kiểu của dữ liệu sẽ đuợc trả về trong trường hợp thành công trong Ok, và E thể hiện kiểu của lỗi mà được trở về trong trường hợp lỗi với biến thể Err. Bởi vì Result có các tham số kiểu generic này, chúng ta có thể sử dụng kiểu Result và các hàm của nó định nghĩa trong nhiều trường hợp khác nhau nơi giá trị thành công hoặc giá trị lỗi có thể nhận các kiểu khác nhau.

Cùng xem xét việc gọi một hàm mà trở về một kiểu Result bởi vì hàm có thể lỗi. Trong Listing 9-3 chúng ta cố gắng mở một file

Filename: src/main.rs

use std::fs::File;

fn main() {
    let f = File::open("hello.txt");
}

Listing 9-3:Mở một file

Cách mà chúng ta biết File::open trở về một kiểu Result?. Chúng có thể xem standard library API documentation, hoặc chúng có thể yêu cầu trình biên dịch (compiler). Nếu chúng đưa f một ký annotation mà chúng ta biết là không phải là giá trị trở kiểu hàm và sau đó cố gắng để biên dịch, trình biên dịch sẽ nói với chúng ta thằng kiểu này sẽ không phù hợp (match). Thông điệpj lỗi sẽ nói với chunts ta kiểu giữ liệu nào f là phù hợp. Cùng thử ví dụ sau: Kiểu File::open không phải là u32, nếu thay đổi let f` tới

use std::fs::File;

fn main() {
    let f: u32 = File::open("hello.txt");
}

Cố gắng để biên dịch đưa chúng ta đầu ra như sau:

$ cargo run
   Compiling error-handling v0.1.0 (file:///projects/error-handling)
error[E0308]: mismatched types
 --> src/main.rs:4:18
  |
4 |     let f: u32 = File::open("hello.txt");
  |            ---   ^^^^^^^^^^^^^^^^^^^^^^^ expected `u32`, found enum `Result`
  |            |
  |            expected due to this
  |
  = note: expected type `u32`
             found enum `Result<File, std::io::Error>`

For more information about this error, try `rustc --explain E0308`.
error: could not compile `error-handling` due to previous error

Điều này nói với chúng ta kiểu trả về của hàm File::open là Result<T,E> Tham số generic T đã được chỉ ra ở đây với kiểu giá trị thành công là std::fs::File, mà là một handle của 1 file (Dạng tham chiếu 1 file). Kiểu E được sử dụng trong giá trị lỗi là std::io::Error.

Kiểu giá trị trả về nghĩa là gọi File::open có thể thành công và trở về handle của file mà bạn có thể đọc hoặc ghi tới. Lời gọi hàm cũng có thể lỗi: Ví dụ, file có thể không tồn tại, hoặc chúng ta có thể không có quyền để truy xuất file. Hàm File::opne cần để có cách để nói với chúng ta liệu nó là thành công hoặc thất bại cùng lúc đưa chúng ta hoặc handle của file hoặc thông tin lỗi. Thông tin này chính là những gì Result enum truyền tải.

Trong trường hợp File::open thành công, giá trị trong biến f sẽ là thực thể của Ok mà bao gồm một file handle. Trong trường hợp lỗi, giá trị f là một thực thể Err mà bao gồm nhiều thông tin về kiểu lỗi đã xảy ra.

Chúng ta có thể thêm code trong Listing 9-3 để xử lý kiểu File::open trả về. Trong Listing 9-4 chỉ ra một cách để xử lý Result cơ bản, cú pháp match chúng ta đã thảo luận trong Chương 6.

Filename: src/main.rs

use std::fs::File;

fn main() {
    let f = File::open("hello.txt");

    let f = match f {
        Ok(file) => file,
        Err(error) => panic!("Problem opening the file: {:?}", error),
    };
}

Listing 9-4: Sử dụng match để xử lý Result

Chú ý rằng, giống Option enum, kiểu Result enum và biến thể của nó có thể khai báo khi import, do đó chúng ta không cần chi tiết Result:: trước Ok và Errtrong cú pháp match.

Khi kết quả là Ok, code sẽ trở giá trị filevà sau đó chúng gán file handle tới biến f. Sau hàm match, chúng ta có thể sử dụng file handle cho việc đọc hoặc ghi.

Một nhánh khác của match xử lý trường hợp chúng ta nhận một giá trị Err từ File::open. Trong trường hợp này, chúng ta gọi macro panic!. Nếu không có file nào tên hello.txt trong đường dẫn hiện tại. Nếu chúng ta chạy code sau , chúng ta sẽ nhìn thấy đầu ra như sau nơi mà macro panic! được gọi

$ cargo run
   Compiling error-handling v0.1.0 (file:///projects/error-handling)
    Finished dev [unoptimized + debuginfo] target(s) in 0.73s
     Running `target/debug/error-handling`
thread 'main' panicked at 'Problem opening the file: Os { code: 2, kind: NotFound, message: "No such file or directory" }', src/main.rs:8:23
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Thông thường, đàu ra nói với chúng ta chính xác lỗi gì.

Xử lý các lỗi khác nhau

Đoạn code trong Listing 9-4 sẽ panic! không quan trọng là File::open lỗi gì. Tuy nhiên, nếu chúng ta muốn xử lý khác nhau cho mỗi kiểu lý do lỗi. Nếu File::opem lỗi bởi vì file không tồn tại, chúng ta muốn tạo file và trở về một handle của một file mới. Nếu File::open lỗi cho bất kỳ lý do nào khác, ví như chúng ta không có quyền để mở một file chúng ta vẫn muốn code panic như chúng ta đã làm trong Listing 9-4. Ví dụ 9-5 sau thêm nhánh của match:

Filename: src/main.rs

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let f = File::open("hello.txt");

    let f = match f {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("hello.txt") {
                Ok(fc) => fc,
                Err(e) => panic!("Problem creating the file: {:?}", e),
            },
            other_error => {
                panic!("Problem opening the file: {:?}", other_error)
            }
        },
    };
}

Listing 9-5: Handling different kinds of errors in different ways

Kiểu của giá trị trả về File::open trong Err là io::Error, nới là một cấu được cung cấp bởi thư viện chuẩn. Cấu trúc này có một phương thức kind mà chúng ta có thể gọi để nhận giá trị io::ErrorKind.

Enum io::ErrorKind được cung cấp bởi thư viện chuẩn và có biến thể thể hiện kiểu khác nhau của lỗi mà có thể trả về từ điều khiển io. BIến thể chúng ta muốn sử dụng ở đây là ErrorKind::NotFound, mà chỉ file chúng ta đang cố gắng để mở nhưng không tồn tại. Do đó Chúng ta, xử lý f, nhúng chúng cũng có kiểu trong error.kind()

Điều kiện chúng ta muốn kiểm tra trong cú pháp match là liệu giá trị trở bởi error.kind() là NotFound - một biến thể của ErrorKind enum. Nếu đúng như vậy, chúng ta cố để tạo một file với File::create. Tuy nhiên, bởi vì File::create cũng có thể lỗi, chúng cần nhánh kiểm tra thứ 2 của match. Khi file không được tạo, một thông điệp lỗi khác sẽ được in ra. Nhánh thứ 2 của match sẽ được gọi nếu bất kỳ lỗi bên lỗi mising file (không tìm thấy file).

Thay đổi sử dụng cú pháp match với Result<T, E>

Biểu thức match khá không những hữu dụng mà còn khá là primitive (dạng nguyên bản). Trong chương 13, bạn sẽ học về closures, nơi được sử dụng với nhiều phương thức được định nghĩa trong Result<T,E>. Những phướng thức này có thể ngắn gọn hơn sử dụng match khi xử lý giá trị Result<T, E> trong code của bạn 9-5 but using closures and the unwrap_or_else method: Eg, đây là một cách khác để viết cùng một logic như vị dụ trong Listing 9-5 nhưng sử dụng closure và phương thức unwrap_or_else :

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let f = File::open("hello.txt").unwrap_or_else(|error| {
        if error.kind() == ErrorKind::NotFound {
            File::create("hello.txt").unwrap_or_else(|error| {
                panic!("Problem creating the file: {:?}", error);
            })
        } else {
            panic!("Problem opening the file: {:?}", error);
        }
    });
}

Mặc dù đoạn code này có cùng hành vi như Listing 9-5, nó không bao gồm biểu thức match và dễ dàng để đọc hơn. Quay lại ví dụ này sau khi bạn đã học Chương 13, và tìm kiếm phương thức unwrap_or_else trong tài liệu thư viện chuẩn. Nhiều phương thức khác có thể được sử dụng với match bên trong khi bạn xử lý với lỗi.

Xử lý panic của lỗi với: unwrap and expect

Sử dụng match cho các trường hợp này khá tốt, nhưng nó có thể dài dòng và không phải lúc nào hiểu ý định nó truyền tải. Kiểu Result<T,E> có nhiều phương thức trợ giúp được định nghĩa để làm cho nhiều dạng mục đích khác nhau. Phương thức unwrap là một phương thức thực hiện cú pháp dạng match chúng ta đã viết trong Listing 9-4. Nếu giá trị Result là Ok, unwrap sẽ trở về gía trị nằm trong Ok. Nếu Result là kiểu Err, unwrap sẽ gọi macro panic! cho chúng ta. Đây là một ví dụ sử dụng unwrap

Filename: src/main.rs

use std::fs::File;

fn main() {
    let f = File::open("hello.txt").unwrap();
}

Nếu chúng ta chạy đoạn code này ngoài một file hello.txt, chúng ta sẽ nhìn thấy một thông điệp lỗi từ panic! được gọi do phương thức unwrap thực hiện.

thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Error {
repr: Os { code: 2, message: "No such file or directory" } }',
src/libcore/result.rs:906:4

Một cách tương tự, phương thức expect để chúng ta lựa chọn thông điệp cho panic!. Sử dụng expect thay unwrap và cung cấp một thông điệp lỗi rõ ràng có thể truyền tải ý định và làm cho dễ dò lỗi đến từ đâu. Cú pháp cho expect như sau:

Filename: src/main.rs

use std::fs::File;

fn main() {
    let f = File::open("hello.txt").expect("Failed to open hello.txt");
}

Chúng ta sử dụng expect trong cùng một cách với unwrap: trở về một file handle hoặc gọi macro panic!. Thông điệp lỗi được sử dụng bởi expect trong lời gọi hàm tới panic! sẽ là tham số truyền vào expect, thay thế thông điệp panic! mặc định mà unwrap sử dụng.

thread 'main' panicked at 'Failed to open hello.txt: Error { repr: Os { code:
2, message: "No such file or directory" } }', src/libcore/result.rs:906:4

Bởi vì thông điệp lỗi này bắt đầu đoạn text mà chúng ta truyền vào Failed to open hello.txt, nó sẽ dễ dàng để tìm kiếm nơi thông điệp lỗi in ra. Nếu chúng ta sử dụng unwrap trong nhiều nơi, sẽ tốn nhiều thời gian để xác định chính xác unwrap nào gây ra lỗi panic bởi tất cả lời gọi unwrap in ra cùng một thông điệp giống nhau.

Lan Truyền Lỗi - Propagating Errors

Khi thực hiện của một hàm gọi một điều gì đó mà có lỗi, thay vì xử lý lỗi trong hàm này, bạn có thể trả về lỗi tới hàm gọi để hàm này có thể quyết định nên làm gì. Đó được gọi là propagating (lan truyền) lỗi và đưa nhiều điều khiển tới lời gọi hàm nơi có thể có nhiều thông tin hoặc logic để ra lệnh lỗi nên được xử lý hơn là gì trong ngữ cảnh code hiện tại.

Ví du, Listing 9-6 chỉ ra một hàm mà đọc một username từ một file. Nếu như file không tồn tài hoặc không thể đọc, hàm này sẽ trở về những lỗi này tới code mà gọi hàm.

Filename: src/main.rs

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let f = File::open("hello.txt");

    let mut f = match f {
        Ok(file) => file,
        Err(e) => return Err(e),
    };

    let mut s = String::new();

    match f.read_to_string(&mut s) {
        Ok(_) => Ok(s),
        Err(e) => Err(e),
    }
}
}

Listing 9-6: Một hàm mà trả về lỗi tới nơi gọi nó sử dụng match

Hàm này có thể được viết trong nhiều cách ngắn gọn hơn, nhưng chúng ta hãy cứ bắt đầu làm vậy để có thể khám phá cách xử lý lỗi; cuối cùng, chúng ta sẽ chỉ cách làm nó ngắn gọn. Hãy nhìn và kiểu trả về của hàm: Result<String, io::Error>. Điều này nghĩa rằng hàm là đang trả về giá trị của kiểu Result<T, E>, nơi mà T là String và kiểu tổng quát E là io::Error. Nếu hàm này thành công ngoại trừ bất kỳ lỗi nào, đoạn code mà gọi hàm này sẽ nhận giá trị Ok mà giữ giá trị String - một username mà hàm này đọc được. Nếu hàm này chạm trán lỗi bất kỳ, lời gọi hàm sẽ nhậ giá trị Err mà giữ một instance của io::Error mà bao gồm nhiều thông tin về lỗi gì. Chúng ta chọn io::Error như kiểu trả về của hàm này bởi vì kiểu xảy ra với điều khiển File::open với điều khiển gọi hàm này read_to_string cùng trả về kiểu này trong khi lỗi.

Thân hàm bắt đầu bởi gọi File::open. Sau đó, chúng ta xử lý Result với cú pháp match tương tự với ví dụ Listing 9-4. Nếu File::open thành công, file handle lưu giữ trong biến f và hàm tiếp tục chạy. Trong trường hợp Err lỗi, thay vì gọi panic!, chúng ta sử dụng từ khóa return để thoát khỏi hàm sớm và trả lỗi từ File::open ra ngoài,, nơi mà đoạn code gọi hàm của chúng ta.

Do đó, nếu chúng ta có file handle trong f, hàm sau đó sẽ tạo một String mới trong biến s và gọi tới phương thức read_to_string từ f để đọc nội dùng của file vào s. Phương thức read_to_string cũng trả về Result bởi vì nó có thể lỗi, mặc dù File::open thành công. Do đó chúng ta cần match khác để xử lý Result: Nếu read_to_string thành công, hàm của chúng đã thành công, và chúng ta trả về username từ một file được bọc trong Ok enum. Nếu read_to_string lỗi, chúng ta trả về giá trị lỗi trong cách giống chúng ta trả về giá trị lỗi khi xử lý File::open. Tuy nhiên, chúng ta không cần viết chính xác return, bởi đó là biểu thức cuối cùng của hàm rồi.

Đoạn code mà gọi hàm này sẽ xử lý hoặc Ok mà bao gồm username, hoặc là Err mà bao gồm io::Error. Nó phụ thuộc đoạn code gọi hàm quyết định sẽ làm gì với các giá trị này. Nếu đoạn code nhận một giá trị Err, nó có thể gọi panic! và crash chương trình, sử dụng username mặc định, hoặc tìm kiềm username trong một file khác chẳng hạn. Chúng ta không đủ thông tin về đoạn code gọi là thực sự đang cố gắng làm, do đó chúng lan truyền tất cả thông tin thành hoặc lỗi tới chúng để xử lý một cách chính xác.

Mẫu cho lan truyền lỗi là khá thông dụng trong Rust và Rust cũng cung cấp một toán tử ? để làm điều này dễ dàng hơn

Cú pháp làn truyền lỗi : Toán tử ?

Listing 9-7 là thực hiện của hàm read_username_from_file mà có cùng chức năng với Listing 9-6, nhưng nó sử dụng toán tử ?

Filename: src/main.rs

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io;
use std::io::Read;

fn read_username_from_file() -> Result<String, io::Error> {
    let mut f = File::open("hello.txt")?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
}
}

Listing 9-7: Một hàm trả về lỗi tới lời gọi hàm sử dụng toán tử ?

? được đặc sau giá trị Result được định nghĩa để làm hầu như giống cách trong match mà chúng ta đã xử lý giá trị Result trong Listing 9-6. Nếu giá trị Result là Ok, giá trị trong Ok sẽ trả về từ biểu thức này và chương trình sẽ tiếp tục. Nếu giá trị trả về là Err, Err sẽ trả về khỏi hàm giống như đã sử dụng từ khóa return,

Có một sử khác nhau giữa match từ ví dụ Listing 9-6 làm và toán tử ? thực hiện: giá trị lỗi mà ? đã gọi chạy qua hàm from, được định nghĩa trong trait From trong thư viện chuẩn, mà sử dụng để biến đổi lỗi từ kiểu này sang kiểu khác. Khi toán tử ? gọi hàm from, kiểu lỗi nhận được là biến thành lỗi định trong kiểu dữ liệu trả về hàm của chúng ta. Điều này là hữu ích khi một hàm trở về một lỗi mà thể hiện tất cả cách có thể lỗi, ngay cả một phần của nó lỗi cho nhiều lý do nào đó. Miễn là có thực hiện impl From for ReturnError để định nghĩa sự biến đổi trong hàm from, toán tử ? lo việc gọi hàm from một cách tự động cho bạn.

Trong ngữ cảnh Listing 9-7, ? gọi tại cuối File::open sẽ trở về giá trị trong Ok tới biến f. Nếu một lỗi xảy ra, toán tử ? sẽ trả trả về sớm và đưa Err tới lời gọi hàm. Hành vi giống nhau áp dụng tới ? tại nơi gọi hàm read_to_string.

Toán tử ? vứt bỏ nhiều thủ tục (boilerplate) và làm cho thực hiện hàm trở nên đơn giản. Chúng thậm chí có thể gọi liên tiếp ? cho đoạn code ngắn gọn hơn như chỉ ra trong Listing 9-8.

Filename: src/main.rs

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io;
use std::io::Read;

fn read_username_from_file() -> Result<String, io::Error> {
    let mut s = String::new();

    File::open("hello.txt")?.read_to_string(&mut s)?;

    Ok(s)
}
}

Listing 9-8: Chaining method calls after the ? operator

Chúng ta tạo một String mới tới s như bắt đầu hàm. Thay vì tạo biến f, chúng ta chain (nối) lời gọi tới read_to_string trực tiếp kết quả của File::open("hello.txt")?. Chúng ta vẫn có ? tại cuối của read_to_string, và chúng ta vẫn trả về giá trị Ok`` bao gồm username trong s khi cả File::open và read_to_string thành công. Hàm này làm cùng cách với Listing 9-=6 và Listing 9-7; nhưng viết theo một cách khá hữu hiệu.

Listing 9-9 chỉ ra một cách để làm ngắn gọn hàm fs::read_to_string.

Filename: src/main.rs

#![allow(unused)]
fn main() {
use std::fs;
use std::io;

fn read_username_from_file() -> Result<String, io::Error> {
    fs::read_to_string("hello.txt")
}
}

Listing 9-9: Using fs::read_to_string instead of opening and then reading the file

Reading a file into a string is a fairly common operation, so the standard library provides the convenient fs::read_to_string function that opens the file, creates a new String, reads the contents of the file, puts the contents into that String, and returns it. Of course, using fs::read_to_string doesn’t give us the opportunity to explain all the error handling, so we did it the longer way first.

Where The ? Operator Can Be Used

The ? operator can only be used in functions whose return type is compatible with the value the ? is used on. This is because the ? operator is defined to perform an early return of a value out of the function, in the same manner as the match expression we defined in Listing 9-6. In Listing 9-6, the match was using a Result value, and the early return arm returned an Err(e) value. The return type of the function has to be a Result so that it’s compatible with this return.

In Listing 9-10, let’s look at the error we’ll get if we use the ? operator in a main function with a return type incompatible with the type of the value we use ? on:

use std::fs::File;

fn main() {
    let f = File::open("hello.txt")?;
}

Listing 9-10: Attempting to use the ? in the main function that returns () won’t compile

This code opens a file, which might fail. The ? operator follows the Result value returned by File::open, but this main function has the return type of (), not Result. When we compile this code, we get the following error message:

$ cargo run
   Compiling error-handling v0.1.0 (file:///projects/error-handling)
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
 --> src/main.rs:4:36
  |
3 | / fn main() {
4 | |     let f = File::open("hello.txt")?;
  | |                                    ^ cannot use the `?` operator in a function that returns `()`
5 | | }
  | |_- this function should return `Result` or `Option` to accept `?`
  |
  = help: the trait `FromResidual<Result<Infallible, std::io::Error>>` is not implemented for `()`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `error-handling` due to previous error

This error points out that we’re only allowed to use the ? operator in a function that returns Result, Option, or another type that implements FromResidual. To fix the error, you have two choices. One choice is to change the return type of your function to be compatible with the value you’re using the ? operator on as long as you have no restrictions preventing that. The other technique is to use a match or one of the Result<T, E> methods to handle the Result<T, E> in whatever way is appropriate.

The error message also mentioned that ? can be used with Option<T> values as well. As with using ? on Result, you can only use ? on Option in a function that returns an Option. The behavior of the ? operator when called on an Option<T> is similar to its behavior when called on a Result<T, E>: if the value is None, the None will be returned early from the function at that point. If the value is Some, the value inside the Some is the resulting value of the expression and the function continues. Listing 9-11 has an example of a function that finds the last character of the first line in the given text:

fn last_char_of_first_line(text: &str) -> Option<char> {
    text.lines().next()?.chars().last()
}

fn main() {
    assert_eq!(
        last_char_of_first_line("Hello, world\nHow are you today?"),
        Some('d')
    );

    assert_eq!(last_char_of_first_line(""), None);
    assert_eq!(last_char_of_first_line("\nhi"), None);
}

Listing 9-11: Using the ? operator on an Option<T> value

This function returns Option<char> because it’s possible that there is a character there, but it’s also possible that there isn’t. This code takes the text string slice argument and calls the lines method on it, which returns an iterator over the lines in the string. Because this function wants to examine the first line, it calls next on the iterator to get the first value from the iterator. If text is the empty string, this call to next will return None, in which case we use ? to stop and return None from last_char_of_first_line. If text is not the empty string, next will return a Some value containing a string slice of the first line in text.

The ? extracts the string slice, and we can call chars on that string slice to get an iterator of its characters. We’re interested in the last character in this first line, so we call last to return the last item in the iterator. This is an Option because it’s possible that the first line is the empty string, for example if text starts with a blank line but has characters on other lines, as in "\nhi". However, if there is a last character on the first line, it will be returned in the Some variant. The ? operator in the middle gives us a concise way to express this logic, allowing us to implement the function in one line. If we couldn’t use the ? operator on Option, we’d have to implement this logic using more method calls or a match expression.

Note that you can use the ? operator on a Result in a function that returns Result, and you can use the ? operator on an Option in a function that returns Option, but you can’t mix and match. The ? operator won’t automatically convert a Result to an Option or vice versa; in those cases, you can use methods like the ok method on Result or the ok_or method on Option to do the conversion explicitly.

So far, all the main functions we’ve used return (). The main function is special because it’s the entry and exit point of executable programs, and there are restrictions on what its return type can be for the programs to behave as expected.

Luckily, main can also return a Result<(), E>. Listing 9-12 has the code from Listing 9-10 but we’ve changed the return type of main to be Result<(), Box<dyn Error>> and added a return value Ok(()) to the end. This code will now compile:

use std::error::Error;
use std::fs::File;

fn main() -> Result<(), Box<dyn Error>> {
    let f = File::open("hello.txt")?;

    Ok(())
}

Listing 9-12: Changing main to return Result<(), E> allows the use of the ? operator on Result values

The Box<dyn Error> type is a trait object, which we’ll talk about in the “Using Trait Objects that Allow for Values of Different Types” section in Chapter 17. For now, you can read Box<dyn Error> to mean “any kind of error.” Using ? on a Result value in a main function with the error type Box<dyn Error> is allowed, because it allows any Err value to be returned early.

When a main function returns a Result<(), E>, the executable will exit with a value of 0 if main returns Ok(()) and will exit with a nonzero value if main returns an Err value. Executables written in C return integers when they exit: programs that exit successfully return the integer 0, and programs that error return some integer other than 0. Rust also returns integers from executables to be compatible with this convention.

The main function may return any types that implement the std::process::Termination trait. As of this writing, the Termination trait is an unstable feature only available in Nightly Rust, so you can’t yet implement it for your own types in Stable Rust, but you might be able to someday!

Now that we’ve discussed the details of calling panic! or returning Result, let’s return to the topic of how to decide which is appropriate to use in which cases.

To panic! or Not to panic!

So how do you decide when you should call panic! and when you should return Result? When code panics, there’s no way to recover. You could call panic! for any error situation, whether there’s a possible way to recover or not, but then you’re making the decision that a situation is unrecoverable on behalf of the calling code. When you choose to return a Result value, you give the calling code options. The calling code could choose to attempt to recover in a way that’s appropriate for its situation, or it could decide that an Err value in this case is unrecoverable, so it can call panic! and turn your recoverable error into an unrecoverable one. Therefore, returning Result is a good default choice when you’re defining a function that might fail.

In situations such as examples, prototype code, and tests, it’s more appropriate to write code that panics instead of returning a Result. Let’s explore why, then discuss situations in which the compiler can’t tell that failure is impossible, but you as a human can. The chapter will conclude with some general guidelines on how to decide whether to panic in library code.

Examples, Prototype Code, and Tests

When you’re writing an example to illustrate some concept, also including robust error-handling code can make the example less clear. In examples, it’s understood that a call to a method like unwrap that could panic is meant as a placeholder for the way you’d want your application to handle errors, which can differ based on what the rest of your code is doing.

Similarly, the unwrap and expect methods are very handy when prototyping, before you’re ready to decide how to handle errors. They leave clear markers in your code for when you’re ready to make your program more robust.

If a method call fails in a test, you’d want the whole test to fail, even if that method isn’t the functionality under test. Because panic! is how a test is marked as a failure, calling unwrap or expect is exactly what should happen.

Cases in Which You Have More Information Than the Compiler

It would also be appropriate to call unwrap when you have some other logic that ensures the Result will have an Ok value, but the logic isn’t something the compiler understands. You’ll still have a Result value that you need to handle: whatever operation you’re calling still has the possibility of failing in general, even though it’s logically impossible in your particular situation. If you can ensure by manually inspecting the code that you’ll never have an Err variant, it’s perfectly acceptable to call unwrap. Here’s an example:

fn main() {
    use std::net::IpAddr;

    let home: IpAddr = "127.0.0.1".parse().unwrap();
}

We’re creating an IpAddr instance by parsing a hardcoded string. We can see that 127.0.0.1 is a valid IP address, so it’s acceptable to use unwrap here. However, having a hardcoded, valid string doesn’t change the return type of the parse method: we still get a Result value, and the compiler will still make us handle the Result as if the Err variant is a possibility because the compiler isn’t smart enough to see that this string is always a valid IP address. If the IP address string came from a user rather than being hardcoded into the program and therefore did have a possibility of failure, we’d definitely want to handle the Result in a more robust way instead.

Guidelines for Error Handling

It’s advisable to have your code panic when it’s possible that your code could end up in a bad state. In this context, a bad state is when some assumption, guarantee, contract, or invariant has been broken, such as when invalid values, contradictory values, or missing values are passed to your code—plus one or more of the following:

• The bad state is something that is unexpected, as opposed to something that will likely happen occasionally, like a user entering data in the wrong format.
• Your code after this point needs to rely on not being in this bad state, rather than checking for the problem at every step.
• There’s not a good way to encode this information in the types you use. We’ll work through an example of what we mean in the “Encoding States and Behavior as Types” section of Chapter 17.

If someone calls your code and passes in values that don’t make sense, the best choice might be to call panic! and alert the person using your library to the bug in their code so they can fix it during development. Similarly, panic! is often appropriate if you’re calling external code that is out of your control and it returns an invalid state that you have no way of fixing.

However, when failure is expected, it’s more appropriate to return a Result than to make a panic! call. Examples include a parser being given malformed data or an HTTP request returning a status that indicates you have hit a rate limit. In these cases, returning a Result indicates that failure is an expected possibility that the calling code must decide how to handle.

When your code performs operations on values, your code should verify the values are valid first and panic if the values aren’t valid. This is mostly for safety reasons: attempting to operate on invalid data can expose your code to vulnerabilities. This is the main reason the standard library will call panic! if you attempt an out-of-bounds memory access: trying to access memory that doesn’t belong to the current data structure is a common security problem. Functions often have contracts: their behavior is only guaranteed if the inputs meet particular requirements. Panicking when the contract is violated makes sense because a contract violation always indicates a caller-side bug and it’s not a kind of error you want the calling code to have to explicitly handle. In fact, there’s no reasonable way for calling code to recover; the calling programmers need to fix the code. Contracts for a function, especially when a violation will cause a panic, should be explained in the API documentation for the function.

However, having lots of error checks in all of your functions would be verbose and annoying. Fortunately, you can use Rust’s type system (and thus the type checking done by the compiler) to do many of the checks for you. If your function has a particular type as a parameter, you can proceed with your code’s logic knowing that the compiler has already ensured you have a valid value. For example, if you have a type rather than an Option, your program expects to have something rather than nothing. Your code then doesn’t have to handle two cases for the Some and None variants: it will only have one case for definitely having a value. Code trying to pass nothing to your function won’t even compile, so your function doesn’t have to check for that case at runtime. Another example is using an unsigned integer type such as u32, which ensures the parameter is never negative.

Creating Custom Types for Validation

Let’s take the idea of using Rust’s type system to ensure we have a valid value one step further and look at creating a custom type for validation. Recall the guessing game in Chapter 2 in which our code asked the user to guess a number between 1 and 100. We never validated that the user’s guess was between those numbers before checking it against our secret number; we only validated that the guess was positive. In this case, the consequences were not very dire: our output of “Too high” or “Too low” would still be correct. But it would be a useful enhancement to guide the user toward valid guesses and have different behavior when a user guesses a number that’s out of range versus when a user types, for example, letters instead.

One way to do this would be to parse the guess as an i32 instead of only a u32 to allow potentially negative numbers, and then add a check for the number being in range, like so:

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    loop {
        // --snip--

        println!("Please input your guess.");

        let mut guess = String::new();

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: i32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        if guess < 1 || guess > 100 {
            println!("The secret number will be between 1 and 100.");
            continue;
        }

        match guess.cmp(&secret_number) {
            // --snip--
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

The if expression checks whether our value is out of range, tells the user about the problem, and calls continue to start the next iteration of the loop and ask for another guess. After the if expression, we can proceed with the comparisons between guess and the secret number knowing that guess is between 1 and 100.

However, this is not an ideal solution: if it was absolutely critical that the program only operated on values between 1 and 100, and it had many functions with this requirement, having a check like this in every function would be tedious (and might impact performance).

Instead, we can make a new type and put the validations in a function to create an instance of the type rather than repeating the validations everywhere. That way, it’s safe for functions to use the new type in their signatures and confidently use the values they receive. Listing 9-13 shows one way to define a Guess type that will only create an instance of Guess if the new function receives a value between 1 and 100.

#![allow(unused)]
fn main() {
pub struct Guess {
    value: i32,
}

impl Guess {
    pub fn new(value: i32) -> Guess {
        if value < 1 || value > 100 {
            panic!("Guess value must be between 1 and 100, got {}.", value);
        }

        Guess { value }
    }

    pub fn value(&self) -> i32 {
        self.value
    }
}
}

Listing 9-13: A Guess type that will only continue with values between 1 and 100

First, we define a struct named Guess that has a field named value that holds an i32. This is where the number will be stored.

Then we implement an associated function named new on Guess that creates instances of Guess values. The new function is defined to have one parameter named value of type i32 and to return a Guess. The code in the body of the new function tests value to make sure it’s between 1 and 100. If value doesn’t pass this test, we make a panic! call, which will alert the programmer who is writing the calling code that they have a bug they need to fix, because creating a Guess with a value outside this range would violate the contract that Guess::new is relying on. The conditions in which Guess::new might panic should be discussed in its public-facing API documentation; we’ll cover documentation conventions indicating the possibility of a panic! in the API documentation that you create in Chapter 14. If value does pass the test, we create a new Guess with its value field set to the value parameter and return the Guess.

Next, we implement a method named value that borrows self, doesn’t have any other parameters, and returns an i32. This kind of method is sometimes called a getter, because its purpose is to get some data from its fields and return it. This public method is necessary because the value field of the Guess struct is private. It’s important that the value field be private so code using the Guess struct is not allowed to set value directly: code outside the module must use the Guess::new function to create an instance of Guess, thereby ensuring there’s no way for a Guess to have a value that hasn’t been checked by the conditions in the Guess::new function.

A function that has a parameter or returns only numbers between 1 and 100 could then declare in its signature that it takes or returns a Guess rather than an i32 and wouldn’t need to do any additional checks in its body.

Summary

Rust’s error handling features are designed to help you write more robust code. The panic! macro signals that your program is in a state it can’t handle and lets you tell the process to stop instead of trying to proceed with invalid or incorrect values. The Result enum uses Rust’s type system to indicate that operations might fail in a way that your code could recover from. You can use Result to tell code that calls your code that it needs to handle potential success or failure as well. Using panic! and Result in the appropriate situations will make your code more reliable in the face of inevitable problems.

Now that you’ve seen useful ways that the standard library uses generics with the Option and Result enums, we’ll talk about how generics work and how you can use them in your code.

Generic, Traits và Lifetimes

Hầu hết các ngôn ngữ lập trình hiện nay đều có các công cụ để giảm thiểu việc trùng lặp code. Đối với Rust, ta có generics: có thể coi là một kiểu dữ liệu dạng tổng quát thay thế cho các kiểu dữ liệu thông thường.

Các tham số truyền vào trong hàm hoàn toàn có thể là các generic, khi đó ta sẽ không cần phải suy nghĩ quá nhiều về kiểu dữ liệu của tham số nữa (vd: i32 hay String). Nếu bạn để ý, Option<T> trong chương 6, Vec<T> và HashMap<K,V> ở chương 8 hay Result<T,E> ở chương 9 đều sử dụng generic.

Trong chương này, ta sẽ học cách định nghĩa kiểu dữ liệu, hàm và phương thức sử dụng generic!

Đầu tiên, ta sẽ tìm hiểu cách giảm trùng lặp code khi sử dụng generic function cho các hàm chỉ có sự khác biệt về kiểu dữ liệu truyền vào. Đồng thời tìm hiểu thêm về generic trong struct và enum.

Tiếp theo, traits sẽ là công cụ giúp tạo ra các phương thức tổng quát và trừu tượng (rất giống interface trong Java).

Trong Rust, generic type là một kiểu dữ liệu có thể chấp nhận nhiều kiểu dữ liệu khác nhau. Ví dụ, một generic type như Vec<T> có thể chứa bất kỳ kiểu dữ liệu nào, từ số nguyên đến chuỗi hay các struct. Tuy nhiên, đôi khi chúng ta muốn giới hạn kiểu dữ liệu được chấp nhận bởi generic type này để chỉ chấp nhận những kiểu dữ liệu có hành vi cụ thể.

Điều này có thể được đạt được bằng cách kết hợp traits và generic types. Trong Rust, traits là một cách để mô tả các hành vi của một kiểu dữ liệu. Bằng cách kết hợp một trait với một generic type, chúng ta có thể giới hạn generic type đó chỉ chấp nhận các kiểu dữ liệu có hành vi tương ứng với trait đó.

Ví dụ, nếu chúng ta muốn tạo một generic type chỉ chấp nhận các kiểu dữ liệu có thể sắp xếp được, chúng ta có thể sử dụng trait Ord của Rust để giới hạn kiểu dữ liệu được chấp nhận bởi generic type này. Bằng cách này, chúng ta sẽ không thể sử dụng generic type này với các kiểu dữ liệu không thể sắp xếp được như chuỗi hay struct không hỗ trợ tính năng sắp xếp.

Cuối cùng, ta sẽ bàn về lifetimes: Lifetime trong Rust là một khái niệm được sử dụng để quản lý việc sử dụng bộ nhớ động trong khi lập trình. Khi một biến được tạo ra, nó được lưu trữ trong bộ nhớ động của máy tính. Tuy nhiên, khi biến đó không còn được sử dụng, bộ nhớ đó cần được giải phóng để sử dụng cho các mục đích khác.

Trong Rust, các biến và các giá trị của chúng có thể có các lifetime khác nhau. Lifetime đại diện cho thời gian mà một giá trị được lưu trữ trong bộ nhớ. Khi một biến được tạo ra, nó được gắn kèm với một lifetime, được biểu thị bằng ký tự 'a (với 'a có thể được thay bằng bất kỳ ký tự nào khác).

Lifetime cho phép Rust xác định thời điểm mà một biến cần được giải phóng khỏi bộ nhớ động. Điều này giúp tránh các lỗi liên quan đến việc sử dụng bộ nhớ không hợp lý, chẳng hạn như truy cập đến vùng bộ nhớ đã được giải phóng hoặc truy cập đến vùng bộ nhớ không hợp lý.

Sử dụng hàm để tránh lặp code

Cùng bắt đầu với đoạn code sau:

Filename: src/main.rs

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let mut largest = number_list[0];

    for number in number_list {
        if number > largest {
            largest = number;
        }
    }

    println!("The largest number is {}", largest);
    assert_eq!(largest, 100);
}

Listing 10-1: Tìm số lớn nhất trong chuỗi số

Mảng các số được lưu bởi biến number_list và gán phần tử đầu tiên vào biến largest. Sau đó duyệt qua toàn bộ mảng, nếu số hiện tại lớn hơn số được lưu ở largest, tiến hành cập nhật giá trị lớn hơn đó vào largest. Trong bài này kết quả nhận được sẽ là 100.

Giả sử có thêm một chuỗi số thứ 2, nhiệm vụ bây giờ là tìm số lớn nhất trong chuối số thứ 2 này. Vì vậy, ta có thể copy đoạn logic vừa làm phía trên xuống để áp dụng cho chuỗi thứ 2. Filename: src/main.rs

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let mut largest = number_list[0];

    for number in number_list {
        if number > largest {
            largest = number;
        }
    }

    println!("The largest number is {}", largest);

    let number_list = vec![102, 34, 6000, 89, 54, 2, 43, 8];

    let mut largest = number_list[0];

    for number in number_list {
        if number > largest {
            largest = number;
        }
    }

    println!("The largest number is {}", largest);
}

Listing 10-2: Tìm số lớn nhất trong từng chuỗi số

Mặc dù nó hoạt động ổn, nhưng đây là một cách viết code tồi khi đoạn logic trên bị lặp lại, ta sẽ cần đưa chúng vào trong một hàm.

Tạo một hàm có tên largest. Gọi hàm này mỗi khi cần tìm số lơn nhất của chuỗi số. Filename: src/main.rs

fn largest(list: &[i32]) -> i32 {
    let mut largest = list[0];

    for &item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {}", result);
    assert_eq!(result, 100);

    let number_list = vec![102, 34, 6000, 89, 54, 2, 43, 8];

    let result = largest(&number_list);
    println!("The largest number is {}", result);
    assert_eq!(result, 6000);
}

Listing 10-3: Sử dụng hàm để tránh lặp code

Cách làm trên giúp giảm thiểu việc lặp code, tuy nhiên nó chỉ tốt khi các chuỗi mà ta làm việc có kiểu i32. Khi kiểu dữ liệu khác đi, (giả sử char hoặc float) hàm này sẽ không thể sử dụng, lúc này generic sẽ phát huy hiệu quả.

Generic Data Types

We use generics to create definitions for items like function signatures or structs, which we can then use with many different concrete data types. Let’s first look at how to define functions, structs, enums, and methods using generics. Then we’ll discuss how generics affect code performance.

In Function Definitions

When defining a function that uses generics, we place the generics in the signature of the function where we would usually specify the data types of the parameters and return value. Doing so makes our code more flexible and provides more functionality to callers of our function while preventing code duplication.

Continuing with our largest function, Listing 10-4 shows two functions that both find the largest value in a slice. We'll then combine these into a single function that uses generics.

Filename: src/main.rs

fn largest_i32(list: &[i32]) -> i32 {
    let mut largest = list[0];

    for &item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn largest_char(list: &[char]) -> char {
    let mut largest = list[0];

    for &item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest_i32(&number_list);
    println!("The largest number is {}", result);
    assert_eq!(result, 100);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest_char(&char_list);
    println!("The largest char is {}", result);
    assert_eq!(result, 'y');
}

Listing 10-4: Two functions that differ only in their names and the types in their signatures

The largest_i32 function is the one we extracted in Listing 10-3 that finds the largest i32 in a slice. The largest_char function finds the largest char in a slice. The function bodies have the same code, so let’s eliminate the duplication by introducing a generic type parameter in a single function.

To parameterize the types in a new single function, we need to name the type parameter, just as we do for the value parameters to a function. You can use any identifier as a type parameter name. But we’ll use T because, by convention, parameter names in Rust are short, often just a letter, and Rust’s type-naming convention is CamelCase. Short for “type,” T is the default choice of most Rust programmers.

When we use a parameter in the body of the function, we have to declare the parameter name in the signature so the compiler knows what that name means. Similarly, when we use a type parameter name in a function signature, we have to declare the type parameter name before we use it. To define the generic largest function, place type name declarations inside angle brackets, <>, between the name of the function and the parameter list, like this:

fn largest<T>(list: &[T]) -> T {

We read this definition as: the function largest is generic over some type T. This function has one parameter named list, which is a slice of values of type T. The largest function will return a value of the same type T.

Listing 10-5 shows the combined largest function definition using the generic data type in its signature. The listing also shows how we can call the function with either a slice of i32 values or char values. Note that this code won’t compile yet, but we’ll fix it later in this chapter.

Filename: src/main.rs

fn largest<T>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {}", result);
}

Listing 10-5: The largest function using generic type parameters; this doesn’t yet compile

If we compile this code right now, we’ll get this error:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0369]: binary operation `>` cannot be applied to type `T`
 --> src/main.rs:5:17
  |
5 |         if item > largest {
  |            ---- ^ ------- T
  |            |
  |            T
  |
help: consider restricting type parameter `T`
  |
1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T {
  |             ++++++++++++++++++++++

For more information about this error, try `rustc --explain E0369`.
error: could not compile `chapter10` due to previous error

The note mentions std::cmp::PartialOrd, which is a trait. We’ll talk about traits in the next section. For now, know that this error states that the body of largest won’t work for all possible types that T could be. Because we want to compare values of type T in the body, we can only use types whose values can be ordered. To enable comparisons, the standard library has the std::cmp::PartialOrd trait that you can implement on types (see Appendix C for more on this trait). You’ll learn how to specify that a generic type has a particular trait in the “Traits as Parameters” section. Before we fix this code (in the section “Fixing the largest Function with Trait Bounds”), let’s first explore other ways of using generic type parameters.

In Struct Definitions

We can also define structs to use a generic type parameter in one or more fields using the <> syntax. Listing 10-6 defines a Point<T> struct to hold x and y coordinate values of any type.

Filename: src/main.rs

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
}

Listing 10-6: A Point<T> struct that holds x and y values of type T

The syntax for using generics in struct definitions is similar to that used in function definitions. First, we declare the name of the type parameter inside angle brackets just after the name of the struct. Then we use the generic type in the struct definition where we would otherwise specify concrete data types.

Note that because we’ve used only one generic type to define Point<T>, this definition says that the Point<T> struct is generic over some type T, and the fields x and y are both that same type, whatever that type may be. If we create an instance of a Point<T> that has values of different types, as in Listing 10-7, our code won’t compile.

Filename: src/main.rs

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let wont_work = Point { x: 5, y: 4.0 };
}

Listing 10-7: The fields x and y must be the same type because both have the same generic data type T.

Listing 10-7: The fields x and y must be the same type because both have the same generic data type T.

In this example, when we assign the integer value 5 to x, we let the compiler know that the generic type T will be an integer for this instance of Point<T>. Then when we specify 4.0 for y, which we’ve defined to have the same type as x, we’ll get a type mismatch error like this:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0308]: mismatched types
 --> src/main.rs:7:38
  |
7 |     let wont_work = Point { x: 5, y: 4.0 };
  |                                      ^^^ expected integer, found floating-point number

For more information about this error, try `rustc --explain E0308`.
error: could not compile `chapter10` due to previous error

To define a Point struct where x and y are both generics but could have different types, we can use multiple generic type parameters. For example, in Listing 10-8, we change the definition of Point to be generic over types T and U where x is of type T and y is of type U.

Filename: src/main.rs

struct Point<T, U> {
    x: T,
    y: U,
}

fn main() {
    let both_integer = Point { x: 5, y: 10 };
    let both_float = Point { x: 1.0, y: 4.0 };
    let integer_and_float = Point { x: 5, y: 4.0 };
}

Listing 10-8: A Point<T, U> generic over two types so that x and y can be values of different types

Now all the instances of Point shown are allowed! You can use as many generic type parameters in a definition as you want, but using more than a few makes your code hard to read. If you're finding you need lots of generic types in your code, it could indicate that your code needs restructuring into smaller pieces.

In Enum Definitions

As we did with structs, we can define enums to hold generic data types in their variants. Let’s take another look at the Option<T> enum that the standard library provides, which we used in Chapter 6:

#![allow(unused)]
fn main() {
enum Option<T> {
    Some(T),
    None,
}
}

This definition should now make more sense to you. As you can see, the Option<T> enum is generic over type T and has two variants: Some, which holds one value of type T, and a None variant that doesn’t hold any value. By using the Option<T> enum, we can express the abstract concept of an optional value, and because Option<T> is generic, we can use this abstraction no matter what the type of the optional value is.

Enums can use multiple generic types as well. The definition of the Result enum that we used in Chapter 9 is one example:

#![allow(unused)]
fn main() {
enum Result<T, E> {
    Ok(T),
    Err(E),
}
}

The Result enum is generic over two types, T and E, and has two variants: Ok, which holds a value of type T, and Err, which holds a value of type E. This definition makes it convenient to use the Result enum anywhere we have an operation that might succeed (return a value of some type T) or fail (return an error of some type E). In fact, this is what we used to open a file in Listing 9-3, where T was filled in with the type std::fs::File when the file was opened successfully and E was filled in with the type std::io::Error when there were problems opening the file.

When you recognize situations in your code with multiple struct or enum definitions that differ only in the types of the values they hold, you can avoid duplication by using generic types instead.

In Method Definitions

We can implement methods on structs and enums (as we did in Chapter 5) and use generic types in their definitions, too. Listing 10-9 shows the Point<T> struct we defined in Listing 10-6 with a method named x implemented on it.

Filename: src/main.rs

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

Listing 10-9: Implementing a method named x on the Point<T> struct that will return a reference to the x field of type T

Here, we’ve defined a method named x on Point<T> that returns a reference to the data in the field x.

Note that we have to declare T just after impl so we can use T to specify that we’re implementing methods on the type Point<T>. By declaring T as a generic type after impl, Rust can identify that the type in the angle brackets in Point is a generic type rather than a concrete type. We could have chosen a different name for this generic parameter than the generic parameter declared in the struct definition, but using the same name is conventional. Methods written within an impl that declares the generic type will be defined on any instance of the type, no matter what concrete type ends up substituting for the generic type.

We can also specify constraints on generic types when defining methods on the type. We could, for example, implement methods only on Point<f32> instances rather than on Point<T> instances with any generic type. In Listing 10-10 we use the concrete type f32, meaning we don’t declare any types after impl.

Filename: src/main.rs

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

Listing 10-10: An impl block that only applies to a struct with a particular concrete type for the generic type parameter T

This code means the type Point<f32> will have a distance_from_origin method; other instances of Point<T> where T is not of type f32 will not have this method defined. The method measures how far our point is from the point at coordinates (0.0, 0.0) and uses mathematical operations that are available only for floating point types.

Generic type parameters in a struct definition aren’t always the same as those you use in that same struct’s method signatures. Listing 10-11 uses the generic types X1 and Y1 for the Point struct and X2 Y2 for the mixup method signature to make the example clearer. The method creates a new Point instance with the x value from the self Point (of type X1) and the y value from the passed-in Point (of type Y2).

Filename: src/main.rs

struct Point<X1, Y1> {
    x: X1,
    y: Y1,
}

impl<X1, Y1> Point<X1, Y1> {
    fn mixup<X2, Y2>(self, other: Point<X2, Y2>) -> Point<X1, Y2> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 5, y: 10.4 };
    let p2 = Point { x: "Hello", y: 'c' };

    let p3 = p1.mixup(p2);

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

Listing 10-11: A method that uses generic types different from its struct’s definition

In main, we’ve defined a Point that has an i32 for x (with value 5) and an f64 for y (with value 10.4). The p2 variable is a Point struct that has a string slice for x (with value "Hello") and a char for y (with value c). Calling mixup on p1 with the argument p2 gives us p3, which will have an i32 for x, because x came from p1. The p3 variable will have a char for y, because y came from p2. The println! macro call will print p3.x = 5, p3.y = c.

The purpose of this example is to demonstrate a situation in which some generic parameters are declared with impl and some are declared with the method definition. Here, the generic parameters X1 and Y1 are declared after impl because they go with the struct definition. The generic parameters X2 and Y2 are declared after fn mixup, because they’re only relevant to the method.

Performance of Code Using Generics

You might be wondering whether there is a runtime cost when using generic type parameters. The good news is that using generic types won't make your run any slower than it would with concrete types.

Rust accomplishes this by performing monomorphization of the code using generics at compile time. Monomorphization is the process of turning generic code into specific code by filling in the concrete types that are used when compiled. In this process, the compiler does the opposite of the steps we used to create the generic function in Listing 10-5: the compiler looks at all the places where generic code is called and generates code for the concrete types the generic code is called with.

Let’s look at how this works by using the standard library’s generic Option<T> enum:

#![allow(unused)]
fn main() {
let integer = Some(5);
let float = Some(5.0);
}

When Rust compiles this code, it performs monomorphization. During that process, the compiler reads the values that have been used in Option<T> instances and identifies two kinds of Option<T>: one is i32 and the other is f64. As such, it expands the generic definition of Option<T> into Option_i32 and Option_f64, thereby replacing the generic definition with the specific ones.

The monomorphized version of the code looks like the following:

Filename: src/main.rs

enum Option_i32 {
    Some(i32),
    None,
}

enum Option_f64 {
    Some(f64),
    None,
}

fn main() {
    let integer = Option_i32::Some(5);
    let float = Option_f64::Some(5.0);
}

The generic Option<T> is replaced with the specific definitions created by the compiler. Because Rust compiles generic code into code that specifies the type in each instance, we pay no runtime cost for using generics. When the code runs, it performs just as it would if we had duplicated each definition by hand. The process of monomorphization makes Rust’s generics extremely efficient at runtime.

Traits: Defining Shared Behavior

A trait defines functionality a particular type has and can share with other types. We can use traits to define shared behavior in an abstract way. We can use trait bounds to specify that a generic type can be any type that has certain behavior.

Note: Traits are similar to a feature often called interfaces in other languages, although with some differences.

Defining a Trait

A type’s behavior consists of the methods we can call on that type. Different types share the same behavior if we can call the same methods on all of those types. Trait definitions are a way to group method signatures together to define a set of behaviors necessary to accomplish some purpose.

For example, let’s say we have multiple structs that hold various kinds and amounts of text: a NewsArticle struct that holds a news story filed in a particular location and a Tweet that can have at most 280 characters along with metadata that indicates whether it was a new tweet, a retweet, or a reply to another tweet.

We want to make a media aggregator library crate named aggregator that can display summaries of data that might be stored in a NewsArticle or Tweet instance. To do this, we need a summary from each type, and we’ll request that summary by calling a summarize method on an instance. Listing 10-12 shows the definition of a public Summary trait that expresses this behavior.

Filename: src/lib.rs

pub trait Summary {
    fn summarize(&self) -> String;
}

Listing 10-12: A Summary trait that consists of the behavior provided by a summarize method

Here, we declare a trait using the trait keyword and then the trait’s name, which is Summary in this case. We’ve also declared the trait as pub so that crates depending on this crate can make use of this trait too, as we’ll see in a few examples. Inside the curly brackets, we declare the method signatures that describe the behaviors of the types that implement this trait, which in this case is fn summarize(&self) -> String.

After the method signature, instead of providing an implementation within curly brackets, we use a semicolon. Each type implementing this trait must provide its own custom behavior for the body of the method. The compiler will enforce that any type that has the Summary trait will have the method summarize defined with this signature exactly.

A trait can have multiple methods in its body: the method signatures are listed one per line and each line ends in a semicolon.

Implementing a Trait on a Type

Now that we’ve defined the desired signatures of the Summary trait’s methods, we can implement it on the types in our media aggregator. Listing 10-13 shows an implementation of the Summary trait on the NewsArticle struct that uses the headline, the author, and the location to create the return value of summarize. For the Tweet struct, we define summarize as the username followed by the entire text of the tweet, assuming that tweet content is already limited to 280 characters.

Filename: src/lib.rs

pub trait Summary {
    fn summarize(&self) -> String;
}

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

pub struct Tweet {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub retweet: bool,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

Listing 10-13: Implementing the Summary trait on the NewsArticle and Tweet types

Implementing a trait on a type is similar to implementing regular methods. The difference is that after impl, we put the trait name we want to implement, then use the for keyword, and then specify the name of the type we want to implement the trait for. Within the impl block, we put the method signatures that the trait definition has defined. Instead of adding a semicolon after each signature, we use curly brackets and fill in the method body with the specific behavior that we want the methods of the trait to have for the particular type.

Now that the library has implemented the Summary trait on NewsArticle and Tweet, users of the crate can call the trait methods on instances of NewsArticle and Tweet in the same way we call regular methods. The only difference is that the user must bring the trait into scope as well as the types. Here’s an example of how a binary crate could use our aggregator library crate:

use aggregator::{Summary, Tweet};

fn main() {
    let tweet = Tweet {
        username: String::from("horse_ebooks"),
        content: String::from(
            "of course, as you probably already know, people",
        ),
        reply: false,
        retweet: false,
    };

    println!("1 new tweet: {}", tweet.summarize());
}

This code prints 1 new tweet: horse_ebooks: of course, as you probably already know, people.

Other crates that depend on the aggregator crate can also bring the Summary trait into scope to implement Summary on their own types. One restriction to note is that we can implement a trait on a type only if at least one of the trait or the type is local to our crate. For example, we can implement standard library traits like Display on a custom type like Tweet as part of our aggregator crate functionality, because the type Tweet is local to our aggregator crate. We can also implement Summary on Vec<T> in our aggregator crate, because the trait Summary is local to our aggregator crate.

But we can’t implement external traits on external types. For example, we can’t implement the Display trait on Vec<T> within our aggregator crate, because Display and Vec<T> are both defined in the standard library and aren’t local to our aggregator crate. This restriction is part of a property called coherence, and more specifically the orphan rule, so named because the parent type is not present. This rule ensures that other people’s code can’t break your code and vice versa. Without the rule, two crates could implement the same trait for the same type, and Rust wouldn’t know which implementation to use.

Default Implementations

Sometimes it’s useful to have default behavior for some or all of the methods in a trait instead of requiring implementations for all methods on every type. Then, as we implement the trait on a particular type, we can keep or override each method’s default behavior.

In Listing 10-14 we specify a default string for the summarize method of the Summary trait instead of only defining the method signature, as we did in Listing 10-12.

Filename: src/lib.rs

pub trait Summary {
    fn summarize(&self) -> String {
        String::from("(Read more...)")
    }
}

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

impl Summary for NewsArticle {}

pub struct Tweet {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub retweet: bool,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

Listing 10-14: Defining a Summary trait with a default implementation of the summarize method

To use a default implementation to summarize instances of NewsArticle, we specify an empty impl block with impl Summary for NewsArticle {}.

Even though we’re no longer defining the summarize method on NewsArticle directly, we’ve provided a default implementation and specified that NewsArticle implements the Summary trait. As a result, we can still call the summarize method on an instance of NewsArticle, like this:

use chapter10::{self, NewsArticle, Summary};

fn main() {
    let article = NewsArticle {
        headline: String::from("Penguins win the Stanley Cup Championship!"),
        location: String::from("Pittsburgh, PA, USA"),
        author: String::from("Iceburgh"),
        content: String::from(
            "The Pittsburgh Penguins once again are the best \
             hockey team in the NHL.",
        ),
    };

    println!("New article available! {}", article.summarize());
}

This code prints New article available! (Read more...).

Creating a default implementation doesn’t require us to change anything about the implementation of Summary on Tweet in Listing 10-13. The reason is that the syntax for overriding a default implementation is the same as the syntax for implementing a trait method that doesn’t have a default implementation.

Default implementations can call other methods in the same trait, even if those other methods don’t have a default implementation. In this way, a trait can provide a lot of useful functionality and only require implementors to specify a small part of it. For example, we could define the Summary trait to have a summarize_author method whose implementation is required, and then define a summarize method that has a default implementation that calls the summarize_author method:

pub trait Summary {
    fn summarize_author(&self) -> String;

    fn summarize(&self) -> String {
        format!("(Read more from {}...)", self.summarize_author())
    }
}

pub struct Tweet {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub retweet: bool,
}

impl Summary for Tweet {
    fn summarize_author(&self) -> String {
        format!("@{}", self.username)
    }
}

To use this version of Summary, we only need to define summarize_author when we implement the trait on a type:

pub trait Summary {
    fn summarize_author(&self) -> String;

    fn summarize(&self) -> String {
        format!("(Read more from {}...)", self.summarize_author())
    }
}

pub struct Tweet {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub retweet: bool,
}

impl Summary for Tweet {
    fn summarize_author(&self) -> String {
        format!("@{}", self.username)
    }
}

After we define summarize_author, we can call summarize on instances of the Tweet struct, and the default implementation of summarize will call the definition of summarize_author that we’ve provided. Because we’ve implemented summarize_author, the Summary trait has given us the behavior of the summarize method without requiring us to write any more code.

use chapter10::{self, Summary, Tweet};

fn main() {
    let tweet = Tweet {
        username: String::from("horse_ebooks"),
        content: String::from(
            "of course, as you probably already know, people",
        ),
        reply: false,
        retweet: false,
    };

    println!("1 new tweet: {}", tweet.summarize());
}

This code prints 1 new tweet: (Read more from @horse_ebooks...).

Note that it isn’t possible to call the default implementation from an overriding implementation of that same method.

Traits as Parameters

Now that you know how to define and implement traits, we can explore how to use traits to define functions that accept many different types. We'll use the Summary trait we implemented on the NewsArticle and Tweet types in Listing 10-13 to define a notify function that calls the summarize method on its item parameter, which is of some type that implements the Summary trait. To do this, we use the impl Trait syntax, like this:

pub trait Summary {
    fn summarize(&self) -> String;
}

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

pub struct Tweet {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub retweet: bool,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

pub fn notify(item: &impl Summary) {
    println!("Breaking news! {}", item.summarize());
}

Instead of a concrete type for the item parameter, we specify the impl keyword and the trait name. This parameter accepts any type that implements the specified trait. In the body of notify, we can call any methods on item that come from the Summary trait, such as summarize. We can call notify and pass in any instance of NewsArticle or Tweet. Code that calls the function with any other type, such as a String or an i32, won’t compile because those types don’t implement Summary.

Trait Bound Syntax

The impl Trait syntax works for straightforward cases but is actually syntax sugar for a longer form known as a trait bound; it looks like this:

pub fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}

This longer form is equivalent to the example in the previous section but is more verbose. We place trait bounds with the declaration of the generic type parameter after a colon and inside angle brackets.

The impl Trait syntax is convenient and makes for more concise code in simple cases, while the fuller trait bound syntax can express more complexity in other cases. For example, we can have two parameters that implement Summary. Doing so with the impl Trait syntax looks like this:

pub fn notify(item1: &impl Summary, item2: &impl Summary) {

Using impl Trait is appropriate if we want this function to allow item1 and item2 to have different types (as long as both types implement Summary). If we want to force both parameters to have the same type, however, we must use a trait bound, like this:

pub fn notify<T: Summary>(item1: &T, item2: &T) {

The generic type T specified as the type of the item1 and item2 parameters constrains the function such that the concrete type of the value passed as an argument for item1 and item2 must be the same.

Specifying Multiple Trait Bounds with the + Syntax

We can also specify more than one trait bound. Say we wanted notify to use display formatting as well as summarize on item: we specify in the notify definition that item must implement both Display and Summary. We can do so using the + syntax:

pub fn notify(item: &(impl Summary + Display)) {

The + syntax is also valid with trait bounds on generic types:

pub fn notify<T: Summary + Display>(item: &T) {

With the two trait bounds specified, the body of notify can call summarize and use {} to format item.

Clearer Trait Bounds with where Clauses

Using too many trait bounds has its downsides. Each generic has its own trait bounds, so functions with multiple generic type parameters can contain lots of trait bound information between the function’s name and its parameter list, making the function signature hard to read. For this reason, Rust has alternate syntax for specifying trait bounds inside a where clause after the function signature. So instead of writing this:

fn some_function<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {

we can use a where clause, like this:

fn some_function<T, U>(t: &T, u: &U) -> i32
    where T: Display + Clone,
          U: Clone + Debug
{

This function’s signature is less cluttered: the function name, parameter list, and return type are close together, similar to a function without lots of trait bounds.

Returning Types that Implement Traits

We can also use the impl Trait syntax in the return position to return a value of some type that implements a trait, as shown here:

pub trait Summary {
    fn summarize(&self) -> String;
}

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

pub struct Tweet {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub retweet: bool,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

fn returns_summarizable() -> impl Summary {
    Tweet {
        username: String::from("horse_ebooks"),
        content: String::from(
            "of course, as you probably already know, people",
        ),
        reply: false,
        retweet: false,
    }
}

By using impl Summary for the return type, we specify that the returns_summarizable function returns some type that implements the Summary trait without naming the concrete type. In this case, returns_summarizable returns a Tweet, but the code calling this function doesn’t need to know that.

The ability to specify a return type only by the trait it implements is especially useful in the context of closures and iterators, which we cover in Chapter 13. Closures and iterators create types that only the compiler knows or types that are very long to specify. The impl Trait syntax lets you concisely specify that a function returns some type that implements the Iterator trait without needing to write out a very long type.

However, you can only use impl Trait if you’re returning a single type. For example, this code that returns either a NewsArticle or a Tweet with the return type specified as impl Summary wouldn’t work:

pub trait Summary {
    fn summarize(&self) -> String;
}

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

pub struct Tweet {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub retweet: bool,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

fn returns_summarizable(switch: bool) -> impl Summary {
    if switch {
        NewsArticle {
            headline: String::from(
                "Penguins win the Stanley Cup Championship!",
            ),
            location: String::from("Pittsburgh, PA, USA"),
            author: String::from("Iceburgh"),
            content: String::from(
                "The Pittsburgh Penguins once again are the best \
                 hockey team in the NHL.",
            ),
        }
    } else {
        Tweet {
            username: String::from("horse_ebooks"),
            content: String::from(
                "of course, as you probably already know, people",
            ),
            reply: false,
            retweet: false,
        }
    }
}

Returning either a NewsArticle or a Tweet isn’t allowed due to restrictions around how the impl Trait syntax is implemented in the compiler. We’ll cover how to write a function with this behavior in the “Using Trait Objects That Allow for Values of Different Types” section of Chapter 17.

Fixing the largest Function with Trait Bounds

Now that you know how to specify the behavior you want using the generic type parameter’s bounds, let’s return to Listing 10-5 to fix the definition of the largest function that uses a generic type parameter! Last time we tried to run that code, we received this error:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0369]: binary operation `>` cannot be applied to type `T`
 --> src/main.rs:5:17
  |
5 |         if item > largest {
  |            ---- ^ ------- T
  |            |
  |            T
  |
help: consider restricting type parameter `T`
  |
1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T {
  |             ++++++++++++++++++++++

For more information about this error, try `rustc --explain E0369`.
error: could not compile `chapter10` due to previous error

In the body of largest we wanted to compare two values of type T using the greater than (>) operator. Because that operator is defined as a default method on the standard library trait std::cmp::PartialOrd, we need to specify PartialOrd in the trait bounds for T so the largest function can work on slices of any type that we can compare. We don’t need to bring PartialOrd into scope because it’s in the prelude. Change the signature of largest to look like this:

fn largest<T: PartialOrd>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {}", result);
}

This time when we compile the code, we get a different set of errors:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0508]: cannot move out of type `[T]`, a non-copy slice
 --> src/main.rs:2:23
  |
2 |     let mut largest = list[0];
  |                       ^^^^^^^
  |                       |
  |                       cannot move out of here
  |                       move occurs because `list[_]` has type `T`, which does not implement the `Copy` trait
  |                       help: consider borrowing here: `&list[0]`

error[E0507]: cannot move out of a shared reference
 --> src/main.rs:4:18
  |
4 |     for &item in list {
  |         -----    ^^^^
  |         ||
  |         |data moved here
  |         |move occurs because `item` has type `T`, which does not implement the `Copy` trait
  |         help: consider removing the `&`: `item`

Some errors have detailed explanations: E0507, E0508.
For more information about an error, try `rustc --explain E0507`.
error: could not compile `chapter10` due to 2 previous errors

The key line in this error is cannot move out of type [T], a non-copy slice. With our non-generic versions of the largest function, we were only trying to find the largest i32 or char. As discussed in the “Stack-Only Data: Copy” section in Chapter 4, types like i32 and char that have a known size can be stored on the stack, so they implement the Copy trait. But when we made the largest function generic, it became possible for the list parameter to have types in it that don’t implement the Copy trait. Consequently, we wouldn’t be able to move the value out of list[0] and into the largest variable, resulting in this error.

To call this code with only those types that implement the Copy trait, we can add Copy to the trait bounds of T! Listing 10-15 shows the complete code of a generic largest function that will compile as long as the types of the values in the slice that we pass into the function implement the PartialOrd and Copy traits, like i32 and char do.

Filename: src/main.rs

fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {}", result);
}

Listing 10-15: A working definition of the largest function that works on any generic type that implements the PartialOrd and Copy traits

If we don’t want to restrict the largest function to the types that implement the Copy trait, we could specify that T has the trait bound Clone instead of Copy. Then we could clone each value in the slice when we want the largest function to have ownership. Using the clone function means we’re potentially making more heap allocations in the case of types that own heap data like String, and heap allocations can be slow if we’re working with large amounts of data.

We could also implement largest by having the function return a reference to a T value in the slice. If we change the return type to &T instead of T, thereby changing the body of the function to return a reference, we wouldn’t need the Clone or Copy trait bounds and we could avoid heap allocations. Try implementing these alternate solutions on your own! If you get stuck with errors having to do with lifetimes, keep reading: the “Validating References with Lifetimes” section coming up will explain, but lifetimes aren’t required to solve these challenges.

Using Trait Bounds to Conditionally Implement Methods

By using a trait bound with an impl block that uses generic type parameters, we can implement methods conditionally for types that implement the specified traits. For example, the type Pair<T> in Listing 10-16 always implements the new function to return a new instance of Pair<T> (recall from the “Defining Methods” section of Chapter 5 that Self is a type alias for the type of the impl block, which in this case is Pair<T>). But in the next impl block, Pair<T> only implements the cmp_display method if its inner type T implements the PartialOrd trait that enables comparison and the Display trait that enables printing.

Filename: src/lib.rs

use std::fmt::Display;

struct Pair<T> {
    x: T,
    y: T,
}

impl<T> Pair<T> {
    fn new(x: T, y: T) -> Self {
        Self { x, y }
    }
}

impl<T: Display + PartialOrd> Pair<T> {
    fn cmp_display(&self) {
        if self.x >= self.y {
            println!("The largest member is x = {}", self.x);
        } else {
            println!("The largest member is y = {}", self.y);
        }
    }
}

Listing 10-16: Conditionally implement methods on a generic type depending on trait bounds

We can also conditionally implement a trait for any type that implements another trait. Implementations of a trait on any type that satisfies the trait bounds are called blanket implementations and are extensively used in the Rust standard library. For example, the standard library implements the ToString trait on any type that implements the Display trait. The impl block in the standard library looks similar to this code:

impl<T: Display> ToString for T {
    // --snip--
}

Because the standard library has this blanket implementation, we can call the to_string method defined by the ToString trait on any type that implements the Display trait. For example, we can turn integers into their corresponding String values like this because integers implement Display:

#![allow(unused)]
fn main() {
let s = 3.to_string();
}

Blanket implementations appear in the documentation for the trait in the “Implementors” section.

Traits and trait bounds let us write code that uses generic type parameters to reduce duplication but also specify to the compiler that we want the generic type to have particular behavior. The compiler can then use the trait bound information to check that all the concrete types used with our code provide the correct behavior. In dynamically typed languages, we would get an error at runtime if we called a method on a type which didn’t define the method. But Rust moves these errors to compile time so we’re forced to fix the problems before our code is even able to run. Additionally, we don’t have to write code that checks for behavior at runtime because we’ve already checked at compile time. Doing so improves performance without having to give up the flexibility of generics.

Validating References with Lifetimes

Lifetimes are another kind of generic that we’ve already been using. Rather than ensuring that a type has the behavior we want, lifetimes ensure that references are valid as long as we need them to be.

One detail we didn’t discuss in the “References and Borrowing” section in Chapter 4 is that every reference in Rust has a lifetime, which is the scope for which that reference is valid. Most of the time, lifetimes are implicit and inferred, just like most of the time, types are inferred. We only must annotate types when multiple types are possible. In a similar way, we must annotate lifetimes when the lifetimes of references could be related in a few different ways. Rust requires us to annotate the relationships using generic lifetime parameters to ensure the actual references used at runtime will definitely be valid.

Annotating lifetimes is not even a concept most other programming languages have, so this is going to feel unfamiliar. Although we won’t cover lifetimes in their entirety in this chapter, we’ll discuss common ways you might encounter lifetime syntax so you can get comfortable with the concept.

Preventing Dangling References with Lifetimes

The main aim of lifetimes is to prevent dangling references, which cause a program to reference data other than the data it’s intended to reference. Consider the program in Listing 10-17, which has an outer scope and an inner scope.

fn main() {
    {
        let r;

        {
            let x = 5;
            r = &x;
        }

        println!("r: {}", r);
    }
}

Listing 10-17: An attempt to use a reference whose value has gone out of scope

Note: The examples in Listings 10-17, 10-18, and 10-24 declare variables without giving them an initial value, so the variable name exists in the outer scope. At first glance, this might appear to be in conflict with Rust’s having no null values. However, if we try to use a variable before giving it a value, we’ll get a compile-time error, which shows that Rust indeed does not allow null values.

The outer scope declares a variable named r with no initial value, and the inner scope declares a variable named x with the initial value of 5. Inside the inner scope, we attempt to set the value of r as a reference to x. Then the inner scope ends, and we attempt to print the value in r. This code won’t compile because the value r is referring to has gone out of scope before we try to use it. Here is the error message:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0597]: `x` does not live long enough
  --> src/main.rs:7:17
   |
7  |             r = &x;
   |                 ^^ borrowed value does not live long enough
8  |         }
   |         - `x` dropped here while still borrowed
9  | 
10 |         println!("r: {}", r);
   |                           - borrow later used here

For more information about this error, try `rustc --explain E0597`.
error: could not compile `chapter10` due to previous error

The variable x doesn’t “live long enough.” The reason is that x will be out of scope when the inner scope ends on line 7. But r is still valid for the outer scope; because its scope is larger, we say that it “lives longer.” If Rust allowed this code to work, r would be referencing memory that was deallocated when x went out of scope, and anything we tried to do with r wouldn’t work correctly. So how does Rust determine that this code is invalid? It uses a borrow checker.

The Borrow Checker

The Rust compiler has a borrow checker that compares scopes to determine whether all borrows are valid. Listing 10-18 shows the same code as Listing 10-17 but with annotations showing the lifetimes of the variables.

fn main() {
    {
        let r;                // ---------+-- 'a
                              //          |
        {                     //          |
            let x = 5;        // -+-- 'b  |
            r = &x;           //  |       |
        }                     // -+       |
                              //          |
        println!("r: {}", r); //          |
    }                         // ---------+
}

Listing 10-18: Annotations of the lifetimes of r and x, named 'a and 'b, respectively

Here, we’ve annotated the lifetime of r with 'a and the lifetime of x with 'b. As you can see, the inner 'b block is much smaller than the outer 'a lifetime block. At compile time, Rust compares the size of the two lifetimes and sees that r has a lifetime of 'a but that it refers to memory with a lifetime of 'b. The program is rejected because 'b is shorter than 'a: the subject of the reference doesn’t live as long as the reference.