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

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

bản dịch Tiếng Việt được thực hiện bởi Tuấn Em, với sự đóng góp của cộng đồng Rust tại Việt Nam

Phiên bản này của cuốn sách giả định rằng bạn đang sử dụng Rust 1.85.0 (phát hành ngày 17-02-2025) hoặc mới hơn với edition = "2024" trong tệp Cargo.toml của tất cả các dự án để cấu hình chúng sử dụng các quy ước của Rust phiên bản 2024. Xem phần “Cài đặt“ của Chương 1 để cài đặt hoặc cập nhật Rust.

Định dạng HTML có sẵn trực tuyến tại https://rust-book.tuanem.com/ và ngoại tuyến với các bản cài đặt Rust được thực hiện với rustup; chạy lệnh rustup doc --book để mở.

Một số bản dịch từ cộng đồng cũng có sẵn.

Cuốn sách này có bản in và định dạng ebook từ No Starch Press.

🚨 Bạn muốn có trải nghiệm học tập tương tác hơn? Hãy thử phiên bản khác của Sách Rust, với các tính năng: câu đố, làm nổi bật, trực quan hóa và nhiều hơn nữa: https://rust-book.cs.brown.edu

Lời nói đầu

Không phải lúc nào cũng rõ ràng, nhưng ngôn ngữ lập trình Rust về cơ bản là sự trao quyền: bất kể bạn đang viết loại mã nào, Rust trao quyền cho bạn vươn xa hơn, lập trình với sự tự tin trong nhiều lĩnh vực đa dạng hơn so với trước đây.

Ví dụ, hãy xem xét công việc "cấp hệ thống" liên quan đến các chi tiết cấp thấp của quản lý bộ nhớ, biểu diễn dữ liệu và lập trình đồng thời. Theo truyền thống, lĩnh vực lập trình này được coi là khó hiểu, chỉ tiếp cận được với một số ít người đã dành nhiều năm học tập để tránh những lỗi tiềm ẩn phổ biến của nó. Và thậm chí những người làm việc với nó cũng làm với sự thận trọng, để tránh mã của họ bị khai thác, gặp sự cố hoặc bị hỏng.

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

Các lập trình viên đã làm việc với mã cấp thấp có thể sử dụng Rust để nâng cao tham vọng của họ. Ví dụ, việc đưa tính song song vào Rust là một hoạt động tương đối ít rủi ro: trình biên dịch sẽ phát hiện các lỗi cổ điển cho bạn. Và bạn có thể giải quyết các tối ưu hóa mạnh mẽ hơn trong mã của mình với sự tự tin rằng bạn sẽ không vô tình gây ra sự cố hoặc lỗ hổng.

Nhưng Rust không giới hạn ở lập trình hệ thống cấp thấp. Nó đủ linh hoạt và tiện dụng để làm cho các ứng dụng CLI, máy chủ web và nhiều loại mã khác trở nên khá dễ chịu để viết — bạn sẽ tìm thấy các ví dụ đơn giản về cả hai 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 kỹ năng có thể chuyển giao từ lĩnh vực này sang lĩnh vực khác; bạn có thể học Rust bằng cách viết một ứng dụng web, sau đó áp dụng những kỹ năng tương tự đó để nhắm đến Raspberry Pi của bạn.

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

— Nicholas Matsakis và Aaron Turon

Giới thiệu

Lưu ý: Phiên bản sách này giống với The Rust Programming Language có sẵn ở dạng in và sách điện tử từ No Starch Press.

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

Rust dành cho ai

Rust lý tưởng cho nhiều người vì nhiều lý do khác nhau. Hãy xem xét một vài nhóm quan trọng nhất.

Các nhóm nhà phát triển

Rust đang chứng minh là một công cụ hiệu quả cho việc hợp tác giữa các nhóm lớn gồm các nhà phát triển với các mức độ kiến thức lập trình hệ thống khác nhau. Mã cấp thấp dễ bị lỗi tinh vi, mà trong hầu hết các ngôn ngữ khác chỉ có thể phát hiện thông qua kiểm tra kỹ lưỡng và xem xét mã cẩn thận bởi các nhà phát triển có kinh nghiệm. Trong Rust, trình biên dịch đóng vai trò như một người gác cổng bằng cách từ chối biên dịch mã với những lỗi khó nắm bắt này, bao gồm cả lỗi đồ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ể tập trung vào logic của chương trình thay vì săn lùng lỗi.

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

• Cargo, trình quản lý phụ thuộc và công cụ xây dựng đi kèm, giúp thêm, biên dịch và quản lý các phụ thuộc một cách dễ dàng và nhất quán trên toàn bộ hệ sinh thái Rust.
• Công cụ định dạng Rustfmt đảm bảo một phong cách mã hóa nhất quán giữa các nhà phát triển.
• Rust-analyzer cung cấp tích hợp với Môi trường Phát triển Tích hợp (IDE) cho việc hoàn thành mã và báo lỗi trực tiếp.

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

Học sinh

Rust dành cho học sinh và những người quan tâm đến việc học về 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 chào đón và sẵn sàng trả lời các câu hỏi của học sinh. Thông qua các nỗ lực như cuốn sách này, các nhóm Rust muốn làm cho các khái niệm hệ thống trở nên dễ tiếp cận hơn với nhiều người, đặc biệt là những người mới bắt đầu 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, bao gồm các công cụ dòng lệnh, dịch vụ web, công cụ DevOps, thiết bị nhúng, phân tích và chuyển mã âm thanh và video, tiền điện tử, tin sinh học, công cụ tìm kiếm, ứng dụng Internet of Things, học máy, và thậm chí là các phần quan trọng của trình duyệt web Firefox.

Các nhà phát triển 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ụ phát triển và thư viện. Chúng tôi rất mong bạn đóng góp vào ngôn ngữ Rust.

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

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

Ngôn ngữ Rust hy vọng hỗ trợ nhiều người dùng khác nữa; những người được đề cập ở đây chỉ là một số bên liên quan nhất. Nhìn chung, tham vọng lớn nhất của Rust là loại bỏ các sự đánh đổi mà các lập trình viên đã chấp nhận trong nhiều thập kỷ bằng cách cung cấp sự an toàn và năng suất, tốc độ và tính tiện dụng. 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 rằng bạn đã viết mã trong một ngôn ngữ lập trình khác nhưng không giả định bạn đã viết mã trong ngôn ngữ nào. Chúng tôi đã cố gắng làm cho tài liệu này dễ tiếp cận rộng rãi với những người có nền tảng lập trình đa dạng. 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ách suy nghĩ về nó. Nếu bạn hoàn toàn mới với lập trình, bạn sẽ được phục vụ tốt hơn bằng cách đọc một cuốn sách cung cấp một giới thiệu về lập trình.

Cách sử dụng cuốn sách này

Nói chung, cuốn sách này giả định rằng bạn đang đọc nó theo thứ tự từ đầu đến cuối. Các chương sau xây dựng 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 về một chủ đề cụ thể nhưng sẽ xem xét lại chủ đề đó trong một chương sau.

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

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

Chương 5 thảo luận về struct và phương thức, và Chương 6 đề cập đến enum, biểu thức match, và cấu trúc luồng điều khiển if let. Bạn sẽ sử dụng struct và enum để tạo các kiểu dữ liệu tùy chỉnh trong Rust.

Trong Chương 7, bạn sẽ học về hệ thống module của Rust và về các quy tắc bảo mật để tổ chức mã của bạn và Giao diện Lập trình Ứng dụng (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 tiêu chuẩn cung cấp, chẳng hạn như vector, chuỗi và hash map. Chương 9 khám phá triết lý và kỹ thuật xử lý lỗi của Rust.

Chương 10 đi sâu vào generics, traits và lifetimes, cho bạn khả năng để định nghĩa mã áp dụng cho nhiều kiểu dữ liệu. Chương 11 là tất cả về kiểm thử, mà ngay cả với các đảm bảo an toàn của Rust cũng 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ẽ triển khai xây dựng cho riêng mình cho một phần chức năng của công cụ dòng lệnh grep tìm kiếm văn bản trong các tệp. Để làm điều này, chúng ta sẽ sử dụng nhiều khái niệm đã thảo luận trong các chương trước.

Chương 13 khám phá closure và iterator: các đặc điểm của Rust đến từ các ngôn ngữ lập trình hàm. Trong Chương 14, chúng ta sẽ xem xét Cargo sâu hơn và nói về các thực hành tốt nhất để chia sẻ thư viện của bạn với người khác. Chương 15 thảo luận về các con trỏ thông minh mà thư viện tiêu chuẩn cung cấp và các traits cần thiết cho 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 trong nhiều luồng một cách không sợ hãi. Trong Chương 17, chúng ta xây dựng trên đó bằng cách khám phá cú pháp async và await của Rust, cùng với các task, future và stream, và mô hình đồng thời nhẹ mà chúng cho phép.

Chương 18 xem xét cách các đặc trưng của Rust 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 19 là một tài liệu tham khảo về mẫu và khớp mẫu, là những cách mạnh mẽ để biểu đạt ý tưởng trong suốt các chương trình Rust. Chương 20 chứa một loạt các chủ đề nâng cao thú vị, bao gồm Rust không an toàn, macro, và tìm hiểu sâu hơn về lifetimes, traits, kiểu dữ liệu, hàm và closure.

Trong Chương 21, 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ữ theo định dạng tham khảo hơn. Phụ lục A đề cập đến các từ khóa của Rust, Phụ lục B đề cập đến các toán tử và ký hiệu của Rust, Phụ lục C đề cập đến các traits có thể được dẫn xuất do thư viện tiêu chuẩn cung cấp, Phụ lục D đề cập đến 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. Trong Phụ lục F, bạn có thể tìm thấy các bản dịch của cuốn sách, và trong Phụ lục G chúng tôi sẽ đề cập đến cách Rust được tạo ra và Rust nightly là gì.

Không có cách nào sai để đọc cuốn sách này: nếu bạn muốn bỏ qua, 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ự nhầm lẫn nào. Nhưng hãy làm bất cứ điều gì phù hợp với bạn.

Một phần quan trọng của quá trình học Rust là học cách đọc các thông báo lỗi mà trình biên dịch hiển thị: những thông báo này sẽ hướng dẫn bạn đến mã chạy được. Vì vậy, chúng tôi sẽ cung cấp nhiều ví dụ 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. Hãy biết rằng nếu bạn nhập và chạy một ví dụ ngẫu nhiên, nó có thể không biên dịch! Hãy chắc chắn rằng bạn đọc văn bản xung quanh để xem liệu ví dụ bạn đang cố gắng chạy sẽ gây lỗi hay không. Ferris cũng sẽ giúp bạn phân biệt mã không chạy được:

Ferris	Ý nghĩa
	Mã này không biên dịch!
	Mã này gây hoảng loạn! (panic!)
	Mã này không tạo ra hành vi mong muốn.

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ỳ mã nào không biên dịch.

Mã nguồn

Các tệp mã nguồn mà từ đó cuốn sách này được tạo ra có thể được tìm thấy trên GitHub.

Bắt đầu

Hãy bắt đầu hành trình Rust của bạn! Có rất nhiều điều để học, nhưng mọi hành trình đều có điểm khởi đầu. Trong chương này, chúng ta sẽ thảo luận:

• Cài đặt Rust trên Linux, macOS và Windows
• Viết một chương trình in ra Hello, world!
• Sử dụng cargo, trình quản lý gói và hệ thống build của Rust

Cài đặt

Bước đầu tiên là cài đặt Rust. Chúng ta sẽ tải Rust thông qua rustup, một công cụ dòng lệnh để quản lý các phiên bản Rust và các công cụ liên quan. Bạn sẽ cần kết nối internet để tải xuống.

Lưu ý: Nếu bạn không muốn sử dụng rustup vì một số lý do, vui lòng xem trang Phương pháp Cài đặt Rust khác để biết thêm lựa chọn.

Các bước sau đây cài đặt phiên bản ổn định mới nhất của trình biên dịch Rust. Sự đảm bảo về tính ổn định của Rust đảm bảo rằng tất cả các ví dụ trong sách này biên dịch được sẽ tiếp tục biên dịch được với các phiên bản Rust mới hơn. Đầu ra có thể khác nhau một chút giữa các phiên bản vì Rust thường cải thiện thông báo lỗi và cảnh báo. Nói cách khác, bất kỳ phiên bản Rust ổn định, mới hơn nào mà bạn cài đặt bằng các bước này sẽ hoạt động như mong đợi với nội dung của cuốn sách này.

Ký hiệu Dòng lệnh

Trong chương này và xuyên suốt cuốn sách, chúng tôi sẽ hiển thị một số lệnh được sử dụng trong terminal. Các dòng mà bạn nên nhập vào terminal đều bắt đầu bằng $. Bạn không cần phải gõ ký tự $; đó là dấu nhắc dòng lệnh được hiển thị để chỉ ra điểm bắt đầu của mỗi lệnh. Các dòng không bắt đầu bằng $ thường hiển thị đầu ra của lệnh trước đó. Ngoài ra, các ví dụ dành riêng cho PowerShell sẽ sử dụng > thay vì $.

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

Nếu bạn đang sử dụng Linux hoặc macOS, mở terminal và nhập lệnh sau:

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

Lệnh này tải xuống một script và bắt đầu cài đặt công cụ rustup, công cụ này sẽ cài đặt phiên bản ổn định mới nhất của Rust. Bạn có thể được yêu cầu nhập mật khẩu. Nếu cài đặt thành công, dòng sau sẽ xuất hiện:

Rust is installed now. Great!

Bạn cũng sẽ cần một linker, là một chương trình mà Rust sử dụng để kết hợp các đầu ra đã biên dịch thành một tệp. Có khả năng bạn đã có sẵn một cái. Nếu bạn gặp lỗi linker, bạn nên cài đặt một trình biên dịch C, thường sẽ bao gồm một linker. Một trình biên dịch C cũng hữu ích vì một số gói Rust phổ biến phụ thuộc vào mã C và sẽ cần một trình biên dịch C.

Trên macOS, bạn có thể có một trình biên dịch C bằng cách chạy:

$ xcode-select --install

Người dùng Linux nên cài đặt GCC hoặc Clang, theo tài liệu của bản phân phối của họ. Ví dụ, nếu bạn sử dụng Ubuntu, bạn có thể cài đặt gói build-essential.

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 đặt Rust. Tại một số điểm trong quá trình cài đặt, bạn sẽ được yêu cầu cài đặt Visual Studio. Điều này cung cấp một linker và các thư viện gốc cần thiết để biên dịch chương trình. Nếu bạn cần thêm trợ giúp với bước này, xem https://rust-lang.github.io/rustup/installation/windows-msvc.html

Phần còn lại của cuốn sách này sử dụng các lệnh hoạt động trong cả cmd.exe và PowerShell. Nếu có sự khác biệt cụ thể, chúng tôi sẽ giải thích nên sử dụng cái nào.

Khắc phục sự cố

Để kiểm tra xem bạn đã cài đặt Rust đúng cách chưa, mở shell và nhập dòng này:

$ rustc --version

Bạn sẽ thấy số phiên bản, commit hash và ngày commit cho phiên bản ổn định mới nhất đã được phát hành, theo định dạng sau:

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

Nếu bạn thấy thông tin này, bạn đã cài đặt Rust thành công! Nếu bạn không thấy thông tin này, kiểm tra xem Rust có trong biến hệ thống %PATH% của bạn như sau.

Trong Windows CMD, sử dụng:

> echo %PATH%

Trong PowerShell, sử dụng:

> echo $env:Path

Trong Linux và macOS, sử dụng:

$ echo $PATH

Nếu tất cả đều đúng và Rust vẫn không hoạt động, có một số nơi bạn có thể nhận trợ giúp. Tìm hiểu cách liên hệ với các Rustaceans khác (một biệt danh ngớ ngẩn mà chúng tôi tự gọi mình) trên trang cộng đồng.

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

Khi Rust đã được cài đặt qua rustup, việc cập nhật lên phiên bản mới phát hành rất dễ dàng. Từ shell của bạn, chạy script cập nhật sau:

$ rustup update

Để gỡ cài đặt Rust và rustup, chạy script gỡ cài đặt sau từ shell của bạn:

$ rustup self uninstall

Tài liệu cục bộ

Việc cài đặt Rust cũng bao gồm một bản sao cục bộ của tài liệu để bạn có thể đọc nó khi không có kết nối internet. Chạy rustup doc để mở tài liệu cục bộ trong trình duyệt của bạn.

Bất cứ khi nào một kiểu dữ liệu hoặc hàm được cung cấp bởi thư viện tiêu chuẩn và bạn không chắc chắn nó làm gì hoặc cách sử dụng nó, hãy sử dụng tài liệu giao diện lập trình ứng dụng (API) để tìm hiểu!

Trình soạn thảo văn bản và Môi trường Phát triển Tích hợp

Cuốn sách này không đưa ra giả định về công cụ bạn sử dụng để viết mã Rust. Hầu hết các trình soạn thảo văn bản đều có thể hoàn thành công việc! Tuy nhiên, nhiều trình soạn thảo văn bản và môi trường phát triển tích hợp (IDEs) có hỗ trợ tích hợp cho Rust. Bạn luôn có thể tìm thấy danh sách khá cập nhật của nhiều trình soạn thảo và IDE trên trang công cụ trên trang web Rust.

Làm việc ngoại tuyến với cuốn sách này

Trong một số ví dụ, chúng tôi sẽ sử dụng các gói Rust ngoài thư viện tiêu chuẩn. Để làm việc qua các ví dụ đó, bạn sẽ cần có kết nối internet hoặc đã tải xuống các phụ thuộc đó trước. Để tải xuống các phụ thuộc trước, bạn có thể chạy các lệnh sau. (Chúng tôi sẽ giải thích cargo là gì và từng lệnh này làm gì chi tiết sau.)

$ cargo new get-dependencies
$ cd get-dependencies
$ cargo add rand@0.8.5 trpl@0.2.0

Điều này sẽ lưu trữ các gói đã tải xuống để bạn không cần phải tải xuống chúng sau này. Sau khi bạn đã chạy lệnh này, bạn không cần giữ thư mục get-dependencies. Nếu bạn đã chạy lệnh này, bạn có thể sử dụng cờ --offline với tất cả các lệnh cargo trong phần còn lại của cuốn sách để sử dụng các phiên bản đã lưu trữ này thay vì cố gắng sử dụng mạng.

Xin chào, Thế giới!

Bây giờ bạn đã cài đặt Rust, đã đến lúc viết chương trình Rust đầu tiên của bạn. Theo truyền thống khi học một ngôn ngữ mới, chúng ta thường viết một chương trình nhỏ in ra dòng chữ Hello, world! lên màn hình, vì vậy chúng ta sẽ làm điều tương tự ở đây!

Lưu ý: Cuốn sách này giả định bạn đã có kiến thức cơ bản về dòng lệnh. Rust không đưa ra yêu cầu cụ thể nào về công cụ soạn thảo hoặc nơi lưu trữ mã của bạn, vì vậy nếu bạn thích sử dụng môi trường phát triển tích hợp (IDE) thay vì dòng lệnh, hãy tự nhiên sử dụng IDE yêu thích của bạn. Nhiều IDE hiện nay có một số mức độ hỗ trợ Rust; hãy kiểm tra tài liệu của IDE để biết chi tiết. Đội ngũ Rust đã tập trung vào việc hỗ trợ IDE thông qua rust-analyzer. Xem Phụ lục D để biết thêm chi tiết.

Tạo thư mục dự án

Bạn sẽ bắt đầu bằng việc tạo một thư mục để lưu trữ mã Rust của bạn. Đối với Rust, nơi lưu trữ mã của bạn không quan trọng, nhưng đối với các bài tập và dự án trong sách này, chúng tôi gợi ý tạo một thư mục projects trong thư mục home của bạn và lưu giữ tất cả các dự án của bạn ở đó.

Mở một terminal và nhập các lệnh sau để tạo một thư mục projects và một thư mục cho dự án “Hello, world!” trong thư mục projects.

Đối với Linux, macOS và PowerShell trên Windows, nhập:

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

Đối với Windows CMD, nhập:

> 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 tệp nguồn mới và gọi nó là main.rs. Các tệp Rust luôn kết thúc bằng phần mở rộng .rs. Nếu bạn sử dụng nhiều hơn một từ trong tên tệp của mình, quy ước là sử dụng dấu gạch dưới để tách chúng. Ví dụ, sử dụng hello_world.rs thay vì helloworld.rs.

Bây giờ mở tệp main.rs mà bạn vừa tạo và nhập mã trong Listing 1-1.

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

Lưu tệp và quay lại cửa sổ terminal của bạn trong thư mục ~/projects/hello_world. Trên Linux hoặc macOS, nhập các lệnh sau để biên dịch và chạy tệp:

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

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

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

Bất kể hệ điều hành của bạn là gì, chuỗi Hello, world! sẽ được in ra terminal. Nếu bạn không thấy đầu ra này, hãy tham khảo lại phần “Khắc phục sự cố” của phần Cài đặt để biết cách nhận trợ giúp.

Nếu Hello, world! đã được in ra, chúc mừng bạn! Bạn đã chính thức viết một chương trình Rust. Điều đó làm cho bạn trở thành một lập trình viên Rust — chào mừng!

Cấu trúc của một chương trình Rust

Hãy xem xét chi tiết chương trình “Hello, world!” này. Đây là mảnh ghép đầu tiên:

fn main() {

}

Những dòng này định nghĩa một hàm tên là main. Hàm main là một hàm đặc biệt: nó luôn là mã đầu tiên chạy trong mọi chương trình Rust thực thi. Ở đây, dòng đầu tiên khai báo một hàm tên là main không có tham số và không trả về gì. Nếu có tham số, chúng sẽ nằm trong dấu ngoặc đơn ().

Thân hàm được bao bọc trong {}. Rust yêu cầu dấu ngoặc nhọn xung quanh tất cả thân hàm. Đó là phong cách tốt để đặt dấu ngoặc nhọn mở trên cùng một dòng với khai báo hàm, thêm một khoảng trắng ở giữa.

Lưu ý: Nếu bạn muốn tuân theo một phong cách chuẩn trong các dự án Rust, bạn có thể sử dụng công cụ định dạng tự động gọi là rustfmt để định dạng mã của bạn theo một phong cách cụ thể (đọc thêm về rustfmt trong Phụ lục D). Đội ngũ phát triển Rust đã bao gồm công cụ này trong bản phân phối Rust tiêu chuẩn, giống như rustc, vì vậy nó có thể đã được cài đặt trên máy tính của bạn!

Thân hàm main chứa mã sau:

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

Dòng này thực hiện tất cả công việc trong chương trình nhỏ này: nó in văn bản lên màn hình. Có ba chi tiết quan trọng cần chú ý ở đây.

Đầu tiên, println! là một macro của Rust. Thay vì nếu nó được gọi là một hàm, nó sẽ được nhập là println (không có !). Các macro của Rust là một cách để viết mã tạo ra mã để mở rộng cú pháp Rust, và chúng ta sẽ thảo luận chi tiết hơn về chúng trong Chương 20. Hiện tại, bạn chỉ cần biết rằng việc sử dụng ! có nghĩa là bạn đang gọi một macro thay vì một hàm bình thường và các macro không luôn tuân theo các quy tắc giống như các hàm.

Thứ hai, bạn thấy chuỗi "Hello, world!". Chúng ta truyền chuỗi này làm đối số cho println!, và chuỗi được in ra màn hình.

Thứ ba, chúng ta kết thúc dòng bằng dấu chấm phẩy (;), điều này cho biết rằng biểu thức này đã kết thúc và biểu thức tiếp theo đã sẵn sàng để bắt đầu. Hầu hết các dòng mã Rust kết thúc bằng dấu chấm phẩy.

Biên dịch và chạy là các bước riêng biệt

Bạn vừa chạy một chương trình mới tạo, vì vậy hãy xem xét từng bước trong quá trình.

Trước khi chạy một chương trình Rust, bạn phải biên dịch nó bằng trình biên dịch Rust bằng cách nhập lệnh rustc và truyền cho nó tên tệp nguồn của bạn, như thế này:

$ rustc main.rs

Nếu bạn có nền tảng C hoặc C++, bạn sẽ nhận thấy điều này tương tự như gcc hoặc clang. Sau khi biên dịch thành công, Rust xuất ra một tệp thực thi nhị phân.

Trên Linux, macOS và PowerShell trên Windows, bạn có thể thấy tệp thực thi bằng cách nhập lệnh ls trong shell của bạn:

$ ls
main  main.rs

Trên Linux và macOS, bạn sẽ thấy hai tệp. Với PowerShell trên Windows, bạn sẽ thấy ba tệp giống như bạn sẽ thấy khi sử dụng CMD. Với CMD trên Windows, bạn sẽ nhập lệnh sau:

> dir /B %= tùy chọn /B chỉ hiển thị tên tệp =%
main.exe
main.pdb
main.rs

Điều này hiển thị tệp mã nguồn với phần mở rộng .rs, tệp thực thi (main.exe trên Windows, nhưng main trên tất cả các nền tảng khác), và, khi sử dụng Windows, một tệp chứa thông tin gỡ lỗi với phần mở rộng .pdb. Từ đây, bạn chạy tệp main hoặc main.exe, như sau:

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

Nếu main.rs của bạn là chương trình “Hello, world!” của bạn, dòng này sẽ in Hello, world! lên terminal của bạn.

Nếu bạn quen thuộc hơn với một ngôn ngữ động, chẳng hạn như Ruby, Python hoặc JavaScript, bạn có thể không quen với việc biên dịch và chạy một chương trình như các bước riêng biệt. Rust là một ngôn ngữ biên dịch trước (ahead-of-time compiled), có nghĩa là bạn có thể biên dịch một chương trình và đưa tệp thực thi cho người khác, và họ có thể chạy nó ngay cả khi không cài đặt Rust. Nếu bạn đưa cho ai đó một tệp .rb, .py hoặc .js, họ cần phải có một triển khai Ruby, Python hoặc JavaScript tương ứng được cài đặt. Nhưng trong những ngôn ngữ đó, bạn chỉ cần một lệnh để biên dịch và chạy chương trình của bạn. Mọi thứ đều là sự đánh đổi trong thiết kế ngôn ngữ.

Chỉ biên dịch với rustc là đủ cho các chương trình đơn giản, nhưng khi dự án của bạn phát triển, bạn sẽ muốn quản lý tất cả các tùy chọn và làm cho việc chia sẻ mã của bạn trở nên dễ dàng. Tiếp theo, chúng tôi sẽ giới thiệu cho bạn công cụ Cargo, công cụ sẽ giúp bạn viết các chương trình Rust thực tế.

Xin chào, Cargo!

Cargo là hệ thống build và quản lý gói của Rust. Hầu hết các Rustacean (lập trình viên Rust) đều sử dụng công cụ này để quản lý các dự án Rust vì Cargo xử lý nhiều tác vụ cho bạn, chẳng hạn như xây dựng code, tải xuống các thư viện mà code của bạn phụ thuộc và build các thư viện đó. (Chúng tôi gọi các thư viện mà code của bạn cần là dependencies - các phụ thuộc.)

Các chương trình Rust đơn giản nhất, như cái chúng ta đã viết cho đến giờ, không có bất kỳ phụ thuộc nào. Nếu chúng ta xây dựng dự án "Hello, world!" với Cargo, nó sẽ chỉ sử dụng một phần của Cargo cho việc xử lý build code của bạn. Khi bạn viết các chương trình Rust phức tạp hơn, bạn sẽ thêm các phụ thuộc, và nếu bạn bắt đầu một dự án bằng Cargo, việc thêm phụ thuộc sẽ dễ dàng hơn nhiều.

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 trình cài đặt chính thức được thảo luận trong phần "Cài đặt". Nếu bạn đã cài đặt Rust thông qua một số phương tiện khác, hãy kiểm tra xem Cargo đã được cài đặt chưa bằng cách nhập lệnh sau vào terminal của bạn:

$ cargo --version

Nếu bạn thấy một số phiên bản, bạn đã có nó! Nếu bạn thấy một lỗi, chẳng hạn như command not found, hãy xem tài liệu cho phương thức cài đặt của bạn để xác định cách cài đặt Cargo riêng biệt.

Tạo một dự án với Cargo

Hãy tạo một dự án mới sử dụng Cargo và xem nó khác với dự án "Hello, world!" ban đầu của chúng ta như thế nào. Quay lại thư mục projects của bạn (hoặc bất cứ nơi nào bạn đã quyết định lưu trữ code). Sau đó, trên bất kỳ hệ điều hành nào, chạy lệnh sau:

$ cargo new hello_cargo
$ cd hello_cargo

Lệnh đầu tiên tạo một thư mục và dự án mới có tên hello_cargo. Chúng ta đã đặt tên dự án là hello_cargo, và Cargo tạo các tệp của nó trong một thư mục cùng tên.

Đi vào thư mục hello_cargo và liệt kê các tệp. Bạn sẽ thấy rằng Cargo đã tạo hai tệp và một thư mục cho chúng ta: một tệp Cargo.toml và một thư mục src với một tệp main.rs bên trong.

Nó cũng đã khởi tạo một repository Git mới cùng với tệp .gitignore. Các tệp Git sẽ không được tạo nếu bạn chạy cargo new trong một Git repository đã tồn tại; bạn có thể ghi đè hành vi này bằng cách sử dụng cargo new --vcs=git.

Lưu ý: Git là một hệ thống quản lý phiên bản phổ biến. Bạn có thể thay đổi cargo new để sử dụng một hệ thống quản lý phiên bản khác hoặc không sử dụng hệ thống quản lý phiên bản nào bằng cách sử dụng cờ --vcs. Chạy cargo new --help để xem các tùy chọn có sẵn.

Mở Cargo.toml trong trình soạn thảo văn bản bạn chọn. Nó sẽ trông giống với mã trong Listing 1-2.

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

[dependencies]

Tệp này có định dạng TOML (Tom's Obvious, Minimal Language), đây là định dạng cấu hình của Cargo.

Dòng đầu tiên, [package], là một tiêu đề phần cho biết rằng các câu lệnh tiếp theo đang cấu hình một gói. Khi chúng ta thêm thông tin vào tệp này, chúng ta sẽ thêm các phần khác.

Ba dòng tiếp theo thiết lập thông tin cấu hình mà Cargo cần để biên dịch chương trình của bạn: tên, phiên bản và phiên bản của Rust để sử dụng. Chúng ta sẽ nói về khóa edition trong Phụ lục E.

Dòng cuối cùng, [dependencies], là phần bắt đầu cho bạn liệt kê bất kỳ phụ thuộc nào của dự án. Trong Rust, các gói mã được gọi là crates. Chúng ta sẽ không cần bất kỳ crate nào khác cho dự án này, nhưng chúng ta sẽ cần trong dự án đầu tiên ở Chương 2, vì vậy chúng ta sẽ sử dụng phần phụ thuộc này sau.

Bây giờ mở src/main.rs và xem qua:

Tên tệp: src/main.rs

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

Cargo đã tạo một chương trình "Hello, world!" cho bạn, giống như cái mà chúng ta đã viết trong Listing 1-1! Cho đến nay, sự khác biệt giữa dự án của chúng ta và dự án mà Cargo đã tạo là Cargo đặt mã trong thư mục src và chúng ta có một tệp cấu hình Cargo.toml ở thư mục cấp cao nhất.

Cargo mong muốn các tệp mã nguồn của bạn nằm trong thư mục src. Thư mục dự án cấp cao nhất chỉ dành cho các tệp README, thông tin giấy phép, các tệp cấu hình và bất kỳ thứ gì khác không liên quan đến mã của bạn. Sử dụng Cargo giúp bạn tổ chức các dự án. Có một vị trí cho mọi thứ, và mọi thứ đều ở đúng vị trí.

Nếu bạn đã bắt đầu một dự án không sử dụng Cargo, như chúng ta đã làm với dự án "Hello, world!", bạn có thể chuyển đổi nó thành một dự án sử dụng Cargo. Di chuyển mã dự án vào thư mục src và tạo một tệp Cargo.toml thích hợp. Một cách dễ dàng để có được tệp Cargo.toml đó là chạy cargo init, nó sẽ tạo tự động cho bạn.

Xây dựng và chạy một dự án Cargo

Bây giờ hãy xem có gì khác khi chúng ta xây dựng và chạy chương trình "Hello, world!" với Cargo! Từ thư mục hello_cargo của bạn, xây dựng dự án của bạn bằng cách nhập 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

Lệnh này tạo một tệp thực thi trong target/debug/hello_cargo (hoặc target\debug\hello_cargo.exe trên Windows) thay vì trong thư mục hiện tại của bạn. Vì bản dựng mặc định là bản dựng debug, Cargo đặt tệp nhị phân vào một thư mục có tên debug. Bạn có thể chạy tệp thực thi bằng lệnh này:

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

Nếu mọi việc suôn sẻ, Hello, world! sẽ được in ra terminal. Chạy cargo build lần đầu tiên cũng khiến Cargo tạo một tệp mới ở cấp cao nhất: Cargo.lock. Tệp này theo dõi các phiên bản chính xác của các phụ thuộc trong dự án của bạn. Dự án này không có phụ thuộc, vì vậy tệp hơi thưa thớt. Bạn sẽ không bao giờ cần thay đổi tệp này theo cách thủ công; Cargo quản lý nội dung của nó cho bạn.

Chúng ta vừa xây dựng một dự án 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 mã và sau đó chạy tệp thực thi kết quả tất cả trong một lệnh:

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

Sử dụng cargo run thuận tiện hơn việc phải nhớ chạy cargo build và sau đó sử dụng toàn bộ đường dẫn đến tệp nhị phân, vì vậy hầu hết các nhà phát triển sử dụng cargo run.

Lưu ý rằng lần này chúng ta không thấy đầu ra cho biết rằng Cargo đang biên dịch hello_cargo. Cargo nhận ra rằng các tệp không thay đổi, vì vậy nó đã không xây dựng lại mà chỉ chạy tệp nhị phân. Nếu bạn đã sửa đổi mã nguồn, Cargo sẽ xây dựng lại dự án trước khi chạy nó, và bạn sẽ thấy đầu ra 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 cũng cung cấp một lệnh có tên là cargo check. Lệnh này nhanh chóng kiểm tra mã của bạn để đảm bảo nó biên dịch được nhưng không tạo ra tệp 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

Tại sao bạn lại không muốn có một tệp thực thi? Thông thường, cargo check nhanh hơn nhiều so với cargo build vì nó bỏ qua bước tạo ra tệp thực thi. Nếu bạn đang liên tục kiểm tra công việc của mình trong khi viết mã, việc sử dụng cargo check sẽ tăng tốc quá trình cho bạn biết liệu dự án của bạn vẫn đang biên dịch hay không! Như vậy, nhiều Rustacean chạy cargo check định kỳ khi họ viết chương trình của họ để đảm bảo nó biên dịch. Sau đó, họ chạy cargo build khi họ sẵn sàng sử dụng tệp thực thi.

Hãy tổng kết những gì chúng ta đã học được cho đến nay về Cargo:

• Chúng ta có thể tạo một dự án bằng cargo new.
• Chúng ta có thể xây dựng một dự án bằng cargo build.
• Chúng ta có thể xây dựng và chạy một dự án trong một bước bằng cargo run.
• Chúng ta có thể xây dựng một dự án mà không tạo ra tệp nhị phân để kiểm tra lỗi bằng cargo check.
• Thay vì lưu kết quả của bản dựng trong cùng thư mục với mã của chúng ta, Cargo lưu trữ nó trong thư mục target/debug.

Một lợi ích bổ sung của việc sử dụng Cargo là các lệnh giống nhau bất kể bạn đang làm việc trên hệ điều hành nào. Vì vậy, tại thời điểm này, chúng tôi sẽ không cung cấp hướng dẫn cụ thể cho Linux và macOS so với Windows nữa.

Build cho release (phát hành)

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

Cargo như là một quy chuẩn

Với các dự án đơn giản, Cargo không cung cấp nhiều giá trị hơn so với chỉ 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 trở nên phức tạp hơn. Khi chương trình phát triển thành nhiều tệp hoặc cần một phụ thuộc, thì sẽ dễ dàng hơn nhiều để Cargo phối hợp việc xây dựng.

Mặc dù dự án hello_cargo đơn giản, nhưng bây giờ nó sử dụng nhiều công cụ thực tế mà bạn sẽ sử dụng trong phần còn lại của sự nghiệp Rust của mình. Trên thực tế, để làm việc trên bất kỳ dự án hiện có nào, bạn có thể sử dụng các lệnh sau để kiểm tra mã sử dụng Git, thay đổi thành thư mục của dự án đó, và xây dựng:

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

Để biết thêm thông tin về Cargo, hãy xem tài liệu của nó.

Tóm tắt

Bạn đã có một khởi đầu tuyệt vời cho hành trình Rust của mình! Trong chương này, bạn đã học cách:

• Cài đặt phiên bản Rust ổn định mới nhất sử dụng rustup
• Cập nhật lên phiên bản Rust mới hơn
• Mở tài liệu đã cài đặt cục bộ
• Viết và chạy chương trình "Hello, world!" sử dụng rustc trực tiếp
• Tạo và chạy một dự án mới sử dụng các quy ước của Cargo

Đây là thời điểm tuyệt vời để xây dựng một chương trình đáng kể hơn để làm quen với việc đọc và viết mã Rust. Vì vậy, trong Chương 2, chúng ta sẽ xây dựng một chương trình trò chơi đoán số. Nếu bạn thích bắt đầu bằng cách học cách các khái niệm lập trình phổ biến hoạt động trong Rust, hãy xem Chương 3 và sau đó quay lại Chương 2.

Lập Trình Một Trò Chơi Đoán Số

Hãy cùng bắt đầu làm quen với Rust thông qua một dự án thực tế! Chương này sẽ giới thiệu cho bạn một số khái niệm phổ biến trong Rust bằng cách hướng dẫn bạn sử dụng chúng trong một chương trình thực tế. Bạn sẽ học về let, match, phương thức, hàm liên kết, crate bên ngoài và nhiều hơn nữa! Trong các 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 chỉ cần thực hành những kiến thức cơ bản.

Chúng ta sẽ triển khai một bài tập lập trình cổ điển dành cho người mới bắt đầu: trò chơi đoán số. Trò chơi hoạt động như sau: chương trình sẽ tạo ra một số nguyên ngẫu nhiên từ 1 đến 100. Sau đó, chương trình sẽ yêu cầu người chơi nhập vào một số để đoán. Sau khi nhập số đoán, chương trình sẽ cho biết số đoán đó là quá nhỏ hay quá lớn. Nếu số đoán chính xác, trò chơi sẽ in ra thông báo chúc mừng và kết thúc.

Thiết Lập Một Dự Án Mới

Để thiết lập một dự án mới, hãy đi đến thư mục projects mà bạn đã tạo trong Chương 1 và tạo một dự án mới bằng Cargo, như sau:

$ cargo new guessing_game
$ cd guessing_game

Lệnh đầu tiên, cargo new, lấy tên của dự án (guessing_game) làm đối số đầu tiên. Lệnh thứ hai sẽ chuyển đến thư mục của dự án mới.

Hãy xem file Cargo.toml đã được tạo ra:

Filename: Cargo.toml

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

[dependencies]

Như bạn đã thấy trong Chương 1, cargo new tạo ra một chương trình “Hello, world!” cho bạn. Hãy xem file src/main.rs:

Filename: src/main.rs

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

Bây giờ hãy biên dịch chương trình “Hello, world!” này và chạy nó trong cùng một bước bằng cách sử dụng lệnh cargo run:

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

Lệnh run rất hữu ích khi bạn cần lặp lại nhanh chóng trên một dự án, như chúng ta sẽ làm trong trò chơi này, nhanh chóng kiểm tra từng lần lặp trước khi chuyển sang lần tiếp theo.

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

Xử Lý Một Số Đoán

Phần đầu tiên của chương trình trò chơi đoán số sẽ yêu cầu người dùng nhập vào, xử lý đầu vào đó và kiểm tra xem đầu vào có đúng dạng mong đợi hay không. Để bắt đầu, chúng ta sẽ cho phép người chơi nhập vào một số đoán. Nhập mã trong Listing 2-1 vào 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}");
}

Mã này chứa rất nhiều thông tin, vì vậy hãy đi qua từng dòng một. Để lấy đầu vào từ người dùng và sau đó in kết quả ra màn hình, chúng ta cần đưa thư viện đầu vào/đầu ra io vào phạm vi. Thư viện io đến từ thư viện tiêu chuẩn, được gọ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}");
}

Theo mặc định, Rust có một tập hợp các mục được định nghĩa trong thư viện tiêu chuẩn mà nó đưa vào phạm vi của mọi chương trình. Tập hợp này được gọi là prelude, và bạn có thể xem tất cả trong tài liệu thư viện tiêu chuẩn.

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

Như bạn đã thấy trong Chương 1, hàm main là điểm vào của 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 một hàm mới; dấu ngoặc đơn, (), chỉ ra rằng không có tham số; và dấu ngoặc nhọn, {, bắt đầu thân của hàm.

Như bạn cũng đã học trong Chương 1, println! là một macro in một chuỗi ra 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}");
}

Mã này đang in ra một lời nhắc cho biết trò chơi là gì và yêu cầu đầu vào từ người dùng.

Lưu Trữ Giá Trị Với Biến

Tiếp theo, chúng ta sẽ tạo một biến để lưu trữ đầu vào từ 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 trở nên thú vị! Có rất nhiều điều đang diễn ra trong dòng nhỏ này. Chúng ta sử dụng câu lệnh let để tạo biến. Đây là một ví dụ khác:

let apples = 5;

Dòng này tạo ra một biến mới có tên là apples và gán nó với giá trị 5. Trong Rust, các biến mặc định là không thay đổi, có nghĩa là một khi chúng ta gán giá trị cho biến, giá trị đó sẽ không thay đổi. Chúng ta sẽ thảo luận chi tiết về khái niệm này trong phần “Biến và Tính Không Thay Đổi” trong Chương 3. Để làm cho một biến có thể thay đổi, chúng ta thêm mut trước tên biến:

let apples = 5; // không thay đổi
let mut bananas = 5; // có thể thay đổi

Lưu ý: Cú pháp // bắt đầu một bình luận kéo dài đến cuối dòng. Rust bỏ qua mọi thứ trong bình luận. Chúng ta sẽ thảo luận chi tiết về bình luận trong Chương 3.

Quay lại chương trình trò chơi đoán số, bây giờ bạn đã biết rằng let mut guess sẽ giới thiệu một biến có thể thay đổi có tên là guess. Dấu bằng (=) cho Rust biết chúng ta muốn gán một cái gì đó cho biến ngay bây giờ. Ở bên phải của dấu bằng là giá trị mà guess được gán, đó là kết quả của việc gọi String::new, một hàm trả về một phiên bản mới của một String. String là một kiểu chuỗi được cung cấp bởi thư viện tiêu chuẩn, là một đoạn văn bản có thể mở rộng, được mã hóa UTF-8.

Cú pháp :: trong dòng ::new chỉ ra rằng new là một hàm liên kết của kiểu String. Một hàm liên kết là một hàm được triển khai 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, trống. Bạn sẽ tìm thấy một hàm new trên nhiều kiểu vì nó là một tên phổ biến cho một hàm tạo ra một giá trị mới của một loại nào đó.

Tóm lại, dòng let mut guess = String::new(); đã tạo ra một biến có thể thay đổi hiện đang được gán với một phiên bản mới, trống của một String. Whew!

Nhận Đầu Vào Từ Người Dùng

Nhớ lại rằng chúng ta đã bao gồm chức năng đầu vào/đầu ra từ thư viện tiêu chuẩn với use std::io; ở 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, điều này sẽ cho phép chúng ta xử lý đầu vào 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 không nhập module io với use std::io; ở đầu chương trình, chúng ta vẫn có thể sử dụng hàm này bằng cách viết lời gọi hàm này là std::io::stdin. Hàm stdin trả về một phiên bản của std::io::Stdin, là một kiểu đại diện cho một tay cầm đến đầu vào tiêu chuẩn cho terminal của bạn.

Tiếp theo, dòng .read_line(&mut guess) gọi phương thức read_line trên tay cầm đầu vào tiêu chuẩn để lấy đầu vào từ người dùng. Chúng ta cũng đang truyền &mut guess làm đối số cho read_line để cho nó biết chuỗi nào để lưu trữ đầu vào từ người dùng. Công việc đầy đủ của read_line là lấy bất cứ thứ gì người dùng nhập vào đầu vào tiêu chuẩn và thêm vào một chuỗi (mà không ghi đè nội dung của nó), vì vậy chúng ta truyền chuỗi đó làm đối số. Đối số chuỗi cần phải có thể thay đổi để phương thức có thể thay đổi nội dung của chuỗi.

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

Xử Lý Khả Năng Thất Bại Với Result

Chúng ta vẫn đang làm việc trên dòng mã này. Chúng ta hiện đang thảo luận về dòng văn bản thứ ba, nhưng lưu ý rằng nó vẫn là một phần của một dòng mã logic duy nhất. 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ể đã viết mã này như sau:

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

Tuy nhiên, một dòng dài rất khó đọc, vì vậy tốt nhất là chia nó ra. Thường thì nên giới thiệu một dòng mới và các khoảng trắng khác để giúp chia nhỏ các 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ờ hãy thảo luận về những gì dòng này làm.

Như đã đề cập trước đó, read_line đặt bất cứ thứ gì người dùng nhập vào chuỗi mà chúng ta truyền cho nó, nhưng nó cũng trả về một giá trị Result. Result là một liệt kê, thường được gọi là enum, là một kiểu có thể ở một trong nhiều trạng thái có thể. Chúng ta gọi mỗi trạng thái có thể là một biến thể.

Chương 6 sẽ bao gồm các enum chi tiết hơn. Mục đích của các kiểu Result này 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 hoạt động đã thành công, và nó chứa giá trị được tạo ra thành công. Biến thể Err có nghĩa là hoạt động đã thất bại, và nó chứa thông tin về cách hoặc lý do tại sao hoạt động thất bại.

Các giá trị của kiểu Result, giống như các giá trị của bất kỳ kiểu nào, có các phương thức được định nghĩa trên chúng. Một phiên bản của Result có một phương thức expect mà bạn có thể gọi. Nếu phiên bản này của Result là một giá trị Err, expect sẽ làm cho chương trình bị sập và hiển thị thông báo mà bạn đã truyền làm đối số cho expect. Nếu phương thức read_line trả về một Err, nó có thể là kết quả của một lỗi đến từ hệ điều hành cơ bản. Nếu phiên bản này của Result là một giá trị Ok, expect sẽ lấy giá trị trả về mà Ok đang giữ và trả về chỉ giá trị đó cho bạn để bạn có thể sử dụng nó. Trong trường hợp này, giá trị đó là số byte trong đầu vào của người dùng.

Nếu bạn không gọi expect, chương trình sẽ biên dịch, nhưng bạn sẽ nhận được một 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: this `Result` may be an `Err` variant, which should be handled
   = note: `#[warn(unused_must_use)]` on by default
help: use `let _ = ...` to ignore the resulting value
   |
10 |     let _ = io::stdin().read_line(&mut guess);
   |     +++++++

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

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

Cách đúng để loại bỏ cảnh báo là thực sự viết mã xử lý lỗi, nhưng trong trường hợp của chúng ta, chúng ta chỉ muốn làm cho chương trình này bị sập khi có vấn đề xảy ra, vì vậy chúng ta có thể sử dụng expect. Bạn sẽ học về cách khôi phục từ lỗi trong Chương 9.

In Giá Trị Với println! Placeholder

Ngoài dấu ngoặc nhọn đóng, chỉ còn một dòng nữa để thảo luận trong mã cho đến nay:

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 chuỗi hiện chứa đầu vào của người dùng. Bộ {} của dấu ngoặc nhọn là một placeholder: hãy nghĩ về {} như những cái kẹp nhỏ giữ một giá trị tại chỗ. Khi in giá trị của một biến, tên biến có thể được đặt bên trong dấu ngoặc nhọn. Khi in kết quả của việc đánh giá một biểu thức, đặt dấu ngoặc nhọn trống trong chuỗi định dạng, sau đó theo sau chuỗi định dạng với một danh sách các biểu thức được phân tách bằng dấu phẩy để in trong mỗi placeholder dấu ngoặc nhọn trống theo cùng thứ tự. In một biến và kết quả của một biểu thức trong một lần gọi println! sẽ trông như thế này:

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

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

Mã này sẽ in x = 5 and y + 2 = 12.

Kiểm Tra Phần Đầu Tiên

Hãy kiểm tra phần đầu tiên của trò chơi đoán số. Chạy nó bằng cách sử dụng cargo run:

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

Tại thời điểm này, phần đầu tiên của trò chơi đã hoàn thành: chúng ta đang nhận đầu vào từ bàn phím và sau đó in nó ra.

Tạo Một Số Bí Mật

Tiếp theo, chúng ta cần tạo ra một số bí mật mà người dùng sẽ cố gắng đoán. Số bí mật nên khác nhau mỗi lần để trò chơi thú vị hơn khi chơi nhiều lần. Chúng ta sẽ sử dụng một số ngẫu nhiên từ 1 đến 100 để trò chơi không quá khó. Rust chưa bao gồm chức năng tạo số ngẫu nhiên trong thư viện tiêu chuẩn của nó. Tuy nhiên, nhóm Rust cung cấp một crate rand với chức năng này.

Sử Dụng Một Crate Để Có Thêm Chức Năng

Nhớ rằng một crate là một tập hợp các file mã nguồn Rust. Dự án mà chúng ta đã xây dựng là một binary crate, là một tệp thực thi. Crate rand là một library crate, chứa mã được sử dụng trong các chương trình khác và không thể thực thi độc lập.

Sự phối hợp của Cargo với các crate bên ngoài là nơi Cargo thực sự tỏa sáng. Trước khi chúng ta có thể viết mã sử dụng rand, chúng ta cần sửa đổi file Cargo.toml để bao gồm crate rand làm phụ thuộc. Mở file đó ngay bây giờ và thêm dòng sau vào cuối, bên dưới phần tiêu đề [dependencies] mà Cargo đã tạo cho bạn. Hãy chắc chắn chỉ định rand chính xác như chúng tôi đã làm ở đây, với số phiên bản này, hoặc các ví dụ mã trong hướng dẫn này có thể không hoạt động:

Filename: Cargo.toml

[dependencies]
rand = "0.8.5"

Trong file Cargo.toml, mọi thứ theo sau một tiêu đề là một phần của phần đó tiếp tục cho đến khi một phần khác bắt đầu. Trong [dependencies] bạn nói với Cargo những crate bên ngoài mà dự án của bạn phụ thuộc vào và các phiên bản của các crate đó mà bạn yêu cầu. Trong trường hợp này, chúng ta chỉ định crate rand với chỉ định phiên bản ngữ nghĩa 0.8.5. Cargo hiểu Semantic Versioning (đôi khi được gọi là SemVer), là một tiêu chuẩn để viết số phiên bản. Chỉ định 0.8.5 thực sự là viết tắt của ^0.8.5, có nghĩa là bất kỳ phiên bản nào ít nhất là 0.8.5 nhưng dưới 0.9.0.

Cargo coi các phiên bản này có API công khai tương thích với phiên bản 0.8.5, và chỉ định này đảm bảo bạn sẽ nhận được bản phát hành vá lỗi mới nhất mà vẫn biên dịch được với mã trong chương này. Bất kỳ phiên bản nào từ 0.9.0 trở lên không được đảm bảo có cùng API như những gì các ví dụ sau đây sử dụng.

Bây giờ, mà không thay đổi bất kỳ mã nào, hãy xây dựng dự án, như được hiển thị trong Listing 2-2.

$ cargo build
  Updating crates.io index
   Locking 15 packages to latest Rust 1.85.0 compatible versions
    Adding rand v0.8.5 (available: v0.9.0)
 Compiling proc-macro2 v1.0.93
 Compiling unicode-ident v1.0.17
 Compiling libc v0.2.170
 Compiling cfg-if v1.0.0
 Compiling byteorder v1.5.0
 Compiling getrandom v0.2.15
 Compiling rand_core v0.6.4
 Compiling quote v1.0.38
 Compiling syn v2.0.98
 Compiling zerocopy-derive v0.7.35
 Compiling zerocopy v0.7.35
 Compiling ppv-lite86 v0.2.20
 Compiling rand_chacha v0.3.1
 Compiling rand v0.8.5
 Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
  Finished `dev` profile [unoptimized + debuginfo] target(s) in 2.48s

Bạn có thể thấy các số phiên bản khác nhau (nhưng tất cả sẽ tương thích với mã, nhờ SemVer!) và các dòng khác nhau (tùy thuộc vào hệ điều hành), và các dòng có thể ở một thứ tự khác.

Khi chúng ta bao gồm một phụ thuộc bên ngoài, Cargo sẽ lấy các phiên bản mới nhất của mọi thứ mà phụ thuộc đó cần từ registry, là một bản sao của dữ liệu từ Crates.io. Crates.io là nơi mọi người trong hệ sinh thái Rust đăng các dự án Rust mã nguồn mở của họ để người khác sử dụng.

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

Nếu bạn ngay lập tức chạy cargo build lại mà không thực hiện bất kỳ thay đổi nào, bạn sẽ không nhận được bất kỳ kết quả nào ngoài dòng Finished. Cargo biết rằng nó đã tải xuống và biên dịch các phụ thuộc, và bạn chưa thay đổi bất kỳ điều gì về chúng trong file Cargo.toml của bạn. Cargo cũng biết rằng bạn chưa thay đổi bất kỳ điều gì về mã của bạn, vì vậy nó không biên dịch lại mã đó. Không có gì để làm, nó chỉ đơn giản thoát ra.

Nếu bạn mở file src/main.rs, thực hiện một thay đổi nhỏ và sau đó lưu nó và xây dựng lại, bạn sẽ chỉ thấy hai dòng kết quả:

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

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

Đảm Bảo Các Bản Dựng Có Thể Tái Tạo Với File Cargo.lock

Cargo có một cơ chế đảm bảo bạn có thể tái tạo cùng một artifact mỗi khi bạn hoặc bất kỳ ai khác xây dựng mã của bạn: Cargo sẽ chỉ sử dụng các phiên bản của các phụ thuộc mà bạn đã chỉ định cho đến khi bạn chỉ định khác. Ví dụ, giả sử rằng tuần tới phiên bản 0.8.6 của crate rand ra mắt, và phiên bản đó chứa một bản sửa lỗi quan trọng, nhưng nó cũng chứa một lỗi hồi quy sẽ làm hỏng mã của bạn. Để xử lý điều này, Rust tạo file Cargo.lock lần đầu tiên bạn chạy cargo build, vì vậy bây giờ chúng ta có file này trong thư mục guessing_game.

Khi bạn xây dựng một dự án lần đầu tiên, Cargo sẽ tìm ra tất cả các phiên bản của các phụ thuộc phù hợp với tiêu chí và sau đó ghi chúng vào file Cargo.lock. Khi bạn xây dựng dự án của mình trong tương lai, Cargo sẽ thấy rằng file Cargo.lock tồn tại và sẽ sử dụng các phiên bản được chỉ định ở đó thay vì làm tất cả công việc tìm ra các phiên bản lại. Điều này cho phép bạn có một bản dựng có thể tái tạo tự động. Nói cách khác, dự án của bạn sẽ vẫn ở phiên bản 0.8.5 cho đến khi bạn nâng cấp rõ ràng, nhờ vào file Cargo.lock. Vì file Cargo.lock quan trọng đối với các bản dựng có thể tái tạo, nó thường được kiểm tra vào kiểm soát nguồn cùng với phần còn lại của mã trong dự án của bạn.

Cập Nhật Một Crate Để Nhận Phiên Bản Mới

Khi bạn muốn cập nhật một crate, Cargo cung cấp lệnh update, lệnh này sẽ bỏ qua file Cargo.lock và tìm ra tất cả các phiên bản mới nhất phù hợp với các chỉ định của bạn trong Cargo.toml. Cargo sau đó sẽ ghi các phiên bản đó vào file Cargo.lock. Trong trường hợp này, Cargo sẽ chỉ tìm các phiên bản lớn hơn 0.8.5 và nhỏ hơn 0.9.0. Nếu crate rand đã phát hành hai phiên bản mới 0.8.6 và 0.9.0, bạn sẽ thấy điều sau nếu bạn chạy cargo update:

$ cargo update
    Updating crates.io index
     Locking 1 package to latest Rust 1.85.0 compatible version
    Updating rand v0.8.5 -> v0.8.6 (available: v0.9.0)

Cargo bỏ qua phiên bản 0.9.0. Tại thời điểm này, bạn cũng sẽ nhận thấy một thay đổi trong file Cargo.lock ghi nhận rằng phiên bản của crate rand mà bạn đang sử dụng bây giờ là 0.8.6. Để sử dụng phiên bản 0.9.0 của rand hoặc bất kỳ phiên bản nào trong loạt 0.9.x, bạn sẽ phải cập nhật file Cargo.toml để trông như thế này:

[dependencies]
rand = "0.9.0"

Lần tiếp theo bạn chạy cargo build, Cargo sẽ cập nhật registry của các crate có sẵn và đánh giá lại các yêu cầu của bạn về rand theo phiên bản mới mà bạn đã chỉ định.

Có rất nhiều điều để nói về Cargo và hệ sinh thái của nó, mà chúng ta sẽ thảo luận trong Chương 14, nhưng hiện tại, đó là tất cả những gì bạn cần biết. Cargo làm cho việc tái sử dụng các thư viện rất dễ dàng, vì vậy các Rustaceans có thể viết các dự án nhỏ hơn được lắp ráp từ một số gói.

Tạo Một Số Ngẫu Nhiên

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

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}");
}

Đầu tiên chúng ta thêm dòng use rand::Rng;. Trait Rng định nghĩa các phương thức mà các bộ tạo số ngẫu nhiên triển khai, và trait này phải nằm trong phạm vi để chúng ta sử dụng các phương thức đó. Chương 10 sẽ bao gồm các trait chi tiết.

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

Lưu ý: Bạn sẽ không chỉ biết các trait nào để sử dụng và các phương thức và hàm nào để gọi từ một crate, vì vậy mỗi crate có tài liệu với hướng dẫn sử dụng nó. Một tính năng thú vị khác của Cargo là chạy lệnh cargo doc --open sẽ xây dựng tài liệu được cung cấp bởi tất cả các phụ thuộc của bạn cục bộ và mở nó trong trình duyệt của bạn. Nếu bạn quan tâm đến các chức năng khác trong crate rand, ví dụ, hãy chạy cargo doc --open và nhấp vào rand trong thanh bên trái.

Dòng mới thứ hai in ra số bí mật. Điều này hữu ích trong khi chúng ta đang phát triển chương trình để có thể kiểm tra nó, nhưng chúng ta sẽ xóa nó khỏi phiên bản cuối cùng. Nó không phải là một trò chơi nếu chương trình in ra câu trả lời ngay khi nó bắt đầu!

Hãy thử chạy chương trình một vài lần:

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.02s
     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` profile [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 nên nhận được các số ngẫu nhiên khác nhau, và tất cả chúng nên là các số từ 1 đến 100. Làm tốt lắm!

So Sánh Số Đoán Với Số Bí Mật

Bây giờ chúng ta đã có đầu vào từ người dùng và một số ngẫu nhiên, chúng ta có thể so sánh chúng. Bước đó được hiển thị trong Listing 2-4. Lưu ý rằng mã này sẽ không biên dịch ngay lập tức, như chúng ta sẽ giải thích.

use std::cmp::Ordering;
use std::io;

use rand::Rng;

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!"),
    }
}

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

Sau đó, chúng ta thêm năm dòng mới ở 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. Nó lấy một tham chiếu đến bất kỳ thứ gì bạn muốn so sánh: ở đây nó đang so sánh guess với secret_number. Sau đó, nó trả về một biến thể của enum Ordering mà chúng ta đã đưa vào phạm vi với câu lệnh use. Chúng ta sử dụng một biểu thức match để quyết định làm gì tiếp theo dựa trên biến thể nào của Ordering được trả về từ lời gọi đến cmp với các giá trị trong guess và secret_number.

Một biểu thức match được tạo thành từ các nhánh. Một nhánh bao gồm một mẫu để so khớp, và mã sẽ được chạy nếu giá trị được đưa vào match phù hợp với mẫu của nhánh đó. Rust lấy giá trị được đưa vào match và xem qua mẫu của từng nhánh lần lượt. Các mẫu và cấu trúc match là các tính năng mạnh mẽ của Rust: chúng cho phép bạn biểu đạt nhiều tình huống mà mã của bạn có thể gặp phải và chúng đảm bảo bạn xử lý tất cả chúng. Các tính năng này sẽ được bao gồm chi tiết trong Chương 6 và Chương 19, tương ứng.

Hãy đi qua một ví dụ với biểu thức match mà chúng ta sử dụng ở đây. Giả sử rằng người dùng đã đoán 50 và số bí mật được tạo ngẫu nhiên lần này là 38.

Khi mã so sánh 50 với 38, phương thức cmp sẽ trả về Ordering::Greater vì 50 lớn hơn 38. Biểu thức match nhận giá trị Ordering::Greater và bắt đầu kiểm tra mẫu của từng nhánh. Nó xem mẫu của nhánh đầu tiên, Ordering::Less, và thấy rằng giá trị Ordering::Greater không phù hợp với Ordering::Less, vì vậy nó bỏ qua mã trong nhánh đó và chuyển sang nhánh tiếp theo. Mẫu của nhánh tiếp theo là Ordering::Greater, điều này phù hợp với Ordering::Greater! Mã liên kết trong nhánh đó sẽ được thực thi và in ra Too big! trên màn hình. Biểu thức match kết thúc sau khi khớp thành công đầu tiên, vì vậy nó sẽ không xem nhánh cuối cùng trong tình huống này.

Tuy nhiên, mã trong Listing 2-4 sẽ không biên dịch ngay lập tức. Hãy thử nó:

$ 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.5
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
error[E0308]: mismatched types
  --> src/main.rs:23:21
   |
23 |     match guess.cmp(&secret_number) {
   |                 --- ^^^^^^^^^^^^^^ expected `&String`, found `&{integer}`
   |                 |
   |                 arguments to this method are incorrect
   |
   = note: expected reference `&String`
              found reference `&{integer}`
note: method defined here
  --> /rustc/4eb161250e340c8f48f66e2b929ef4a5bed7c181/library/core/src/cmp.rs:964:8

For more information about this error, try `rustc --explain E0308`.
error: could not compile `guessing_game` (bin "guessing_game") due to 1 previous error

Lỗi cốt lõi cho biết rằng có các kiểu không khớp. Rust có một hệ thống kiểu mạnh mẽ và tĩnh. Tuy nhiên, nó cũng có suy luận kiểu. Khi chúng ta viết let mut guess = String::new(), Rust có thể suy luận rằng guess nên là một String và không bắt chúng ta phải viết kiểu. Mặt khác, secret_number là một kiểu số. 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ố 32-bit không dấu; i64, một số 64-bit; cũng như các kiểu khác. Trừ khi được chỉ định khác, Rust mặc định là một i32, đó là kiểu của secret_number trừ khi bạn thêm thông tin kiểu ở nơi khác để Rust suy luận một kiểu số khác. Lý do cho lỗi là Rust không thể so sánh một chuỗi và một kiểu số.

Cuối cùng, chúng ta muốn chuyển đổi String mà chương trình đọc làm đầu vào thành một kiểu số để chúng ta có thể so sánh nó 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 thân hàm main:

Filename: src/main.rs

use std::cmp::Ordering;
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.");

    // --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 này là:

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

Chúng ta tạo một biến có tên là guess. Nhưng chờ đã, chương trình đã có một biến có tên là guess chưa? Đúng vậy, nhưng may mắn thay Rust cho phép chúng ta che bóng giá trị trước đó của guess bằng một giá trị mới. Che bóng cho phép chúng ta tái sử dụng tên biến guess thay vì buộc chúng ta phải tạo hai biến duy nhất, chẳng hạn như guess_str và guess, ví dụ. Chúng ta sẽ bao gồm điều này chi tiết hơn trong Chương 3, nhưng hiện tại, hãy biết rằng tính năng này thường được sử dụng khi bạn muốn chuyển đổi một giá trị từ một kiểu sang một kiểu khác.

Chúng ta gán biến mới này với biểu thức guess.trim().parse(). guess trong biểu thức đề cập đến biến guess ban đầu chứa đầu vào dưới dạng chuỗi. Phương thức trim trên một phiên bản String sẽ loại bỏ bất kỳ khoảng trắng nào ở đầu và cuối, điều mà chúng ta phải làm trước khi có thể chuyển đổi chuỗi thành một u32, chỉ có thể chứa dữ liệu số. Người dùng phải nhấn enter để thỏa mãn read_line và nhập số đoán của họ, điều này thêm một ký tự xuống dòng vào chuỗi. Ví dụ, nếu người dùng nhập 5 và nhấn enter, guess trông như thế này: 5\n. \n đại diện cho “xuống dòng.” (Trên Windows, nhấn enter sẽ dẫn đến một ký tự xuống dòng và một ký tự trở về, \r\n.) Phương thức trim loại bỏ \n hoặc \r\n, chỉ để lại 5.

Phương thức parse trên chuỗi chuyển đổi một chuỗi thành một kiểu khác. Ở đây, chúng ta sử dụng nó để chuyển đổi từ một chuỗi thành một số. Chúng ta cần nói với Rust kiểu số chính xác mà chúng ta muốn bằng cách sử dụng let guess: u32. Dấu hai chấm (:) sau guess cho Rust biết rằng chúng ta sẽ chú thích kiểu của biến. Rust có một vài kiểu số tích hợp; u32 được thấy ở đây là một số nguyên 32-bit không dấu. Đó là một lựa chọn mặc định tốt cho một số dương nhỏ. Bạn sẽ học về các kiểu số khác trong Chương 3.

Ngoài ra, chú thích u32 trong chương trình ví dụ này và so sánh với secret_number có nghĩa là Rust sẽ suy luận rằng secret_number cũng nên là một u32. Vì vậy, bây giờ so sánh sẽ là giữa hai giá trị cùng kiểu!

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

Hãy chạy chương trình ngay bây giờ:

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

Tuyệt vời! Mặc dù đã thêm các khoảng trắng trước số đoán, chương trình vẫn nhận ra rằng người dùng đã đoán 76. Chạy chương trình một vài lần để xác minh hành vi khác nhau với các loại đầu vào khác nhau: đoán số chính xác, đoán một số quá lớn và đoán một số quá nhỏ.

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

Cho Phép Nhiều Lần Đoán Với 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 phép người dùng có nhiều cơ hội đoán số hơn:

Filename: src/main.rs

use std::cmp::Ordering;
use std::io;

use rand::Rng;

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 có thể thấy, chúng ta đã di chuyển mọi thứ từ lời nhắc nhập số đoán trở đi vào một vòng lặp. Hãy chắc chắn thụt lề các dòng bên trong vòng lặp thêm bốn khoảng trắng mỗi dòng và chạy chương trình lại. Chương trình bây giờ sẽ yêu cầu một số đoán khác mãi mãi, điều này thực sự giới thiệu một vấn đề mới. Dường như người dùng không thể thoát ra!

Người dùng luôn có thể ngắt chương trình bằng cách sử dụng phím tắt ctrl-c. Nhưng có một cách khác để thoát khỏi con quái vật không thể thỏa mãn này, như đã đề cập trong phần thảo luận về parse trong “So Sánh Số Đoán Với Số Bí Mật”: nếu người dùng nhập một câu trả lời không phải là số, chương trình sẽ bị sập. Chúng ta có thể tận dụng điều đó để cho phép người dùng thoát ra, như được hiển thị ở đây:

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.23s
     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 src/main.rs:28:47:
Please type a number!: ParseIntError { kind: InvalidDigit }
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Nhập quit sẽ thoát khỏi trò chơi, nhưng như bạn sẽ nhận thấy, việc nhập bất kỳ đầu vào không phải là số nào khác cũng sẽ thoát ra. Điều này là không tối ưu, ít nhất là; chúng ta muốn trò chơi cũng dừng lại khi số đoán chính xác.

Thoát Sau Khi Đoán Đúng

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

Filename: src/main.rs

use std::cmp::Ordering;
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}");

    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 khỏi vòng lặp khi người dùng đoán đúng số bí mật. Thoát khỏi vòng lặp cũng có nghĩa là thoát khỏi chương trình, 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ệ

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

use std::cmp::Ordering;
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}");

    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;
            }
        }
    }
}

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

Nếu parse có thể chuyển đổi thành công chuỗi thành một số, nó sẽ trả về một giá trị Ok chứa số kết quả. Giá trị Ok đó sẽ khớp với mẫu của nhánh đầu tiên, và biểu thức match sẽ chỉ trả về giá trị num mà parse đã tạo ra và đặt bên trong giá trị Ok. Số đó sẽ kết thúc ngay tại nơi chúng ta muốn trong biến guess mới mà chúng ta đang tạo.

Nếu parse không thể chuyển đổi chuỗi thành một số, nó sẽ trả về một giá trị Err chứa thêm thông tin về lỗi. Giá trị Err không khớp với mẫu Ok(num) trong nhánh đầu tiên của match, nhưng nó khớp với mẫu Err(_) trong nhánh thứ hai. Dấu gạch dưới, _, là một giá trị bắt tất cả; trong ví dụ này, chúng ta đang nói rằng chúng ta muốn khớp với tất cả các giá trị Err, bất kể thông tin nào chúng có bên trong. Vì vậy, chương trình sẽ thực thi mã của nhánh thứ hai, continue, điều này cho chương trình biết đi đến lần lặp tiếp theo của loop và yêu cầu một số đoán khác. Vì vậy, về cơ bản, chương trình bỏ qua tất cả các lỗi mà parse có thể gặp phải!

Bây giờ mọi thứ trong chương trình nên hoạt động như mong đợi. Hãy thử nó:

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.13s
     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 tinh chỉnh nhỏ cuối cùng, chúng ta sẽ hoàn thành trò chơi đoán số. Nhớ rằng chương trình vẫn đang in ra số bí mật. Điều đó hoạt động tốt cho việc kiểm tra, nhưng nó làm hỏng trò chơi. Hãy xóa println! in ra số bí mật. Listing 2-6 hiển thị mã hoàn chỉnh.

use std::cmp::Ordering;
use std::io;

use rand::Rng;

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;
            }
        }
    }
}

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

Tóm Tắt

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

Các Khái Niệm Lập Trình Phổ Biến

Chương này bao gồm các khái niệm xuất hiện trong hầu hết 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 ở cốt lõi. Không có khái niệm nào được trình bày trong chương này là độc quyền của Rust, nhưng chúng ta sẽ thảo luận về chúng trong bối cảnh của 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ẽ học về biến, các kiểu dữ liệu cơ bản, hàm, bình luận, và luồng điều khiển. Những nền tảng này sẽ có trong mọi chương trình Rust, và việc học chúng sớm sẽ giúp bạn có một nền tảng vững chắc để bắt đầu.

Từ khóa

Ngôn ngữ Rust có một tập hợp các từ khóa được dành riêng để sử dụng bởi ngôn ngữ này, tương tự như trong các ngôn ngữ khác. Hãy lưu ý rằng bạn không thể sử dụng những từ này làm tên của biến hoặc hàm. Hầu hết các từ khóa đều có ý nghĩa đặc biệt, và bạn sẽ sử dụng chúng để thực hiện các nhiệm vụ khác nhau trong chương trình Rust của mình; một số ít không có chức năng cụ thể nào liên quan đến 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 và Tính Khả Biến

Như đã đề cập trong phần "Lưu Trữ Giá Trị với Biến", theo mặc định, các biến là không thể thay đổi (immutable). Đây là một trong nhiều sự hướng dẫn mà Rust cung cấp cho bạn để viết code theo cách tận dụng lợi thế về tính an toàn và dễ dàng trong xử lý đồng thời mà Rust mang lại. Tuy nhiên, bạn vẫn có tùy chọn để làm cho các biến của mình có thể thay đổi (mutable). Hãy cùng khám phá 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 và lý do tại sao đôi khi bạn có thể muốn lựa chọn khác.

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

Sau đó, trong thư mục variables mới của bạn, mở src/main.rs và thay thế mã của nó bằng đoạn mã sau, mã này sẽ chưa biên dịch được ngay:

Tên tệp: 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 và chạy chương trình bằng cách sử dụng cargo run. Bạn sẽ nhận được thông báo lỗi liên quan đến lỗi bất biến, như được hiển thị trong 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`
3 |     println!("The value of x is: {x}");
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
2 |     let mut x = 5;
  |         +++

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

Ví dụ này cho thấy cách trình biên dịch giúp bạn tìm ra lỗi trong các chương trình của mình. Lỗi biên dịch có thể gây khó chịu, nhưng thực sự chúng chỉ có nghĩa là chương trình của bạn chưa an toàn để thực hiệ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! Ngay cả những người dùng Rust có kinh nghiệm vẫn gặp lỗi biên dịch.

Bạn nhận được thông báo lỗi cannot assign twice to immutable variable `x` bởi vì bạn đã cố gắn một giá trị thứ hai cho biến bất biến x.

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

Nhưng tính khả biến có thể rất hữu ích và có thể làm cho code trở nên thuận tiện hơn khi viết. Mặc dù các biến là bất biến theo mặc định, bạn có thể làm cho chúng trở nên khả biến bằng cách thêm mut trước tên biến như bạn đã làm trong Chương 2. Thêm mut cũng truyền đạt ý định cho 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 src/main.rs thành như sau:

Tên tệp: 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 bây giờ, chúng ta sẽ nhận được:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished `dev` profile [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ới x từ 5 thành 6 khi sử dụng mut. Cuối cùng, quyết định sử dụng tính khả biến hay không tùy thuộc vào bạn và phụ thuộc vào những gì bạn nghĩ là rõ ràng nhất trong tình huống cụ thể đó.

Hằng số

Giống như các biến bất biến, hằng số là các giá trị được gắn với một tên và không được phép thay đổi, nhưng có một vài sự 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ỉ bất biến theo mặc định—chúng luôn bất biến. Bạn khai báo hằng số bằng từ khóa const thay vì từ khóa let, và kiểu của giá trị phải được chú thích. Chúng ta sẽ đề cập đến các kiểu và chú thích kiểu trong phần tiếp theo, "Kiểu Dữ Liệu", vì vậy đừng lo lắng về các chi tiết ngay bây giờ. Chỉ cần biết rằng bạn phải luôn chú thích kiể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, làm cho chúng hữu ích cho các giá trị mà nhiều phần của code cần biết.

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

Đây là một ví dụ về khai báo hằng số:

#![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 đặt thành kết quả của việc nhân 60 (số giây trong một phút) với 60 (số phút trong một giờ) với 3 (số giờ mà chúng ta muốn đếm trong chương trình này). Quy ước đặt tên của Rust cho hằng số là sử dụng tất cả các chữ in hoa với dấu gạch dưới giữa các từ. Trình biên dịch có thể đánh giá một tập hợp giới hạn các hoạt động tại thời điểm biên dịch, cho phép chúng ta chọn cách viết giá trị này theo cách dễ hiểu và xác minh hơn, thay vì đặt hằng số này thành giá trị 10.800. Xem phần đánh giá hằng số trong Rust Reference để biết thêm thông tin về các hoạt động có thể được sử dụng khi khai báo hằng số.

Hằng số có hiệu lực trong suốt 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ố hữu ích cho các giá trị trong lĩnh vực ứng dụng của bạn mà nhiều phần của chương trình có thể cần biết, chẳng hạn như số điểm tối đa mà bất kỳ người chơi nào của trò chơi được phép kiếm được, hoặc tốc độ ánh sáng.

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

Che Khuất (Shadowing)

Như bạn đã thấy trong hướng dẫn trò chơi đ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 với một biến trước đó. Người dùng Rust nói rằng biến đầu tiên bị che khuất bởi biến thứ hai, có nghĩa là biến thứ hai là những gì trình biên dịch sẽ thấy khi bạn sử dụng tên của biến. Trên thực tế, biến thứ hai che khuất biến đầu tiên, lấy bất kỳ việc sử dụng nào của tên biến cho chính nó cho đến khi nó tự bị che khuất hoặc phạm vi kết thúc. Chúng ta có thể che khuất một biến bằng cách sử dụng cùng tên biến và lặp lại việc sử dụng từ khóa let như sau:

Tên tệp: 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}");
}

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

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished `dev` profile [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

Che khuất khác với việc đánh dấu một biến là mut vì chúng ta sẽ gặp lỗi biên dịch 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 vài biến đổi trên một giá trị nhưng làm cho biến đó bất biến sau khi các biến đổi đó đã hoàn thành.

Sự khác biệt khác giữa mut và che khuất là vì chúng ta đang tạo một biến mới khi chúng ta sử dụng từ khóa let lần nữa, chúng ta có thể thay đổi kiểu của giá trị nhưng vẫn tái sử dụng cùng một 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ị số lượng khoảng trắng mà họ muốn giữa một số văn bản 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 là kiểu chuỗi và biến spaces thứ hai là kiểu số. Việc che khuất do đó giúp chúng ta không phải nghĩ ra các tên khác nhau, như spaces_str và spaces_num; thay vào đó, chúng ta có thể tái sử dụng cái tên đơn giản hơn là spaces. Tuy nhiên, nếu chúng ta cố gắng sử dụng mut cho việc này, như được hiển thị ở đây, chúng ta sẽ gặp lỗi biên dịch:

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

Lỗi nói rằng chúng ta không được phép thay đổi kiể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` (bin "variables") due to 1 previous error

Bây giờ chúng ta đã khám phá cách hoạt động của các biến, hãy xem xét nhiều loại dữ liệu khác mà biến có thể có.

Kiểu Dữ Liệu

Mỗi giá trị trong Rust thuộc về một kiểu dữ liệu nhất định, điều này cho Rust biết loại dữ liệu đang được chỉ định để nó biết cách làm việc với dữ liệu đó. Chúng ta sẽ xem xét hai tập con kiểu dữ liệu: kiểu vô hướng (scalar) và kiểu phức hợp (compound).

Hãy nhớ rằng Rust là một ngôn ngữ kiểu tĩnh, nghĩa là nó phải biết kiể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 có thể suy ra kiểu mà chúng ta muốn sử dụng dựa trên giá trị và cách chúng ta sử dụng nó. Trong các trường hợp có nhiều kiểu có thể xảy ra, chẳng hạn như khi chúng ta chuyển đổi một String thành một kiểu số bằng cách sử dụng parse trong phần "So sánh số đoán với số bí mật" ở Chương 2, chúng ta phải thêm chú thích kiể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 : u32 như trong đoạn mã trên, Rust sẽ hiển thị lỗi sau, có nghĩa là trình biên dịch cần thêm thông tin từ chúng ta để biết kiểu nào chúng ta muốn sử dụng:

$ cargo build
   Compiling no_type_annotations v0.1.0 (file:///projects/no_type_annotations)
error[E0284]: type annotations needed
 --> src/main.rs:2:9
  |
2 |     let guess = "42".parse().expect("Not a number!");
  |         ^^^^^        ----- type must be known at this point
  |
  = note: cannot satisfy `<_ as FromStr>::Err == _`
help: consider giving `guess` an explicit type
  |
2 |     let guess: /* Type */ = "42".parse().expect("Not a number!");
  |              ++++++++++++

For more information about this error, try `rustc --explain E0284`.
error: could not compile `no_type_annotations` (bin "no_type_annotations") due to 1 previous error

Bạn sẽ thấy các chú thích kiểu khác nhau cho các kiểu dữ liệu khác.

Kiểu Vô Hướng

Một kiểu vô hướng biểu diễn một giá trị đơn lẻ. Rust có bốn kiểu vô hướng cơ bản: số nguyên, số thực dấu phẩy động, Boolean và ký tự. Có thể bạn đã quen thuộc với những kiểu này từ các ngôn ngữ lập trình khác. Chúng ta hãy xem cách chúng hoạt động trong Rust.

Kiểu Số Nguyên

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

Bảng 3-1: Các Kiểu Số Nguyên trong Rust

Mỗi biến thể có thể có dấu hoặc không dấu và có một kích thước rõ ràng. Có dấu và không dấu đề cập đến việc liệu số đó có thể âm hay không—nói cách khác, liệu số đó cần có dấu kèm theo (có dấu) hay chỉ bao giờ cũng dương và do đó có thể được biểu diễn mà không cần dấu (không dấu). Giống như viết số trên giấy: khi dấu quan trọng, số được hiển thị với dấu cộng hoặc dấu trừ; tuy nhiên, khi có thể giả định rằng số đó là dương, nó được hiển thị không có dấu. Số có dấu được lưu trữ bằng cách sử dụng biểu diễn bù hai.

Mỗi biến thể có dấu có thể lưu trữ số từ −(2^{n − 1}) đến 2^{n − 1} − 1 bao gồm cả hai đầu, trong đó n là số bit mà biến thể đó sử dụng. Vì vậy, i8 có thể lưu trữ số từ −(2⁷) đến 2⁷ − 1, tương đương từ −128 đến 127. Các biến thể không dấu có thể lưu trữ số từ 0 đến 2ⁿ − 1, nên u8 có thể lưu trữ số từ 0 đến 2⁸ − 1, tương đương từ 0 đến 255.

Ngoài ra, các kiểu isize và usize phụ thuộc vào kiến trúc của máy tính mà chương trình của bạn đang chạy: 64 bit nếu bạn đang sử dụng kiến trúc 64 bit và 32 bit nếu bạn đang sử dụng kiến trúc 32 bit.

Bạn có thể viết số nguyên theo bất kỳ dạng nào được hiển thị trong Bảng 3-2. Lưu ý rằng các số nguyên có thể thuộc nhiều kiểu số khác nhau cho phép hậu tố kiểu, chẳng hạn như 57u8, để chỉ định kiểu. Số nguyên cũng có thể sử dụng _ như một dấu phân cách trực quan để làm cho số dễ đọc hơn, chẳng hạn như 1_000, sẽ có giá trị giống như khi bạn chỉ định 1000.

Bảng 3-2: Các Số Nguyên trong Rust

Vậy làm thế nào để biết kiểu số nguyên nào để sử dụng? Nếu bạn không chắc chắn, mặc định của Rust thường là nơi tốt để bắt đầu: các kiểu số nguyên mặc định là i32. Trường hợp chính mà bạn sẽ sử dụng isize hoặc usize là khi đánh chỉ số cho một số loại bộ sưu tập.

Tràn số nguyên

Giả sử bạn có một biến kiểu u8 có thể lưu giá trị từ 0 đến 255. Nếu bạn cố gắng thay đổi biến thành một giá trị ngoài phạm vi đó, chẳng hạn như 256, tràn số nguyên 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 bao gồm các kiểm tra tràn số nguyên khiến chương trình của bạn panic khi chạy nếu hành vi này xảy ra. Rust sử dụng thuật ngữ panicking khi một chương trình kết thúc với lỗi; chúng ta sẽ thảo luận sâu hơn về panic trong phần "Lỗi không thể khôi phục với panic!" trong Chương 9.

Khi bạn biên dịch ở chế độ phát hành với cờ --release, Rust không bao gồm các kiểm tra tràn số nguyên gây ra panic. Thay vào đó, nếu xảy ra tràn, Rust thực hiện bao quanh bù hai. Nói ngắn gọn, các giá trị lớn hơn giá trị tối đa mà kiểu có thể lưu trữ "bao quanh" về giá trị tối thiểu mà kiểu có thể lưu trữ. Trong trường hợp của u8, giá trị 256 trở thành 0, giá trị 257 trở thành 1, và cứ thế. Chương trình sẽ không panic, nhưng biến sẽ có giá trị có lẽ không phải là giá trị mà bạn mong đợi nó phải có. Việc dựa vào hành vi bao quanh của tràn số nguyên được coi là một lỗi.

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

• Bao quanh trong mọi chế độ với các phương thức wrapping_*, như wrapping_add.
• Trả về giá trị None nếu có tràn với các phương thức checked_*.
• Trả về giá trị và một Boolean cho biết liệu có tràn hay không với các phương thức overflowing_*.
• Bão hòa ở giá trị tối thiểu hoặc tối đa của giá trị với các phương thức saturating_*.

Kiểu Số Thực Dấu Phẩy Động

Rust cũng có hai kiểu nguyên thủy cho số thực dấu phẩy động, là số có dấu thập phân. Kiểu số thực dấu phẩy động của Rust là f32 và f64, có kích thước lần lượt là 32 bit và 64 bit. Kiểu mặc định là f64 vì trên CPU hiện đại, nó có tốc độ gần tương đương với f32 nhưng có khả năng chính xác cao hơn. Tất cả các kiểu số thực dấu phẩy động đều có dấu.

Đây là một ví dụ thể hiện số thực dấu phẩy động trong hành động:

Tên tập tin: 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.

Phép Toán Số Học

Rust hỗ trợ các phép toán cơ bản mà bạn mong đợi cho tất cả các loại số: cộng, trừ, nhân, chia và lấy phần dư. Phép chia số nguyên cắt cụt về phía số không đến số nguyên gần nhất. Đoạn mã sau cho thấy cách bạn sử dụng mỗi phép toán trong một câu lệnh let:

Tên tập tin: 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 truncated = -5 / 3; // Results in -1

    // remainder
    let remainder = 43 % 5;
}

Mỗi biểu thức trong các câu lệnh này sử dụng một toán tử toán học và đánh giá thành một giá trị duy nhất, sau đó được gắn với một biến. Phụ lục B chứa danh sách tất cả các toán tử mà Rust cung cấp.

Kiểu Boolean

Cũng giống như trong hầu hết các ngôn ngữ lập trình khác, kiểu Boolean trong Rust có hai giá trị có thể có: true và false. Boolean có kích thước một byte. Kiểu Boolean trong Rust được chỉ định bằng bool. Ví dụ:

Tên tập tin: src/main.rs

fn main() {
    let t = true;

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

Cách chính để sử dụng giá trị Boolean là thông qua các điều kiện, chẳng hạn như biểu thức if. Chúng ta sẽ tìm hiểu cách biểu thức if hoạt động trong Rust trong phần "Luồng Điều Khiển".

Kiểu Ký Tự

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

Tên tập tin: src/main.rs

fn main() {
    let c = 'z';
    let z: char = 'ℤ'; // with explicit type annotation
    let heart_eyed_cat = '😻';
}

Lưu ý rằng chúng ta chỉ định các ký tự bằng dấu nháy đơn, khác với chuỗi, sử dụng dấu nháy kép. Kiểu char của Rust có kích thước bốn byte và đại diện cho một giá trị scalar của Unicode, nghĩa là nó có thể đại diện cho nhiều hơn chỉ là ASCII. Các chữ cái có dấu; ký tự tiếng Trung, tiếng Nhật và tiếng Hàn; biểu tượng cảm xúc; và khoảng trắng có độ rộng bằng không đều là giá trị char hợp lệ trong Rust. Giá trị scalar của Unicode nằm trong khoảng từ U+0000 đến U+D7FF và U+E000 đến U+10FFFF bao gồm. Tuy nhiên, "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ự" có thể không khớp với khái niệm char trong Rust. Chúng ta sẽ thảo luận chi tiết về chủ đề này trong "Lưu Trữ Văn Bản Mã Hóa UTF-8 với Chuỗi" ở Chương 8.

Kiểu Phức Hợp

Kiểu phức hợp có thể nhóm nhiều giá trị thành một kiểu. Rust có hai kiểu phức hợp nguyên thủy: bộ giá trị (tuple) và mảng.

Kiểu Bộ Giá Trị

Một bộ giá trị là một cách chung để nhóm một số giá trị có nhiều kiểu khác nhau vào một kiểu phức hợp. Bộ giá trị có độ dài cố định: một khi được khai báo, chúng không thể tăng hoặc giảm kích thước.

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

Tên tập tin: src/main.rs

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

Biến tup gắn với toàn bộ bộ giá trị vì bộ giá trị được coi là một phần tử phức hợp đơn lẻ. Để lấy các giá trị riêng lẻ từ một bộ giá trị, chúng ta có thể sử dụng pattern matching để phá hủy cấu trúc một giá trị bộ giá trị, như sau:

Tên tập tin: 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 này đầu tiên tạo ra một bộ giá trị và gắn nó với biến tup. Sau đó, nó sử dụng một pattern với let để lấy tup và biến nó thành ba biến riêng biệt, x, y và z. Điều này được gọi là phá hủy cấu trúc vì nó chia một bộ giá trị thành ba phần. Cuối cùng, chương trình in giá trị của y, là 6.4.

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

Tên tập tin: 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 này tạo ra bộ giá trị x và sau đó truy cập vào mỗi phần tử của bộ giá trị bằng cách sử dụng các chỉ số tương ứng của chúng. Như với hầu hết các ngôn ngữ lập trình, chỉ số đầu tiên trong bộ giá trị là 0.

Bộ giá trị không có giá trị nào có một tên đặc biệt, unit. Giá trị này và kiểu tương ứng của nó đều được viết là () và đại diện cho một giá trị trống hoặc một kiểu trả về trống. Biểu thức ngầm định trả về giá trị unit nếu chúng không trả về bất kỳ giá trị nào khác.

Kiểu Mảng

Một cách khác để có một tập hợp gồm nhiều giá trị là với một mảng. Không giống như bộ giá trị, mọi phần tử của mảng phải có cùng kiểu. Không giống như mảng trong một số ngôn ngữ khác, mảng trong Rust có độ dài cố định.

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

Tên tập tin: src/main.rs

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

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

Tuy nhiên, mảng hữu ích hơn khi bạn biết số lượng phần tử sẽ không cần thay đổi. Ví dụ, nếu bạn đang sử dụng tên của các tháng trong một chương trình, bạn có lẽ sẽ sử dụng một mảng thay vì một vector vì bạn biết nó sẽ 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 của một mảng bằng cách sử dụng dấu ngoặc vuông với kiểu của mỗi phần tử, dấu chấm phẩy, và sau đó là số phần tử trong mảng, như sau:

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

Ở đây, i32 là kiểu của mỗi phần tử. Sau dấu chấm phẩy, số 5 cho biết mảng chứa năm phần tử.

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

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

Mảng có tên a sẽ chứa 5 phần tử mà tất cả sẽ được thiết lập ban đầu với giá trị 3. Điều này tương đương với việc viết let a = [3, 3, 3, 3, 3]; nhưng theo cách ngắn gọn hơn.

Truy Cập Phần Tử Mảng

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

Tên tập tin: 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 có tên first sẽ nhận giá trị 1 vì đó là giá trị tại chỉ số [0] trong mảng. Biến có tên second sẽ nhận giá trị 2 từ chỉ số [1] trong mảng.

Truy Cập Phần Tử Mảng Không Hợp Lệ

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

Tên tập tin: 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 {index} is: {element}");
}

Mã này biên dịch thành công. Nếu bạn chạy mã này bằng 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ỉ số đó trong mảng. Nếu thay vào đó bạn nhập một số ngoài cuối mảng, chẳng hạn như 10, bạn sẽ thấy đầu ra như sau:

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

Chương trình dẫn đến lỗi thời gian chạy ở điểm sử dụng một giá trị không hợp lệ trong phép toán đánh chỉ số. Chương trình kết thúc với một 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ử bằng cách sử dụng chỉ số, Rust sẽ kiểm tra xem chỉ số mà bạn đã chỉ định có nhỏ hơn độ dài mảng hay không. Nếu chỉ số lớn hơn hoặc bằng độ dài, Rust sẽ panic. Kiểm tra này phải được thực hiện ở thời gian chạy, đặc biệt là trong trường hợp này, vì trình biên dịch không thể nào biết được người dùng sẽ nhập giá trị nào khi họ chạy mã sau này.

Đây là một ví dụ về nguyên tắc an toàn bộ nhớ của Rust trong hành động. Trong nhiều ngôn ngữ bậc 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ỉ số không chính xác, bộ nhớ không hợp lệ có thể bị truy cập. Rust bảo vệ bạn khỏi loại lỗi này bằng cách thoát ngay lập tức thay vì cho phép truy cập bộ nhớ và tiếp tục. Chương 9 thảo luận thêm về xử lý lỗi của Rust và cách bạn có thể viết mã an toàn, dễ đọc mà không panic cũng không cho phép truy cập bộ nhớ không hợp lệ.

Các Hàm

Hàm xuất hiện phổ biến trong mã Rust. Bạn đã thấy một trong những hàm quan trọng nhất trong ngôn ngữ này: hàm main, đó là điểm khởi đầu của nhiều chương trình. Bạn cũng đã thấy từ khóa fn, cho phép bạn khai báo các hàm mới.

Mã Rust sử dụng snake case là quy ước phong cách cho tên hàm và tên biến, trong đó tất cả các chữ cái đều là chữ thường và dấu gạch dưới phân tách các từ. Đây là một chương trình chứa ví dụ về đị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 một hàm trong Rust bằng cách nhập fn theo sau là tên hàm và một tập hợp dấu ngoặc đơn. Dấu ngoặc nhọn cho trình biên dịch biết nơi bắt đầu và kết thúc thân hàm.

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

Hãy bắt đầu một dự án nhị phân mới có tên là functions để khám phá hàm sâu hơn. Đặt ví dụ another_function trong src/main.rs và chạy nó. Bạn sẽ thấy kết quả sau:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished `dev` profile [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ự chúng xuất hiện trong hàm main. Đầu tiên, thông báo "Hello, world!" được in ra, và sau đó another_function được gọi và thông báo của nó được in ra.

Tham số

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

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

Filename: src/main.rs

fn main() {
    another_function(5);
}

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

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

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

Khai báo của another_function có một tham số có tên là x. Kiểu của x được xác định là i32. Khi chúng ta truyền 5 vào another_function, macro println! đặt 5 vào nơi có cặp dấu ngoặc nhọn chứa x trong chuỗi định dạng.

Trong chữ ký hàm, bạn phải khai báo kiểu của mỗi tham số. Đây là một quyết định có chủ đích trong thiết kế của Rust: yêu cầu chú thích kiểu trong định nghĩa hàm có nghĩa là trình biên dịch hầu như không cần bạn sử dụng chúng ở nơi khác trong mã để xác định kiểu bạn muốn. Trình biên dịch cũng có thể đưa ra thông báo lỗi hữu ích hơn nếu nó biết kiểu nào mà hàm mong đợi.

Khi định nghĩa nhiều tham số, hãy phân tách khai báo tham số bằng dấu phẩy, như thế này:

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 là print_labeled_measurement với hai tham số. Tham số đầu tiên có tên là value và là một i32. Tham số thứ hai có tên là unit_label và có kiểu char. Sau đó hàm in ra văn bản chứa cả value và unit_label.

Hãy thử chạy mã này. Thay thế chương trình hiện có trong tập tin src/main.rs của dự án functions bằng ví dụ trước đó và chạy nó bằng cargo run:

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

Vì chúng ta đã gọi hàm với 5 là giá trị cho value và 'h' là giá trị cho unit_label, kết quả chương trình chứa những giá trị đó.

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

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

• Câu lệnh là những chỉ thị thực hiện một số hành động và không trả về giá trị.
• Biểu thức đánh giá thành một giá trị kết quả.

Hãy xem một số ví dụ.

Chúng ta thực sự đã sử dụng câu lệnh và biểu thức rồi. Việc tạo ra một biến và gán 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.

fn main() {
    let y = 6;
}

Định nghĩa hàm cũng là câu lệnh; toàn bộ ví dụ trước đó là một câu lệnh tự nó. (Như chúng ta sẽ thấy dưới đây, gọi một hàm không phải là một câu lệnh, tuy nhiên.)

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 cho một biến khác, như mã sau cố gắng làm; bạn sẽ gặp lỗi:

Filename: src/main.rs

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

Khi bạn chạy chương trình này, lỗi bạn sẽ nhận được trông như thế này:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
error: expected expression, found `let` statement
 --> src/main.rs:2:14
  |
2 |     let x = (let y = 6);
  |              ^^^
  |
  = note: only supported directly in conditions of `if` and `while` expressions

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;
  |

warning: `functions` (bin "functions") generated 1 warning
error: could not compile `functions` (bin "functions") due to 1 previous error; 1 warning emitted

Câu lệnh let y = 6 không trả về giá trị, vì vậy không có gì để x ràng buộc. Điều này khác với những gì xảy ra trong các ngôn ngữ khác, chẳng hạn như C và Ruby, nơi phép gán trả về giá trị của phép gán. Trong các ngôn ngữ đó, bạn có thể viết x = y = 6 và cả x và y đều có giá trị 6; điều đó không đúng trong Rust.

Biểu thức đánh giá thành một giá trị và tạo nên phần lớn phần còn lại của mã mà bạn sẽ viết trong Rust. Hãy xem xét một phép toán toán học, chẳng hạn như 5 + 6, đó là một biểu thức đánh giá thành giá trị 11. Biểu thức có thể là một phần của câu lệnh: trong Listing 3-1, 6 trong câu lệnh let y = 6; là một biểu thức đánh giá thành giá trị 6. Gọi một hàm 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 với 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
}

là một khối mà trong trường hợp này, đánh giá thành 4. Giá trị đó được ràng buộc với 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, khác với hầu hết các dòng mà bạn đã thấy cho đến nay. Biểu thức không bao gồm dấu chấm phẩy kết thúc. Nếu bạn thêm dấu chấm phẩy vào cuối một biểu thức, bạn biến nó thành một câu lệnh, và nó sẽ không trả về giá trị nữa. Hãy ghi nhớ điều này khi bạn khám phá giá trị trả về của hàm và biểu thức tiếp theo.

Hàm với Giá trị Trả về

Hàm có thể trả về giá trị cho mã gọi chúng. Chúng ta không đặt tên cho các giá trị trả về, nhưng chúng ta phải khai báo kiểu của chúng sau một 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 khối của phần thân hàm. Bạn có thể trả về sớm từ một hàm bằng cách sử dụng từ khóa return và chỉ định một giá trị, nhưng hầu hết các hàm đều trả về biểu thức cuối cùng một cách ngầm định. Đây là một ví dụ về một hàm trả về một 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ó lời gọi hàm, macro, hay thậm chí câu lệnh let trong hàm five—chỉ có số 5 đứng một mình. Đó là một hàm hoàn toàn hợp lệ trong Rust. Lưu ý rằng kiểu trả về của hàm cũng được chỉ định, là -> i32. Hãy thử chạy mã này; kết quả sẽ trông như thế này:

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

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

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

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

Hãy xem 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
}

Chạy mã này sẽ in ra The value of x is: 6. Nhưng nếu chúng ta đặt một dấu chấm phẩy ở cuối dòng chứa x + 1, biến nó từ một biểu thức thành một câu lệnh, chúng ta sẽ nhận được lỗi:

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 mã này tạo 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: remove this semicolon to return this value

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

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

Chú thích

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

Đây là một chú thích đơn giản:

#![allow(unused)]
fn main() {
// xin chào, thế giới
}

Trong Rust, phong cách chú thích thông dụng bắt đầu bằng hai dấu gạch chéo, và chú thích tiếp tục đến hết dòng. Đối với các chú thích kéo dài hơn một dòng, bạn cần phải thêm // ở mỗi dòng, như thế này:

#![allow(unused)]
fn main() {
// Chúng ta đang làm một điều gì đó phức tạp ở đây, đủ dài để chúng ta cần
// nhiều dòng chú thích để làm điều đó! Ồ! Hy vọng rằng, chú thích này sẽ
// giải thích những gì đang diễn ra.
}

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

Tên tệp: src/main.rs

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

Nhưng bạn sẽ thường thấy chúng được sử dụng trong định dạng này, với chú thích trên một dòng riêng phía trên mã mà nó đang chú thích:

Tên tệp: src/main.rs

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

Rust cũng có một loại chú thích khác, chú thích tài liệu, mà chúng ta sẽ thảo luận trong phần "Xuất bản một Crate lên Crates.io" của Chương 14.

Luồng Điều Khiển

Khả năng chạy một số mã tùy thuộc vào việc một điều kiện là true và chạy một số mã lặp đi lặp lại trong khi một điều kiện là true là những khối xây dựng cơ bản trong hầu hết các ngôn ngữ lập trình. 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 của mã Rust là biểu thức if và vòng lặp.

Biểu Thức if

Biểu thức if cho phép bạn phân nhánh mã của mình dựa trên các điều kiện. Bạn cung cấp một điều kiện và sau đó nói, "Nếu điều kiện này được đáp ứng, hãy chạy khối mã này. Nếu điều kiện không được đáp ứng, đừng chạy khối mã này."

Tạo một dự án mới có tên branches trong thư mục projects của bạn để khám phá biểu thức if. Trong tệp src/main.rs, nhập nội dung sau:

Tên tệp: src/main.rs

fn main() {
    let number = 3;

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

Tất cả các biểu thức if bắt đầu bằng từ khóa if, theo sau là một điều kiện. Trong trường hợp này, điều kiện kiểm tra xem biến number có giá trị nhỏ hơn 5 hay không. Chúng ta đặt khối mã để thực thi nếu điều kiện là true ngay sau điều kiện bên trong dấu ngoặc nhọn. Các khối mã liên kết với các điều kiện trong biểu thức if đôi khi được gọi là nhánh, giống như các nhánh trong biểu thức match mà chúng ta đã thảo luận trong phần "So Sánh Dự Đoán với Số Bí Mật" của Chương 2.

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

Hãy thử chạy mã này; bạn sẽ thấy đầu ra sau:

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

Hãy thử thay đổi giá trị của number thành một giá trị khiến điều kiện thành false để 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 lần nữa và xem đầu ra:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished `dev` profile [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 mã này phải là một bool. Nếu điều kiện không phải là bool, chúng ta sẽ gặp lỗi. Ví dụ, hãy thử chạy mã sau:

Tên tệp: src/main.rs

fn main() {
    let number = 3;

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

Điều kiện if đánh giá thành một giá trị 3 lần này, và Rust báo 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` (bin "branches") due to 1 previous error

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

Tên tệp: src/main.rs

fn main() {
    let number = 3;

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

Chạy mã 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ể sử dụng nhiều điều kiện bằng cách kết hợp if và else trong một biểu thức else if. Ví dụ:

Tên tệp: 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ó bốn đường dẫn có thể thực hiện. Sau khi chạy nó, bạn sẽ thấy đầu ra sau:

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

Khi chương trình này thực thi, nó kiểm tra từng biểu thức if lần lượt và thực thi thân đầu tiên mà điều kiện đánh giá thành true. Lưu ý rằng mặc dù 6 chia hết cho 2, chúng ta không thấy đầu ra number is divisible by 2, cũng không thấy văn bản number is not divisible by 4, 3, or 2 từ khối else. Đó là vì Rust chỉ thực thi khối cho điều kiện true đầu tiên, và khi tìm thấy một điều kiện, nó thậm chí không kiểm tra phần còn lại.

Sử dụng quá nhiều biểu thức else if có thể làm rối mã của bạn, vì vậy nếu bạn có nhiều hơn một, bạn có thể muốn cấu trúc lại mã của mình. Chương 6 mô tả một cấu trúc phân nhánh mạnh mẽ của Rust gọi là match cho những trường hợp này.

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

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

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

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

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

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

Hãy nhớ rằng các khối mã đánh giá thành biểu thức cuối cùng trong chúng, và các số tự chúng 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 khối mã nào được thực thi. Điều này có nghĩa là các giá trị có khả năng là kết quả từ mỗi nhánh của if phải cùng một loại; trong Listing 3-2, kết quả của cả nhánh if và nhánh else đều là số nguyên i32. Nếu các loại không khớp, như trong ví dụ sau, chúng ta sẽ gặp lỗi:

Tên tệp: src/main.rs

fn main() {
    let condition = true;

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

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

Khi cố gắng biên dịch mã này, chúng ta sẽ gặp lỗi. Các nhánh if và else có kiểu giá trị không tương thích, và Rust chỉ ra chính xác nơi tìm thấy 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` (bin "branches") due to 1 previous error

Biểu thức trong khối if đánh giá thành một số nguyên, và biểu thức trong khối else đánh giá thành một chuỗi. Điều này sẽ không hoạt động 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 kiểu biến number là gì, một cách chắc chắn. Biết kiểu của number cho phép trình biên dịch xác minh kiểu là hợp lệ ở mọi nơi chúng ta sử dụng number. Rust sẽ không thể làm điều đó nếu kiểu của number chỉ được xác định trong thời gian chạy; trình biên dịch sẽ phức tạp hơn và sẽ cung cấp ít đảm bảo hơn về mã nếu 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 Vòng Lặp

Thường rất hữu ích để thực thi một khối mã nhiều lần. Cho nhiệm vụ này, Rust cung cấp một số vòng lặp, sẽ chạy qua mã bên trong thân vòng lặp đến cuối và sau đó bắt đầu lại từ đầu ngay lập tức. Để thử nghiệm với vòng lặp, hãy tạo một dự án mới có tên loops.

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

Lặp Lại Mã với loop

Từ khóa loop yêu cầu Rust thực thi một khối mã 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ụ, hãy thay đổi tệp src/main.rs trong thư mục loops của bạn để trông như thế này:

Tên tệp: src/main.rs

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

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

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

Ký hiệu ^C biểu thị nơi bạn đã nhấn ctrl-c.

Bạn có thể sẽ thấy hoặc không thấy từ again! được in sau ^C, tùy thuộc vào vị trí mã 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 mã. Bạn có thể đặt từ khóa break trong vòng lặp để yêu cầu chương trình dừng thực thi vòng lặp. Hãy nhớ rằng chúng ta đã làm điều này trong trò chơi đoán số ở phần "Thoát Sau Khi Đoán Đúng" của Chương 2 để thoát chương trình khi người dùng thắng trò chơi bằng cách đoán đúng số.

Chúng ta cũng đã sử dụng continue trong trò chơi đoán số, trong một vòng lặp nó bảo chương trình bỏ qua bất kỳ mã còn lại nào trong lần lặp này của vòng lặp và chuyển sang lần lặp tiếp theo.

Trả Về Giá Trị từ Vòng Lặp

Một trong những cách sử dụng của loop là thử lại một hoạt động mà bạn biết có thể thất bại, chẳng hạn như kiểm tra xem một luồng đã hoàn thành công việc của nó hay chưa. Bạn cũng có thể cần truyền kết quả của hoạt động đó ra khỏi vòng lặp đến phần còn lại của mã của bạn. Để 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 bạn sử dụng để dừng vòng lặp; giá trị đó sẽ được trả về từ vòng lặp để bạn có thể sử dụng nó, 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à khởi tạo nó thành 0. Sau đó, chúng ta khai báo một biến có tên result để giữ giá trị trả về từ vòng lặp. Trong mỗi lần lặp của vòng lặp, chúng ta thêm 1 vào biến counter, và sau đó kiểm tra xem counter có bằng 10 không. Khi nó bằng 10, chúng ta sử dụng từ khóa break với giá trị 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ị cho result. Cuối cùng, chúng ta in giá trị trong result, trong trường hợp này là 20.

Bạn cũng có thể return từ bên trong một vòng lặp. Trong khi break chỉ thoát khỏi vòng lặp hiện tại, return luôn thoát khỏi hàm hiện tại.

Nhãn Vòng Lặp để Phân Biệt Giữa Nhiều Vòng Lặp

Nếu bạn có vòng lặp trong vòng lặp, break và continue áp dụng cho vòng lặp bên trong nhất tại thời điểm đó. Bạn có thể tùy chọn chỉ định một nhãn vòng lặp trên một vòng lặp mà bạn có thể sử dụng với break hoặc continue để chỉ định rằng những từ khóa đó áp dụng cho vòng lặp được gắn nhãn thay vì vòng lặp bên trong nhất. Nhãn vòng lặp phải bắt đầu bằng một dấu nháy đơn. Đây là một ví dụ với 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 lên từ 0 đến 2. Vòng lặp bên trong không có nhãn đếm ngược từ 10 đến 9. break đầu tiên không chỉ định nhã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 bên ngoài. Mã này in:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished `dev` profile [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

Vòng Lặp Có Điều Kiện với while

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

fn main() {
    let mut number = 3;

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

        number -= 1;
    }

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

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

Lặp Qua một Tập Hợp với for

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

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

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

        index += 1;
    }
}

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

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished `dev` profile [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ị mảng xuất hiện trong terminal, như mong đợi. Mặc dù index sẽ đạt đến giá trị 5 tại một thời điểm nào đó, vòng lặp dừng thực thi trước khi cố gắng lấy giá trị thứ sáu từ mảng.

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

Là một lựa chọn thay thế ngắn gọn hơn, bạn có thể sử dụng vòng lặp for và thực thi một số mã cho mỗi phần tử trong một tập hợp. Một vòng lặp for trông giống như mã trong Listing 3-5.

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

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

Khi chúng ta chạy mã này, chúng ta sẽ thấy đầu ra giống như trong Listing 3-4. Quan trọng hơn, bây giờ chúng ta đã tăng độ an toàn của mã và loại bỏ khả năng xảy ra lỗi có thể dẫn đến vượt quá cuối mảng hoặc không đi đủ xa và bỏ qua một số phần tử. Mã máy được tạo từ vòng lặp for cũng có thể hiệu quả hơn, vì chỉ mục không cần phải so sánh với độ dài của mảng ở mỗi lần lặp.

Sử dụng vòng lặp for, bạn sẽ không cần phải nhớ thay đổi bất kỳ mã nào khác nếu bạn thay đổi số lượng giá trị trong mảng, như bạn sẽ làm với phương pháp được sử dụng trong Listing 3-4.

Sự an toàn và ngắn gọn của vòng lặp for làm cho chúng trở thành cấu trúc vòng lặp được sử dụng phổ biến nhất trong Rust. Ngay cả trong những tình huống mà bạn muốn chạy một số mã một số lần nhất định, như trong ví dụ đếm ngược sử dụng vòng lặp while trong Listing 3-3, hầu hết người dùng Rust sẽ sử dụng vòng lặp for. Cách để làm điều đó sẽ là sử dụng một Range, được cung cấp bởi thư viện tiêu 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.

Đây là cách đếm ngược sẽ trông như thế nào khi sử dụng vòng lặp for và một phương pháp khác mà chúng ta chưa nói đến, rev, để đảo ngược phạm vi:

Tên tệp: src/main.rs

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

Mã này tốt hơn một chút, phải không?

Tóm Tắt

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

• Chuyển đổi nhiệt độ giữa Fahrenheit và Celsius.
• Tạo số Fibonacci thứ n.
• In lời bài hát 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 mà 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.

Hiểu về Ownership

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

Quyền Sở Hữu Là Gì?

Quyền sở hữu (Ownership) là một tập hợp các quy tắc chi phối cách chương trình Rust quản lý bộ nhớ. Tất cả các chương trình đều phải quản lý cách sử dụng bộ nhớ máy tính khi chạy. Một số ngôn ngữ có cơ chế thu gom rác (garbage collection) thường xuyên tìm kiếm bộ nhớ không còn được sử dụng khi chương trình đang 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 hệ thống quyền sở hữu với một tập hợp các quy tắc mà trình biên dịch kiểm tra. 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 được. Không có tính năng nào của quyền sở hữu sẽ làm chậm chương trình khi nó đang chạy.

Vì quyền sở hữu là một khái niệm mới đối với nhiều lập trình viên, nên cần một khoảng thời gian để làm quen. Tin tốt là càng có nhiều kinh nghiệm với Rust và các quy tắc của hệ thống quyền sở hữu, bạn sẽ càng dễ dàng phát triển một cách tự nhiên các đoạn mã an toàn và hiệu quả. Hãy cứ tiếp tục!

Khi bạn hiểu quyền sở hữu, bạn sẽ có một nền tảng vững chắc để hiểu các tính năng khiến Rust trở nên độc đáo. Trong chương này, bạn sẽ học về quyền sở hữu thông qua làm việc với một số ví dụ tập trung vào một 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 suy 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 hay heap ảnh hưởng đến cách ngôn ngữ hoạt động và lý do bạn phải đưa ra những quyết định nhất định. Các phần của quyền sở hữu sẽ được mô tả liên quan đến stack và heap sau trong chương này, vì vậy đây là một giải thích ngắn gọn để chuẩn bị.

Cả stack và heap đều là những phần của bộ nhớ có sẵn để mã của bạn sử dụng trong thời gian chạy, nhưng chúng được cấu trúc theo những cách khác nhau. Stack lưu trữ các giá trị theo thứ tự 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à vào sau, ra trước (last in, first out). Hãy nghĩ về một chồng đĩa: khi bạn thêm đĩa, bạn đặt chúng lên trên cùng của chồng, và khi bạn cần một cái đĩa, bạn lấy một cái từ trên cùng. Việc thêm hoặc xóa đĩa từ giữa hoặc đáy sẽ không hiệu quả! Việc thêm dữ liệu được gọi là đẩy vào stack, và việc xóa dữ liệu được gọi là lấy ra khỏi stack. Tất cả dữ liệu được lưu trữ trên stack phải có kích thước đã biết và cố định. Dữ liệu có kích thước không xác định 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 thay thế.

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

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

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

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

Theo dõi những phần mã nào đang sử dụng dữ liệu nào trên heap, giảm thiểu lượng dữ liệu trùng lặp trên heap, và dọn sạch dữ liệu không sử dụng trên heap để bạn không bị hết không gian, tất cả đều là những vấn đề mà quyền sở hữu giải quyết. Một khi bạn hiểu quyền sở hữu, bạn sẽ không cần phải nghĩ về stack và heap thường xuyên nữa, nhưng biết rằng mục đích chính của quyền sở hữu là quản lý dữ liệu heap có thể giúp giải thích lý do tại sao nó hoạt động như vậy.

Các Quy Tắc Quyền Sở Hữu

Đầu tiên, hãy xem xét các quy tắc quyền sở hữu. Ghi nhớ những quy tắc này khi chúng ta làm việc với các ví dụ minh họa:

• Mỗi giá trị trong Rust có một chủ sở hữu.
• Tại một thời điểm chỉ có thể có một chủ sở hữu.
• Khi chủ sở hữu ra khỏi phạm vi, giá trị sẽ bị hủy.

Phạm Vi Biến

Bây giờ chúng ta đã vượt qua cú pháp Rust cơ bản, chúng ta sẽ không bao gồm tất cả mã fn main() { trong các ví dụ, vì vậy nếu bạn đang làm theo, hãy đảm bảo đặt các ví dụ sau vào hàm main một cách thủ công. Do đó, các ví dụ của chúng ta sẽ ngắn gọn hơn một chút, cho phép chúng ta tập trung vào các chi tiết thực tế hơn là mã boilerplate.

Như một ví dụ đầu tiên về quyền sở hữu, chúng ta sẽ xem xét phạm vi của một số biến. Một phạm vi là phạm vi trong một chương trình mà một mục có giá trị. Xét biến sau:

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

Biến s tham chiếu đến một chuỗi chữ, trong đó giá trị của chuỗi được mã hóa cứng vào văn bản của chương trình của chúng ta. Biến có giá trị từ điểm mà nó được khai báo cho đến khi kết thúc phạm vi hiện tại. Listing 4-1 cho thấy một chương trình với các chú thích cho biết nơi biến s sẽ có giá trị.

fn main() {
    {                      // s is not valid here, since it's not yet declared
        let s = "hello";   // s is valid from this point forward

        // do stuff with s
    }                      // this scope is now over, and s is no longer valid
}

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

• Khi s vào phạm vi, nó có giá trị.
• Nó vẫn có giá trị cho đến khi nó ra khỏi phạm vi.

Ở đ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ờ chúng ta sẽ xây dựng dựa trên hiểu biết này bằng cách giới thiệu kiểu dữ liệu String.

Kiểu String

Để minh họa các quy tắc của quyền sở hữu, chúng ta cần một kiểu dữ liệu phức tạp hơn những gì chúng ta đã đề cập trong phần "Kiểu Dữ Liệu" của Chương 3. Các kiểu được đề cập trước đó có kích thước đã biết, có thể được lưu trữ trên stack và lấ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à dễ dàng để tạo một phiên bản độc lập mới nếu một phần khác của mã cần sử dụng cùng giá trị trong 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 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 quyền sở hữu. Những 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, dù chúng được cung cấp bởi thư viện chuẩn hay được tạo bởi bạn. Chúng ta sẽ thảo luận về String sâu hơn trong Chương 8.

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

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

Toán tử hai dấu hai chấm :: cho phép chúng ta đặt tên hàm from cụ thể này dưới kiểu String thay vì sử dụng một 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 "Cú pháp Phương thức" của Chương 5, và khi chúng ta nói về không gian tên với các mô-đun trong "Đường dẫn để Tham chiếu đến một Mục trong Cây Mô-đun" trong Chương 7.

Loại chuỗi này có thể thay đổi:

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

    s.push_str(", world!"); // push_str() appends a literal to a String

    println!("{s}"); // this will print `hello, world!`
}

Vậy, sự khác biệt ở đây là gì? Tại sao String có thể thay đổi được nhưng các chuỗi chữ thì không? Sự khác biệt nằm ở cách hai loại này xử lý bộ nhớ.

Bộ Nhớ và Cấp Phát

Trong trường hợp của chuỗi chữ, 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 mã hóa cứng trực tiếp vào tệp thực thi cuối cùng. Đây là lý do tại sao chuỗi chữ nhanh chóng và hiệu quả. Nhưng những thuộc tính này chỉ có từ tính không thay đổi của chuỗi chữ. Tiếc thay, chúng ta không thể đặt một khối bộ nhớ vào tệp 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à có kích thước 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 và 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, để chứa nội dung. Điều này có nghĩa:

• Bộ nhớ phải được yêu cầu từ bộ phân bổ bộ nhớ tại thời điểm chạy.
• 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 đã xong với String của mình.

Phần đầu tiên được thực hiện bởi chúng ta: 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 lập trình ngôn ngữ.

Tuy nhiên, phần thứ hai là khác nhau. Trong các ngôn ngữ có bộ thu gom rác (GC), 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 nghĩ về nó. Trong hầu hết các ngôn ngữ không có GC, trách nhiệm của chúng ta là xác định khi nào bộ nhớ không còn được sử dụng và gọi mã để giải phóng nó một cách rõ ràng, giống như chúng ta đã yêu cầu nó. Làm điều này một cách chính xác về mặt lịch sử là một vấn đề lập trình khó khăn. Nếu chúng ta quên, chúng ta sẽ lãng phí bộ nhớ. Nếu chúng ta làm quá sớm, chúng ta sẽ có một biến không hợp lệ. Nếu chúng ta làm 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 chính xác một free.

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

fn main() {
    {
        let s = String::from("hello"); // s is valid from this point forward

        // do stuff with s
    }                                  // this scope is now over, and s is no
                                       // longer valid
}

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

Lưu ý: Trong C++, mô hình này của việc phân bổ tài nguyên tại cuối của vòng đời của một mục đôi khi được gọi là Resource Acquisition Is Initialization (RAII). Chức năng drop trong Rust sẽ quen thuộc với bạn nếu bạn đã sử dụng các mẫu RAII.

Mô hình này có một tác động sâu sắc đến cách mã Rust được viết. Nó có vẻ đơn giản ngay bây giờ, nhưng hành vi của mã có thể bất ngờ 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 đã cấp phát trên heap. Hãy khám phá một số tình huống đó ngay bây giờ.

Các Biến và Dữ Liệu Tương Tác với 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;
}

Chúng ta có thể đoán được đoạn mã này đang làm gì: "gán giá trị 5 cho x; sau đó tạo một bản sao của giá trị trong x và gán nó cho y." Bây giờ chúng ta có hai biến, x và y, và cả hai đề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 với kích thước đã biết, cố định, và hai giá trị 5 này được đẩy vào stack.

Bây giờ hãy xem 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, vì vậy chúng ta 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 điều này không hoàn toàn là những gì xảy ra.

Hãy xem Hình 4-1 để xem điều gì đang xảy ra với String bên dưới bề mặt. Một String bao gồm ba phần, được hiển thị ở bên trái: một con trỏ đến bộ nhớ chứa nội dung của chuỗi, một độ dài, và một dung lượng. 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 chứa giá trị "hello" được gắn với s1

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

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

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

Biểu diễn không trông giống như Hình 4-3, đây là cách bộ nhớ sẽ trông như thế nào nếu Rust cũng sao chép dữ liệu heap. Nếu Rust làm điều này, thao tác 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 ta đã nói rằng khi một biến ra khỏi phạm vi, Rust tự động gọi hàm drop và dọn sạch bộ nhớ heap cho biến đó. Nhưng Hình 4-2 cho thấy cả hai con trỏ dữ liệu đều trỏ đến cùng một vị trí. Đây là một vấn đề: khi s2 và s1 ra khỏi phạm vi, 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 giải phóng bộ nhớ hai lần và là một trong những lỗi an toàn bộ nhớ mà chúng ta đã đề cập trước đó. Giải phóng bộ nhớ hai lần có thể dẫn đến hư hỏng bộ nhớ, điều này có thể dẫn đến lỗ hổng bảo mật.

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

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

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

Bạn sẽ nhận được 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:15
  |
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!("{s1}, world!");
  |               ^^^^ value borrowed here after move
  |
  = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider cloning the value if the performance cost is acceptable
  |
3 |     let s2 = s1.clone();
  |                ++++++++

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

Nếu bạn đã nghe về các thuật ngữ sao chép nông (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ư đang thực hiện sao chép nông. Nhưng vì Rust cũng làm cho biến đầu tiên không hợp lệ, nên thay vì được gọi là sao chép nông, nó được gọi là di chuyển (move). Trong ví dụ này, chúng ta sẽ nói rằng s1 đã được di chuyển vào s2. Vì vậy, những gì thực sự xảy ra được hiển thị 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 ta! Với chỉ s2 hợp lệ, khi nó ra khỏi phạm vi, nó một mình sẽ giải phóng bộ nhớ, và chúng ta đã hoàn thành.

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" của dữ liệu của bạn. Do đó, bất kỳ tự động sao chép nào cũng có thể được giả định là có chi phí thấp về hiệu suất thời gian chạy.

Phạm Vi và Gán

Điều ngược lại cũng đúng cho mối quan hệ giữa phạm vi, quyền sở hữu và bộ nhớ được giải phóng thông qua hàm drop. Khi bạn gán một giá trị hoàn toàn mới cho một biến hiện có, Rust sẽ gọi drop và giải phóng bộ nhớ của giá trị ban đầu ngay lập tức. Xem xét mã này, ví dụ:

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

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

Ban đầu chúng ta khai báo một biến s và gắn nó với một String có giá trị "hello". Sau đó chúng ta ngay lập tức tạo một String mới với giá trị "ahoy" và gán nó cho s. Tại thời điểm này, không có gì tham chiếu đến giá trị ban đầu trên heap một chút nào.

Hình 4-5: Biểu diễn trong bộ nhớ sau khi giá trị ban đầu đã bị thay thế hoàn toàn.

Vì vậy, chuỗi ban đầu ngay lập tức ra khỏi phạm vi. Rust sẽ chạy hàm drop trên nó và bộ nhớ của nó sẽ được giải phóng ngay lập tức. Khi chúng ta in giá trị vào cuối, nó sẽ là "ahoy, world!".

Các Biến và Dữ Liệu Tương Tác với Clone

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

Đây là một ví dụ về phương thức clone trong hành động:

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

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

Điều này 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 thực sự được sao chép.

Khi bạn thấy một lệnh gọi đến clone, bạn biết rằng một số mã tùy ý đang được thực thi và mã đó có thể tốn kém. Đó là một dấu hiệu trực quan rằng điều gì đó khác biệt đang xảy ra.

Dữ Liệu Chỉ Trên Stack: Copy

Còn một chi tiết khác mà chúng ta chưa đề cập. Mã này sử dụng số nguyên—một phần đã đượ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 = {x}, y = {y}");
}

Nhưng mã này dường như trái ngược với những gì chúng ta vừa học: chúng ta không có lệnh gọi clone, nhưng x vẫn hợp lệ và không bị di chuyển vào y.

Lý do là các kiểu 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, nên các bản sao của giá trị thực tế được tạo nhanh chóng. Điều đó có nghĩa là không có lý do tại sao chúng ta muốn ngăn x không còn hợp lệ sau khi chúng ta 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à nông ở đây, vì vậy việc gọi clone sẽ không làm gì khác so với sao chép nông thông thường, và chúng ta có thể bỏ qua nó.

Rust có một chú thích đặc biệt gọi là trait Copy mà chúng ta có thể đặt trên các kiểu được lưu trữ trên stack, như số nguyên (chúng ta sẽ nói nhiều hơn về trait trong Chương 10). Nếu một kiểu triển khai trait Copy, các biến sử dụng nó không bị di chuyển, mà là được sao chép một cách tầm thường, khiến chúng vẫn hợp lệ sau khi gán cho một biến khác.

Rust sẽ không cho phép chúng ta chú thích một kiểu với Copy nếu kiểu đó, hoặc bất kỳ phần nào của nó, đã triển khai trait Drop. Nếu kiểu cần điều gì đó đặc biệt xảy ra khi giá trị ra khỏi phạm vi và chúng ta thêm chú thích Copy vào kiểu đó, chúng ta sẽ nhận được lỗi biên dịch. Để tìm hiểu về cách thêm chú thích Copy vào kiểu của bạn để triển khai trait, xem "Các Trait Có thể Dẫn xuất" trong Phụ lục C.

Vậy, các kiểu nào triển khai trait Copy? Bạn có thể kiểm tra tài liệu cho kiểu đã 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ó gì yêu cầu cấp phát hoặc là một dạng tài nguyên có thể triển khai Copy. Đây là một số kiểu 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 số thực, chẳng hạn như f64.
• Kiểu ký tự, char.
• Tuple, nếu chúng chỉ chứa các kiểu cũng triển khai Copy. Ví dụ, (i32, i32) triển khai Copy, nhưng (i32, String) thì không.

Quyền Sở Hữu và Hàm

Cơ chế của việc truyền một giá trị cho một hàm tương tự như khi gán một giá trị cho 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ư gán. Listing 4-3 có một ví dụ với một số chú thích cho thấy các biến đi vào và ra khỏi phạm vi ở đâu.

fn main() {
    let s = String::from("hello");  // s comes into scope

    takes_ownership(s);             // s's value moves into the function...
                                    // ... and so is no longer valid here

    let x = 5;                      // x comes into scope

    makes_copy(x);                  // Because i32 implements the Copy trait,
                                    // x does NOT move into the function,
                                    // so it's okay to use x afterward.

} // Here, x goes out of scope, then s. However, because s's value was moved,
  // nothing special happens.

fn takes_ownership(some_string: String) { // some_string comes into scope
    println!("{some_string}");
} // Here, some_string goes out of scope and `drop` is called. The backing
  // memory is freed.

fn makes_copy(some_integer: i32) { // some_integer comes into scope
    println!("{some_integer}");
} // Here, some_integer goes out of scope. Nothing special happens.

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

Giá Trị Trả Về và Phạm Vi

Việc trả về giá trị cũng có thể chuyển quyền sở hữu. 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.

fn main() {
    let s1 = gives_ownership();        // gives_ownership moves its return
                                       // value into s1

    let s2 = String::from("hello");    // s2 comes into scope

    let s3 = takes_and_gives_back(s2); // s2 is moved into
                                       // takes_and_gives_back, which also
                                       // moves its return value into s3
} // Here, s3 goes out of scope and is dropped. s2 was moved, so nothing
  // happens. s1 goes out of scope and is dropped.

fn gives_ownership() -> String {       // gives_ownership will move its
                                       // return value into the function
                                       // that calls it

    let some_string = String::from("yours"); // some_string comes into scope

    some_string                        // some_string is returned and
                                       // moves out to the calling
                                       // function
}

// This function takes a String and returns a String.
fn takes_and_gives_back(a_string: String) -> String {
    // a_string comes into
    // scope

    a_string  // a_string is returned and moves out to the calling function
}

Quyền sở hữu của một biến tuân theo cùng một mô hình mọi lú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 ra khỏi phạm vi, giá trị sẽ được dọn dẹp bởi drop trừ khi quyền sở hữu của dữ liệu đã được chuyển sang một biến khác.

Mặc dù điều này hoạt động, việc lấy quyền sở hữu và sau đó trả lại quyền sở hữu với mọi hàm hơi tẻ nhạt. Nếu chúng ta muốn cho một hàm sử dụng một giá trị nhưng không lấy quyền sở hữu? Khá là phiền toái khi bất cứ thứ gì chúng ta truyền vào cũng cần được truyền lại nếu chúng ta muốn sử dụng lại, cùng với bất kỳ dữ liệu nào có từ thân hàm mà chúng ta cũng 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 tuple, như được hiển thị trong Listing 4-5.

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

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

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

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len(); // len() returns the length of a String

    (s, length)
}

Nhưng đây là quá nhiều nghi thức và rất nhiều công việc cho một khái niệm nên phổ biến. May mắn thay, Rust có một tính năng để sử dụng một giá trị mà không chuyển quyền sở hữu, được gọi là tham chiếu (references).

Tham Chiếu và Mượn

Vấn đề với đoạn mã tuple trong Listing 4-5 là chúng ta phải trả lại String cho hàm gọi để chúng ta vẫn có thể sử dụng String sau cuộc gọi đến calculate_length, bởi vì String đã được chuyển vào calculate_length. Thay vào đó, chúng ta có thể cung cấp một tham chiếu đến giá trị String. Tham chiếu (reference) giống như một con trỏ ở chỗ nó là một địa chỉ mà chúng ta có thể theo dõi để truy cập dữ liệu được lưu trữ tại địa chỉ đó; dữ liệu đó thuộc sở hữu của một biến khác. Không giống như 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 dữ liệu cụ thể trong suốt thời gian tồn tại của tham chiếu đó.

Đây là cách bạn sẽ định nghĩa và sử dụng một hàm calculate_length có một tham chiếu đến một đối tượng làm tham số thay vì lấy quyền sở hữu của giá trị:

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

    let len = calculate_length(&s1);

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

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

Đầu tiên, lưu ý rằng tất cả các mã 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 ta truyền &s1 vào calculate_length và trong định nghĩa của nó, chúng ta lấy &String thay vì String. Các dấu và (&) này đại diện cho tham chiếu, và chúng cho phép bạn tham chiếu đến một số giá trị mà không lấy quyền sở hữu của nó. Hình 4-6 minh họa khái niệm này.

Hình 4-6: Một sơ đồ của &String s trỏ đến String s1

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

Hãy xem xét kỹ hơn cuộc gọi hàm ở đây:

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

    let len = calculate_length(&s1);

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

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

Cú pháp &s1 cho phép chúng ta tạo một tham chiếu trỏ đến giá trị của s1 nhưng không sở hữu nó. Vì tham chiếu không sở hữu nó, giá trị mà nó trỏ đến sẽ không bị hủy khi tham chiếu không còn được sử dụng nữa.

Tương tự, chữ ký của hàm sử dụng & để chỉ ra rằng kiểu của tham số s là một tham chiếu. Hãy thêm một số chú thích giải thích:

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

    let len = calculate_length(&s1);

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

fn calculate_length(s: &String) -> usize { // s is a reference to a String
    s.len()
} // Here, s goes out of scope. But because s does not have ownership of what
  // it refers to, the String is not dropped.

Phạm vi mà biến s có giá trị giống như phạm vi của bất kỳ tham số hàm nào, nhưng giá trị được trỏ đến bởi tham chiếu không bị hủy khi s không còn được sử dụng nữa, vì s không có quyền sở hữu. Khi các hàm có tham chiếu làm tham số thay vì các giá trị thực tế, chúng ta sẽ không cần trả lại các giá trị để trả lại quyền sở hữu, vì chúng ta chưa bao giờ có quyền sở hữu.

Chúng ta gọi hành động tạo một tham chiếu là mượn (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 xong việc, 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ứ gì đó mà chúng ta đang mượn? Hãy thử mã trong Listing 4-6. Cảnh báo trước: nó không hoạt động!

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

    change(&s);
}

fn change(some_string: &String) {
    some_string.push_str(", world");
}

Đây là lỗi:

$ 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
  |
8 |     some_string.push_str(", world");
  |     ^^^^^^^^^^^ `some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable
  |
help: consider changing this to be a mutable reference
  |
7 | fn change(some_string: &mut String) {
  |                         +++

For more information about this error, try `rustc --explain E0596`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

Giống như các biến là không thay đổi theo mặc định, các tham chiếu cũng vậy. Chúng ta không được phép sửa đổi một thứ mà chúng ta có tham chiếu đến.

Tham Chiếu Có Thể Thay Đổi

Chúng ta có thể sửa mã 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 điều chỉnh nhỏ sử dụng, thay vào đó, một tham chiếu có thể thay đổi (mutable reference):

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 thành mut. Sau đó, chúng ta tạo một tham chiếu có thể thay đổi với &mut s khi chúng ta gọi hàm change, và cập nhật chữ ký hàm để 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ó mượn.

Tham chiếu có thể thay đổi có một hạn chế lớn: nếu bạn có một tham chiếu có thể thay đổi đến một giá trị, bạn không thể có tham chiếu nào khác đến giá trị đó. Mã này cố gắng tạo hai tham chiếu có thể thay đổi đến s sẽ thất bại:

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` (bin "ownership") due to 1 previous error

Lỗi này nói rằng mã này không hợp lệ vì chúng ta không thể mượn s như một biến có thể thay đổi nhiều hơn một lần tại một thời điểm. Lần mượn có thể thay đổi đầu tiên là trong r1 và phải kéo dài cho đến khi nó được sử dụng trong println!, nhưng giữa việc tạo tham chiếu có thể thay đổi đó và việc sử dụng nó, chúng ta đã cố gắng tạo một tham chiếu có thể thay đổi khác trong r2 mà mượn cùng 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 tại cùng một thời điểm cho phép thay đổi nhưng theo một cách rất có kiểm soát. Đây là điều mà các lập trình viên Rust mới gặp khó khăn vì hầu hết các ngôn ngữ cho phép bạn thay đổi bất cứ khi nào bạn muốn. Lợi ích của việc có hạn chế này là Rust có thể ngăn chặn đua dữ liệu tại thời điểm biên dịch. Đua dữ liệu (data race) tương tự như một điều kiện đua và xảy ra khi có ba hành vi sau:

• Hai hoặc nhiều con trỏ truy cập cùng một dữ liệu tại cùng một thời điểm.
• Í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 đang được sử dụng để đồng bộ hóa việc truy cập vào dữ liệu.

Đua dữ liệu gây ra hành vi không xác định và có thể khó chẩn đoán và sửa chữa khi bạn đang cố gắng theo dõi chúng trong thời gian chạy; Rust ngăn chặn vấn đề này bằng cách từ chối biên dịch mã có đua dữ liệu!

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, miễn là chúng không đồng thời xuất hiện:

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

    {
        let r1 = &mut s;
    } // r1 goes out of scope here, so we can make a new reference with no problems.

    let r2 = &mut s;
}

Rust áp dụng một quy tắc tương tự cho việc kết hợp tham chiếu có thể thay đổi và không thể thay đổi. Mã 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!("{r1}, {r2}, and {r3}");
}

Đây là lỗi:

$ 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!("{r1}, {r2}, and {r3}");
  |               ---- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

Ôi! Chúng ta cũng không thể có một tham chiếu có thể thay đổi trong khi chúng ta có một tham chiếu không thể thay đổi đến cùng một giá trị.

Người dùng của một tham chiếu không thể thay đổi không mong đợi giá trị đột nhiên thay đổi dưới chân họ! Tuy nhiên, nhiều tham chiếu không thể thay đổi được cho phép vì không ai chỉ đọc dữ liệu có khả năng ảnh hưởng đến việc đọc dữ liệu của người khác.

Lưu ý rằng phạm vi của một tham chiếu bắt đầu từ nơi nó được giới thiệu và tiếp tục thông qua lần cuối cùng tham chiếu đó được sử dụng. Ví dụ, mã này sẽ biên dịch vì lần sử dụng cuối cùng của các tham chiếu không thể thay đổi là trong println!, trước khi tham chiếu có thể thay đổi được giới thiệu:

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

    let r1 = &s; // no problem
    let r2 = &s; // no problem
    println!("{r1} and {r2}");
    // Variables r1 and r2 will not be used after this point.

    let r3 = &mut s; // no problem
    println!("{r3}");
}

Phạm vi của các tham chiếu không thể thay đổi r1 và r2 kết thúc sau println! nơi chúng được sử dụng lần cuối, đó là trước khi tham chiếu có thể thay đổi r3 được tạo. Các phạm vi này không chồng lấn, vì vậy mã này được cho phép: trình biên dịch có thể biết rằng 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.

Mặc dù các lỗi mượn có thể gây bực bội đôi khi, 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 thời điểm biên dịch thay vì tại thời điểm chạy) và chỉ cho bạn chính xác nơi vấn đề nằm ở. Sau đó, bạn không phải theo dõi lý do tại sao dữ liệu của bạn không phải là những gì bạn nghĩ nó là.

Tham Chiếu Treo

Trong các ngôn ngữ có con trỏ, rất dễ vô tình tạo ra 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 ai đó khác—bằng cách giải phóng một số bộ nhớ trong khi vẫn giữ một con trỏ đến 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: nếu bạn có một 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 ra khỏi phạm vi trước tham chiếu đến dữ liệu đó.

Hãy thử tạo một tham chiếu treo để xem cách Rust ngăn chúng với một lỗi thời điểm biên dịch:

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String {
    let s = String::from("hello");

    &s
}

Đây là lỗi:

$ 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, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
  |
5 | fn dangle() -> &'static String {
  |                 +++++++
help: instead, you are more likely to want to return an owned value
  |
5 - fn dangle() -> &String {
5 + fn dangle() -> String {
  |

error[E0515]: cannot return reference to local variable `s`
 --> src/main.rs:8:5
  |
8 |     &s
  |     ^^ returns a reference to data owned by the current function

Some errors have detailed explanations: E0106, E0515.
For more information about an error, try `rustc --explain E0106`.
error: could not compile `ownership` (bin "ownership") due to 2 previous errors

Thông báo lỗi này đề cập đến một tính năng mà chúng ta chưa đề cập: thời gian tồn tại (lifetimes). Chúng ta sẽ thảo luận về thời gian tồn tại chi tiết trong Chương 10. Nhưng, nếu bạn bỏ qua các phần về thời gian tồn tại, thông báo có chứa chìa khóa cho lý do tại sao mã này là một vấn đề:

kiểu trả về của hàm này chứa một giá trị đã mượn, nhưng không có giá trị
nào để mượn từ đó

Hãy xem xét kỹ hơn chính xác những gì đang xảy ra ở mỗi giai đoạn của mã dangle của chúng ta:

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String { // dangle returns a reference to a String

    let s = String::from("hello"); // s is a new String

    &s // we return a reference to the String, s
} // Here, s goes out of scope and is dropped, so its memory goes away.
  // Danger!

Vì s được tạo bên trong dangle, khi mã của dangle hoàn thành, s sẽ bị giải phóng. 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 hợp lệ. Điều đó không tốt! Rust sẽ không cho phép 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ó vấn đề gì. Quyền sở hữu được chuyển ra ngoài và không có gì bị giải phóng.

Các Quy Tắc của Tham Chiếu

Hãy tổng kết những gì chúng ta đã thảo luận về tham chiếu:

• Tại bất kỳ thời điểm nào, bạn có thể có hoặc là một tham chiếu có thể thay đổi hoặc là bất kỳ số lượng tham chiếu không thể thay đổi nào.
• Tham chiếu phải luôn hợp lệ.

Tiếp theo, chúng ta sẽ xem xét một loại tham chiếu khác: slice.

Kiểu Slice

Slices cho phép bạn tham chiếu đến một chuỗi liên tiếp các phần tử trong một bộ sưu tập. Slice là một loại tham chiếu, nên nó không có quyền sở hữu.

Đây là một bài toán nhỏ: viết một hàm nhận vào một chuỗi các từ được phân tách bởi khoảng trắng 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, toàn bộ chuỗi phải là một từ, do đó toàn bộ chuỗi sẽ được trả về.

Lưu ý: Để giới thiệu về string slice, chúng ta giả định chỉ xử lý ASCII trong phần này; một thảo luận chi tiết hơn về xử lý UTF-8 nằm trong phần "Lưu trữ văn bản được mã hóa UTF-8 với Strings" ở Chương 8.

Hãy cùng xem xét cách viết chữ ký của hàm này mà không sử dụng slices, để hiểu vấn đề mà slices sẽ giải quyết:

fn first_word(s: &String) -> ?

Hàm first_word có một tham số kiểu &String. Chúng ta không cần quyền sở hữu, nên điều này là hợp lý. (Theo cách viết thông thường của Rust, hàm không lấy quyền sở hữu của các đối số của chúng trừ khi cần thiết, và lý do sẽ trở nên rõ ràng hơn khi chúng ta tiếp tục.) Nhưng chúng ta nên trả về gì? Chúng ta không thực sự có cách để nói về một phần của một chuỗi. Tuy nhiên, chúng ta có thể trả về chỉ số của vị trí kết thúc từ, được chỉ định bằng một khoảng trắng. Hãy thử điều đó, như trong Listing 4-7.

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() {}

Vì chúng ta cần đi qua từng phần tử của String và kiểm tra xem một giá trị có phải là khoảng trắng không, chúng ta sẽ chuyển đổi String thành một mảng byte bằng phương thức 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 iterator qua mảng byte bằng phương thức 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 về iterators chi tiết hơn trong Chương 13. Hiện tại, hãy biết rằng iter là một phương thức trả về mỗi phần tử trong một bộ sưu tập và enumerate bao bọc kết quả của iter và trả về mỗi phần tử dưới dạng một tuple. Phần tử đầu tiên của tuple trả về từ enumerate là chỉ số, và phần tử thứ hai là 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 chỉ số.

Vì phương thức enumerate trả về một tuple, chúng ta có thể sử dụng các mẫu để phân rã tuple đó. Chúng ta sẽ thảo luận về các mẫu chi tiết hơn trong Chương 6. Trong vòng lặp for, chúng ta chỉ định một mẫu có i cho chỉ số trong tuple và &item cho byte đơn lẻ trong tuple. Bởi vì chúng ta có được tham chiếu đến phần tử từ .iter().enumerate(), chúng ta sử dụng & trong mẫu.

Bên 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 byte literal. Nếu chúng ta tìm thấy một khoảng trắng, chúng ta trả về vị trí. 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ó cách để tìm ra chỉ số của vị trí kết thúc từ đầu tiên trong chuỗi, nhưng có một vấn đề. Chúng ta đang trả về một usize riêng lẻ, nhưng đó chỉ là một số có ý nghĩa trong ngữ cảnh của &String. Nói cách khác, vì nó là một giá trị tách biệt khỏi String, không có gì đảm bảo rằng nó sẽ vẫn hợp lệ 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.

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 will get the value 5

    s.clear(); // this empties the String, making it equal to ""

    // word still has the value 5 here, but s no longer has any content that we
    // could meaningfully use with the value 5, so word is now totally invalid!
}

Chương trình này biên dịch mà không có lỗi nào và cũng sẽ như vậy nếu chúng ta sử dụng word sau khi gọi s.clear(). Bởi vì word không liên kết với trạng thái của s chút nào, word vẫn chứa giá trị 5. Chúng ta có thể sử dụng giá trị 5 đó với biến s để cố gắng trích xuất từ đầu tiên, nhưng điều nà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 vào word.

Việc phải lo lắng về chỉ số trong word không đồng bộ với dữ liệu trong s là tẻ nhạt và dễ gây lỗi! Việc quản lý các chỉ số này thậm chí còn mong manh hơn nếu chúng ta viết một hàm second_word. Chữ ký 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 một chỉ số bắt đầu và một chỉ số kết thúc, và chúng ta có nhiều giá trị hơn được tính toán từ dữ liệu trong một trạng thái cụ thể nhưng không gắn liền với trạng thái đó chút nào. Chúng ta có ba biến không liên quan đến nhau nổi xung quanh cần phải được giữ đồng bộ.

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 chuỗi liên tiếp các phần tử 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ì một tham chiếu đến toàn bộ String, hello là một tham chiếu đến một phần của String, được chỉ định trong phần [0..5]. Chúng ta tạo slices bằng cách sử dụng một phạm vi trong ngoặc vuông bằng cách chỉ định [starting_index..ending_index], trong đó starting_index là vị trí đầu tiên trong slice và ending_index là vị trí sau vị trí cuối cùng trong slice. Về mặt nội bộ, cấu trúc dữ liệu slice lưu trữ vị trí bắt đầu và độ dài của slice, mà tương ứng với ending_index trừ đi starting_index. Vì vậy, trong trường hợp let world = &s[6..11];, world sẽ là một slice chứa một con trỏ đến byte tại chỉ số 6 của s với giá trị độ dài là 5.

Hình 4-7 minh họa điều này trong một sơ đồ.

Hình 4-7: String slice tham chiếu đến một phần của một String

Với cú pháp phạm vi .. của Rust, nếu bạn muốn bắt đầu từ chỉ số 0, bạn có thể bỏ giá trị trước hai dấu chấm. Nói cách khác, hai cách viết sau là tương đương:

#![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ỏ số cuối. Điều đó có nghĩa là các cách viết sau là tương đương:

#![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. Vì vậy, hai cách viết sau là tương đương:

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

let len = s.len();

let slice = &s[0..len];
let slice = &s[..];
}

Lưu ý: Các chỉ số phạm vi của string slice phải nằm tại các 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ự đa byte, chương trình của bạn sẽ kết thúc với một lỗi.

Với tất cả thông tin này, hãy viết lại first_word để trả về một slice. Kiểu dùng để biểu thị "string slice" được viết là &str:

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 lấy chỉ số cho vị trí kết thúc của từ theo cách tương tự như trong Listing 4-7, bằng cách tìm kiếm lần xuất hiện đầu tiên của một khoảng trắng. Khi chúng ta tìm thấy một khoảng trắng, chúng ta trả về một string slice sử dụng phần đầu của chuỗi và chỉ số 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 được một giá trị duy nhất gắn liền với dữ liệu cơ bản. Giá trị bao gồm một tham chiếu đến điểm bắt đầu của slice và số phần tử trong slice.

Việc trả về một slice cũng sẽ hoạt động cho một hàm second_word:

fn second_word(s: &String) -> &str {

Bây giờ chúng ta có một API đơn giản hơn nhiều mà khó bị sai sót hơn bởi 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 lỗi trong chương trình ở Listing 4-8, khi chúng ta nhận được chỉ số đến vị trí kết thúc từ đầu tiên nhưng sau đó xóa chuỗi khiến cho chỉ số của chúng ta không còn hợp lệ? Đoạn mã đó về mặt logic là không đúng nhưng không hiển thị lỗi ngay lập tức. Các vấn đề sẽ xuất hiện sau nếu chúng ta tiếp tục cố gắng sử dụng chỉ số từ đầu tiên với một chuỗi đã bị làm rỗng. Slices làm cho lỗi này là không thể và cho chúng ta biết rằng chúng ta có vấn đề với mã của mình sớm hơn nhiều. Sử dụng phiên bản slice của first_word sẽ báo lỗi khi biên dịch:

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}");
}

Đây là lỗi biên dịch:

$ 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` (bin "ownership") due to 1 previous error

Hãy nhớ lại từ quy tắc mượn rằng nếu chúng ta có một tham chiếu bất biến đến một thứ gì đó, chúng ta không thể đồng thời lấy một tham chiếu có thể thay đổi. Bởi vì clear cần cắt ngắn String, nó cần lấy một tham chiếu có thể thay đổi. println! sau lời gọi đến clear sử dụng tham chiếu trong word, do đó tham chiếu bất biến phải vẫn cò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à việc biên dịch thất bại. 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ộ một lớp lỗi tại thời điểm biên dịch!

String Literals dưới dạng Slices

Nhớ lại rằng chúng ta đã nói về việc string literals được lưu trữ bên trong mã nhị phân. Bây giờ khi 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: đó là một slice trỏ đến một điểm cụ thể của mã 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 dưới dạng Tham số

Khi biết rằng bạn có thể lấy slices của literals và giá trị String dẫn chúng ta đến một cải tiến nữa cho first_word, và đó là chữ ký của nó:

fn first_word(s: &String) -> &str {

Một Rustacean có kinh nghiệm hơn sẽ viết chữ ký như trong Listing 4-9 thay vì như trên vì nó cho phép chúng ta sử dụng cùng một hàm cho 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);
}

Nếu chúng ta có một string slice, chúng ta có thể truyền nó 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. Tính linh hoạt này tận dụng deref coercions, một tính năng mà chúng ta sẽ đề cập trong phần "Implicit Deref Coercions with Functions and Methods" của Chương 15.

Việc định nghĩa một hàm nhận một string slice thay vì một 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 mất bất kỳ chức năng nào:

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);
}

Các Slices Khác

String slices, như bạn có thể tưởng tượng, là đặc biệt dành cho chuỗi. Nhưng có một kiểu slice chung hơn. Xét mảng này:

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

Cũng như chúng ta có thể muốn tham chiếu đến một phần của một chuỗi, chúng ta có thể muốn tham chiếu đến một phần của một mảng. Chúng ta sẽ thực hiện như sau:

#![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 giống như string slices, bằng cách lưu trữ một tham chiếu đến phần tử đầu tiên và một độ dài. Bạn sẽ sử dụng kiểu slice này cho tất cả các loại bộ sưu tập khác. Chúng ta sẽ thảo luận về các bộ sưu tập này chi tiết khi chúng ta nói về vectors trong Chương 8.

Tóm tắt

Các khái niệm về quyền sở hữu, mượn và slices đảm bảo an toàn 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 bạn quyền kiểm soát đối với việc sử dụng bộ nhớ của bạn theo cách giống như các ngôn ngữ lập trình hệ thống khác, nhưng việc có chủ sở hữu của dữ liệu tự động dọn dẹp dữ liệu đó khi chủ sở hữu ra khỏi phạm vi có nghĩa là bạn không cần phải viết và gỡ lỗi mã bổ sung để có được sự kiểm soát này.

Quyền sở hữu ảnh hưởng đến cách thức hoạt động của nhiều phần khác của Rust, vì vậy chúng ta sẽ nói về các khái niệm này thêm 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 một struct.

Sử dụng Structs để Cấu trúc Dữ liệu Liên quan

Một struct, hay structure, là một kiểu dữ liệu tùy chỉnh cho phép bạn đóng gói và đặt tên cho nhiều giá trị liên quan tạo thành một nhóm có ý nghĩa. Nếu bạn đã quen với ngôn ngữ hướng đối tượng, struct giống như các thuộc tính dữ liệu của một đối tượng. Trong chương này, chúng ta sẽ so sánh và đối chiếu tuple với struct để xây dựng trên những gì bạn đã biết và chứng minh khi nào struct là cách tốt hơn để nhóm dữ liệu.

Chúng ta sẽ trình bày cách định nghĩa và khởi tạo struct. Chúng ta sẽ thảo luận về cách định nghĩa các hàm liên kết, đặc biệt là loại hàm liên kết được gọi là methods, để chỉ định hành vi liên quan đến một kiểu struct. Struct và enums (được thảo luận trong Chương 6) là các khối xây dựng để tạo ra các kiểu mới trong miền chương trình của bạn để tận dụng tối đa khả năng kiểm tra kiểu tại thời điểm biên dịch của Rust.

Định nghĩa và Khởi tạo Struct

Struct tương tự như tuple, đã được thảo luận trong phần "Kiểu Tuple", ở chỗ cả hai đều chứa nhiều giá trị liên quan. Giống như tuple, các thành phần của một struct có thể có kiểu khác nhau. Khác với tuple, trong một struct, bạn sẽ đặt tên cho từng phần dữ liệu để làm rõ ý nghĩa của các giá trị. Việc thêm các tên này có nghĩa là struct linh hoạt hơn tuple: bạn không phải dựa vào thứ tự của dữ liệu để xác định hoặc truy cập các giá trị của một thực thể.

Để định nghĩa một struct, chúng ta nhập từ khóa struct và đặt tên cho toàn bộ struct. Tên của struct nên mô tả ý nghĩa của các phần dữ liệu được nhóm lại với nhau. Sau đó, bên trong dấu ngoặc nhọn, chúng ta định nghĩa tên và kiểu của các phần dữ liệu, mà chúng ta gọi là trường (fields). Ví dụ, Listing 5-1 hiển thị một struct lưu trữ thông tin về tài khoản người dùng.

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {}

Để sử dụng struct sau khi đã định nghĩa nó, chúng ta tạo ra một instance (thực thể) của struct đó bằng cách xác định giá trị cụ thể cho mỗi trường. Chúng ta tạo một thực thể bằng cách nêu tên của struct và sau đó thêm dấu ngoặc nhọn chứa các cặp key: value, trong đó key là tên của các trường và value là dữ liệu mà chúng ta muốn lưu trữ trong các trường đó. Chúng ta không cần phải chỉ định các trường theo cùng thứ tự mà chúng ta đã khai báo trong struct. Nói cách khác, định nghĩa struct giống như một khuôn mẫu chung cho kiểu dữ liệu, và các thực thể điền vào khuôn mẫu đó với dữ liệu cụ thể để tạo ra các giá trị của kiểu đó. Ví dụ, chúng ta có thể khai báo một người dùng cụ thể như trong Listing 5-2.

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    let user1 = User {
        active: true,
        username: String::from("someusername123"),
        email: String::from("someone@example.com"),
        sign_in_count: 1,
    };
}

Để lấy một giá trị cụ thể từ struct, chúng ta sử dụng ký hiệu dấu chấm. Ví dụ, để truy cập địa chỉ email của người dùng này, chúng ta sử dụng user1.email. Nếu thực thể là có thể thay đổi, chúng ta có thể thay đổi giá trị bằng cách sử dụng ký hiệu dấu chấm và gán vào một trường cụ thể. Listing 5-3 cho thấy cách thay đổi giá trị trong trường email của một thực thể User có thể thay đổi.

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    let mut user1 = User {
        active: true,
        username: String::from("someusername123"),
        email: String::from("someone@example.com"),
        sign_in_count: 1,
    };

    user1.email = String::from("anotheremail@example.com");
}

Lưu ý rằng toàn bộ thực thể phải là có thể thay đổi; Rust không cho phép chúng ta đánh dấu chỉ một số trường nhất định là có thể thay đổi. Giống như với bất kỳ biểu thức nào, chúng ta có thể tạo một thực thể mới của struct làm biểu thức cuối cùng trong thân hàm để ngầm định trả về thực thể mới đó.

Listing 5-4 hiển thị một hàm build_user trả về một thực thể User với email và tên người dùng đã cho. Trường active nhận giá trị là true, và sign_in_count nhận giá trị là 1.

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn build_user(email: String, username: String) -> User {
    User {
        active: true,
        username: username,
        email: email,
        sign_in_count: 1,
    }
}

fn main() {
    let user1 = build_user(
        String::from("someone@example.com"),
        String::from("someusername123"),
    );
}

Việc đặt tên các tham số của hàm giống với tên trường của struct là hợp lý, nhưng việc phải lặp lại tên trường email và username cùng với biến là hơi tẻ nhạt. Nếu struct có nhiều trường hơn, việc lặp lại mỗi tên sẽ càng phiền phức hơn. May mắn thay, có một cách viết tắt thuận tiện!

Sử dụng Field Init Shorthand

Vì tên tham số và tên trường struct là hoàn toàn giống nhau trong Listing 5-4, chúng ta có thể sử dụng cú pháp field init shorthand để viết lại build_user để nó hoạt động chính xác như cũ nhưng không có sự lặp lại của username và email, như trong Listing 5-5.

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn build_user(email: String, username: String) -> User {
    User {
        active: true,
        username,
        email,
        sign_in_count: 1,
    }
}

fn main() {
    let user1 = build_user(
        String::from("someone@example.com"),
        String::from("someusername123"),
    );
}

Ở đây, chúng ta đang tạo một thực thể mới của struct User, nó có một trường tên là email. Chúng ta muốn đặt giá trị của trường email thành giá trị trong tham số email của hàm build_user. Vì trường email và tham số email có cùng tên, chúng ta chỉ cần viết email thay vì email: email.

Tạo Thực thể từ Các Thực thể Khác với Cú pháp Cập nhật Struct

Thường rất hữu ích khi tạo một thực thể mới của một struct bao gồm hầu hết các giá trị từ một thực thể khác của cùng kiểu, nhưng thay đổi một số. Bạn có thể làm điều này bằng cách sử dụng cú pháp cập nhật struct (struct update syntax).

Đầu tiên, trong Listing 5-6, chúng ta thấy cách tạo một thực thể User mới trong user2 theo cách thông thường, không sử dụng cú pháp cập nhật. Chúng ta đặt một giá trị mới cho email nhưng sử dụng các giá trị giống nhau từ user1 mà chúng ta đã tạo ra 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("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        active: user1.active,
        username: user1.username,
        email: String::from("another@example.com"),
        sign_in_count: user1.sign_in_count,
    };
}

Sử dụng cú pháp cập nhật struct, chúng ta có thể đạt được cùng kết quả với ít mã hơn, như trong Listing 5-7. Cú pháp .. chỉ định rằng các trường còn lại không được đặt rõ ràng sẽ có cùng giá trị với các trường trong thực thể đã cho.

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    // --snip--

    let user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        email: String::from("another@example.com"),
        ..user1
    };
}

Mã trong Listing 5-7 cũng tạo ra một thực thể trong user2 có giá trị khác cho email nhưng có cùng giá trị cho các trường username, active, và sign_in_count từ user1. ..user1 phải đặt cuối cùng để chỉ định rằng bất kỳ trường còn lại nào nên lấy giá trị của chúng từ các trường tương ứng trong user1, nhưng chúng ta có thể chọn chỉ định giá trị cho nhiều trường tùy ý theo bất kỳ thứ tự nào, bất kể thứ tự của các trường trong định nghĩa struct.

Lưu ý rằng cú pháp cập nhật struct sử dụng = như một phép gán; điều này là vì nó di chuyển dữ liệu, giống như chúng ta đã thấy trong phần "Variables and Data Interacting with Move". Trong ví dụ này, chúng ta không còn có thể sử dụng user1 sau khi tạo user2 vì String trong trường username của user1 đã được di chuyển vào user2. Nếu chúng ta đã cung cấp cho user2 giá trị String mới cho cả email và username, và do đó chỉ sử dụng các giá trị active và sign_in_count từ user1, thì user1 vẫn sẽ hợp lệ sau khi tạo ra user2. Cả active và sign_in_count đều là các kiểu thực hiện trait Copy, do đó hành vi mà chúng ta đã thảo luận trong phần "Stack-Only Data: Copy" sẽ được áp dụng. Chúng ta cũng vẫn có thể sử dụng user1.email trong ví dụ này, vì giá trị của nó không bị di chuyển ra khỏi user1.

Sử dụng Tuple Struct Không Có Trường Được Đặt Tên để Tạo Các Kiểu Khác Nhau

Rust cũng hỗ trợ struct trông giống như tuple, được gọi là tuple struct. Tuple struct có thêm ý nghĩa mà tên struct cung cấp nhưng không có tên được liên kết với các trường của chúng; thay vào đó, chúng chỉ có các kiểu của các trường. Tuple struct hữu ích khi bạn muốn đặt tên cho toàn bộ tuple và làm cho tuple đó thành một kiểu khác với các tuple khác, và khi đặt tên cho mỗi trường như trong một struct thông thường sẽ dài dòng hoặc thừa thãi.

Để định nghĩa một tuple struct, bắt đầu với từ khóa struct và tên struct theo sau là các kiểu trong tuple. Ví dụ, ở đây chúng ta định nghĩa và sử dụng hai tuple struct 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);
}

Lưu ý rằng giá trị black và origin là các kiểu khác nhau vì chúng là các thực thể của các tuple struct khác nhau. Mỗi struct bạn định nghĩa là kiểu riêng của nó, ngay cả khi các trường trong struct có thể có cùng kiểu. Ví dụ, một hàm nhận một tham số kiểu Color không thể nhận một Point làm đối số, mặc dù cả hai kiểu đều được tạo thành từ ba giá trị i32. Nếu không, các thực thể tuple struct tương tự như tuple ở chỗ bạn có thể phân rã chúng thành các phần riêng lẻ, và bạn có thể sử dụng . theo sau bởi chỉ số để truy cập một giá trị riêng lẻ. Khác với tuple, tuple struct yêu cầu bạn đặt tên kiểu của struct khi bạn phân rã chúng. Ví dụ, chúng ta sẽ viết let Point(x, y, z) = origin; để phân rã các giá trị trong điểm origin thành các biến có tên là x, y, và z.

Unit-Like Struct Không Có Trường Nào

Bạn cũng có thể định nghĩa struct không có trường nào! Những thứ này được gọi là unit-like struct vì chúng hoạt động tương tự như (), kiểu đơn vị mà chúng ta đã đề cập trong phần "The Tuple Type". Unit-like struct có thể hữu ích khi bạn cần thực hiện một trait trên một kiểu nhưng không có bất kỳ dữ liệu nào mà bạn muốn lưu trữ trong chính kiểu đó. Chúng ta sẽ thảo luận về trait trong Chương 10. Đây là một ví dụ về việc khai báo và khởi tạo một unit struct có tên là AlwaysEqual:

struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}

Để định nghĩa AlwaysEqual, chúng ta sử dụng từ khóa struct, tên mà chúng ta muốn, và sau đó là dấu chấm phẩy. Không cần dấu ngoặc nhọn hoặc dấu ngoặc tròn! Sau đó chúng ta có thể lấy một thực thể của AlwaysEqual trong biến subject theo cách tương tự: sử dụng tên mà chúng ta đã định nghĩa, không có dấu ngoặc nhọn hoặc dấu ngoặc tròn nào. Hãy tưởng tượng rằng sau này chúng ta sẽ thực hiện hành vi cho kiểu này sao cho mọi thực thể của AlwaysEqual luôn bằng với mọi thực thể của bất kỳ kiểu nào khác, có lẽ để có một kết quả đã biết cho mục đích kiểm tra. Chúng ta sẽ không cần bất kỳ dữ liệu nào để thực hiện hành vi đó! Bạn sẽ thấy trong Chương 10 cách định nghĩa trait và thực hiện chúng trên bất kỳ kiểu nào, bao gồm cả unit-like struct.

Quyền sở hữu Dữ liệu trong Struct

Trong định nghĩa struct User ở Listing 5-1, chúng ta đã sử dụng kiểu String có quyền sở hữu thay vì kiểu string slice &str. Đây là một lựa chọn có chủ đích bởi vì chúng ta muốn mỗi thực thể của struct này sở hữu tất cả dữ liệu của nó và cho dữ liệu đó hợp lệ miễn là toàn bộ struct còn hợp lệ.

Cũng có thể để struct lưu trữ các tham chiếu đến dữ liệu thuộc sở hữu của một thứ khác, nhưng để làm điều đó đòi hỏi phải sử dụng lifetimes, một tính năng của Rust mà chúng ta sẽ thảo luận trong Chương 10. Lifetimes đảm bảo rằng dữ liệu được tham chiếu bởi một struct là hợp lệ miễn là struct còn tồn tại. Hãy giả sử bạn cố gắng lưu trữ một tham chiếu trong một struct mà không chỉ định lifetimes, như sau; điều này sẽ không hoạt động:

struct User {
    active: bool,
    username: &str,
    email: &str,
    sign_in_count: u64,
}

fn main() {
    let user1 = User {
        active: true,
        username: "someusername123",
        email: "someone@example.com",
        sign_in_count: 1,
    };
}

Trình biên dịch sẽ phàn nàn rằng nó cần bộ chỉ định lifetime:

$ 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` (bin "structs") due to 2 previous errors

Trong Chương 10, chúng ta sẽ thảo luận về cách sửa những lỗi này để bạn có thể lưu trữ tham chiếu trong struct, nhưng hiện tại, chúng ta sẽ sửa các lỗi như thế này bằng cách sử dụng các kiểu có quyền sở hữu như String thay vì các tham chiếu như &str.

Chương trình Ví dụ Sử dụng Structs

Để hiểu khi nào chúng ta nên sử dụng structs, hãy viết một chương trình tính diện tích của hình chữ nhật. Chúng ta sẽ bắt đầu bằng việc sử dụng các biến đơn lẻ, và sau đó cải tiến chương trình cho đến khi chúng ta sử dụng structs.

Hãy tạo một dự án binary mới với Cargo có tên rectangles để tính diện tích hình chữ nhật dựa trên chiều rộng và chiều cao được chỉ định bằng pixel. Listing 5-8 hiển thị một chương trình ngắn với một cách thực hiện chính xác điều đó trong tệp src/main.rs của dự án chúng ta.

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
}

Bây giờ, chạy chương trình này bằng cargo run:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.42s
     Running `target/debug/rectangles`
The area of the rectangle is 1500 square pixels.

Đoạn mã này thành công trong việc tính diện tích của hình chữ nhật bằng cách gọi hàm area với mỗi kích thước, nhưng chúng ta có thể làm nhiều hơn nữa để làm cho mã này rõ ràng và dễ đọc hơn.

Vấn đề với đoạn mã này thể hiện rõ trong chữ ký của hàm area:

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 được cho là để tính diện tích của một hình chữ nhật, nhưng hàm mà chúng ta đã viết có hai tham số, và không có chỗ nào trong chương trình của chúng ta làm rõ rằng các tham số này có liên quan đến nhau. Sẽ dễ đọc và dễ quản lý hơn nếu nhóm chiều rộng và chiều cao lại với nhau. Chúng ta đã thảo luận về một cách chúng ta có thể làm điều đó trong phần "Kiểu Tuple" của Chương 3: bằng cách sử dụng các tuple.

Cải tiến với Tuples

Listing 5-9 hiển thị một phiên bản khác của chương trình chúng ta sử dụng tuples.

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
}

Ở một khía cạnh, chương trình này tốt hơn. Tuples cho phép chúng ta thêm một chút cấu trúc và giờ đây chúng ta chỉ truyền một đối số. Nhưng ở một khía cạnh khác, phiên bản này ít rõ ràng hơn: tuples không đặt tên cho các phần tử của chúng, vì vậy chúng ta phải lập chỉ mục vào các phần của tuple, làm cho phép tính của chúng ta kém rõ ràng hơn.

Việc nhầm lẫn chiều rộng và chiều cao sẽ không ảnh hưởng đến phép tính diện tích, nhưng nếu chúng ta muốn vẽ hình chữ nhật trên màn hình, điều đó sẽ quan trọng! Chúng ta sẽ phải nhớ rằng width là chỉ mục tuple 0 và height là chỉ mục tuple 1. Điều này sẽ càng khó hơn cho người khác để hiểu và ghi nhớ nếu họ sử dụng mã của chúng ta. Bởi vì chúng ta chưa truyền đạt ý nghĩa của dữ liệu trong mã của mình, việc dễ gây ra lỗi hơn.

Cải tiến với Structs: Thêm Ý nghĩa

Chúng ta sử dụng structs để thêm ý nghĩa bằng cách gắn nhãn cho dữ liệu. Chúng ta có thể chuyển đổi tuple chúng ta đang sử dụng thành một struct với một tên cho toàn bộ cũng như các tên cho các phần, như được hiển thị trong Listing 5-10.

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
}

Ở đây, chúng ta đã định nghĩa một struct và đặt tên nó là Rectangle. Bên trong dấu ngoặc nhọn, chúng ta định nghĩa các trường là width và height, cả hai đều có kiểu u32. Sau đó, trong main, chúng ta tạo một instance cụ thể của Rectangle có chiều rộng 30 và chiều cao 50.

Hàm area của chúng ta bây giờ được định nghĩa với một tham số, mà chúng ta đã đặt tên là rectangle, có kiểu là một tham chiếu không thể thay đổi đến một instance struct Rectangle. Như đã đề cập trong Chương 4, chúng ta muốn mượn struct thay vì lấy quyền sở hữu của nó. Bằng cách này, main giữ quyền sở hữu và có thể tiếp tục sử dụng rect1, đó là lý do tại sao chúng ta sử dụng & trong chữ ký hàm và nơi chúng ta gọi hàm.

Hàm area truy cập vào các trường width và height của instance Rectangle (lưu ý rằng việc truy cập các trường của một instance struct đã được mượn không di chuyển các giá trị trường, đó là lý do tại sao bạn thường thấy việc mượn các struct). Chữ ký hàm cho area bây giờ nói chính xác những gì chúng ta muốn: tính diện tích của Rectangle, sử dụng các trường width và height. Điều này truyền đạt rằng chiều rộng và chiều cao có liên quan đến nhau, và nó đưa ra các tên mô tả cho các giá trị thay vì sử dụng các giá trị chỉ mục tuple 0 và 1. Đây là một thắng lợi cho sự rõ ràng.

Thêm Chức năng Hữu ích với Derived Traits

Sẽ rất hữu ích nếu có thể in ra một instance của Rectangle trong khi chúng ta đang gỡ lỗi chương trình và xem các giá trị cho tất cả các trường của nó. Listing 5-11 thử sử dụng macro println! như chúng ta đã sử dụng trong các chương trước. Tuy nhiên, điều này sẽ không hoạt động.

struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!("rect1 is {rect1}");
}

Khi chúng ta biên dịch đoạn mã này, chúng ta nhận được một lỗi với thông báo cốt lõi này:

error[E0277]: `Rectangle` doesn't implement `std::fmt::Display`

Macro println! có thể thực hiện nhiều loại định dạng, và theo mặc định, dấu ngoặc nhọn báo cho println! sử dụng định dạng được gọi là Display: đầu ra dành cho người dùng cuối trực tiếp. Các kiểu nguyên thủy mà chúng ta đã thấy cho đến nay triển khai Display theo mặc định vì chỉ có một cách bạn muốn hiển thị 1 hoặc bất kỳ kiểu nguyên thủy nào khác cho người dùng. Nhưng với các struct, cách println! nên định dạng đầu ra ít rõ ràng hơn vì có nhiều khả năng hiển thị hơn: Bạn có muốn dấu phẩy hay không? Bạn có muốn in dấu ngoặc nhọn? Tất cả các trường có nên được hiển thị không? Do tính mơ hồ này, Rust không cố đoán những gì chúng ta muốn, và các struct không có sẵn thực thi của Display để sử dụng với println! và placeholder {}.

Nếu chúng ta tiếp tục đọc các lỗi, chúng ta sẽ tìm thấy ghi chú hữu ích này:

   = 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ử nó! Lệnh gọi macro println! bây giờ sẽ trông như println!("rect1 is {rect1:?}");. Đặt đặc tả :? bên trong dấu ngoặc nhọn báo cho println! rằng chúng ta muốn sử dụng một định dạng đầu ra được gọi là Debug. Trait Debug cho phép chúng ta in struct theo cách hữu ích cho các nhà phát triển để chúng ta có thể thấy giá trị của nó trong khi chúng ta đang gỡ lỗi mã của mình.

Biên dịch mã với thay đổi này. Chết tiệt! Chúng ta vẫn nhận được một lỗi:

error[E0277]: `Rectangle` doesn't implement `Debug`

Nhưng một lần nữa, trình biên dịch cung cấp cho chúng ta một ghi chú hữu ích:

   = help: the trait `Debug` is not implemented for `Rectangle`
   = note: add `#[derive(Debug)]` to `Rectangle` or manually `impl Debug for Rectangle`

Rust có bao gồm chức năng để in ra thông tin gỡ lỗi, nhưng chúng ta phải chọn tham gia một cách rõ ràng để làm cho chức năng đó có sẵn cho struct của chúng ta. Để làm điều đó, chúng ta thêm thuộc tính ngoài #[derive(Debug)] ngay trước định nghĩa struct, như được hiển thị trong Listing 5-12.

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!("rect1 is {rect1:?}");
}

Bây giờ khi chúng ta chạy chương trình, chúng ta sẽ không gặp bất kỳ lỗi nào, và chúng ta sẽ thấy đầu ra sau:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/rectangles`
rect1 is Rectangle { width: 30, height: 50 }

Tuyệt! Đây không phải là đầu ra đẹp nhất, nhưng nó hiển thị các giá trị của tất cả các trường cho instance này, điều này chắc chắn sẽ giúp ích trong quá trình gỡ lỗi. Khi chúng ta có các struct lớn hơn, sẽ hữu ích khi có đầu ra dễ đọc hơn một chút; trong những trường hợp đó, chúng ta có thể sử dụng {:#?} thay vì {:?} trong chuỗi println!. Trong ví dụ này, sử dụng kiểu {:#?} sẽ xuất ra như sau:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/rectangles`
rect1 is Rectangle {
    width: 30,
    height: 50,
}

Một cách khác để in ra một giá trị sử dụng định dạng Debug là sử dụng macro dbg!, lấy quyền sở hữu của một biểu thức (trái ngược với println!, lấy một tham chiếu), in ra tệp và số dòng nơi lệnh gọi macro dbg! đó xuất hiện trong mã của bạn cùng với giá trị kết quả của biểu thức đó, và trả lại quyền sở hữu của giá trị.

Lưu ý: Gọi macro dbg! in ra luồng bảng điều khiển lỗi tiêu chuẩn (stderr), trái ngược với println!, in ra luồng bảng điều khiển đầu ra tiêu chuẩn (stdout). Chúng ta sẽ nói thêm về stderr và stdout trong phần "Viết Thông báo Lỗi cho Standard Error Thay vì Standard Output" trong Chương 12.

Đây là một ví dụ trong đó chúng ta quan tâm đến giá trị được gán cho trường width, cũng như giá trị của toàn bộ struct trong rect1:

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let scale = 2;
    let rect1 = Rectangle {
        width: dbg!(30 * scale),
        height: 50,
    };

    dbg!(&rect1);
}

Chúng ta có thể đặt dbg! xung quanh biểu thức 30 * scale và, bởi vì dbg! trả lại quyền sở hữu của giá trị biểu thức, trường width sẽ nhận được cùng một giá trị như thể chúng ta không có lệnh gọi dbg! ở đó. Chúng ta không muốn dbg! lấy quyền sở hữu của rect1, vì vậy chúng ta sử dụng một tham chiếu đến rect1 trong lệnh gọi tiếp theo. Đây là đầu ra của ví dụ này:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.61s
     Running `target/debug/rectangles`
[src/main.rs:10:16] 30 * scale = 60
[src/main.rs:14:5] &rect1 = Rectangle {
    width: 60,
    height: 50,
}

Chúng ta có thể thấy phần đầu tiên của đầu ra đến từ dòng 10 của src/main.rs nơi chúng ta đang gỡ lỗi biểu thức 30 * scale, và giá trị kết quả của nó là 60 (định dạng Debug được thực hiện cho các số nguyên là chỉ in giá trị của chúng). Lệnh gọi dbg! trên dòng 14 của src/main.rs xuất ra giá trị của &rect1, đó là struct Rectangle. Đầu ra này sử dụng định dạng Debug đẹp của kiểu Rectangle. Macro dbg! có thể thực sự hữu ích khi bạn đang cố gắng tìm hiểu xem mã của bạn đang làm gì!

Ngoài trait Debug, Rust đã cung cấp một số trait cho chúng ta sử dụng với thuộc tính derive có thể thêm hành vi hữu ích cho các kiểu tùy chỉnh của chúng ta. Những trait đó và hành vi của chúng được liệt kê trong Phụ lục C. Chúng ta sẽ đề cập đến cách triển khai các trait này với hành vi tùy chỉnh cũng như cách tạo trait của riêng mình trong Chương 10. Ngoài ra còn có nhiều thuộc tính khác ngoài derive; để biết thêm thông tin, xem phần "Thuộc tính" của Tham chiếu Rust.

Hàm area của chúng ta rất cụ thể: nó chỉ tính diện tích của hình chữ nhật. Sẽ hữu ích hơn nếu gắn hành vi này chặt chẽ hơn với struct Rectangle của chúng ta vì nó sẽ không hoạt động với bất kỳ kiểu nào khác. Hãy xem xét làm thế nào chúng ta có thể tiếp tục cải tiến mã này bằng cách chuyển hàm area thành phương thức area được định nghĩa trên kiểu Rectangle của chúng ta.

Cú pháp Method

Method tương tự như các hàm: chúng ta khai báo chúng với từ khóa fn và một tên, chúng có thể có các tham số và giá trị trả về, và chúng chứa một số mã được chạy khi method được gọi từ nơi khác. Không giống như các hàm, method được định nghĩa trong ngữ cảnh của một struct (hoặc một enum hoặc một trait object, mà chúng ta sẽ đề cập trong Chương 6 và Chương 18, tương ứng), và tham số đầu tiên của chúng luôn là self, đại diện cho instance của struct mà method đang được gọi.

Định nghĩa Method

Hãy thay đổi hàm area có một instance Rectangle làm tham số và thay vào đó, tạo một method area được định nghĩa trên struct Rectangle, như thể hiện trong Listing 5-13.

#[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()
    );
}

Để định nghĩa hàm trong ngữ cảnh của Rectangle, chúng ta bắt đầu một khối impl (implementation) cho Rectangle. Mọi thứ trong khối impl này sẽ được liên kết với kiểu Rectangle. Sau đó, chúng ta di chuyển hàm area vào trong dấu ngoặc nhọn impl và thay đổi tham số đầu tiên (và trong trường hợp này, duy nhất) thành self trong chữ ký và mọi nơi trong nội dung hàm. Trong main, nơi chúng ta đã gọi hàm area và truyền rect1 như một đối số, chúng ta có thể sử dụng cú pháp method để gọi method area trên instance Rectangle của chúng ta. Cú pháp method được đặt sau một instance: chúng ta thêm một dấu chấm theo sau bởi tên method, dấu ngoặc đơn, và bất kỳ đối số nào.

Trong chữ ký cho area, chúng ta sử dụng &self thay vì rectangle: &Rectangle. &self thực tế là viết tắt của self: &Self. Trong một khối impl, kiểu Self là bí danh cho kiểu mà khối impl đang áp dụng. Method phải có một tham số tên là self kiểu Self làm tham số đầu tiên, vì vậy Rust cho phép bạn viết tắt điều này với chỉ tên self ở vị trí tham số đầu tiên. Lưu ý rằng chúng ta vẫn cần sử dụng & trước viết tắt self để chỉ ra rằng method này mượn instance Self, giống như chúng ta đã làm trong rectangle: &Rectangle. Method có thể lấy quyền sở hữu của self, mượn self không thay đổi như chúng ta đã làm ở đây, hoặc mượn self có thể thay đổi, giống như chúng có thể với bất kỳ tham số nào khác.

Chúng ta chọn &self ở đây vì cùng lý do chúng ta đã sử dụng &Rectangle trong phiên bản hàm: chúng ta không muốn lấy quyền sở hữu, và chúng ta chỉ muốn đọc dữ liệu trong struct, không viết vào nó. Nếu chúng ta muốn thay đổi instance mà chúng ta đã gọi method như một phần của những gì method làm, chúng ta sẽ sử dụng &mut self làm tham số đầu tiên. Có một method lấy quyền sở hữu của instance bằng cách chỉ sử dụng self làm tham số đầu tiên là hiếm; kỹ thuật này thường được sử dụng khi method chuyển đổi self thành một cái gì đó khác và bạn muốn ngăn người gọi sử dụng instance ban đầu sau khi chuyển đổi.

Lý do chính để sử dụng method thay vì hàm, ngoài việc cung cấp cú pháp method và không phải lặp lại kiểu của self trong mọi chữ ký method, là để tổ chức. Chúng ta đã đặt tất cả những thứ có thể làm với một instance của một kiểu trong một khối impl thay vì làm cho người dùng tương lai của mã chúng ta phải tìm kiếm khả năng của Rectangle ở nhiều nơi khác nhau trong thư viện mà chúng ta cung cấp.

Lưu ý rằng chúng ta có thể chọn đặt tên cho một method giống với tên của một trong các trường của struct. Ví dụ, chúng ta có thể định nghĩa một method trên Rectangle cũng được đặt tên là width:

#[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, chúng ta đang chọn cách làm cho method width trả về true nếu giá trị trong trường width của instance lớn hơn 0 và false nếu giá trị là 0: chúng ta có thể sử dụng một trường trong một method cùng tên cho bất kỳ mục đích nào. Trong main, khi chúng ta theo sau rect1.width với dấu ngoặc đơn, Rust biết chúng ta đang đề cập đến method width. Khi chúng ta không sử dụng dấu ngoặc đơn, Rust biết chúng ta đang đề cập đến trường width.

Thường xuyên, nhưng không phải lúc nào cũng vậy, khi chúng ta đặt cho một method cùng tên với một trường, chúng ta muốn nó chỉ trả về giá trị trong trường đó và không làm gì khác. Các method như thế này được gọi là getter, và Rust không tự động triển khai chúng cho các trường của struct như một số ngôn ngữ khác. Getter rất hữu ích vì bạn có thể làm cho trường này riêng tư nhưng method là công khai, và do đó cho phép truy cập chỉ đọc vào trường đó như một phần của API công khai của kiểu. Chúng ta sẽ thảo luận về các khái niệm công khai và riêng tư là gì và cách chỉ định một trường hoặc method là công khai hay riêng tư trong Chương 7.

Toán tử -> Ở Đâu?

Trong C và C++, hai toán tử khác nhau được sử dụng để gọi method: bạn sử dụng . nếu bạn đang gọi một method trực tiếp trên đối tượng và -> nếu bạn đang gọi method trên một con trỏ đến đối tượng và cần giải tham chiếu con trỏ trước. Nói cách khác, nếu object là một con trỏ, object->something() tương tự như (*object).something().

Rust không có một toán tử tương đương với ->; thay vào đó, Rust có một tính năng gọi là tham chiếu và giải tham chiếu tự động. Gọi method là một trong số ít nơi trong Rust có hành vi này.

Đây là cách nó hoạt động: khi bạn gọi một method bằng object.something(), Rust tự động thêm &, &mut, hoặc * để object khớp với chữ ký của method. Nói cách khác, những điều sau đây là giống nhau:

#![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ái đầu tiên trông gọn gàng hơn nhiều. Hành vi tham chiếu tự động này hoạt động bởi vì method có một người nhận rõ ràng—kiểu của self. Với người nhận và tên của một method, Rust có thể xác định rõ ràng liệu method đang đọc (&self), biến đổi (&mut self), hay tiêu thụ (self). Thực tế là Rust làm cho việc mượn ngầm định cho người nhận method là một phần lớn của việc làm cho quyền sở hữu trở nên tiện dụng trong thực tế.

Method với Nhiều Tham số

Hãy thực hành sử dụng method bằng cách triển khai một method thứ hai trên struct Rectangle. Lần này chúng ta muốn một instance của Rectangle lấy một instance khác của Rectangle và trả về true nếu Rectangle thứ hai có thể nằm hoàn toàn bên trong self (tức là Rectangle đầu tiên); nếu không, nó sẽ trả về false. Nghĩa là, một khi chúng ta đã định nghĩa method can_hold, chúng ta muốn có thể viết chương trình được hiển thị trong Listing 5-14.

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));
}

Đầu ra dự kiến sẽ trông giống như sau bởi vì cả hai kích thước của rect2 đều nhỏ hơn kích thước của rect1, nhưng rect3 rộng hơn rect1:

Can rect1 hold rect2? true
Can rect1 hold rect3? false

Chúng ta biết mình muốn định nghĩa một method, vì vậy nó sẽ nằm trong khối impl Rectangle. Tên method sẽ là can_hold, và nó sẽ lấy một bản mượn không thay đổi của một Rectangle khác làm tham số. Chúng ta có thể biết kiểu của tham số sẽ là gì bằng cách nhìn vào mã gọi method: rect1.can_hold(&rect2) truyền vào &rect2, đó là một bản mượn không thay đổi cho rect2, một instance của Rectangle. Điều này có ý nghĩa vì chúng ta chỉ cần đọc rect2 (thay vì viết, có nghĩa là chúng ta cần một bản mượn có thể thay đổi), và chúng ta muốn main giữ quyền sở hữu của rect2 để chúng ta có thể sử dụng nó lại sau khi gọi method can_hold. Giá trị trả về của can_hold sẽ là một giá trị Boolean, và việc triển khai sẽ kiểm tra xem chiều rộng và chiều cao của self có lớn hơn chiều rộng và chiều cao của Rectangle khác hay không, tương ứng. Hãy thêm method can_hold mới vào khối impl từ Listing 5-13, như được hiển thị trong Listing 5-15.

#[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));
}

Khi chúng ta chạy mã này với hàm main trong Listing 5-14, chúng ta sẽ nhận được đầu ra mong muốn. Method có thể lấy nhiều tham số mà chúng ta thêm vào chữ ký sau tham số self, và những tham số đó hoạt động giống như tham số trong hàm.

Hàm Liên kết

Tất cả các hàm được định nghĩa trong một khối impl được gọi là hàm liên kết bởi vì chúng được liên kết với kiểu được đặt tên sau impl. Chúng ta có thể định nghĩa các hàm liên kết mà không có self là tham số đầu tiên của chúng (và do đó không phải là method) bởi vì chúng không cần một instance của kiểu để làm việc với. Chúng ta đã sử dụng một hàm như thế này: hàm String::from mà được định nghĩa trên kiểu String.

Các hàm liên kết không phải là method thường được sử dụng cho các constructor sẽ trả về một instance mới của struct. Những hàm này thường được gọi là new, nhưng new không phải là một tên đặc biệt và không được tích hợp sẵn trong ngôn ngữ. Ví dụ, chúng ta có thể chọn cung cấp một hàm liên kết có tên square sẽ có một tham số kích thước và sử dụng nó làm cả chiều rộng và chiều cao, từ đó giúp tạo một Rectangle vuông dễ dàng hơn thay vì phải chỉ định cùng một giá trị hai lần:

Tên tệp: src/main.rs

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn square(size: u32) -> Self {
        Self {
            width: size,
            height: size,
        }
    }
}

fn main() {
    let sq = Rectangle::square(3);
}

Từ khóa Self trong kiểu trả về và trong nội dung của hàm là bí danh cho kiểu xuất hiện sau từ khóa impl, trong trường hợp này là Rectangle.

Để gọi hàm liên kết này, chúng ta sử dụng cú pháp :: với tên struct; let sq = Rectangle::square(3); là một ví dụ. Hàm này được đặt tên trong không gian tên bởi struct: cú pháp :: được sử dụng cho cả hàm liên kết và không gian tên được tạo bởi các module. Chúng ta sẽ thảo luận về các module trong Chương 7.

Nhiều Khối impl

Mỗi struct được phép có nhiều khối impl. Ví dụ, Listing 5-15 tương đương với mã được hiển thị trong Listing 5-16, trong đó mỗi method nằm trong khối impl riêng của nó.

#[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));
}

Không có lý do gì để tách các method này thành nhiều khối impl ở đây, nhưng đây là cú pháp hợp lệ. Chúng ta sẽ thấy một trường hợp trong đó nhiều khối impl là hữu ích trong Chương 10, nơi chúng ta thảo luận về các kiểu và trait generic.

Tóm tắt

Struct cho phép bạn tạo các kiểu tùy chỉnh có ý nghĩa cho miền của bạn. Bằng cách sử dụng struct, bạn có thể giữ các phần dữ liệu liên quan với nhau và đặt tên cho mỗi phần để làm mã của bạn rõ ràng. Trong các khối impl, bạn có thể định nghĩa các hàm được liên kết với kiểu của bạn, và method là một loại hàm liên kết cho phép bạn chỉ định hành vi mà các instance của struct của bạn có.

Nhưng struct không phải là cách duy nhất để bạn tạo kiểu tùy chỉnh: hãy chuyển sang tính năng enum của Rust để thêm một công cụ khác vào hộp công cụ của bạn.

Enums và Pattern Matching

Trong chương này, chúng ta sẽ tìm hiểu về enumerations, hay còn được gọi là enums. Enums cho phép bạn định nghĩa một kiểu bằng cách liệt kê các biến thể (variants) có thể có của nó. Đầu tiên chúng ta sẽ định nghĩa và sử dụng một enum để chỉ ra cách một enum có thể mã hóa ý nghĩa cùng với dữ liệu. Tiếp theo, chúng ta sẽ khám phá một enum đặc biệt hữu ích là Option, nó biểu thị rằng một giá trị có thể là một cái gì đó hoặc không là gì cả. Sau đó, chúng ta sẽ xem xét cách mà pattern matching trong biểu thức match giúp dễ dàng chạy các đoạn mã khác nhau cho các giá trị khác nhau của một enum. Cuối cùng, chúng ta sẽ tìm hiểu cách cấu trúc if let là một thành ngữ khác tiện lợi và ngắn gọn có sẵn để xử lý enums trong mã của bạn.

Định nghĩa một Enum

Trong khi struct cung cấp cho bạn cách nhóm các trường và dữ liệu liên quan với nhau, như một Rectangle với width và height của nó, enum cho bạn cách để nói rằng một giá trị là một trong một tập hợp các giá trị có thể có. Ví dụ, chúng ta có thể muốn nói rằng Rectangle là một trong một tập hợp các hình dạng có thể có bao gồm cả Circle và Triangle. Để làm được điều này, Rust cho phép chúng ta mã hóa các khả năng này như một enum.

Hãy xem xét một tình huống mà chúng ta có thể muốn biểu đạt trong mã và tìm hiểu tại sao enum hữu ích và phù hợp hơn struct trong trường hợp này. Giả sử chúng ta cần làm việc với địa chỉ IP. Hiện tại, hai chuẩn chính được sử dụng cho địa chỉ IP: phiên bản bốn và phiên bản sáu. Vì đây là những khả năng duy nhất cho một địa chỉ IP mà chương trình của chúng ta sẽ gặp phải, chúng ta có thể liệt kê tất cả các biến thể có thể có, đó là nơi mà enumeration có được tên gọi của nó.

Bất kỳ địa chỉ IP nào cũng có thể là địa chỉ phiên bản bốn hoặc phiên bản sáu, nhưng không thể là cả hai cùng một lúc. Đặc tính đó của địa chỉ IP làm cho cấu trúc dữ liệu enum trở nên thích hợp bởi vì một giá trị enum chỉ có thể là một trong các biến thể của nó. Cả hai địa chỉ phiên bản bốn và phiên bản sáu đều về cơ bản vẫn là địa chỉ IP, vì vậy chúng nên được xử lý như cùng một kiểu khi mã đang xử lý các tình huống áp dụng cho bất kỳ loại địa chỉ IP nào.

Chúng ta có thể biểu đạt khái niệm này trong mã bằng cách định nghĩa một enum IpAddrKind và liệt kê các loại có thể có của địa chỉ IP, V4 và V6. Đây là các biến thể 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 bây giờ là một kiểu dữ liệu tùy chỉnh mà chúng ta có thể sử dụng ở nơi khác trong mã của mình.

Giá trị Enum

Chúng ta có thể tạo các instance của mỗi biến thể của IpAddrKind 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 biến thể của enum được đặt tên trong không gian tên dưới định danh của nó, và chúng ta sử dụng dấu hai chấm kép để tách chúng. Điều này hữu ích bởi vì bây giờ cả hai giá trị IpAddrKind::V4 và IpAddrKind::V6 đều thuộc cùng một kiểu: IpAddrKind. Chúng ta sau đó có thể, ví dụ, định nghĩa một hàm nhận 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 cả hai biến thể:

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 có nhiều lợi thế hơn. Khi suy nghĩ nhiều hơn về kiểu địa chỉ IP của chúng ta, hiện tại chúng ta không có cách nào để lưu trữ dữ liệu thực tế của địa chỉ IP; chúng ta chỉ biết nó thuộc loại nào. Vì bạn vừa mới học về struct trong Chương 5, bạn có thể bị cám dỗ để giải quyết vấn đề này với struct như được thể hiện 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"),
    };
}

Ở đây, chúng ta đã định nghĩa một struct IpAddr có hai trường: một trường kind là kiểu IpAddrKind (enum mà chúng ta đã định nghĩa trước đó) và một trường address kiểu String. Chúng ta có hai instance của struct này. Instance đầu tiên là home, và nó có giá trị IpAddrKind::V4 làm kind với dữ liệu địa chỉ liên quan là 127.0.0.1. Instance thứ hai là loopback. Nó có biến thể khác của IpAddrKind làm giá trị kind của nó, V6, và có địa chỉ ::1 liên kết với nó. Chúng ta đã sử dụng một struct để nhóm các giá trị kind và address lại với nhau, vì vậy bây giờ biến thể được liên kết với giá trị.

Tuy nhiên, biểu diễn cùng một khái niệm chỉ bằng enum thì ngắn gọn hơn: thay vì một enum bên trong một struct, chúng ta có thể đưa dữ liệu trực tiếp vào mỗi biến thể enum. Định nghĩa mới này của enum IpAddr nói rằng cả hai biến thể V4 và V6 sẽ có các giá trị String liên quan:

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 dữ liệu trực tiếp vào mỗi biến thể của enum, vì vậy không cần một struct bổ sung. Ở đây, cũng dễ dàng hơn để thấy một chi tiết khác về cách enum hoạt động: tên của mỗi biến thể enum mà chúng ta định nghĩa cũng trở thành một hàm xây dựng một instance của enum đó. Nghĩa là, IpAddr::V4() là một lệnh gọi hàm nhận một đối số String và trả về một instance của kiểu IpAddr. Chúng ta tự động nhận được hàm constructor này được định nghĩa là kết quả của việc định nghĩa enum.

Có một lợi thế khác khi sử dụng enum thay vì struct: mỗi biến thể có thể có các loại và số lượng dữ liệu liên quan khác nhau. Địa chỉ IP phiên bản bốn sẽ luôn có bốn thành phần số mà sẽ có giá trị từ 0 đến 255. Nếu chúng ta muốn lưu trữ địa chỉ V4 dưới dạng bốn giá trị u8 nhưng vẫn biểu đạt địa chỉ V6 dưới dạng một giá trị String, chúng ta sẽ không thể làm được với một struct. Enum 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 ta đã thể hiện một số cách khác nhau để định nghĩa cấu trúc dữ liệu để lưu trữ phiên bản bốn và phiên bản sáu địa chỉ IP. Tuy nhiên, hóa ra, muốn lưu trữ địa chỉ IP và mã hóa loại nào của chúng là rất phổ biến đến nỗi thư viện chuẩn đã có một định nghĩa 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ó chính xác enum và các biến thể 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 biến thể dưới dạng hai struct khác nhau, được định nghĩa khác nhau cho mỗi biến thể:

#![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 biến thể enum: chuỗi, kiểu số, hoặc struct, ví dụ vậy. Bạn thậm chí có thể bao gồm một enum khác! Ngoài ra, các kiểu thư viện chuẩn thường không phức tạp hơn nhiều so với những gì bạn có thể nghĩ ra.

Lưu ý rằng mặc dù thư viện chuẩn chứa một định nghĩa cho IpAddr, chúng ta vẫn có thể tạo và sử dụng định nghĩa của riêng mình mà không gây xung đột vì chúng ta chưa đưa định nghĩa của thư viện chuẩn vào phạm vi của mình. Chúng ta sẽ nói thêm về việc đưa các kiểu vào phạm vi trong Chương 7.

Hãy xem một ví dụ khác về enum trong Listing 6-2: ví dụ này có sự đa dạng về các kiểu nhúng trong các biến thể của nó.

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {}

Enum này có bốn biến thể với các kiểu khác nhau:

• Quit Không có dữ liệu nào liên kết với nó.
• Move Có các trường có tên, giống như một struct.
• Write Bao gồm một String duy nhất.
• ChangeColor Bao gồm ba giá trị i32.

Định nghĩa một enum với các biến thể như trong Listing 6-2 tương tự như việc định nghĩa các loại định nghĩa struct khác nhau, ngoại trừ việc enum không sử dụng từ khóa struct và tất cả các biến thể được nhóm lại với nhau dưới kiểu Message. Các struct sau đây có thể lưu trữ cùng dữ liệu mà các biến thể enum trước đó lưu trữ:

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, chúng ta không thể dễ dàng định nghĩa một hàm để nhận bất kỳ loại thông điệp nào trong số này như chúng ta có thể làm với enum Message được định nghĩa trong Listing 6-2, vốn là một kiểu duy nhất.

Có một điểm tương đồng nữa giữa enum và struct: giống như chúng ta có thể định nghĩa các phương thức trên struct bằng cách sử dụng impl, chúng ta cũng có thể định nghĩa các phương thức trên enum. Đây là một phương thức có tên call mà chúng ta có thể định nghĩa trên enum Message của chúng ta:

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();
}

Nội dung 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 ta đã tạo một biến m có giá trị Message::Write(String::from("hello")), và đó là giá trị mà self sẽ là trong nội dung của phương thức call khi m.call() chạy.

Hãy xem một enum khác trong thư viện chuẩn rất phổ biến và hữu ích: Option.

Enum Option và Lợi thế của Nó So với Giá trị Null

Phần này khám phá một trường hợp nghiên cứu của Option, một enum khác được định nghĩa bởi thư viện chuẩn. Kiểu Option mã hóa kịch bản rất phổ biến trong đó một giá trị có thể là một thứ gì đó hoặc có thể là không có gì.

Ví dụ, nếu bạn yêu cầu phần tử đầu tiên trong danh sách không rỗng, bạn sẽ nhận được một giá trị. Nếu bạn yêu cầu phần tử đầu tiên trong danh sách rỗng, bạn sẽ không nhận được gì. Biểu đạt khái niệm này trong hệ thống kiểu có nghĩa là trình biên dịch có thể kiểm tra liệu bạn đã xử lý tất cả các trường hợp mà bạn nên xử lý hay chưa; điều này có thể ngăn chặn các lỗi cực kỳ 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 nghĩ đến theo nghĩa của các tính năng bạn bao gồm, nhưng các tính năng bạn loại trừ cũng quan trọng. Rust không có tính năng null 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, biến luôn có thể ở một trong hai trạng thái: null hoặc không-null.

Trong bài thuyết trình năm 2009 của mình "Null References: The Billion Dollar Mistake," Tony Hoare, người phát minh ra null, đã nói như sau:

Tôi gọi đó là sai lầm hàng tỷ đô la của mình. Vào thời điểm đó, tôi đang thiết kế hệ thống kiểu đầu tiên toàn diện cho các tham chiếu trong một 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 tham chiếu phải hoàn toàn an toàn, 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 cám dỗ đặt vào một tham chiếu null, đơ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 và hệ thống bị sập, có lẽ đã gây ra tổn thất 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 một giá trị null như một giá trị không-null, bạn sẽ gặp một loại lỗi nào đó. Bởi vì thuộc tính null hoặc không-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 mà null đang cố gắng biểu đạt vẫn là một khái niệm hữu ích: một null là một giá trị hiện không hợp lệ hoặc vắng mặt vì một lý do nào đó.

Vấn đề thực sự không phải là với khái niệm mà là với cách triển khai cụ thể. Vì vậy, Rust không có null, nhưng nó có một enum có thể mã hóa khái niệm về một giá trị đang hiện diện hoặc vắng mặt. Enum này là Option<T>, và nó được định nghĩa bởi thư viện chuẩn như sau:

#![allow(unused)]
fn main() {
enum Option<T> {
    None,
    Some(T),
}
}

Enum Option<T> rất hữu ích đến nỗi nó thậm chí được đưa vào prelude; 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 prelude: bạn có thể sử dụng Some và None trực tiếp mà không cần tiền tố Option::. Enum Option<T> vẫn chỉ là một enum thông thường, và Some(T) và None vẫn là các biến thể của kiểu Option<T>.

Cú pháp <T> là một tính năng của Rust mà chúng ta chưa nói đến. Đó là một tham số kiểu generic, và chúng ta sẽ đề cập đến generic 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> có nghĩa là biến thể Some của enum Option có thể chứa một phần dữ liệu của bất kỳ kiểu nào, và mỗi kiểu cụ thể được sử dụng thay thế cho T làm cho toàn bộ kiểu Option<T> trở thành một kiểu khác. Dưới đây là một số ví dụ về việc sử dụng các giá trị Option để lưu trữ các kiểu số và kiểu ký tự:

fn main() {
    let some_number = Some(5);
    let some_char = Some('e');

    let absent_number: Option<i32> = None;
}

Kiểu của some_number là Option<i32>. Kiểu của some_char là Option<char>, là một kiểu khác. Rust có thể suy ra các kiểu này bởi vì chúng ta đã 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 ta chú thích toàn bộ kiểu Option: trình biên dịch không thể suy ra kiểu mà biến thể Some tương ứng sẽ giữ bằng cách chỉ nhìn vào một giá trị None. Ở đây, chúng ta nói với Rust rằng chúng ta muốn absent_number có kiểu Option<i32>.

Khi chúng ta có một giá trị Some, chúng ta biết rằng một giá trị đang hiện diện và giá trị đó được giữ bên trong Some. Khi chúng ta có một giá trị None, theo một nghĩa nào đó, nó có nghĩa giống như null: chúng ta không có một giá trị hợp lệ. Vậy tại sao việc có Option<T> lại tốt hơn việc có null?

Nói ngắn gọn, bởi vì Option<T> và T (trong đó T có thể là bất kỳ kiểu nào) là các kiểu khác nhau, trình biên dịch sẽ không cho phép chúng ta sử dụng giá trị Option<T> như thể nó là một giá trị hợp lệ chắc chắn. Ví dụ, đoạn mã này sẽ không biên dịch, bởi vì nó đang cố gắng 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 ta chạy mã này, chúng ta sẽ nhận được một thông báo lỗi như thế này:

$ 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`
  = help: the following other types implement trait `Add<Rhs>`:
            `&i8` implements `Add<i8>`
            `&i8` implements `Add`
            `i8` implements `Add<&i8>`
            `i8` implements `Add`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `enums` (bin "enums") due to 1 previous error

Mạnh mẽ! Về thực chất, thông báo lỗi này có nghĩa là Rust không hiểu cách cộng một i8 và một Option<i8>, bởi vì chúng là các kiểu khác nhau. Khi chúng ta có một giá trị của một kiểu như i8 trong Rust, trình biên dịch sẽ đảm bảo rằng chúng ta luôn 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 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ỳ kiểu giá trị nào mà chúng ta đang làm việc) thì chúng ta mới phải lo lắng về việc có thể không có một giá trị, và trình biên dịch sẽ đảm bảo chúng ta 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 đổi một Option<T> thành một T trước khi bạn có thể thực hiện các hoạt động T với nó. Nói chung, điều này giúp bắt được một trong những vấn đề phổ biến nhất với null: giả định rằng một thứ không phải null khi nó thực sự là null.

Việc loại bỏ nguy cơ giả định không chính xác một giá trị không-null giúp bạn tự tin hơn về mã của mình. Để có một giá trị có thể là null, bạn phải chọn tham gia một cách rõ ràng bằng cách làm cho kiểu của giá trị đó là Option<T>. Sau đó, khi bạn sử dụng giá trị đó, bạn bắt buộc phải xử lý một cách rõ ràng trường hợp khi giá trị là null. Mọi nơi mà một giá trị có kiểu 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ế sự phổ biến của null và tăng tính an toàn của mã Rust.

Vậy làm thế nào để bạn lấy giá trị T ra khỏi một biến thể Some khi bạn có một giá trị kiểu Option<T> để bạn có thể sử dụng giá trị đó? Enum Option<T> có một số lượng lớn các phương thức hữu ích trong nhiều tình huống khác nhau; bạn có thể kiểm tra chúng trong tài liệu của nó. Làm quen với các phương thức 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ý mỗi biến thể. Bạn muốn một số mã chỉ chạy khi bạn có giá trị Some(T), và mã này được phép sử dụng T bên trong. Bạn muốn một số mã khác chỉ chạy nếu bạn có một giá trị None, và mã đó không có giá trị T nào để sử dụng. Biểu thức match là một cấu trúc luồng điều khiển làm chính xác điều này khi được sử dụng với enum: nó sẽ chạy mã khác nhau tùy thuộc vào biến thể nào của enum mà nó có, và mã đó có thể sử dụng dữ liệu bên trong giá trị phù hợp.

Cấu trúc Điều khiển Luồng match

Rust có một cấu trúc điều khiển luồng cực kỳ mạnh mẽ 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ị văn bản, tên biến, ký tự đại diện, và nhiều thứ khác; Chương 19 bao gồm tất cả các loại mẫu khác nhau và chức năng của chúng. Sức mạnh của match đến từ tính biểu đạt của các mẫu và việc 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ề biểu thức match giống như một máy phân loại tiền xu: các đồ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 và vừa với nó. Tương tự như vậy, các giá trị đi qua từng mẫu trong một match, và tại mẫu đầu tiên mà giá trị "vừa vặn," giá trị đó rơi vào khối mã liên quan để đượ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ụ với match! Chúng ta có thể viết một hàm nhận một đồng xu không xác định của Hoa Kỳ và, tương tự như máy đếm, xác định loại đồng xu nào và trả về giá trị của nó bằng xu, như 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() {}

Hãy phân tích match trong hàm value_in_cents. Đầu tiên, chúng ta liệt kê từ khóa match và theo sau là một biểu thức, trong trường hợp này là giá trị coin. Điều này có vẻ rất giống với một biểu thức điều kiện được sử dụng với if, nhưng có một sự khác biệt lớn: với if, điều kiện cần phải đánh giá thành một giá trị Boolean, nhưng ở đây nó có thể là bất kỳ kiểu dữ liệu nào. Kiểu của coin trong ví dụ này là enum Coin mà chúng ta đã định nghĩa ở dòng đầu tiên.

Tiếp theo là các nhánh của match. Một nhánh có hai phần: một mẫu và một đoạn mã. Nhánh đầu tiên ở đây có mẫu là giá trị Coin::Penny và sau đó là toán tử => tách biệt mẫu và mã sẽ chạy. Mã trong trường hợp này chỉ đơn giản là giá trị 1. Mỗi nhánh được tách biệt với nhánh tiếp theo bằng một 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ị, đoạn mã liên kết với mẫu đó sẽ được thực thi. Nếu mẫu đó không khớp với giá trị, việc thực thi tiếp tục đến nhánh tiếp theo, tương tự như trong máy phân loại tiền xu. Chúng ta có thể có nhiều nhánh tùy theo nhu cầu: trong Listing 6-3, match của chúng ta có bốn nhánh.

Đoạn mã 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 khớ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ã trong nhánh match ngắn gọn, như trong Listing 6-3 nơi 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 match, bạn phải sử dụng dấu ngoặc nhọn, và dấu phẩy sau nhánh sau đó là tùy chọn. Ví dụ, đoạn mã sau in ra "Lucky penny!" mỗi khi phương thức được gọi với một Coin::Penny, nhưng vẫn trả về giá trị cuối cùng của khối, 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 Gắn với Giá trị

Một tính năng hữu ích khác của nhánh match là chúng có thể gắn với các phần của giá trị khớp với mẫu. Đây là cách chúng ta có thể trích xuất các giá trị từ các biến thể enum.

Ví dụ, hãy thay đổi một trong các biến thể enum của chúng ta để lưu trữ dữ liệu bên trong nó. Từ năm 1999 đến 2008, Hoa Kỳ đã đúc đồng 25 xu với các thiết kế khác nhau cho mỗi tiểu bang trong số 50 tiểu bang trên một mặt. Không có đồng xu nào khác có thiết kế tiểu bang, vì vậy chỉ có đồng quarter 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 biến thể Quarter để bao gồm một giá trị UsState được lưu trữ bên trong nó, như chúng ta đã làm 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() {}

Hãy tưởng tượng rằng một người bạn đang cố gắng sưu tập tất cả 50 đồng quarter của các tiểu bang. Trong khi chúng ta phân loại tiền lẻ theo loại đồng xu, chúng ta cũng sẽ nói to tên của tiểu bang liên quan đến mỗi đồng quarter để nếu đó là một đồng mà bạn của chúng ta chưa có, họ có thể thêm nó vào bộ sưu tập của mình.

Trong biểu thức match cho đoạn mã này, chúng ta thêm một biến có tên state vào mẫu khớp với các giá trị của biến thể Coin::Quarter. Khi một Coin::Quarter khớp, biến state sẽ gắn với giá trị của tiểu bang của đồng quarter đó. Sau đó, chúng ta có thể sử dụng state trong đoạn mã cho nhánh đó, như sau:

#[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 ta so sánh giá trị đó với từng nhánh match, không có nhánh nào khớp cho đến khi chúng ta đến Coin::Quarter(state). Tại thời điểm đó, giá trị gắn với state sẽ là UsState::Alaska. Chúng ta có thể sử dụng giá trị gắn đó trong biểu thức println!, từ đó lấy được giá trị tiểu bang bên trong ra khỏi biến thể enum Coin cho Quarter.

Khớp với Option<T>

Trong phần trước, chúng ta muốn lấy giá trị T bên trong ra khỏi trường hợp Some khi sử dụng Option<T>; chúng ta cũng có thể xử lý Option<T> bằng cách sử dụng match, như chúng ta đã làm với enum Coin! Thay vì so sánh các đồng xu, chúng ta sẽ so sánh các biến thể của Option<T>, nhưng cách biểu thức match hoạt động vẫn giữ nguyên.

Giả sử chúng ta muốn viết một hàm nhận một Option<i32> và, nếu có giá trị bên trong, cộng 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ỳ thao tác nào.

Hàm này rất dễ viết, nhờ match, và sẽ trông giố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);
}

Hãy xem xét lần thực thi đầ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 của plus_one sẽ có giá trị Some(5). Sau đó, chúng ta so sánh giá trị đó 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) không? Có! Chúng ta có cùng một biến thể. i gắn với giá trị được chứa trong Some, vì vậy i nhận giá trị 5. Sau đó, mã trong nhánh match được thực thi, vì vậy chúng ta cộng 1 vào giá trị của i và tạo ra một giá trị Some mới với tổng 6 bên trong.

Bây giờ hãy xem xét lần gọi thứ hai của plus_one trong Listing 6-5, trong đó x là None. Chúng ta đi vào match và so sánh với 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ó khớp! Không có giá trị để cộng thêm, vì vậy chương trình dừng lại và trả về giá trị None ở phía bên phải của =>. Bởi vì nhánh đầu tiên đã khớp, 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 tình huống. Bạn sẽ thấy mẫu này rất nhiều trong mã Rust: match đối với một enum, gắn một biến với dữ liệu bên trong, và sau đó thực thi mã dựa trên nó. Ban đầu có thể hơi khó hiểu, nhưng một khi bạn đã quen với nó, bạn sẽ ước rằng mọi ngôn ngữ đều có nó. Nó luôn là một tính năng yêu thích của người dùng.

Các Match Đều Phải Đầy đủ

Có một khía cạnh khác của match mà chúng ta cần thảo luận: các mẫu của nhánh phải bao gồm tất cả các khả năng. Hãy xem xét phiên bản này của hàm plus_one của chúng ta, có một lỗi và sẽ không biên dịch được:

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, đây là một lỗi mà Rust biết cách phát hiện. Nếu chúng ta cố gắng biên dịch mã này, chúng ta sẽ nhận được lỗi này:

$ 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
  |
note: `Option<i32>` defined here
 --> /rustc/4eb161250e340c8f48f66e2b929ef4a5bed7c181/library/core/src/option.rs:572:1
 ::: /rustc/4eb161250e340c8f48f66e2b929ef4a5bed7c181/library/core/src/option.rs:576:5
  |
  = note: not covered
  = note: the matched value is of type `Option<i32>`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
  |
4 ~             Some(i) => Some(i + 1),
5 ~             None => todo!(),
  |

For more information about this error, try `rustc --explain E0004`.
error: could not compile `enums` (bin "enums") due to 1 previous error

Rust biết rằng chúng ta không bao gồm mọi trường hợp có thể xảy ra, và thậm chí còn biết mẫu nào chúng ta đã quên! Các match trong Rust là đầy đủ: chúng ta phải liệt kê tất cả các khả năng để mã hợp lệ. Đặc biệt là trong trường hợp 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 việc giả định rằng chúng ta có một giá trị khi chúng ta có thể có null, từ đó làm cho lỗi hàng tỷ đô la đã thảo luận trước đó trở nên không thể.

Mẫu Bắt tất cả và Placeholder _

Sử dụng enum, chúng ta cũng có thể thực hiện các hành động đặc biệt cho một số giá trị cụ thể, nhưng đối với tất cả các giá trị khác, thực hiện một hành động mặc định. Hãy tưởng tượng chúng ta đang triển khai một trò chơi, trong đó, nếu bạn tung được số 3 trên xúc xắc, người chơi của bạn không di chuyển, mà thay vào đó nhận được một chiếc mũ đẹp mới. Nếu bạn tung được số 7, người chơi của bạn mất một chiếc mũ đẹp. Đối với tất cả các giá trị khác, người chơi của bạn di chuyển số ô đó trên bàn chơi. Dưới đây là một match triển khai logic đó, với kết quả của việc tung xúc xắc được cố định thay vì một giá trị ngẫu nhiên, và tất cả logic khác được biểu diễn bằng các hàm không có nội dung vì 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ị văn bản 3 và 7. Đối với nhánh cuối cùng bao gồm mọi giá trị có thể khác, mẫu là biến mà chúng ta đã chọn đặt tên là other. Mã chạy cho nhánh other sử dụng biến bằng cách truyền nó vào hàm move_player.

Mã này biên dịch được, mặc dù chúng ta chưa liệt kê tất cả các giá trị có thể có của một u8, bởi 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 bắt tất cả 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 bắt tất cả cuối cùng vì các mẫu được đánh giá theo thứ tự. Nếu chúng ta đặt nhánh bắt tất cả sớm hơn, các nhánh khác sẽ không bao giờ chạy, vì vậy Rust sẽ cảnh báo chúng ta nếu chúng ta thêm nhánh sau một nhánh bắt tất cả!

Rust cũng có một mẫu mà chúng ta có thể sử dụng khi muốn bắt tất cả nhưng không muốn sử dụng giá trị trong mẫu bắt tất cả: _ là một mẫu đặc biệt khớp với bất kỳ giá trị nào và không gắn với giá trị đó. Điều này nói với Rust 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 luật của trò chơi: bây giờ, nếu bạn tung bất kỳ số nào khác ngoài 3 hoặc 7, bạn phải tung lại. Chúng ta không còn cần sử dụng giá trị bắt tất cả nữa, 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 rõ ràng 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ì.

Cuối cùng, chúng ta sẽ thay đổi luật 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ỳ số nào khác ngoài 3 hoặc 7. Chúng ta có thể biểu đạt điều đó bằng cách sử dụng giá trị đơn vị (kiểu tuple rỗng mà chúng ta đã đề cập trong phần "Kiểu Tuple") làm mã đi kèm 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ẫu trong một nhánh trước đó, và chúng ta không muốn chạy bất kỳ mã nào trong trường hợp này.

Còn nhiều điều về mẫu và khớp mà chúng ta sẽ đề cập trong Chương 19. Hiện tại, chúng ta sẽ tiếp tục với cú pháp if let, có thể hữu ích trong các tình huống mà biểu thức match hơi dài dòng.

Điều khiển Luồng Ngắn Gọn với if let và let else

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. Hãy xem xét chương trình trong Listing 6-6 khớp với một giá trị Option<u8> trong biến config_max nhưng chỉ muốn thực thi mã nếu giá trị là biến thể Some.

fn main() {
    let config_max = Some(3u8);
    match config_max {
        Some(max) => println!("The maximum is configured to be {max}"),
        _ => (),
    }
}

Nếu giá trị là Some, chúng ta in ra giá trị trong biến thể Some bằng cách gắn giá trị với biến max trong mẫu. Chúng ta không muốn làm gì với giá trị None. Để thỏa mãn biểu thức match, chúng ta phải thêm _ => () sau khi xử lý chỉ một biến thể, đó là mã mẫu khó chịu cần thêm.

Thay vào đó, chúng ta có thể viết điều này ngắn gọ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 lấy 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 cách như match, trong đó biểu thức được đưa vào match và mẫu là nhánh đầu tiên của nó. Trong trường hợp này, mẫu là Some(max), và max gắn 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 tương tự như cách chúng ta sử dụng max trong nhánh match tương ứng. Mã trong khối if let chỉ chạy nếu giá trị khớp với mẫu.

Sử dụng if let có nghĩa là ít phải gõ hơn, ít thụt đầu dòng, và ít mã mẫu. Tuy nhiên, bạn mất đi kiểm tra tính đầy đủ mà match bắt buộc để đảm bảo bạn không quên xử lý bất kỳ trường hợp nào. Việc 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ể và liệu việc đạt được sự ngắn gọn có phải là một sự đánh đổi phù hợp cho việc mất đi kiểm tra tính đầy đủ hay không.

Nói cách khác, bạn có thể coi if let như là cú pháp đường tắt cho match mà 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 ta có thể bao gồm một else với if let. Khối mã đi kèm với else giống như khối mã sẽ đi kèm với trường hợp _ trong biểu thức match tương đương với if let và else. Nhớ lại định nghĩa enum Coin trong Listing 6-4, trong đó biến thể Quarter cũng chứa một giá trị UsState. Nếu chúng ta muốn đếm tất cả các đồng xu không phải quarter mà chúng ta thấy đồng thời thông báo về tiểu bang của các quarter, chúng ta có thể làm điều đó với 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 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;
    }
}

Duy trì trên "Đường Hạnh phúc" với let...else

Mẫu phổ biến là thực hiện một số tính toán khi một giá trị hiện diện và trả về một giá trị mặc định nếu không. Tiếp tục với ví dụ của chúng ta về tiền xu với một giá trị UsState, nếu chúng ta muốn nói điều gì đó hài hước tùy thuộc vào tuổi của tiểu bang trên đồng quarter, chúng ta có thể giới thiệu một phương thức trên UsState để kiểm tra tuổi của một tiểu bang, như sau:

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

impl UsState {
    fn existed_in(&self, year: u16) -> bool {
        match self {
            UsState::Alabama => year >= 1819,
            UsState::Alaska => year >= 1959,
            // -- snip --
        }
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn describe_state_quarter(coin: Coin) -> Option<String> {
    if let Coin::Quarter(state) = coin {
        if state.existed_in(1900) {
            Some(format!("{state:?} is pretty old, for America!"))
        } else {
            Some(format!("{state:?} is relatively new."))
        }
    } else {
        None
    }
}

fn main() {
    if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
        println!("{desc}");
    }
}

Sau đó, chúng ta có thể sử dụng if let để khớp với loại xu, giới thiệu một biến state trong phần thân của điều kiện, như trong Listing 6-7.

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

impl UsState {
    fn existed_in(&self, year: u16) -> bool {
        match self {
            UsState::Alabama => year >= 1819,
            UsState::Alaska => year >= 1959,
            // -- snip --
        }
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn describe_state_quarter(coin: Coin) -> Option<String> {
    if let Coin::Quarter(state) = coin {
        if state.existed_in(1900) {
            Some(format!("{state:?} is pretty old, for America!"))
        } else {
            Some(format!("{state:?} is relatively new."))
        }
    } else {
        None
    }
}

fn main() {
    if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
        println!("{desc}");
    }
}

Điều đó hoàn thành công việc, nhưng nó đã đẩy công việc vào trong phần thân của câu lệnh if let, và nếu công việc cần làm phức tạp hơn, có thể khó theo dõi chính xác cách các nhánh cấp cao liên quan đến nhau. Chúng ta cũng có thể tận dụng thực tế là các biểu thức tạo ra một giá trị hoặc để tạo ra state từ if let hoặc để trả về sớm, như trong Listing 6-8. (Bạn cũng có thể làm tương tự với match.)

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

impl UsState {
    fn existed_in(&self, year: u16) -> bool {
        match self {
            UsState::Alabama => year >= 1819,
            UsState::Alaska => year >= 1959,
            // -- snip --
        }
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn describe_state_quarter(coin: Coin) -> Option<String> {
    let state = if let Coin::Quarter(state) = coin {
        state
    } else {
        return None;
    };

    if state.existed_in(1900) {
        Some(format!("{state:?} is pretty old, for America!"))
    } else {
        Some(format!("{state:?} is relatively new."))
    }
}

fn main() {
    if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
        println!("{desc}");
    }
}

Điều này cũng hơi khó theo dõi theo cách riêng của nó! Một nhánh của if let tạo ra một giá trị, và nhánh kia trả về hoàn toàn từ hàm.

Để làm cho mẫu phổ biến này dễ diễn đạt hơn, Rust có let...else. Cú pháp let...else lấy một mẫu ở phía bên trái và một biểu thức ở bên phải, rất giống với if let, nhưng nó không có nhánh if, chỉ có nhánh else. Nếu mẫu khớp, nó sẽ gắn giá trị từ mẫu trong phạm vi bên ngoài. Nếu mẫu không khớp, chương trình sẽ chuyển vào nhánh else, phải trả về từ hàm.

Trong Listing 6-9, bạn có thể thấy Listing 6-8 trông như thế nào khi sử dụng let...else thay cho if let.

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

impl UsState {
    fn existed_in(&self, year: u16) -> bool {
        match self {
            UsState::Alabama => year >= 1819,
            UsState::Alaska => year >= 1959,
            // -- snip --
        }
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn describe_state_quarter(coin: Coin) -> Option<String> {
    let Coin::Quarter(state) = coin else {
        return None;
    };

    if state.existed_in(1900) {
        Some(format!("{state:?} is pretty old, for America!"))
    } else {
        Some(format!("{state:?} is relatively new."))
    }
}

fn main() {
    if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
        println!("{desc}");
    }
}

Lưu ý rằng nó vẫn "trên đường hạnh phúc" trong phần thân chính của hàm theo cách này, không có luồng điều khiển khác biệt đáng kể cho hai nhánh như if let đã làm.

Nếu bạn có tình huống mà chương trình của bạn có logic quá dài dòng để diễn đạt bằng match, hãy nhớ rằng if let và let...else cũng có trong bộ 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 kiểu tùy chỉnh có thể là một trong một tập hợp các giá trị được liệt kê. Chúng ta đã thấy cách kiểu Option<T> của thư viện tiêu chuẩn giúp bạn sử dụng hệ thống kiểu để ngăn chặn lỗi. Khi các giá trị enum có dữ liệu bên trong, 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 giờ đây 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 struct và enum. Việc tạo các kiểu tùy chỉnh để sử dụng trong API của bạn đảm bảo tính an toàn kiểu: trình biên dịch sẽ đảm bảo rằng các hàm của bạn chỉ nhận các giá trị thuộc 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ễ dàng 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ý Dự án Ngày càng Lớn với Packages, Crates, và Modules

Khi bạn viết các chương trình lớn, việc tổ chức mã của bạn sẽ ngày càng trở nên quan trọng. Bằng cách nhóm các chức năng liên quan và tách riêng mã với các tính năng riêng biệt, bạn sẽ làm rõ nơi tìm mã thực hiện một tính năng cụ thể và nơi để thay đổi cách một tính năng hoạt động.

Các chương trình chúng ta đã viết cho đến nay đều nằm trong một module trong một tệp. Khi một dự án phát triển, bạn nên tổ chức mã bằng cách chia nó thành nhiều module và sau đó là nhiều tệp. Một package có thể chứa nhiều binary crate và tùy chọn một library crate. Khi một package phát triển, bạn có thể trích xuất các phần thành các crate riêng biệt trở thành các phụ thuộc bên ngoài. Chương này đề cập đến tất cả các kỹ thuật này. Đối với các dự án rất lớn bao gồm một tập hợp các package có liên quan phát triển cùng nhau, Cargo cung cấp workspaces, mà chúng ta sẽ đề cập trong "Cargo Workspaces" ở Chương 14.

Chúng ta cũng sẽ thảo luận về việc đóng gói chi tiết triển khai, điều này cho phép bạn tái sử dụng mã ở mức cao hơn: khi bạn đã triển khai một thao tác, mã khác có thể gọi mã của bạn thông qua giao diện công khai mà không cần biết cách triển khai hoạt động như thế nào. Cách bạn viết mã định nghĩa những phần nào là công khai cho mã khác sử dụng và những phần nào là chi tiết triển khai riêng tư mà bạn có quyền thay đổi. Đây là một cách khác để hạn chế lượng chi tiết mà bạn phải giữ trong đầu.

Một khái niệm liên quan là phạm vi: ngữ cảnh lồng nhau mà mã được viết có một tập hợp các tên được định nghĩa là "trong phạm vi." Khi đọc, viết và biên dịch mã, các lập trình viên và trình biên dịch cần biết liệu một tên cụ thể tại một vị trí cụ thể đề cập đến một biến, hàm, struct, enum, module, hằng số, hoặc mục khác và mục đó có ý nghĩa gì. Bạn có thể tạo phạm vi và thay đổi những tên nào đang ở trong hoặc ngoài phạm vi. Bạn không thể có hai mục với cùng một tên trong cùng một phạm vi; các công cụ 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 mã của mình, bao gồm những chi tiết nào được hiển thị, những chi tiết nào là riêng tư, và những tên nào nằm trong mỗi phạm vi trong chương trình của bạn. Những tính năng này, đôi khi được gọi chung là hệ thống module, bao gồm:

• Packages: Một tính năng của Cargo cho phép bạn xây dựng, kiểm tra và chia sẻ crates
• Crates: Một cây các module tạo ra một thư viện hoặc một tệp thực thi
• Modules và use: Cho phép bạn kiểm soát tổ chức, phạm vi và quyền riêng tư của các đường dẫn
• Paths: Một cách để đặt tên cho một mục, chẳng hạn như struct, hàm hoặc module

Trong chương này, chúng ta sẽ đề cập đến tất cả các tính năng này, thảo 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. Đến cuối chương, bạn sẽ có hiểu biết vững chắc về hệ thống module và có thể làm việc với các phạm vi như một chuyên gia!

Packages và Crates

Phần đầu tiên của hệ thống module mà chúng ta sẽ đề cập đến là packages và crates.

Một crate là đơn vị code nhỏ nhất mà trình biên dịch Rust xem xét tại một thời điểm. Ngay cả khi bạn chạy rustc thay vì cargo và truyền vào một tệp mã nguồn duy nhất (như chúng ta đã làm trong "Viết và Chạy Chương Trình Rust" ở Chương 1), trình biên dịch xem tệp đó là một crate. Crates có thể chứa modules, và các modules có thể được định nghĩa trong các tệp khác được biên dịch cùng với crate, như chúng ta sẽ thấy trong các phần tiếp theo.

Một crate có thể có một trong hai hình thức: binary crate hoặc library crate. Binary crates là các chương trình bạn có thể biên dịch thành một tệp thực thi để chạy, như một chương trình dòng lệnh hoặc một máy chủ. Mỗi crate này phải có một hàm gọi là main để xác định điều gì sẽ xảy ra khi chương trình thực thi chạy. Tất cả các crate chúng ta đã tạo cho đến nay đều là binary crates.

Library crates không có hàm main, và chúng không được biên dịch thành tệp thực thi. Thay vào đó, chúng định nghĩa các chức năng được thiết kế để chia sẻ giữa nhiều dự án. Ví dụ, crate rand mà chúng ta đã sử dụng trong Chương 2 cung cấp chức năng tạo số ngẫu nhiên. Hầu hết thời gian khi các lập trình viên Rust nói “crate,“ họ thường muốn nói đến library crate, và họ sử dụng "crate" thay thế cho khái niệm lập trình chung là “library.“

Crate root là một tệp mã nguồn mà trình biên dịch Rust bắt đầu từ đó và tạo thành module gốc của crate của bạn (chúng ta sẽ giải thích kỹ về modules trong "Định nghĩa Modules để Kiểm soát Phạm vi và Quyền riêng tư").

Một package là một gói gồm một hoặc nhiều crates cung cấp một tập hợp chức năng. Một package chứa một tệp Cargo.toml mô tả cách xây dựng các crates đó. Cargo thực chất là một package chứa binary crate cho công cụ dòng lệnh mà bạn đã sử dụng để xây dựng mã của mình. Package Cargo cũng chứa một library crate mà binary crate phụ thuộc vào. Các dự án khác có thể phụ thuộc vào library crate Cargo để sử dụng logic tương tự như công cụ dòng lệnh Cargo sử dụng.

Một package có thể chứa nhiều binary crates tùy thích, nhưng nhiều nhất chỉ có một library crate. Một package phải chứa ít nhất một crate, dù đó là library hay binary crate.

Hãy đi qua những gì xảy ra khi chúng ta tạo một package. Đầu tiên, chúng ta nhập lệnh cargo new my-project:

$ cargo new my-project
     Created binary (application) `my-project` package
$ ls my-project
Cargo.toml
src
$ ls my-project/src
main.rs

Sau khi chúng ta chạy cargo new my-project, chúng ta sử dụng ls để xem những gì Cargo tạo ra. Trong thư mục dự án, có một tệp Cargo.toml, tạo ra một package. Có một thư mục src chứa main.rs. Mở Cargo.toml trong trình soạn thảo của bạn và lưu ý rằng không có đề cập đến src/main.rs. Cargo tuân theo quy ước rằng src/main.rs là crate root của một binary crate có cùng tên với package. Tương tự, Cargo biết rằng nếu thư mục package chứa src/lib.rs, thì package chứa một library crate có cùng tên với package, và src/lib.rs là crate root. Cargo truyền các tệp crate root cho rustc để xây dựng thư viện hoặc chương trình.

Ở đây, chúng ta có một package chỉ chứa src/main.rs, nghĩa là nó chỉ chứa một binary crate có tên là my-project. Nếu một package chứa src/main.rs và src/lib.rs, nó có hai crates: một binary và một library, cả hai đều có cùng tên với package. Một package có thể có nhiều binary crates bằng cách đặt các tệp trong thư mục src/bin: mỗi tệp sẽ là một binary crate riêng biệt.

Định nghĩa Modules để Kiểm soát Phạm vi và Quyền riêng tư

Trong phần này, chúng ta sẽ nói về modules và các phần khác của hệ thống module, cụ thể là paths (đường dẫn), cho phép bạn đặt tên cho các item; từ khóa use đưa một đường dẫn vào phạm vi; và từ khóa pub để công khai các item. Chúng ta cũng sẽ thảo luận về từ khóa as, các gói bên ngoài, và toán tử glob.

Bảng tóm tắt về Modules

Trước khi đi vào chi tiết về modules và đường dẫn, ở đây chúng tôi cung cấp một tài liệu tham khảo nhanh về cách modules, đường dẫn, từ khóa use và từ khóa pub hoạt động trong trình biên dịch, và cách mà hầu hết các nhà phát triển tổ chức mã của họ. Chúng ta sẽ đi qua các ví dụ cho từng quy tắc này trong suốt chương này, nhưng đây là một nơi tuyệt vời để tham khảo như một lời nhắc về cách modules hoạt động.

• Bắt đầu từ crate root: Khi biên dịch một crate, trình biên dịch đầu tiên tìm kiếm trong tệp crate root (thường là src/lib.rs cho library crate hoặc src/main.rs cho binary crate) để biên dịch mã.
• Khai báo modules: Trong tệp crate root, bạn có thể khai báo modules mới; giả sử bạn khai báo một module "garden" với mod garden;. Trình biên dịch sẽ tìm kiếm mã của module ở những nơi sau:
  • Trực tiếp, trong dấu ngoặc nhọn thay thế dấu chấm phẩy sau mod garden
  • Trong tệp src/garden.rs
  • Trong tệp src/garden/mod.rs
• Khai báo submodules: Trong bất kỳ tệp nào khác ngoài crate root, bạn có thể khai báo submodules. Ví dụ, bạn có thể khai báo mod vegetables; trong src/garden.rs. Trình biên dịch sẽ tìm kiếm mã của submodule trong thư mục có tên của module cha ở những nơi sau:
  • Trực tiếp, ngay sau mod vegetables, trong dấu ngoặc nhọn thay vì dấu chấm phẩy
  • Trong tệp src/garden/vegetables.rs
  • Trong tệp src/garden/vegetables/mod.rs
• Đường dẫn đến mã trong modules: Khi một module là một phần của crate của bạn, bạn có thể tham chiếu đến mã trong module đó từ bất kỳ nơi nào khác trong cùng crate đó, miễn là các quy tắc quyền riêng tư cho phép, sử dụng đường dẫn đến mã. Ví dụ, một kiểu Asparagus trong module vegetables của garden sẽ được tìm thấy tại crate::garden::vegetables::Asparagus.
• Riêng tư vs. công khai: Mã trong một module mặc định là riêng tư từ các module cha của nó. Để làm cho một module công khai, khai báo nó với pub mod thay vì mod. Để làm cho các item trong một module công khai cũng công khai, sử dụng pub trước khai báo của chúng.
• Từ khóa use: Trong một phạm vi, từ khóa use tạo ra các lối tắt đến các item để giảm lặp lại các đường dẫn dài. Trong bất kỳ phạm vi nào có thể tham chiếu đến crate::garden::vegetables::Asparagus, bạn có thể tạo một lối tắt với use crate::garden::vegetables::Asparagus; và từ đó trở đi bạn chỉ cần viết Asparagus để sử dụng kiểu đó trong phạm vi.

Ở đây, chúng ta tạo một binary crate có tên backyard minh họa các quy tắc này. Thư mục của crate, cũng có tên là backyard, chứa các tệp và thư mục sau:

backyard
├── Cargo.lock
├── Cargo.toml
└── src
    ├── garden
    │   └── vegetables.rs
    ├── garden.rs
    └── main.rs

Tệp crate root trong trường hợp này là src/main.rs, và nó chứa:

use crate::garden::vegetables::Asparagus;

pub mod garden;

fn main() {
    let plant = Asparagus {};
    println!("I'm growing {plant:?}!");
}

Dòng pub mod garden; cho trình biên dịch biết để bao gồm mã mà nó tìm thấy trong src/garden.rs, đó là:

pub mod vegetables;

Ở đây, pub mod vegetables; có nghĩa là mã trong src/garden/vegetables.rs cũng được bao gồm. Mã đó là:

#[derive(Debug)]
pub struct Asparagus {}

Bây giờ chúng ta hãy đi vào chi tiết của các quy tắc này và minh họa chúng trong hành động!

Nhóm Mã Liên quan trong Modules

Modules cho phép chúng ta tổ chức mã trong một crate để dễ đọc và tái sử dụng. Modules cũng cho phép chúng ta kiểm soát quyền riêng tư của các item vì mã trong một module mặc định là riêng tư. Các item riêng tư là chi tiết triển khai nội bộ không có sẵn cho việc sử dụng bên ngoài. Chúng ta có thể chọn làm cho các modules và các item bên trong chúng công khai, điều này làm cho chúng hiện ra để cho phép mã bên ngoài sử dụng và phụ thuộc vào chúng.

Làm ví dụ, chúng ta hãy viết một library crate cung cấp chức năng của một nhà hàng. Chúng ta sẽ định nghĩa các chữ ký của các hàm nhưng để phần thân của chúng trống để tập trung vào việc tổ chức mã hơn là triển khai của một nhà hàng.

Trong ngành công nghiệp nhà hàng, một số phần của nhà hàng được gọi là front of house (tiền sảnh) và những phần khác là back of house (hậu trường). Front of house là nơi khách hàng đến; điều này bao gồm nơi các chủ nhà đón tiếp khách hàng, nhân viên phục vụ ghi nhận đơn hàng và thanh toán, và người pha chế pha đồ uống. Back of house là nơi các đầu bếp và người nấu ăn làm việc trong nhà bếp, người rửa bát dọn dẹp, và người quản lý làm công việc hành chính.

Để cấu trúc crate của chúng ta theo cách này, chúng ta có thể tổ chức các hàm của nó thành các modules lồng nhau. Tạo một thư viện mới có tên restaurant bằng cách chạy cargo new restaurant --lib. Sau đó nhập mã trong Listing 7-1 vào src/lib.rs để định nghĩa một số modules và chữ ký hàm; mã này là phần front of house.

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() {}
    }
}

Chúng ta định nghĩa một module với từ khóa mod theo sau là tên của module (trong trường hợp này, front_of_house). Phần thân của module sau đó đi vào trong dấu ngoặc nhọn. Bên trong modules, chúng ta có thể đặt các module khác, như trong trường hợp này với các module hosting và serving. Modules cũng có thể chứa các định nghĩa cho các item khác, như structs, enums, constants, traits, và như trong Listing 7-1, các hàm.

Bằng cách sử dụng modules, chúng ta có thể nhóm các định nghĩa liên quan với nhau và đặt tên tại sao chúng liên quan. Các lập trình viên sử dụng mã này có thể điều hướng mã dựa trên các nhóm thay vì phải đọc qua tất cả các định nghĩa, làm cho việc tìm kiếm các định nghĩa liên quan đến họ trở nên dễ dàng hơn. 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 mã để giữ cho chương trình được tổ chức.

Trước đây, chúng ta đã đề 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 ở gốc của cấu trúc module của crate, được gọi là cây module.

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

Cây này cho thấy cách một số modules lồng bên trong các module khác; ví dụ, hosting lồng bên trong front_of_house. Cây cũng cho thấy rằng một số modules là siblings (anh chị em), có nghĩa là chúng được định nghĩa trong cùng một module; hosting và serving là anh chị em được định nghĩa trong front_of_house. Nếu module A được chứa bên trong module B, chúng ta nói rằng module A là con của module B và module B là cha của module A. Lưu ý rằng toàn bộ cây module được gốc dưới module ẩn có tên crate.

Cây module có thể nhắc bạn nhớ đến 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 đúng! Giống như các thư mục trong hệ thống tệp, bạn sử dụng modules để tổ chức mã của mình. Và giống như các tệp trong một thư mục, chúng ta cần một cách để tìm thấy các module của mình.

Đường dẫn để Tham chiếu đến một Item trong Cây Module

Để chỉ cho Rust vị trí một item trong cây module, chúng ta sử dụng một đường dẫn tương tự như cách chúng ta sử dụng đường dẫn khi điều hướng trong hệ thống tệp. Để 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ó hai hình thức:

• Một đường dẫn tuyệt đối là đường dẫn đầy đủ bắt đầu từ gốc của crate; đối với mã từ một crate bên ngoài, đường dẫn tuyệt đối bắt đầu bằng tên crate, và đối với mã từ crate hiện tại, nó bắt đầu bằng từ khóa crate.
• 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 định danh trong module hiện tại.

Cả đườ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ởi dấu hai chấm kép (::).

Quay lại Listing 7-1, giả sử chúng ta muốn gọi hàm add_to_waitlist. Điều này cũng giống như việc hỏi: đâu là đường dẫn của hàm add_to_waitlist? Listing 7-3 chứa nội dung của Listing 7-1 nhưng đã loại bỏ một số modules và hàm.

Chúng ta sẽ thể hiện 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 gốc của crate. Các đường dẫn này là đúng, nhưng vẫn còn một vấn đề khác sẽ ngăn ví dụ này biên dịch như hiện tại. Chúng ta sẽ giải thích lý do sau.

Hàm eat_at_restaurant là một phần của API công khai của thư viện crate của chúng ta, vì vậy chúng ta đánh dấu nó bằng từ khóa pub. Trong phần "Hiển thị Đường dẫn với từ khóa pub", chúng ta sẽ đi sâu hơn về pub.

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();
}

Lần đầu tiên chúng ta gọi hàm add_to_waitlist trong eat_at_restaurant, chúng ta sử dụng đường dẫn tuyệt đối. Hàm add_to_waitlist được định nghĩa trong cùng crate với eat_at_restaurant, điều đó 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 đó, chúng ta bao gồm từng module liên tiếp cho đến khi chúng ta đến được add_to_waitlist. Bạn có thể tưởng tượng một hệ thống tệp với cùng cấu trúc: chúng ta sẽ chỉ định đường dẫn /front_of_house/hosting/add_to_waitlist để chạy chương trình add_to_waitlist; việc sử dụng tên crate để bắt đầu từ gốc của crate giống như việc 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 một đường dẫn tương đối. Đường dẫn bắt đầu với front_of_house, tên của module được định nghĩa ở cùng cấp độ của cây module với eat_at_restaurant. Ở đây, tương đương với hệ thống tệp sẽ là sử dụng đường dẫn front_of_house/hosting/add_to_waitlist. Việc bắt đầu bằng tên module 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 tuyệt đối là một quyết định bạn sẽ đưa ra dựa trên dự án của mình, và nó phụ thuộc vào việc bạn có nhiều khả năng di chuyển mã định nghĩa item riêng biệt hay cùng với mã sử dụng item đó. Ví dụ, nếu chúng ta di chuyển module front_of_house và hàm eat_at_restaurant vào một module có tên customer_experience, chúng ta sẽ cần cập nhật đường dẫn tuyệt đối đến add_to_waitlist, nhưng đường dẫn tương đối vẫn sẽ hợp lệ. Tuy nhiên, nếu chúng ta di chuyển riêng hàm eat_at_restaurant vào một module có tên dining, đường dẫn tuyệt đối đến lệnh gọi add_to_waitlist sẽ giữ nguyên, nhưng đường dẫn tương đối sẽ cần được cập nhật. Ưu tiên chung của chúng ta là chỉ định đường dẫn tuyệt đối vì có khả năng cao hơn là chúng ta sẽ muốn di chuyển các định nghĩa mã và lệnh gọi các item độc lập với nhau.

Hãy thử biên dịch Listing 7-3 và tìm hiểu tại sao nó chưa thể biên dịch! Các lỗi mà chúng ta nhận được đượ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();
  |                            ^^^^^^^  --------------- function `add_to_waitlist` is not publicly re-exported
  |                            |
  |                            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();
   |                     ^^^^^^^  --------------- function `add_to_waitlist` is not publicly re-exported
   |                     |
   |                     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` (lib) due to 2 previous errors

Các thông báo lỗi nói rằng module hosting là riêng tư. Nói cách khác, chúng ta có các đường dẫn đúng cho module hosting và hàm add_to_waitlist, nhưng Rust không cho phép chúng ta sử dụng chúng vì nó không có quyền truy cập vào các phần riêng tư. Trong Rust, tất cả các item (hàm, phương thức, cấu trúc, enums, modules, và hằng số) mặc định là riêng tư đối với các module cha. Nếu bạn muốn làm cho một item như một hàm hoặc cấu trúc riêng tư, bạn đặt nó trong một module.

Các item trong một module cha không thể sử dụng các item riêng tư bên trong các module con, nhưng các item trong các module con có thể sử dụng các item trong module tổ tiên của chúng. Điều này là vì các module con bọc và ẩn chi tiết triển khai của chúng, nhưng các module con có thể thấy bối cảnh mà chúng được định nghĩa. Để tiếp tục với ẩn dụ của chúng ta, hãy nghĩ về các quy tắc quyền riêng tư giống như văn phòng phía sau của một nhà hàng: những gì diễn ra ở đó là riêng tư đối với khách hàng nhà hàng, nhưng các 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 để việc ẩ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 mã bên trong mà bạn có thể thay đổi mà không làm hỏng mã bên ngoài. Tuy nhiên, Rust có cung cấp cho bạn tùy chọn để hiển thị các phần bên trong của mã module con cho các module tổ tiên bên ngoài bằng cách sử dụng từ khóa pub để làm một item công khai.

Hiển thị Đường dẫn với từ khóa pub

Hãy quay lại lỗi trong Listing 7-4 đã nói với chúng ta rằng module hosting là riêng tư. Chúng ta muốn hàm eat_at_restaurant trong module cha có quyền truy cập vào hàm add_to_waitlist trong module con, vì vậy chúng ta đánh dấu module hosting bằng từ khóa pub, như được hiển thị trong Listing 7-5.

mod front_of_house {
    pub mod hosting {
        fn add_to_waitlist() {}
    }
}

// -- snip --
pub fn eat_at_restaurant() {
    // Absolute path
    crate::front_of_house::hosting::add_to_waitlist();

    // Relative path
    front_of_house::hosting::add_to_waitlist();
}

Thật không may, mã trong Listing 7-5 vẫn dẫn đến lỗi trình biên dịch, 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:10:37
   |
10 |     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:13:30
   |
13 |     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` (lib) due to 2 previous errors

Chuyện gì đã xảy ra? Thêm từ khóa pub trước mod hosting làm cho module công khai. Với 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 là riêng tư; việc làm cho module công khai không làm cho nội dung của nó công khai. Từ khóa pub trên một module chỉ cho phép mã trong các module tổ tiên của nó tham chiếu đến nó, không phải truy cập vào mã bên trong của nó. Bởi vì các module là vùng chứa, không có nhiều điều chúng ta có thể làm chỉ bằng cách làm cho module công khai; chúng ta cần đi xa hơn và chọn làm cho một hoặc nhiều item trong module công khai.

Các lỗi trong Listing 7-6 nói rằng hàm add_to_waitlist là riêng tư. Các quy tắc quyền riêng tư áp dụng cho các cấu trúc, enums, hàm, và phương thức cũng như các module.

Hãy cũng làm cho hàm add_to_waitlist công khai bằng cách thêm từ khóa pub trước định nghĩa của nó, như trong Listing 7-7.

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

// -- snip --
pub fn eat_at_restaurant() {
    // Absolute path
    crate::front_of_house::hosting::add_to_waitlist();

    // Relative path
    front_of_house::hosting::add_to_waitlist();
}

Bây giờ mã sẽ biên dịch! Để hiểu tại sao việc thêm từ khóa pub cho phép chúng ta sử dụng các đường dẫn này trong eat_at_restaurant liên quan đến các quy tắc quyền riêng tư, hãy xem đường dẫn tuyệt đối và tương đối.

Trong đường dẫn tuyệt đối, chúng ta bắt đầu với crate, gốc của cây module của crate. Module front_of_house được định nghĩa trong gốc của crate. Mặc dù front_of_house không công khai, vì hàm eat_at_restaurant được định nghĩa trong cùng module với front_of_house (nghĩa là, eat_at_restaurant và front_of_house là anh chị em), chúng ta có thể tham chiếu đến front_of_house từ eat_at_restaurant. Tiếp theo là module hosting được đánh dấu là pub. Chúng ta có thể truy cập module cha của hosting, nên chúng ta có thể truy cập hosting. Cuối cùng, hàm add_to_waitlist được đánh dấu là pub và chúng ta 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 với đường dẫn tuyệt đối ngoại trừ bước đầu tiên: thay vì bắt đầu từ gốc của crate, đường dẫn bắt đầu từ front_of_house. Module front_of_house được định nghĩa trong cùng module với eat_at_restaurant, nên đường dẫn tương đối bắt đầu từ module mà eat_at_restaurant được định nghĩa hoạt động. Sau đó, vì hosting và add_to_waitlist được đánh dấu là 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 có kế hoạch chia sẻ crate thư viện của mình để các dự án khác có thể sử dụng mã của bạn, API công khai của bạn là hợp đồng của bạn với người dùng của crate xác định cách họ có thể 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ý thay đổi đối với API công khai của bạn để giúp mọi người dễ dàng hơn khi phụ thuộc vào crate của bạ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 Các Hướng dẫn API của Rust.

Các Phương pháp Tốt nhất cho Packages với Binary và Library

Chúng ta đã đề cập rằng một package có thể chứa cả gốc của binary crate src/main.rs cũng như gốc của library crate src/lib.rs, và cả hai crates sẽ có tên package theo mặc định. Thông thường, các package với mô hình này chứa cả library và binary crate sẽ có đủ lượng mã trong binary crate để khởi động một chương trình thực thi gọi mã được khai báo trong library crate. Điều này cho phép các dự án khác hưởng lợi từ hầu hết chức năng mà package cung cấp vì mã 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ỳ item công khai nào có thể được sử dụng trong binary crate bằng cách bắt đầu đườ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 hoàn toàn sẽ sử dụng library crate: nó chỉ có thể sử dụng API công khai. Điều này giúp bạn thiết kế một API tốt; không chỉ là bạn là tác giả, bạn cũng là khách hàng!

Trong Chương 12, chúng ta sẽ minh họa phương pháp tổ chức này với một chương trình dòng lệnh sẽ chứa cả binary crate và library crate.

Bắt đầu Đường dẫn Tương đối với super

Chúng ta có thể xây dựng đường dẫn tương đối bắt đầu ở module cha, thay vì module hiện tại hoặc gốc của crate, bằng cách sử dụng super ở đầu đường dẫn. Điều này giống như việc bắt đầu một đường dẫn hệ thống tệp với cú pháp .. có nghĩa là đi đến thư mục cha. Sử dụng super cho phép chúng ta tham chiếu đến một item mà chúng ta biết là trong module cha, điều này có thể làm cho việc sắp xếp lại cây module dễ dàng hơn khi module có liên quan chặt chẽ với module cha nhưng module cha có thể được di chuyển đến nơi khác trong cây module vào một ngày nào đó.

Hãy xem xét mã trong Listing 7-8 mô hình hóa tình huống mà một đầu bếp sửa một đơn hàng không chính xác và tự mang ra cho khách hàng. Hàm 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.

fn deliver_order() {}

mod back_of_house {
    fn fix_incorrect_order() {
        cook_order();
        super::deliver_order();
    }

    fn cook_order() {}
}

Hàm fix_incorrect_order nằm trong module back_of_house, nên chúng ta có thể sử dụng super để đi đến module cha của back_of_house, trong trường hợp này là crate, gốc. Từ đó, chúng ta tìm kiếm deliver_order và tìm thấy nó. Thành công! Chúng ta nghĩ rằng module back_of_house và hàm deliver_order có khả năng sẽ giữ nguyên mối quan hệ với nhau và được di chuyển cùng nhau nếu chúng ta quyết định tổ chức lại cây module của crate. Do đó, chúng ta đã sử dụng super để chúng ta sẽ có ít nơi hơn để cập nhật mã trong tương lai nếu mã này được di chuyển đến một module khác.

Làm cho Structs và Enums Công khai

Chúng ta cũng có thể sử dụng pub để chỉ định structs và enums là công khai, nhưng có một vài chi tiết bổ sung đối với việc sử dụng pub với structs và enums. Nếu chúng ta sử dụng pub trước định nghĩa struct, chúng ta làm cho struct công khai, nhưng các trường của struct vẫn sẽ là riêng tư. Chúng ta có thể làm cho từng trường công khai hoặc không tùy theo từng trường hợp. Trong Listing 7-9, chúng ta đã định nghĩa một struct back_of_house::Breakfast công khai với một trường toast công khai nhưng một trường seasonal_fruit riêng tư. Điều này mô hình hóa trường hợp trong một nhà hàng mà 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 đi kèm với bữa ăn dựa trên mùa nào và có sẵn trong kho. Loại 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ể thấy họ sẽ nhận được loại trái cây nào.

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");
}

Bởi vì trường toast trong struct back_of_house::Breakfast là công khai, trong eat_at_restaurant chúng ta có thể viết và đọc trường toast bằng cách sử dụng ký hiệu dấu chấm. Lưu ý rằng chúng ta không thể sử dụng trường seasonal_fruit trong eat_at_restaurant, bởi vì seasonal_fruit là riêng tư. Hãy thử bỏ comment dòng sửa đổi giá trị trường seasonal_fruit để xem lỗi bạn nhận được!

Cũng lưu ý rằng bởi vì back_of_house::Breakfast có một trường riêng tư, struct cần cung cấp một hàm liên kết công khai để xây dựng một thể hiện của Breakfast (chúng ta đã đặt tên nó là summer ở đây). Nếu Breakfast không có một hàm như vậy, chúng ta không thể tạo một thể hiện của Breakfast trong eat_at_restaurant bởi vì chúng ta không thể đặt giá trị của trường riêng tư seasonal_fruit trong eat_at_restaurant.

Ngược lại, nếu chúng ta làm cho một enum công khai, tất cả các biến thể của nó đều công khai. Chúng ta chỉ cần từ khóa pub trước từ khóa enum, như được hiển thị trong Listing 7-10.

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;
}

Vì chúng ta đã làm cho enum Appetizer công khai, chúng ta 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 là công khai; sẽ rất phiền toái khi phải chú thích tất cả các biến thể enum với pub trong mọi trường hợp, vì vậy mặc định cho các biến thể enum là công khai. Structs thường hữu ích mà không cần các trường của chúng là công khai, vì vậy các trường struct tuân theo quy tắc chung là mọi thứ mặc định là riêng tư trừ khi được chú thích với pub.

Có một tình huống khác liên quan đến pub mà chúng ta chưa đề cập, và đó là tính năng hệ thống module cuối cùng của chúng ta: từ khóa use. Chúng ta sẽ đề cập đến use riêng lẻ trước, và sau đó chúng ta sẽ thể hiện cách kết hợp pub và use.

Đưa Đường dẫn vào Phạm vi với từ khóa use

Việc phải viết ra các đường dẫn để gọi hàm có thể cảm thấy bất tiện và lặp đi lặp lại. Trong Listing 7-7, cho dù chúng ta chọn đường dẫn tuyệt đối hoặc 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 phải chỉ định cả front_of_house và hosting. May mắn thay, có một cách để đơn giản hóa quá trình này: chúng ta có thể tạo một lối tắt đến đường dẫn với từ khóa use một lần, và sau đó sử dụng tên ngắn hơn ở mọi nơi khác trong phạm vi.

Trong Listing 7-11, chúng ta đưa module crate::front_of_house::hosting vào phạm vi của hàm eat_at_restaurant để chúng ta chỉ cần chỉ định hosting::add_to_waitlist để gọi hàm add_to_waitlist trong eat_at_restaurant.

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();
}

Việc thêm use và một đường dẫn trong một phạm vi tương tự như việc 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 gốc crate, hosting bây giờ là một tên hợp lệ trong phạm vi đó, giống như thể module hosting đã được định nghĩa trong gốc crate. Đường dẫn được đưa vào phạm vi bằng 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 phạm vi 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 phạm vi khác với câu lệnh use, vì vậy phần thân hàm sẽ không biên dịch được.

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();
    }
}

Lỗi trình biên dịch cho thấy lối 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`
   |
help: consider importing this module through its public re-export
   |
10 +     use crate::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` (lib) due to 1 previous error; 1 warning emitted

Lưu ý cũng có một cảnh báo rằng use không còn được sử dụng trong phạm vi của nó! Để khắc phục vấn đề này, hãy di chuyển use vào module customer, hoặc tham chiếu lối tắt trong module cha với super::hosting trong module con customer.

Tạo Đường dẫn use Thuần phong

Trong Listing 7-11, bạn có thể đã tự hỏi tại sao chúng ta chỉ định use crate::front_of_house::hosting và sau đó gọi hosting::add_to_waitlist trong eat_at_restaurant, thay vì chỉ định đường dẫn use hoàn toàn đến hàm add_to_waitlist để đạt được kết quả tương tự, như trong Listing 7-13.

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();
}

Mặc dù cả Listing 7-11 và Listing 7-13 đều thực hiện cùng một nhiệm vụ, Listing 7-11 là cách thuần phong để đưa một hàm vào phạm vi với use. Việc đưa module cha của hàm vào phạm vi với use có nghĩa là chúng ta phải chỉ định module cha khi gọi hàm. Chỉ định module cha khi gọi hàm làm rõ rằng hàm không được định nghĩa cục bộ trong khi vẫn giảm thiểu việc lặp lại đường dẫn đầy đủ. Đoạn mã trong Listing 7-13 không rõ ràng về nơi add_to_waitlist được định nghĩa.

Mặt khác, khi đưa vào structs, enums, và các item khác với use, việc chỉ định đường dẫn đầy đủ là thuần phong. Listing 7-14 thể hiện cách thuần phong để đưa struct HashMap của thư viện chuẩn vào phạm vi của một binary crate.

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert(1, 2);
}

Không có lý do mạnh mẽ đằng sau cách viết này: đó chỉ là quy ước đã nổi lê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 cách viết này là nếu chúng ta đưa hai item có cùng tên vào phạm vi với các câu lệnh use, vì Rust không cho phép điều đó. Listing 7-15 thể hiện cách đưa hai kiểu Result vào phạm vi có cùng tên nhưng có module cha khác nhau, và cách tham chiếu đến chúng.

use std::fmt;
use std::io;

fn function1() -> fmt::Result {
    // --snip--
    Ok(())
}

fn function2() -> io::Result<()> {
    // --snip--
    Ok(())
}

Như bạn có thể thấy, việc sử dụng các module cha phân biệt hai kiểu Result. Nếu thay vào đó chúng ta chỉ định use std::fmt::Result và use std::io::Result, chúng ta sẽ có hai kiểu Result trong cùng một phạm vi, và Rust sẽ không biết chúng ta muốn nói đến kiểu nào khi chúng ta sử dụng Result.

Cung cấp Tên Mới với từ khóa as

Có một giải pháp khác cho vấn đề đưa hai kiểu có cùng tên vào cùng một phạm vi 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 alias (biệt danh), cho kiểu đó. Listing 7-16 thể hiện 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 sử dụng as.

use std::fmt::Result;
use std::io::Result as IoResult;

fn function1() -> Result {
    // --snip--
    Ok(())
}

fn function2() -> IoResult<()> {
    // --snip--
    Ok(())
}

Trong câu lệnh use thứ hai, chúng ta đã chọn tên mới IoResult cho kiểu std::io::Result, điều này sẽ không xung đột với Result từ std::fmt mà chúng ta cũng đã đưa vào phạm vi. Listing 7-15 và Listing 7-16 đều được coi là thuần phong, vì vậy sự lựa chọn là ở bạn!

Tái xuất Tên với pub use

Khi chúng ta đưa một tên vào phạm vi với từ khóa use, tên đó là riêng tư đối với phạm vi mà chúng ta đã nhập nó vào. Để cho phép mã bên ngoài phạm vi đó tham chiếu đến tên đó như thể nó đã được định nghĩa trong phạm vi đó, chúng ta có thể kết hợp pub và use. Kỹ thuật này được gọi là re-exporting (tái xuất) vì chúng ta đưa một item vào phạm vi nhưng cũng làm cho item đó có sẵn cho người khác đưa vào phạm vi của họ.

Listing 7-17 thể hiện mã trong Listing 7-11 với use trong module gốc được thay đổi thành pub use.

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();
}

Trước thay đổi này, mã bên ngoài sẽ phải gọi hàm add_to_waitlist bằng cách sử dụng đường dẫn restaurant::front_of_house::hosting::add_to_waitlist(), điều này cũng đòi hỏi module front_of_house phải được đánh dấu là pub. Bây giờ pub use này đã tái xuất module hosting từ module gốc, mã bên ngoài có thể sử dụng đường dẫn restaurant::hosting::add_to_waitlist() thay thế.

Tái xuất rất hữu ích khi cấu trúc nội bộ của mã của bạn khác với cách các lập trình viên gọi mã của bạn sẽ nghĩ về miền. Ví dụ, trong phép ẩn dụ 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 ghé thăm một nhà hàng có lẽ sẽ không nghĩ về các phần của nhà hàng theo những thuật ngữ đó. Với pub use, chúng ta có thể viết mã 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 giúp thư viện của chúng ta đượ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 một ví dụ khác về pub use và cách nó ảnh hưởng đến tài liệu crate của bạn trong "Xuất một Public API Tiện lợi với pub use" trong Chương 14.

Sử dụng Các Gói Bên ngoài

Trong Chương 2, chúng ta đã lập trình một dự án trò chơi đoán số sử dụng một gói bên ngoài có tên là rand để có được số ngẫu nhiên. Để sử dụng rand trong dự án của chúng ta, chúng ta đã thêm dòng này vào Cargo.toml:

rand = "0.8.5"

Thêm rand như một phụ thuộc trong Cargo.toml cho Cargo biết phải tải xuống gói rand và bất kỳ phụ thuộc nào từ crates.io và làm cho rand có sẵn cho dự án của chúng ta.

Sau đó, để đưa các định nghĩa rand vào phạm vi của gói của chúng ta, chúng ta đã thêm một dòng use bắt đầu bằng tên của crate, rand, và liệt kê các item chúng ta muốn đưa vào phạm vi. Hãy nhớ lại rằng trong "Tạo một Số Ngẫu nhiên" trong Chương 2, chúng ta đã đưa trait Rng vào phạm vi 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 đã làm cho nhiều gói có sẵn tại crates.io, và việc kéo bất kỳ gói nào vào gói của bạn đều liên quan đến các bước tương tự: liệt kê chúng trong tệp Cargo.toml của gói của bạn và sử dụng use để đưa các item từ các crate đó vào phạm vi.

Lưu ý rằng thư viện chuẩn std cũng là một crate bên ngoài đối với gói của chúng ta. Bởi vì thư viện chuẩn được đi kèm với ngôn ngữ Rust, chúng ta không cần phải thay đổi Cargo.toml để bao gồm std. Nhưng chúng ta cần tham chiếu đến nó với use để đưa các item từ đó vào phạm vi của gói của chúng ta. Ví dụ, với HashMap chúng ta sẽ sử dụng dòng này:

#![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 crate thư viện chuẩn.

Sử dụng Đường dẫn Lồng nhau để Làm sạch Danh sách use Lớn

Nếu chúng ta sử dụng nhiều item được định nghĩa trong cùng một crate hoặc cùng một module, việc liệt kê mỗi item trên một dòng riêng có thể chiếm nhiều không gian dọc trong các tệp của chúng ta. Ví dụ, hai câu lệnh use này chúng ta đã có trong trò chơi đoán số trong Listing 2-4 đưa các item từ std vào phạm vi:

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 đường dẫn lồng nhau để đưa các item tương tự vào phạm vi trong một dòng. Chúng ta làm đ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, và sau đó là dấu ngoặc nhọn quanh danh sách các phần của đường dẫn khác nhau, như được hiển thị trong Listing 7-18.

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!"),
    }
}

Trong các chương trình lớn hơn, việc đưa nhiều item vào phạm vi từ cùng một crate hoặc module sử dụng đường dẫn lồng nhau có thể giảm đáng kể số lượng câu lệnh use riêng biệt cần thiết!

Chúng ta có thể sử dụng đường dẫn lồng nhau ở bất kỳ cấp độ 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 có chung một đường dẫn con. Ví dụ, Listing 7-19 thể hiện hai câu lệnh use: một câu lệnh đưa std::io vào phạm vi và một câu lệnh đưa std::io::Write vào phạm vi.

use std::io;
use std::io::Write;

Phần chung của hai đường dẫn này là std::io, và đó là toàn bộ đường dẫn đầu tiên. Để 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.

use std::io::{self, Write};

Dòng này đưa std::io và std::io::Write vào phạm vi.

Toán tử Glob

Nếu chúng ta muốn đưa tất cả các item công khai được định nghĩa trong một đường dẫn vào phạm vi, chúng ta có thể chỉ định đường dẫn đó theo sau bởi 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 công khai được định nghĩa trong std::collections vào phạm vi hiện tại. Hãy cẩn thận khi sử dụng toán tử glob! Glob có thể làm cho nó khó hơn để biết những tên nào đang trong phạm vi và tên được sử dụng trong chương trình của bạn được định nghĩa ở đâu. Ngoài ra, nếu phụ thuộc thay đổi các định nghĩa của nó, những gì bạn đã import cũng thay đổi theo, điều này có thể dẫn đến lỗi trình biên dịch khi bạn nâng cấp phụ thuộc nếu phụ thuộc đó thêm một định nghĩa có cùng tên với một định nghĩa của bạn trong cùng phạm vi, chẳng hạn.

Toán tử glob thường được sử dụng khi kiểm thử để đưa mọi thứ đang được kiểm thử vào module tests; chúng ta sẽ nói về điều đó trong "Cách Viết Kiểm thử" trong Chương 11. Toán tử glob cũng đôi khi được sử dụng như một phần của mẫu prelude: xem tài liệu thư viện chuẩn để biết thêm thông tin về mẫu đó.

Tách Module Thành Nhiều File Khác Nhau

Cho đến nay, tất cả các ví dụ trong chương này đều định nghĩa nhiều module trong một file. Khi các module trở nên lớn, bạn có thể muốn di chuyển các định nghĩa của chúng vào một file riêng biệt để làm cho mã dễ điều hướng hơn.

Ví dụ, hãy bắt đầu từ mã trong Listing 7-17 với nhiều module nhà hàng. Chúng ta sẽ trích xuất module vào các file thay vì định nghĩa tất cả module trong file gốc của crate. Trong trường hợp này, file gốc của crate là src/lib.rs, nhưng quy trình này cũng hoạt động với các crate nhị phân mà file gốc của crate là src/main.rs.

Đầu tiên, chúng ta sẽ trích xuất module front_of_house vào file riêng của nó. Xóa mã trong dấu ngoặc nhọn của module front_of_house, chỉ để lại khai báo mod front_of_house;, để src/lib.rs chứa mã hiển thị trong Listing 7-21. Lưu ý rằng mã này sẽ không biên dịch được cho đến khi chúng ta tạo file src/front_of_house.rs trong Listing 7-22.

mod front_of_house;

pub use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

Tiếp theo, đặt mã đã nằm trong dấu ngoặc nhọn vào một file mới có tên src/front_of_house.rs, như trong Listing 7-22. Trình biên dịch biết phải tìm file này vì nó đã gặp khai báo module trong gốc của crate với tên front_of_house.

pub mod hosting {
    pub fn add_to_waitlist() {}
}

Lưu ý rằng bạn chỉ cần tải một file bằng khai báo mod một lần trong cây module của bạn. Khi trình biên dịch biết file đó là một phần của dự án (và biết vị trí của mã trong cây module dựa vào 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 mã của file đã được tải bằng đường dẫn đến nơi nó được khai báo, như đã đề cập trong phần "Đường dẫn để tham chiếu đến một mục trong cây module". Nói cách khác, mod không phải là một thao tác "include" mà bạn có thể đã thấy trong các ngôn ngữ lập trình khác.

Tiếp theo, chúng ta sẽ trích xuất module hosting vào file riêng của nó. Quy trình này hơi khác vì hosting là một module con của front_of_house, không phải của module gốc. Chúng ta sẽ đặt file cho hosting trong một thư mục mới được đặt tên theo tổ tiên của nó trong cây module, trong trường hợp này là src/front_of_house.

Để bắt đầu di chuyển hosting, chúng ta thay đổi src/front_of_house.rs để chỉ chứa khai báo của module hosting:

pub mod hosting;

Sau đó chúng ta tạo một thư mục src/front_of_house và một file hosting.rs để chứa các định nghĩa được tạo trong module hosting:

pub fn add_to_waitlist() {}

Nếu thay vào đó chúng ta đặt hosting.rs trong thư mục src, trình biên dịch sẽ mong đợi mã hosting.rs nằm trong một module hosting được khai báo trong gốc của crate, chứ không phải được khai báo là con của module front_of_house. Các quy tắc của trình biên dịch về việc kiểm tra file nào cho mã của module nào có nghĩa là các thư mục và file khớp chặt chẽ hơn với cây module.

Đường dẫn file thay thế

Cho đến nay chúng ta đã đề cập đến các đường dẫn file kiểu mẫu nhất mà trình biên dịch Rust sử dụng, nhưng Rust cũng hỗ trợ một kiểu đường dẫn file cũ hơn. Đối với module có tên front_of_house được khai báo trong gốc của crate, trình biên dịch sẽ tìm kiếm mã của module trong:

• src/front_of_house.rs (những gì chúng ta đã đề cập)
• src/front_of_house/mod.rs (kiểu cũ hơn, vẫn được hỗ trợ)

Đối với module có tên hosting là một module con của front_of_house, trình biên dịch sẽ tìm kiếm mã của module trong:

• src/front_of_house/hosting.rs (những gì chúng ta đã đề cập)
• src/front_of_house/hosting/mod.rs (kiểu cũ hơn, vẫn được hỗ trợ)

Nếu bạn sử dụng cả hai kiểu cho cùng một module, bạn sẽ gặp lỗi biên dịch. Sử dụng kết hợp cả hai kiểu cho các module khác nhau trong cùng một dự án là được phép, nhưng có thể gây nhầm lẫn cho những người điều hướng dự án của bạn.

Nhược điểm chính của kiểu sử dụng các file có tên mod.rs là dự án của bạ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 cùng lúc trong trình soạn thảo.

Chúng ta đã di chuyển mã của mỗi module vào một file riêng biệ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ần bất kỳ sự 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 vào các file mới khi chúng tăng 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, và use cũng không có bất kỳ tác động nào đến việc 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 để lấy mã đi vào module đó.

Tóm tắt

Rust cho phép bạn chia một gói thành nhiều crate và một crate thành nhiều module để bạn có thể tham chiếu đến các mục được định nghĩa 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 đường dẫn tuyệt đối hoặc đường dẫn tương đối. Các đường dẫn này có thể được đưa vào phạm vi với một câu lệnh use để bạn có thể sử dụng một đường dẫn ngắn hơn cho nhiều lần sử dụng mục đó trong phạm vi đó. Mã module là riêng tư theo mặc định, nhưng bạn có thể công khai các định nghĩa 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 tập hợp trong thư viện chuẩn mà bạn có thể sử dụng trong mã được tổ chức gọn gàng của mình.

Các Bộ Sưu Tập Thông Dụng

Thư viện 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à các bộ sưu tập (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 bộ sưu tập có thể chứa nhiều giá trị. Không giống như các kiểu mảng và bộ (tuple) tích hợp sẵn, dữ liệu mà các bộ sưu tập này trỏ đến được lưu trữ trên heap, có nghĩa là lượng dữ liệu không cần phải biết tại thời điểm biên dịch và có thể tăng hoặc giảm khi chương trình chạy. Mỗi loại bộ sưu tập có khả năng và chi phí khác nhau, và việc chọn một bộ sưu tập phù hợp cho tình huống hiện tại của bạn là một kỹ năng mà 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 bộ sưu tập được sử dụng rất thường xuyên trong các chương trình Rust:

• Một vector cho phép bạn lưu trữ một số lượng biến đổi các giá trị cạnh nhau.
• Một chuỗi (string) là một bộ sưu tập các ký tự. Chúng ta đã đề cập đến kiểu String trước đây, nhưng trong chương này chúng ta sẽ nói về nó một cách chi tiết.
• Một bảng băm (hash map) cho phép bạn liên kết một giá trị với một khóa cụ thể. Đây là một triển khai cụ thể của cấu trúc dữ liệu tổng quát hơn được gọi là map.

Để tìm hiểu về các loại bộ sưu tập khác được cung cấp bởi thư viện chuẩn, hãy xem tài liệu.

Chúng ta sẽ thảo luận về cách tạo và cập nhật vector, chuỗi, và bảng băm, cũng như những điều gì làm cho mỗi loại đặc biệt.

Lưu Trữ Danh Sách Giá Trị với Vector

Loại bộ sưu tập đầu tiên mà chúng ta sẽ xem xét là Vec<T>, còn được gọi là vector. Vector cho phép bạn lưu trữ nhiều giá trị trong một cấu trúc dữ liệu duy nhất, đặt tất cả các giá trị liền kề nhau trong bộ nhớ. Vector chỉ có thể lưu trữ các giá trị cùng kiểu. Chúng rất hữu ích khi bạn có một danh sách các mục, chẳng hạn như các dòng văn bản trong một tập tin hoặc giá của các mặt hàng trong một giỏ hàng.

Tạo một Vector Mới

Để tạo một vector rỗng mới, chúng ta gọi hàm Vec::new, như hiển thị trong Listing 8-1.

fn main() {
    let v: Vec<i32> = Vec::new();
}

Lưu ý rằng chúng ta đã thêm một chú thích kiể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 không biết chúng ta dự định lưu trữ những phần tử kiểu gì. Đây là một điểm quan trọng. Vector được triển khai bằng cách sử dụng generics; chúng ta sẽ đề cập đến cách sử dụng generics với các kiểu riêng của bạn trong Chương 10. Hiện tại, hãy biết rằng kiểu Vec<T> được cung cấp bởi thư viện chuẩn có thể chứa bất kỳ kiểu nào. Khi chúng ta tạo một vector để chứa một kiểu cụ thể, chúng ta có thể chỉ định kiểu đó trong dấu ngoặc nhọn. Trong Listing 8-1, chúng ta đã cho Rust biết rằng Vec<T> trong v sẽ chứa các phần tử kiểu i32.

Thường thì bạn sẽ tạo một Vec<T> với các giá trị ban đầu và Rust sẽ suy luận kiểu giá trị mà bạn muốn lưu trữ, vì vậy bạn hiếm khi cần phải chú thích kiểu. Rust cung cấp một cách tiện lợi với macro vec!, sẽ tạo một vector mới chứa các giá trị bạn cung cấp. Listing 8-2 tạo một Vec<i32> mới chứa các giá trị 1, 2, và 3. Kiểu số nguyên là i32 vì đó là kiểu số nguyên mặc định, như chúng ta đã thảo luận trong phần "Kiểu Dữ Liệu" của Chương 3.

fn main() {
    let v = vec![1, 2, 3];
}

Vì chúng ta đã cung cấp các giá trị i32 ban đầu, Rust có thể suy luận rằng kiểu của v là Vec<i32>, và không cần thiết phải chú thích kiểu. Tiếp theo, chúng ta sẽ xem cách sửa đổi một vector.

Cập Nhật một Vector

Để tạo một vector và sau đó thêm các phần tử vào nó, chúng ta có thể sử dụng phương thức push, như hiển thị trong Listing 8-3.

fn main() {
    let mut v = Vec::new();

    v.push(5);
    v.push(6);
    v.push(7);
    v.push(8);
}

Giống như với bất kỳ biến nào, nếu chúng ta muốn có thể thay đổi giá trị của nó, chúng ta cần làm cho nó có thể thay đổi bằng cách sử dụng từ khóa mut, như đã thảo luận trong Chương 3. Các số mà chúng ta đặt vào đều thuộc kiểu i32, và Rust suy luận điều này từ dữ liệu, vì vậy chúng ta không cần chú thích Vec<i32>.

Đọc Các Phần Tử của Vector

Có hai cách để tham chiếu đến một giá trị được lưu trữ trong vector: thông qua chỉ mục hoặc bằng cách sử dụng phương thức get. Trong các ví dụ sau, chúng ta đã chú thích các kiểu của giá trị được trả về từ các hàm này để có thêm độ rõ ràng.

Listing 8-4 hiển thị cả hai phương pháp truy cập giá trị trong vector, với cú pháp lập chỉ mục và 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}");

    let third: Option<&i32> = v.get(2);
    match third {
        Some(third) => println!("The third element is {third}"),
        None => println!("There is no third element."),
    }
}

Lưu ý một vài chi tiết ở đây. Chúng ta sử dụng giá trị chỉ mục 2 để lấy phần tử thứ ba vì vector được đánh chỉ mục bằng số, bắt đầu từ không. Sử dụng & và [] cho chúng ta một tham chiếu đến phần tử tại giá trị chỉ mục. Khi chúng ta sử dụng phương thức get với chỉ mục được truyền vào dưới dạng đối số, chúng ta nhận được một Option<&T> mà chúng ta có thể sử dụng với match.

Rust cung cấp hai cách để tham chiếu đến một phần tử để bạn có thể chọn cách chương trình hoạt động khi bạn cố gắng sử dụng một giá trị chỉ mục nằm ngoài phạm vi của các phần tử hiện có. Ví dụ, hãy xem điều gì xảy ra khi chúng ta có một vector gồm năm phần tử và sau đó chúng ta cố gắng truy cập một phần tử tại chỉ mục 100 với mỗi kỹ thuật, như hiển thị trong Listing 8-5.

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

    let does_not_exist = &v[100];
    let does_not_exist = v.get(100);
}

Khi chúng ta chạy mã này, phương thức [] đầu tiên sẽ làm cho chương trình hoảng loạn vì nó tham chiếu đến một phần tử không tồn tại. Phương pháp này được sử dụng tốt nhất khi bạn muốn chương trình của mình gặp sự cố nếu có một nỗ lực truy cập một phần tử ngoài phạm vi của vector.

Khi phương thức get được truyền một chỉ mục ngoài vector, nó trả về None mà không hoảng loạn. Bạn sẽ sử dụng phương pháp này nếu việc truy cập một phần tử ngoài phạm vi của vector có thể xảy ra thỉnh thoảng trong các trường hợp bình thường. Mã của bạn sau đó sẽ có logic để xử lý việc có cả Some(&element) hoặc None, như đã thảo luận trong Chương 6. Ví dụ, chỉ mục có thể đến từ một người nhập một số. Nếu họ vô tình nhập một số quá lớn và chương trình nhận được giá trị None, bạn có thể cho người dùng biết có bao nhiêu mục trong vector hiện tại và cho họ một cơ hội khác để nhập một giá trị hợp lệ. Điều đó sẽ thân thiện với người dùng hơn là làm cho chương trình gặp sự cố do một lỗi đánh máy!

Khi chương trình có một tham chiếu hợp lệ, bộ kiểm tra mượn sẽ thực thi các quy tắc quyền sở hữu và mượn (được đề cập trong Chương 4) để đảm bảo tham chiếu này và bất kỳ tham chiếu nào khác tới nội dung của vector vẫn có giá trị. Nhớ lại quy tắc cho rằng bạn không thể có tham chiếu có thể thay đổi và không thể thay đổi trong cùng phạm vi. Quy tắc đó áp dụng trong Listing 8-6, nơi chúng ta giữ một tham chiếu bất biến đến phần tử đầu tiên trong một vector và cố gắng thêm một phần tử vào cuối. Chương trình này sẽ không hoạt động nếu chúng ta cũng cố gắng tham chiếu đến phần tử đó sau đó 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}");
}

Biên dịch mã này sẽ dẫn đến lỗi này:

$ 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` (bin "collections") due to 1 previous error

Mã trong Listing 8-6 có vẻ như nên hoạt động: tại sao một tham chiếu đến phần tử đầu tiên lại quan tâm đến những thay đổi ở cuối vector? Lỗi này là do cách vector hoạt động: vì vector đặt các giá trị liền kề nhau trong bộ nhớ, việc thêm một phần tử mới vào cuối vector có thể yêu cầu cấp phát bộ nhớ mới và sao chép các phần tử cũ sang không gian mới, nếu không có đủ chỗ để đặt tất cả các phần tử liền kề nhau tại nơi vector hiện đang được lưu trữ. Trong trường hợp đó, tham chiếu đến phần tử đầu tiên sẽ trỏ đến bộ nhớ đã giải phóng. Các quy tắc mượn ngăn chặn các chương trình rơi vào tình huống đó.

Lưu ý: Để biết thêm về chi tiết triển khai của kiểu Vec<T>, hãy xem "The Rustonomicon".

Lặp Qua Các Giá Trị trong một Vector

Để truy cập từng phần tử trong một vector theo lượt, chúng ta sẽ lặp qua tất cả các phần tử thay vì sử dụng chỉ mục để truy cập từng phần tử một lần. Listing 8-7 hiển thị cách sử dụng vòng lặp for để lấy các tham chiếu bất biến đến từng phần tử trong một vector các giá trị i32 và in chúng ra.

fn main() {
    let v = vec![100, 32, 57];
    for i in &v {
        println!("{i}");
    }
}

Chúng ta cũng có thể lặp qua các tham chiếu có thể thay đổi đến từng phần tử trong một vector có thể thay đổi để thực hiện các thay đổi cho tất cả các phần tử. Vòng lặp for trong Listing 8-8 sẽ thêm 50 vào mỗi phần tử.

fn main() {
    let mut v = vec![100, 32, 57];
    for i in &mut v {
        *i += 50;
    }
}

Để thay đổi giá trị mà tham chiếu có thể thay đổi đề cập đến, chúng ta phải sử dụng toán tử giải tham chiếu * để đến được giá trị trong i trước khi có thể sử dụng toán tử +=. Chúng ta sẽ nói thêm về toán tử giải tham chiếu trong phần "Theo con trỏ đến giá trị" của Chương 15.

Việc lặp qua một vector, dù là bất biến hay có thể thay đổi, đều an toàn nhờ vào quy tắc của bộ kiểm tra mượn. Nếu chúng ta cố gắng chèn hoặc xóa các mục trong thân vòng lặp for trong Listing 8-7 và Listing 8-8, chúng ta sẽ gặp lỗi biên dịch tương tự như lỗi chúng ta gặp với mã trong Listing 8-6. Tham chiếu đến vector mà vòng lặp for giữ ngăn chặn việc sửa đổi đồng thời toàn bộ vector.

Sử dụng Enum để Lưu Trữ Nhiều Kiểu

Vector chỉ có thể lưu trữ các giá trị có cùng kiểu. Điều này có thể gây bất tiện; chắc chắn có những trường hợp sử dụng cần lưu trữ một danh sách các mục thuộc các kiểu khác nhau. May mắn thay, các biến thể của một enum được định nghĩa dưới cùng một kiểu enum, vì vậy khi chúng ta cần một kiểu để đại diện cho các phần tử của các kiểu khác nhau, chúng ta có thể định nghĩa và sử dụng một enum!

Ví dụ, giả sử chúng ta muốn lấy các giá trị từ một hàng trong một bảng tính trong đó một số cột trong hàng chứa số nguyên, một số chứa số dấu phẩy động, và một số chứa chuỗi. Chúng ta có thể định nghĩa một enum có các biến thể sẽ chứa các kiểu giá trị khác nhau, và tất cả các biến thể enum sẽ được coi là cùng một kiểu: kiểu của enum đó. Sau đó chúng ta có thể tạo một vector để chứa enum đó và do đó, cuối cùng, chứa các kiểu khác nhau. Chúng ta đã minh họa điều này trong Listing 8-9.

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),
    ];
}

Rust cần biết những kiểu nào sẽ có trong vector tại thời điểm biên dịch để biết chính xác bao nhiêu bộ nhớ trên heap sẽ cần để lưu trữ mỗi phần tử. Chúng ta cũng phải rõ ràng về những kiểu nào được phép trong vector này. Nếu Rust cho phép một vector chứa bất kỳ kiểu nào, sẽ có khả năng một hoặc nhiều kiểu sẽ gây ra lỗi với các hoạt động được thực hiện trên các phần tử của vector. Sử dụng enum cùng với biểu thức match nghĩa là Rust sẽ đảm bảo tại thời điểm biên dịch rằng mọi trường hợp khả dĩ đều được xử lý, như đã thảo luận trong Chương 6.

Nếu bạn không biết tập hợp đầy đủ các kiểu mà một chương trình sẽ nhận được tại thời điểm chạy để lưu trữ trong vector, kỹ thuật enum sẽ không hoạt động. Thay vào đó, bạn có thể sử dụng trait object, mà chúng ta sẽ đề cập trong Chương 18.

Giờ chúng ta đã thảo luận về một số cách sử dụng vector phổ biến nhất, hãy đảm bảo xem xét tài liệu API để biết tất cả các phương thức hữu ích được định nghĩa cho Vec<T> bởi thư viện chuẩn. Ví dụ, ngoài push, phương thức pop loại bỏ và trả về phần tử cuối cùng.

Giải phóng một Vector sẽ Giải phóng Các Phần tử của Nó

Giống như bất kỳ struct nào khác, một vector được giải phóng khi nó ra khỏi phạm vi, như được chú thích trong Listing 8-10.

fn main() {
    {
        let v = vec![1, 2, 3, 4];

        // do stuff with v
    } // <- v goes out of scope and is freed here
}

Khi vector bị giải phóng, tất cả nội dung của nó cũng bị giải phóng, nghĩa là các số nguyên mà nó chứa sẽ được dọn sạch. Bộ kiểm tra mượn đảm bảo rằng bất kỳ tham chiếu nào đến nội dung của vector chỉ được sử dụng khi bản thân vector còn có giá trị.

Hãy chuyển sang loại bộ sưu tập tiếp theo: String!

Lưu Trữ Văn Bản Mã Hóa UTF-8 với Chuỗi

Chúng ta đã nói về chuỗi trong Chương 4, nhưng bây giờ chúng ta sẽ xem xét chúng chi tiết hơn. Những người mới học Rust thường bị mắc kẹt với chuỗi vì sự kết hợp của ba lý do: khuynh hướng của Rust trong việc tiết lộ các lỗi có thể xảy ra, chuỗi là một cấu trúc dữ liệu phức tạp hơn nhiều so với những gì nhiều lập trình viên đánh giá, và UTF-8. Những yếu tố này kết hợp theo cách dường như khó khăn khi bạn đến từ các ngôn ngữ lập trình khác.

Chúng ta thảo luận về chuỗi trong bối cảnh của các bộ sưu tập vì chuỗi được triển khai như một bộ sưu tập các byte, cộng thêm một số phương thức để cung cấp chức năng hữu ích khi những byte này được diễn giải dưới dạng văn bản. Trong phần này, chúng ta sẽ nói về các hoạt động trên String mà mọi loại bộ sưu tập đều có, chẳng hạn như tạo, cập nhật và đọc. Chúng ta cũng sẽ thảo luận về những cách mà String khác với các bộ sưu tập khác, cụ thể là cách mà việc lập chỉ mục vào một String bị phức tạp hóa bởi sự khác biệt giữa cách con người và máy tính diễn giải dữ liệu String.

Chuỗi Là Gì?

Đầu tiên, chúng ta sẽ định nghĩa những gì chúng ta hiểu bằng thuật ngữ chuỗi. Rust chỉ có một kiểu chuỗi trong ngôn ngữ cốt lõi, đó là lát cắt chuỗi str thường được thấy dưới dạng mượn &str. Trong Chương 4, chúng ta đã nói về lát cắt chuỗi, là tham chiếu đến một số dữ liệu chuỗi mã hóa UTF-8 được lưu trữ ở nơi khác. Các chuỗi nghĩa đen, chẳng hạn, được lưu trữ trong tệp nhị phân của chương trình và do đó là lát cắt chuỗi.

Kiểu String, được cung cấp bởi thư viện chuẩn của Rust thay vì được mã hóa trong ngôn ngữ cốt lõi, là một kiểu chuỗi có thể phát triển, có thể thay đổi, được sở hữu, mã hóa UTF-8. Khi người dùng Rust nhắc đến "chuỗi" trong Rust, họ có thể nhắc đến kiểu String hoặc kiểu lát cắt chuỗi &str, không chỉ một trong những kiểu đó. Mặc dù phần này chủ yếu nói về String, cả hai kiểu đều được sử dụng nhiều trong thư viện chuẩn của Rust, và cả String và lát cắt chuỗi đều được mã hóa UTF-8.

Tạo Một Chuỗi Mới

Nhiều hoạt động tương tự có sẵn với Vec<T> cũng có sẵn với String vì String thực sự được triển khai như một bao bọc xung quanh một vector byte với một số đảm bảo, hạn chế và khả năng bổ sung. Một ví dụ về một hàm hoạt động giống nhau với Vec<T> và String là hàm new để tạo một thể hiện, như hiển thị trong Listing 8-11.

fn main() {
    let mut s = String::new();
}

Dòng này tạo ra một chuỗi mới, rỗng có tên là s, mà chúng ta sau đó có thể tải dữ liệu vào. Thường thì chúng ta sẽ có một số dữ liệu ban đầu mà chúng ta muốn bắt đầu chuỗi với. Để làm điều đó, chúng ta sử dụng phương thức to_string, có sẵn trên bất kỳ kiểu nào triển khai trait Display, như các chuỗi nghĩa đen có. Listing 8-12 hiển thị hai 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();
}

Mã này tạo ra một chuỗi chứa initial contents.

Chúng ta cũng có thể sử dụng hàm String::from để tạo một String từ một chuỗi nghĩa đen. Mã trong Listing 8-13 tương đương với mã trong Listing 8-12 sử dụng to_string.

fn main() {
    let s = String::from("initial contents");
}

Vì chuỗi được sử dụng cho rất nhiều thứ, chúng ta có thể sử dụng nhiều API chung khác nhau cho chuỗi, cung cấp cho chúng ta rất nhiều tùy chọn. Một số trong số chúng có vẻ thừa thãi, nhưng tất cả đều có vị trí riêng của mình! Trong trường hợp này, String::from và to_string làm cùng một việc, vì vậy việc bạn chọn cái nào là vấn đề của phong cách và khả năng đọc.

Hãy nhớ rằng chuỗi được mã hóa UTF-8, vì vậy chúng ta có thể bao gồm bất kỳ dữ liệu nào được mã hóa đúng cách trong chúng, như hiển thị trong Listing 8-14.

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");
}

Tất cả những điều này đều là các giá trị String hợp lệ.

Cập Nhật một Chuỗi

Một String có thể tăng kích thước và nội dung của nó có thể thay đổi, giống như nội dung của một Vec<T>, nếu bạn đẩy thêm dữ liệu vào nó. Ngoài ra, bạn có thể thuận tiện sử dụng toán tử + hoặc macro format! để nối các giá trị String.

Thêm vào Chuỗi với push_str và push

Chúng ta có thể làm cho một String phát triển bằng cách sử dụng phương thức push_str để thêm một lát cắt chuỗi, như hiển thị trong Listing 8-15.

fn main() {
    let mut s = String::from("foo");
    s.push_str("bar");
}

Sau hai dòng này, s sẽ chứa foobar. Phương thức push_str lấy một lát cắt chuỗi vì chúng ta không nhất thiết muốn lấy quyền sở hữu của tham số. Ví dụ, trong mã trong Listing 8-16, chúng ta muốn có thể sử dụng s2 sau khi thêm nội dung của nó vào s1.

fn main() {
    let mut s1 = String::from("foo");
    let s2 = "bar";
    s1.push_str(s2);
    println!("s2 is {s2}");
}

Nếu phương thức push_str lấy quyền sở hữu của s2, chúng ta sẽ không thể in giá trị của nó trên dòng cuối cùng. Tuy nhiên, mã này hoạt động như chúng ta mong đợi!

Phương thức push lấy một ký tự duy nhất làm tham số và thêm nó vào String. Listing 8-17 thêm chữ cái l vào một String bằng cách sử dụng phương thức push.

fn main() {
    let mut s = String::from("lo");
    s.push('l');
}

Kết quả là, s sẽ chứa lol.

Nối với Toán Tử + hoặc Macro format!

Thường thì bạn sẽ muốn kết hợp hai chuỗi hiện có. Một cách để làm điều đó là sử dụng toán tử +, như hiển thị trong 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
}

Chuỗi s3 sẽ chứa Hello, world!. Lý do s1 không còn hợp lệ sau khi thêm, và lý do chúng ta sử dụng một tham chiếu đến s2, có liên quan đến chữ ký của phương thức được gọi khi chúng ta sử dụng toán tử +. Toán tử + sử dụng phương thức add, có chữ ký trông giống như thế này:

fn add(self, s: &str) -> String {

Trong thư viện chuẩn, bạn sẽ thấy add được định nghĩa bằng cách sử dụng generics và liên kết kiểu. Ở đây, chúng ta đã thay thế bằng các kiểu cụ thể, điều này xảy ra khi chúng ta gọi phương thức này với các giá trị String. Chúng ta sẽ thảo luận về generics trong Chương 10. Chữ ký này cung cấp cho chúng ta những manh mối chúng ta cần để hiểu các phần phức tạp của toán tử +.

Đầu tiên, s2 có một &, có nghĩa là chúng ta đang thêm một tham chiếu của chuỗi thứ hai vào chuỗi đầu tiên. Điều này là do tham số s trong hàm add: chúng ta chỉ có thể thêm một &str vào một String; chúng ta không thể thêm hai giá trị String với nhau. Nhưng khoan—kiểu của &s2 là &String, không phải &str, như đã được chỉ định trong tham số thứ hai cho add. Vậy tại sao Listing 8-18 biên dịch?

Lý do chúng ta có thể sử dụng &s2 trong lệnh gọi đến add là vì trình biên dịch có thể ép buộc đối số &String thành &str. Khi chúng ta gọi phương thức add, Rust sử dụng ép buộc deref, nơi đây biến &s2 thành &s2[..]. Chúng ta sẽ thảo luận về ép buộc deref chi tiết hơn trong Chương 15. Bởi vì add không lấy quyền sở hữu của tham số s, s2 vẫn sẽ là một String hợp lệ sau hoạt động này.

Thứ hai, chúng ta có thể thấy trong chữ ký rằng add lấy quyền sở hữu của self vì self không có &. Điều này có nghĩa s1 trong Listing 8-18 sẽ bị di chuyển vào lệnh gọi add và sẽ không còn hợp lệ sau đó. Vì vậy, mặc dù let s3 = s1 + &s2; trông như thể nó sẽ sao chép cả hai chuỗi và tạo một chuỗi mới, câu lệnh này thực sự lấy quyền sở hữu của s1, thêm một bản sao nội dung của s2, và sau đó trả lại quyền sở hữu của kết quả. Nói cách khác, nó trông như thể nó đang tạo ra rất nhiều bản sao, nhưng không phải vậy; việc triển khai hiệu quả hơn là sao chép.

Nếu chúng ta cần nối nhiều chuỗi, hành vi của toán tử + trở nên khó xử lý:

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");

    let s = s1 + "-" + &s2 + "-" + &s3;
}

Lúc này, s sẽ là tic-tac-toe. Với tất cả các ký tự + và ", khó có thể thấy điều gì đang xảy ra. Để kết hợp các chuỗi theo cách phức tạp hơn, chúng ta có thể sử dụng macro format!:

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");

    let s = format!("{s1}-{s2}-{s3}");
}

Mã này cũng đặt s thành tic-tac-toe. Macro format! hoạt động giống như println!, nhưng thay vì in đầu ra ra màn hình, nó trả về một String với nội dung. Phiên bản mã sử dụng format! dễ đọc hơn nhiều, và mã được tạo ra bởi macro format! sử dụng tham chiếu nên lời gọi này không lấy quyền sở hữu của bất kỳ tham số nào của nó.

Lập Chỉ Mục vào Chuỗi

Trong nhiều ngôn ngữ lập trình khác, việc truy cập các ký tự riêng lẻ trong một chuỗi bằng cách tham chiếu đến chúng bằng chỉ mục là một hoạt động hợp lệ và phổ biến. Tuy nhiên, nếu bạn cố gắng truy cập các phần của một String sử dụng cú pháp lập chỉ mục trong Rust, bạn sẽ gặp lỗi. Xem xét mã không hợp lệ trong Listing 8-19.

fn main() {
    let s1 = String::from("hi");
    let h = s1[0];
}

Mã này sẽ dẫn đến lỗi sau:

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
error[E0277]: the type `str` cannot be indexed by `{integer}`
 --> src/main.rs:3:16
  |
3 |     let h = s1[0];
  |                ^ string indices are ranges of `usize`
  |
  = note: you can use `.chars().nth()` or `.bytes().nth()`
          for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
  = help: the trait `SliceIndex<str>` is not implemented for `{integer}`
          but trait `SliceIndex<[_]>` is implemented for `usize`
  = help: for that trait implementation, expected `[_]`, found `str`
  = note: required for `String` to implement `Index<{integer}>`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `collections` (bin "collections") due to 1 previous error

Lỗi và ghi chú kể câu chuyện: chuỗi Rust không hỗ trợ lập chỉ mục. Nhưng tại sao không? Để trả lời câu hỏi đó, chúng ta cần thảo luận về cách Rust lưu trữ chuỗi trong bộ nhớ.

Biểu Diễn Nội Bộ

Một String là một bao bọc trên một Vec<u8>. Hãy xem một số ví dụ chuỗi được mã hóa UTF-8 đúng của chúng ta từ Listing 8-14. Đầu tiên là ví dụ 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, len sẽ là 4, có nghĩa là vector lưu trữ chuỗi "Hola" dài 4 byte. Mỗi chữ cái này chiếm một byte khi được mã hóa trong UTF-8. Tuy nhiên, dòng sau đây có thể làm bạn ngạc nhiên (lưu ý rằng chuỗi này bắt đầu bằng chữ cái Cyrillic viết hoa Ze, không phải số 3):

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");
}

Nếu bạn được hỏi chuỗi dài bao nhiêu, bạn có thể nói 12. Thực tế, câu trả lời của Rust là 24: đó là số byte cần thiết để mã hóa "Здравствуйте" trong UTF-8, vì mỗi giá trị vô hướng Unicode trong chuỗi đó chiếm 2 byte lưu trữ. Do đó, một chỉ mục vào byte của chuỗi sẽ không phải lúc nào cũng tương quan với một giá trị vô hướng Unicode hợp lệ. Để minh họa, hãy xem xét mã Rust không hợp lệ này:

let hello = "Здравствуйте";
let answer = &hello[0];

Bạn đã biết rằng answer sẽ không phải là З, chữ cái đầu tiên. Khi được mã hóa trong UTF-8, byte đầu tiên của З là 208 và byte thứ hai là 151, vì vậy nó sẽ có vẻ như answer thực sự nên là 208, nhưng 208 không phải là một ký tự hợp lệ tự nó. Trả về 208 có thể không phải là điều mà người dùng muốn nếu họ hỏi về chữ cái đầu tiên của chuỗi này; tuy nhiên, đó là dữ liệu duy nhất mà Rust có tại chỉ mục byte 0. Người dùng thường không muốn giá trị byte được trả về, ngay cả khi chuỗi chỉ chứa các chữ cái Latin: nếu &"hi"[0] là mã hợp lệ trả về giá trị byte, nó sẽ trả về 104, không phải h.

Câu trả lời, vì vậy, là để tránh trả về một giá trị không mong đợi và gây ra lỗi có thể không được phát hiện ngay lập tức, Rust không biên dịch mã này và ngăn chặn hiểu lầm sớm trong quá trình phát triển.

Byte, Giá Trị Vô Hướng và Cụm Tự Hình! Ôi Trời!

Một điểm khác về UTF-8 là thực sự có ba cách liên quan để nhìn chuỗi từ góc độ của Rust: dưới dạng byte, giá trị vô hướng, và cụm tự hình (điều gần nhất với những gì chúng ta gọi là chữ cái).

Nếu chúng ta nhìn vào từ tiếng Hindi "नमस्ते" được viết bằng chữ viết Devanagari, nó được lưu trữ dưới dạng một vector các giá trị u8 trông như thế này:

[224, 164, 168, 224, 164, 174, 224, 164, 184, 224, 165, 141, 224, 164, 164,
224, 165, 135]

Đó là 18 byte và đây là cách máy tính cuối cùng lưu trữ dữ liệu này. Nếu chúng ta nhìn vào chúng như các giá trị vô hướng Unicode, đó là kiểu char của Rust, những byte đó trông như thế này:

['न', 'म', 'स', '्', 'त', 'े']

Có sáu giá trị char ở đây, nhưng giá trị thứ tư và thứ sáu không phải là chữ cái: đó là các dấu phụ không có ý nghĩa khi đứng một mình. Cuối cùng, nếu chúng ta nhìn vào chúng như cụm tự hình, chúng ta sẽ có được những gì mà một người sẽ gọi là bốn chữ cái tạo nên từ tiếng Hindi:

["न", "म", "स्", "ते"]

Rust cung cấp các cách khác nhau để diễn giải dữ liệu chuỗi thô mà máy tính lưu trữ để mỗi chương trình có thể chọn cách diễn giải mà nó cần, bất kể ngôn ngữ con người nào mà dữ liệu đó thuộc về.

Một lý do cuối cùng mà Rust không cho phép chúng ta lập chỉ mục vào một String để lấy một ký tự là vì các hoạt động lập chỉ mục được mong đợi luôn mất thời gian không đổi (O(1)). Nhưng không thể đảm bảo hiệu suất đó với một String, vì Rust sẽ phải đi qua nội dung từ đầu đến chỉ mục để xác định có bao nhiêu ký tự hợp lệ.

Cắt Chuỗi

Lập chỉ mục vào một chuỗi thường là một ý tưởng tồi vì không rõ kiểu trả về của hoạt động lập chỉ mục chuỗi nên là gì: một giá trị byte, một ký tự, một cụm tự hình, hay một lát cắt chuỗi. Do đó, nếu bạn thực sự cần sử dụng chỉ mục để tạo lát cắt chuỗi, Rust yêu cầu bạn cần cụ thể hơn.

Thay vì lập chỉ mục bằng [] với một số duy nhất, bạn có thể sử dụng [] với một phạm vi để tạo một lát cắt chuỗi chứa các byte cụ thể:

#![allow(unused)]
fn main() {
let hello = "Здравствуйте";

let s = &hello[0..4];
}

Ở đây, s sẽ là một &str chứa bốn byte đầu tiên của chuỗi. Trước đó, chúng ta đã đề cập rằng mỗi ký tự này chiếm hai byte, điều đó có nghĩa s sẽ là Зд.

Nếu chúng ta cố gắng cắt chỉ một phần byte của một ký tự với một cái gì đó như &hello[0..1], Rust sẽ hoảng loạn tại thời điểm chạy theo cách tương tự như khi một chỉ mục không hợp lệ được truy cập trong một vector:

$ cargo run
   Compiling collections v0.1.0 (file:///projects/collections)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.43s
     Running `target/debug/collections`

thread 'main' panicked at src/main.rs:4:19:
byte index 1 is not a char boundary; it is inside 'З' (bytes 0..2) of `Здравствуйте`
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Bạn nên thận trọng khi tạo lát cắt chuỗi với phạm vi, vì làm như vậy có thể làm sập chương trình của bạn.

Phương Thức để Lặp Qua Chuỗi

Cách tốt nhất để hoạt động trên các phần của chuỗi là rõ ràng về việc bạn muốn ký tự hay byte. Đối với các giá trị vô hướng Unicode riêng lẻ, hãy sử dụng phương thức chars. Gọi chars trên "Зд" tách ra và trả về hai giá trị kiểu char, và bạn có thể lặp qua kết quả để truy cập từng phần tử:

#![allow(unused)]
fn main() {
for c in "Зд".chars() {
    println!("{c}");
}
}

Mã này sẽ in ra như sau:

З
д

Ngoài ra, phương thức bytes trả về từng byte thô, điều này có thể phù hợp cho miền của bạn:

#![allow(unused)]
fn main() {
for b in "Зд".bytes() {
    println!("{b}");
}
}

Mã này sẽ in ra bốn byte tạo nên chuỗi này:

208
151
208
180

Nhưng hãy nhớ rằng các giá trị vô hướng Unicode hợp lệ có thể bao gồm nhiều hơn một byte.

Lấy cụm tự hình từ chuỗi, như với chữ viết Devanagari, là phức tạp, vì vậy chức năng này không được cung cấp bởi thư viện chuẩn. Các crate có sẵn trên crates.io nếu đây là chức năng bạn cần.

Chuỗi Không Đơn Giản

Tóm lại, chuỗi là phức tạp. Các ngôn ngữ lập trình khác nhau đưa ra những lựa chọn khác nhau về cách trình bày sự phức tạp này cho lập trình viên. Rust đã chọn làm cho việc xử lý dữ liệu String đúng cách trở thành hành vi mặc định cho tất cả các chương trình Rust, điều này có nghĩa là lập trình viên phải suy nghĩ nhiều hơn về việc xử lý dữ liệu UTF-8 ngay từ đầu. Sự đánh đổi này tiết lộ nhiều sự phức tạp của chuỗi hơn là rõ ràng trong các ngôn ngữ lập trình khác, nhưng nó ngăn bạn phải xử lý lỗi liên quan đến các ký tự không phải ASCII sau này trong vòng đời phát triển của bạn.

Tin tốt là thư viện chuẩn cung cấp rất nhiều chức năng được xây dựng dựa trên các kiểu String và &str để giúp xử lý các tình huống phức tạp này một cách chính xác. Hãy chắc chắn kiểm tra tài liệu để biết các phương thức hữu ích như contains để tìm kiếm trong một chuỗi và replace để thay thế các phần của một chuỗi bằng một chuỗi khác.

Hãy chuyển sang một thứ ít phức tạp hơn một chút: bảng băm!

Lưu Trữ Khóa với Giá Trị Liên Kết trong Bảng Băm

Loại bộ sưu tập phổ biến cuối cùng của chúng ta là bảng băm. Kiểu HashMap<K, V> lưu trữ một ánh xạ từ khóa kiểu K đến giá trị kiểu V bằng cách sử dụng một hàm băm, xác định cách nó đặt các khóa và giá trị này vào bộ nhớ. 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 nhau, chẳng hạn như hash, map, object, hash table, dictionary, hoặc associative array, chỉ để kể vài tên.

Bảng băm hữu ích khi bạn muốn tra cứu dữ liệu không bằng cách sử dụng chỉ mục, như bạn có thể làm với vector, mà bằng cách sử dụng khóa có thể thuộc bất kỳ kiểu nào. Ví dụ, trong một trò chơi, bạn có thể theo dõi điểm số của mỗi đội trong một bảng băm trong đó mỗi khóa là tên của một đội và giá trị là điểm số của mỗi đội. Cho tên đội, bạn có thể lấy ra điểm số của nó.

Chúng ta sẽ xem qua API cơ bản của bảng băm trong phần này, nhưng còn nhiều thứ hữu ích khác ẩn trong các hàm được định nghĩa trên HashMap<K, V> bởi thư viện chuẩn. Như mọi khi, hãy kiểm tra tài liệu của thư viện chuẩn để biết thêm thông tin.

Tạo Bảng Băm Mới

Một cách để tạo bảng băm rỗng là sử dụng new và thêm các phần tử bằng insert. Trong Listing 8-20, chúng ta đang theo dõi điểm số của hai đội có tên 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);
}

Lưu ý rằng chúng ta cần use HashMap từ phần collections của thư viện chuẩn trước. Trong ba bộ sưu tập phổ biến của chúng ta, bộ sưu tập này được sử dụng ít nhất, nên nó không được đưa vào phạm vi tự động trong phần prelude. Bảng băm cũng nhận được ít hỗ trợ hơn từ thư viện chuẩn; chẳng hạn, không có macro tích hợp sẵn để xây dựng chúng.

Giống như vector, bảng băm lưu trữ dữ liệu của chúng trên heap. HashMap này có khóa kiểu String và giá trị kiểu i32. Giống như vector, bảng băm là đồng nhất: tất cả các khóa phải có cùng kiểu, và tất cả các giá trị phải có cùng kiểu.

Truy Cập Giá Trị trong Bảng Băm

Chúng ta có thể lấy một giá trị từ bảng băm bằng cách cung cấp khóa của nó cho phương thức get, như được hiển thị trong Listing 8-21.

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).copied().unwrap_or(0);
}

Ở đây, score sẽ có giá trị được liên kết với đội Blue, và kết quả sẽ là 10. Phương thức get trả về một Option<&V>; nếu không có giá trị cho khóa đó trong bảng băm, get sẽ trả về None. Chương trình này xử lý Option bằng cách gọi copied để lấy một Option<i32> thay vì một Option<&i32>, sau đó unwrap_or để đặt score thành không nếu scores không có mục cho khóa.

Chúng ta có thể lặp qua từng cặp khóa-giá trị trong một bảng băm theo cách tương tự như chúng ta làm với vector, sử dụng vòng lặp 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}");
    }
}

Mã này sẽ in mỗi cặp theo thứ tự ngẫu nhiên:

Yellow: 50
Blue: 10

Bảng Băm và Quyền Sở Hữu

Đối với các kiểu triển khai trait Copy, như i32, các giá trị được sao chép vào bảng băm. Đối với các giá trị được sở hữu như String, các giá trị sẽ bị di chuyển và bảng băm sẽ là chủ sở hữu của các giá trị đó, như được minh họa 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!
}

Chúng ta không thể sử dụng các biến field_name và field_value sau khi chúng đã được di chuyển vào bảng băm bằng lệnh gọi đến insert.

Nếu chúng ta chèn tham chiếu đến các giá trị vào bảng băm, các giá trị sẽ không bị di chuyển vào bảng băm. Các giá trị mà các tham chiếu trỏ đến phải hợp lệ ít nhất miễn là bảng băm còn hợp lệ. Chúng ta sẽ nói thêm về các vấn đề này trong "Xác thực Tham chiếu với Vòng đời" trong Chương 10.

Cập Nhật Bảng Băm

Mặc dù số lượng cặp khóa và giá trị có thể tăng lên, mỗi khóa duy nhất chỉ có thể có một giá trị liên kết với nó tại một thời điểm (nhưng không ngược lại: ví dụ, cả đội Blue và đội Yellow đều có thể có giá trị 10 được lưu trữ trong bảng băm scores).

Khi bạn muốn thay đổi dữ liệu trong một bảng băm, bạn phải quyết định cách xử lý trường hợp khi một khóa đã có một giá trị được gán. Bạn có thể thay thế giá trị cũ bằng giá trị mới, hoàn toàn bỏ qua giá trị cũ. Bạn có thể giữ giá trị cũ và bỏ qua giá trị mới, chỉ thêm giá trị mới nếu khóa không đã có một giá trị. Hoặc bạn có thể kết hợp giá trị cũ và giá trị mới. Hãy xem cách thực hiện mỗi điều này!

Ghi Đè Một Giá Trị

Nếu chúng ta chèn một khóa và một giá trị vào một bảng băm và sau đó chèn cùng khóa đó với một giá trị khác, giá trị liên kết với khóa đó sẽ bị thay thế. Mặc dù mã trong Listing 8-23 gọi insert hai lần, bảng băm sẽ chỉ chứa một cặp khóa-giá trị vì chúng ta đang chèn giá trị cho khóa của đội Blue cả hai 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:?}");
}

Mã này sẽ in {"Blue": 25}. Giá trị ban đầu 10 đã bị ghi đè.

Chỉ Thêm Khóa và Giá Trị Nếu Khóa Không Tồn Tại

Thông thường, người ta kiểm tra xem một khóa cụ thể đã tồn tại trong bảng băm với một giá trị hay chưa và sau đó thực hiện các hành động sau: nếu khóa đó tồn tại trong bảng băm, giá trị hiện tại nên giữ nguyên như vậy; nếu khóa không tồn tại, chèn nó và một giá trị cho nó.

Bảng băm có một API đặc biệt cho việc này gọi là entry lấy khóa bạn muốn kiểm tra làm tham số. Giá trị trả về của phương thức entry là một enum gọi là Entry đại diện cho một giá trị có thể tồn tại hoặc không. Giả sử chúng ta muốn kiểm tra xem khóa cho đội Yellow có giá trị liên kết với nó không. Nếu không, chúng ta muốn chèn giá trị 50, và tương tự cho đội Blue. Sử dụng API entry, mã trông giống như Listing 8-24.

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:?}");
}

Phương thức or_insert trên Entry được định nghĩa để trả về một tham chiếu có thể thay đổi đến giá trị cho khóa Entry tương ứng nếu khóa đó tồn tại, và nếu không, nó chèn tham số làm giá trị mới cho khóa này và trả về một tham chiếu có thể thay đổi đến giá trị mới. Kỹ thuật này sạch sẽ hơn nhiều so với việc tự viết logic và, ngoài ra, hoạt động tốt hơn với bộ kiểm tra mượn.

Chạy mã trong Listing 8-24 sẽ in {"Yellow": 50, "Blue": 10}. Lệnh gọi đầu tiên đến entry sẽ chèn khóa cho đội Yellow với giá trị 50 vì đội Yellow chưa có giá trị. Lệnh gọi thứ hai đến entry sẽ không thay đổi bảng băm vì đội Blue đã có giá trị 10.

Cập Nhật Giá Trị Dựa trên Giá Trị Cũ

Trường hợp sử dụng phổ biến khác cho bảng băm là tra cứu giá trị của một khóa và sau đó cập nhật nó dựa trên giá trị cũ. Ví dụ, Listing 8-25 hiển thị mã đếm số lần xuất hiện của mỗi từ trong một đoạn văn bản. Chúng ta sử dụng bảng băm với các từ làm khóa và tăng giá trị để theo dõi số lần chúng ta đã thấy từ đó. Nếu đó là lần đầu tiên chúng ta thấy một từ, chúng ta sẽ chèn giá trị 0 trước.

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:?}");
}

Mã này sẽ in {"world": 2, "hello": 1, "wonderful": 1}. Bạn có thể thấy các cặp khóa-giá trị giống nhau được in ra theo thứ tự khác nhau: hãy nhớ lại từ "Truy cập Giá trị trong Bảng băm" rằng việc lặp qua một bảng băm xảy ra theo thứ tự ngẫu nhiên.

Phương thức split_whitespace trả về một iterator qua các lát cắt con, được phân tách bởi khoảng trắng, của giá trị trong text. Phương thức or_insert trả về một tham chiếu có thể thay đổi (&mut V) đến giá trị cho khóa được chỉ định. Ở đây, chúng ta lưu trữ tham chiếu có thể thay đổi đó trong biến count, vì vậy để gán cho giá trị đó, chúng ta phải giải tham chiếu count bằng cách sử dụng dấu hoa thị (*). Tham chiếu có thể thay đổi hết phạm vi tại cuối vòng lặp for, vì vậy tất cả các thay đổi này là an toàn và được cho phép bởi các quy tắc mượn.

Hàm Băm

Theo mặc định, HashMap sử dụng một hàm băm gọi là SipHash có thể cung cấp khả năng chống lại các cuộc tấn công từ chối dịch vụ (DoS) liên quan đến bảng băm¹. Đây không phải là thuật toán băm nhanh nhất có sẵn, nhưng sự đánh đổi cho bảo mật tốt hơn đi kèm với sự sụt giảm hiệu suất là đáng giá. Nếu bạn phân tích mã của mình và thấy rằng hàm băm mặc định quá chậm cho mục đích của bạn, bạn có thể chuyển sang một hàm khác bằng cách chỉ định một bộ băm khác. Một hasher là một kiểu triển khai trait BuildHasher. Chúng ta sẽ nói về trait và cách triển khai chúng trong Chương 10. Bạn không nhất thiết phải triển khai bộ băm riêng của bạn từ đầu; crates.io có các thư viện được chia sẻ bởi người dùng Rust khác cung cấp các hasher triển khai nhiều thuật toán băm phổ biến.

Tóm tắt

Vector, chuỗi và bảng băm sẽ cung cấp một lượng lớn chức năng cần thiết trong các chương trình khi bạn cần lưu trữ, truy cập và sửa đổi dữ liệu. Đây là một số bài tập mà bạn bây giờ đã có thể giải quyết:

1. Cho một danh sách các số nguyên, sử dụng vector và trả về trung vị (khi được sắp xếp, giá trị ở vị trí giữa) và mode (giá trị xuất hiện nhiều nhất; một bảng băm sẽ hữu ích ở đây) của danh sách.
2. Chuyển đổi chuỗi sang pig latin. Phụ âm đầu tiên của mỗi từ được di chuyển đến cuối từ và thêm ay, vì vậy first trở thành irst-fay. Các từ bắt đầu bằng một nguyên âm được thêm hay vào cuối thay vào đó (apple trở thành apple-hay). Hãy ghi nhớ các chi tiết về mã hóa UTF-8!
3. Sử dụng bảng băm và vector, tạo một giao diện văn bản để cho phép người dùng thêm tên nhân viên vào một phòng ban trong công ty; ví dụ, "Add Sally to Engineering" hoặc "Add Amir to Sales." Sau đó cho phép người dùng lấy danh sách tất cả mọi người trong một phòng ban hoặc tất cả mọi người trong công ty theo phòng ban, được sắp xếp theo thứ tự bảng chữ cái.

Tài liệu API thư viện chuẩn mô tả các phương thức mà vector, chuỗi, và bảng băm có sẽ hữu ích cho các bài tập này!

Chúng ta đang đi vào các chương trình phức tạp hơn trong đó các hoạt động có thể thất bại, vì vậy đó là thời điểm hoàn hảo để thảo luận về xử lý lỗi. Chúng ta sẽ làm điều đó tiếp theo!

1. https://en.wikipedia.org/wiki/SipHash ↩

Xử Lý Lỗi

Lỗi là điều không thể tránh khỏi trong phần mềm, vì vậy Rust có một số tính năng để xử lý các tình huống khi có sự cố xảy ra. Trong nhiều trường hợp, Rust yêu cầu bạn phải thừa nhận khả năng xảy ra lỗi và thực hiện một số hành động trước khi mã của bạn được biên dịch. Yêu cầu này làm cho chương trình của bạn trở nên mạnh mẽ hơn bằng cách đảm bảo rằng bạn sẽ phát hiện lỗi và xử lý chúng một cách thích hợp trước khi triển khai mã của bạn lên môi trường sản phẩm!

Rust phân loại lỗi thành hai danh mục chính: lỗi có thể khôi phục và lỗi không thể khôi phục. Đối với lỗi có thể khôi phục, chẳng hạn như lỗi không tìm thấy tệp, chúng ta rất có thể chỉ muốn báo cáo vấn đề cho người dùng và thử lại thao tác đó. Lỗi không thể khôi phục luôn là dấu hiệu của các lỗi phần mềm, chẳng hạn như cố gắng truy cập vào vị trí vượt quá giới hạn của mảng, và vì vậy chúng ta 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 hai loại lỗi này và xử lý cả hai theo cùng một cách, sử dụng các cơ chế như exception. Rust không có exception. Thay vào đó, nó có kiểu Result<T, E> cho lỗi có thể khôi phục và macro panic! để dừng thực thi khi chương trình gặp lỗi không thể khôi phục. Chương này đề cập đến việc gọi panic! trước, sau đó nói về việc trả về giá trị Result<T, E>. Ngoài ra, chúng ta sẽ khám phá các cân nhắc khi quyết định liệu có nên cố gắng khôi phục từ lỗi hay dừng thực thi.

Lỗi Không Thể Khôi Phục với panic!

Đôi khi những điều không mong muốn xảy ra trong code của bạn, và bạn không thể làm gì để ngăn chặn nó. Trong những trường hợp này, Rust có macro panic!. Có hai cách để gây ra panic trong thực tế: thực hiện một hành động khiến code của chúng ta panic (ví dụ như truy cập vượt quá giới hạn của mảng) hoặc gọi trực tiếp macro panic!. Trong cả hai trường hợp, chúng ta gây ra panic trong chương trình. Theo mặc định, những panic này sẽ hiển thị thông báo lỗi, unwind (tháo gỡ), dọn dẹp stack, và thoát. Thông qua một biến môi trường, bạn cũng có thể yêu cầu Rust hiển thị call stack khi xảy ra panic để dễ dàng theo dõi nguồn gốc của panic.

Tháo Gỡ Stack hoặc Hủy Bỏ Khi Xảy Ra Panic

Theo mặc định, khi panic xảy ra, chương trình bắt đầu tháo gỡ (unwinding), có nghĩa là Rust đi ngược lại stack và dọn dẹp dữ liệu từ mỗi hàm mà nó gặp phải. Tuy nhiên, việc đi ngược lại và dọn dẹp tốn rất nhiều công sức. Vì vậy, Rust cho phép bạn chọn phương án thay thế là hủy bỏ (aborting) ngay lập tức, điều này kết thúc chương trình mà không dọn dẹp gì cả.

Bộ nhớ mà chương trình đang sử dụng sau đó sẽ cần được dọn dẹp bởi hệ điều hành. Nếu trong dự án của bạn cần làm cho tệp nhị phân kết quả nhỏ nhất có thể, bạn có thể chuyển từ tháo gỡ sang hủy bỏ khi panic bằng cách thêm panic = 'abort' vào các phần [profile] thích hợp trong tệp Cargo.toml. Ví dụ, nếu bạn muốn hủy bỏ khi panic trong chế độ phát hành (release mode), hãy thêm điều này:

[profile.release]
panic = 'abort'

Hãy thử gọi panic! trong một chương trình đơn giản:

fn main() {
    panic!("crash and burn");
}

Khi bạn chạy chương trình, bạn sẽ thấy điều gì đó như thế này:

$ cargo run
   Compiling panic v0.1.0 (file:///projects/panic)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.25s
     Running `target/debug/panic`

thread 'main' panicked at src/main.rs:2:5:
crash and burn
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Lệnh gọi panic! gây ra thông báo lỗi trong hai dòng cuối cùng. Dòng đầu tiên hiển thị thông báo panic của chúng ta và vị trí trong mã nguồn nơi panic xảy ra: src/main.rs:2:5 chỉ ra rằng đó là dòng thứ hai, ký tự thứ năm trong tệp src/main.rs của chúng ta.

Trong trường hợp này, dòng được chỉ ra là một phần của code chúng ta, và nếu chúng ta đến dòng đó, chúng ta sẽ thấy lời gọi macro panic!. Trong các trường hợp khác, lời gọi panic! có thể nằm trong code mà code của chúng ta gọi, và tên tệp và số dòng được báo cáo bởi thông báo lỗi sẽ là code của người khác nơi macro panic! được gọi, không phải dòng code của chúng ta cuối cùng dẫn đến lời gọi panic!.

Chúng ta có thể sử dụng backtrace của các hàm từ lời gọi panic! để tìm ra phần code của chúng ta đang gây ra vấn đề. Để hiểu cách sử dụng backtrace của panic!, hãy xem xét một ví dụ khác và xem nó như thế nào khi lời gọi panic! đến từ một thư viện do lỗi trong code của chúng ta thay vì từ code của chúng ta gọi trực tiếp macro. Listing 9-1 có một số code cố gắng truy cập một chỉ mục trong vector vượt quá phạm vi các chỉ mục hợp lệ.

fn main() {
    let v = vec![1, 2, 3];

    v[99];
}

Ở đây, chúng ta đang cố gắng truy cập phần tử thứ 100 của vector (ở chỉ mục 99 vì chỉ mục bắt đầu từ 0), nhưng vector chỉ có ba phần tử. Trong trường hợp này, Rust sẽ panic. Sử dụng [] được cho là để trả về một phần tử, nhưng nếu bạn truyền một chỉ mục không hợp lệ, không có phần tử nào mà Rust có thể trả về ở đây một cách chính xác.

Trong C, việc cố gắng đọc vượt quá giới hạn của một cấu trúc dữ liệu là hành vi không xác định. Bạn có thể nhận được bất cứ thứ gì ở vị trí trong bộ nhớ mà sẽ tương ứng với phần tử đó trong cấu trúc dữ liệu, mặc dù bộ nhớ không thuộc về cấu trúc đó. Điều này được gọi là buffer overread (đọc quá bộ đệm) và có thể dẫn đến lỗ hổng bảo mật nếu kẻ tấn công có thể thao túng chỉ mục theo cách để đọc dữ liệu mà họ không được phép truy cập, được lưu trữ sau cấu trúc dữ liệu.

Để bảo vệ chương trình của bạn khỏi loại lỗ hổng này, nếu bạn cố gắng đọc một phần tử ở chỉ mục không tồn tại, Rust sẽ dừng thực thi và từ chối tiếp tục. Hãy thử và xem:

$ cargo run
   Compiling panic v0.1.0 (file:///projects/panic)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.27s
     Running `target/debug/panic`

thread 'main' panicked at src/main.rs:4:6:
index out of bounds: the len is 3 but the index is 99
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Lỗi này chỉ đến dòng 4 của tệp main.rs nơi chúng ta cố gắng truy cập chỉ mục 99 của vector trong v.

Dòng note: cho chúng ta biết rằng chúng ta có thể thiết lập biến môi trường RUST_BACKTRACE để nhận backtrace chính xác về những gì đã xảy ra để gây ra lỗi. Một backtrace là danh sách tất cả các hàm đã được gọi để đến thời điểm này. Backtraces trong Rust hoạt động giống như trong các ngôn ngữ khác: chìa khóa để đọc backtrace là bắt đầu từ đầu và đọc cho đến khi bạn thấy các tệp bạn đã viết. Đó là nơi vấn đề bắt nguồn. Các dòng phía trên đó là code mà code của bạn đã gọi; các dòng bên dưới là code đã gọi code của bạn. Các dòng trước và sau này có thể bao gồm code Rust cốt lõi, code thư viện chuẩn, hoặc các crate mà bạn đang sử dụng. Hãy thử lấy backtrace bằng cách thiết lập biến môi trường RUST_BACKTRACE thành bất kỳ giá trị nào ngoại trừ 0. Listing 9-2 hiển thị đầu ra tương tự như những gì bạn sẽ thấy.

$ RUST_BACKTRACE=1 cargo run
thread 'main' panicked at src/main.rs:4:6:
index out of bounds: the len is 3 but the index is 99
stack backtrace:
   0: rust_begin_unwind
             at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library/std/src/panicking.rs:692:5
   1: core::panicking::panic_fmt
             at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library/core/src/panicking.rs:75:14
   2: core::panicking::panic_bounds_check
             at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library/core/src/panicking.rs:273:5
   3: <usize as core::slice::index::SliceIndex<[T]>>::index
             at file:///home/.rustup/toolchains/1.85/lib/rustlib/src/rust/library/core/src/slice/index.rs:274:10
   4: core::slice::index::<impl core::ops::index::Index<I> for [T]>::index
             at file:///home/.rustup/toolchains/1.85/lib/rustlib/src/rust/library/core/src/slice/index.rs:16:9
   5: <alloc::vec::Vec<T,A> as core::ops::index::Index<I>>::index
             at file:///home/.rustup/toolchains/1.85/lib/rustlib/src/rust/library/alloc/src/vec/mod.rs:3361:9
   6: panic::main
             at ./src/main.rs:4:6
   7: core::ops::function::FnOnce::call_once
             at file:///home/.rustup/toolchains/1.85/lib/rustlib/src/rust/library/core/src/ops/function.rs:250:5
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

Đó là rất nhiều thông tin! Đầu ra chính xác bạn thấy có thể khác tùy thuộc vào hệ điều hành và phiên bản Rust của bạn. Để nhận được backtrace với thông tin này, các ký hiệu gỡ lỗi phải được bật. Các ký hiệu gỡ lỗi được bật theo mặc định khi sử dụng cargo build hoặc cargo run mà không có cờ --release, như chúng ta đang làm ở đây.

Trong đầu ra ở Listing 9-2, dòng 6 của backtrace chỉ đến dòng trong dự án chúng ta đang gây ra vấn đề: dòng 4 của src/main.rs. Nếu chúng ta không muốn chương trình của chúng ta panic, chúng ta nên bắt đầu điều tra ở vị trí được chỉ ra bởi dòng đầu tiên đề cập đến tệp chúng ta đã viết. Trong Listing 9-1, nơi chúng ta cố ý viết code sẽ panic, cách để sửa panic là không yêu cầu một phần tử vượt quá phạm vi chỉ mục của vector. Khi code của bạn panic trong tương lai, bạn sẽ cần phải tìm ra hành động nào mà code đang thực hiện với những giá trị nào để gây ra panic và code nên làm gì thay thế.

Chúng ta sẽ quay lại panic! và khi nào chúng ta nên và không nên sử dụng panic! để xử lý các điều kiện lỗi trong phần "To panic! or Not to panic!" sau này trong chương này. Tiếp theo, chúng ta sẽ xem xét cách khôi phục từ lỗi sử dụng Result.

Các 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 để yêu cầu chương trình dừng hoàn toàn. Đôi khi khi một hàm thất bại, đó là vì lý do mà bạn có thể dễ dàng hiểu và phản hồi. Ví dụ, nếu bạn cố mở một tập tin và thao tác đó thất bại vì tập tin không tồn tại, bạn có thể muốn tạo tập tin đó thay vì kết thúc tiến trình.

Nhắc lại từ "Xử lý thất bại tiềm ẩn với Result" trong Chương 2 rằng enum Result được định nghĩa với hai biến thể, Ok và Err, như sau:

#![allow(unused)]
fn main() {
enum Result<T, E> {
    Ok(T),
    Err(E),
}
}

T và E là các tham số kiểu generic: chúng ta sẽ thảo luận chi tiết về generics trong Chương 10. Điều bạn cần biết ngay bây giờ là T đại diện cho kiểu của giá trị sẽ được trả về trong trường hợp thành công bên trong biến thể Ok, và E đại diện cho kiểu của lỗi sẽ được trả về trong trường hợp thất bại bên trong 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 định nghĩa trên nó trong nhiều tình huống khác nhau, nơi giá trị thành công và giá trị lỗi mà chúng ta muốn trả về có thể khác nhau.

Hãy gọi một hàm trả về giá trị Result vì hàm có thể thất bại. Trong Listing 9-3, chúng ta thử mở một tập tin.

use std::fs::File;

fn main() {
    let greeting_file_result = File::open("hello.txt");
}

Kiểu trả về của File::open là Result<T, E>. Tham số generic T đã được điền bởi quá trình triển khai của File::open với kiểu của giá trị thành công, std::fs::File, là một handle của tập tin. Kiểu của E được sử dụng trong giá trị lỗi là std::io::Error. Kiểu trả về này có nghĩa là lời gọi đến File::open có thể thành công và trả về một handle của tập tin mà chúng ta có thể đọc hoặc ghi. Lời gọi hàm cũng có thể thất bại: ví dụ, tập tin có thể không tồn tại, hoặc chúng ta có thể không có quyền truy cập vào tập tin. Hàm File::open cần có cách để nói cho chúng ta biết liệu nó đã thành công hay thất bại và đồng thời cung cấp cho chúng ta handle của tập tin hoặc thông tin lỗi. Thông tin này chính xác là những gì mà enum Result truyền đạt.

Trong trường hợp File::open thành công, giá trị trong biến greeting_file_result sẽ là một thực thể của Ok chứa một handle của tập tin. Trong trường hợp thất bại, giá trị trong greeting_file_result sẽ là một thực thể của Err chứa thêm thông tin về loại lỗi đã xảy ra.

Chúng ta cần thêm vào mã trong Listing 9-3 để thực hiện các hành động khác nhau tùy thuộc vào giá trị mà File::open trả về. Listing 9-4 cho thấy một cách để xử lý Result bằng cách sử dụng công cụ cơ bản, biểu thức match mà chúng ta đã thảo luận trong Chương 6.

use std::fs::File;

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => panic!("Problem opening the file: {error:?}"),
    };
}

Lưu ý rằng, giống như enum Option, enum Result và các biến thể của nó đã được đưa vào phạm vi bởi prelude, vì vậy chúng ta không cần chỉ định Result:: trước các biến thể Ok và Err trong các nhánh của match.

Khi kết quả là Ok, mã này sẽ trả về giá trị file bên trong từ biến thể Ok, và sau đó chúng ta gán giá trị handle của tập tin đó cho biến greeting_file. Sau match, chúng ta có thể sử dụng handle của tập tin để đọc hoặc ghi.

Nhánh khác của match xử lý trường hợp chúng ta nhận được giá trị Err từ File::open. Trong ví dụ này, chúng ta đã chọn gọi macro panic!. Nếu không có tập tin nào có tên hello.txt trong thư mục hiện tại của chúng ta và chúng ta chạy mã này, chúng ta sẽ thấy đầu ra sau đây từ macro panic!:

$ cargo run
   Compiling error-handling v0.1.0 (file:///projects/error-handling)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.73s
     Running `target/debug/error-handling`

thread 'main' panicked at src/main.rs:8:23:
Problem opening the file: Os { code: 2, kind: NotFound, message: "No such file or directory" }
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Như thường lệ, đầu ra này cho chúng ta biết chính xác điều gì đã sai.

Xử lý các lỗi khác nhau

Mã trong Listing 9-4 sẽ gọi panic! bất kể vì sao File::open thất bại. Tuy nhiên, chúng ta muốn thực hiện các hành động khác nhau với các lý do thất bại khác nhau. Nếu File::open thất bại vì tập tin không tồn tại, chúng ta muốn tạo tập tin và trả về handle cho tập tin mới. Nếu File::open thất bại vì bất kỳ lý do nào khác—ví dụ, vì chúng ta không có quyền mở tập tin—chúng ta vẫn muốn mã gọi panic! theo cách giống như trong Listing 9-4. Để làm điều này, chúng ta thêm một biểu thức match bên trong, như trong Listing 9-5.

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        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:?}"),
            },
            _ => {
                panic!("Problem opening the file: {error:?}");
            }
        },
    };
}

Kiểu của giá trị mà File::open trả về bên trong biến thể Err là io::Error, đây là một struct được cung cấp bởi thư viện chuẩn. Struct này có một phương thức kind mà chúng ta có thể gọi để lấy một giá trị io::ErrorKind. Enum io::ErrorKind được cung cấp bởi thư viện chuẩn và có các biến thể đại diện cho các loại lỗi khác nhau có thể phát sinh từ một thao tác io. Biến thể mà chúng ta muốn sử dụng là ErrorKind::NotFound, cho biết tập tin mà chúng ta đang cố gắng mở không tồn tại. Vì vậy, chúng ta khớp với greeting_file_result, nhưng chúng ta cũng có một match bên trong trên error.kind().

Điều kiện mà chúng ta muốn kiểm tra trong match bên trong là liệu giá trị trả về bởi error.kind() có phải là biến thể NotFound của enum ErrorKind hay không. Nếu đúng, chúng ta cố gắng tạo tập tin với File::create. Tuy nhiên, vì File::create cũng có thể thất bại, chúng ta cần một nhánh thứ hai trong biểu thức match bên trong. Khi tập tin không thể được tạo, một thông báo lỗi khác được in ra. Nhánh thứ hai của match bên ngoài không đổi, vì vậy chương trình sẽ panic khi có bất kỳ lỗi nào khác ngoài lỗi tập tin không tồn tại.

Các lựa chọn thay thế cho việc sử dụng match với Result<T, E>

match thật là nhiều! Biểu thức match rất hữu ích nhưng cũng rất nguyên thủy. Trong Chương 13, bạn sẽ học về closures, được sử dụng với nhiều phương thức được định nghĩa trên Result<T, E>. Các phương thức này có thể ngắn gọn hơn việc sử dụng match khi xử lý các giá trị Result<T, E> trong mã của bạn.

Ví dụ, đây là một cách khác để viết logic tương tự như đã hiển thị trong Listing 9-5, lần này sử dụng closures và phương thức unwrap_or_else:

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let greeting_file = File::open("hello.txt").unwrap_or_else(|error| {
        if error.kind() == ErrorKind::NotFound {
            File::create("hello.txt").unwrap_or_else(|error| {
                panic!("Có vấn đề khi tạo tập tin: {error:?}");
            })
        } else {
            panic!("Có vấn đề khi mở tập tin: {error:?}");
        }
    });
}

Mặc dù mã này có cùng hành vi với Listing 9-5, nhưng nó không chứa bất kỳ biểu thức match nào và dễ đọc hơn. Quay lại ví dụ này sau khi bạn đã đọc Chương 13, và tìm kiếm phương thức unwrap_or_else trong tài liệu của thư viện chuẩn. Nhiều phương thức khác có thể làm gọn các biểu thức match lồng nhau lớn khi bạn xử lý lỗi.

Các cách viết tắt cho Panic khi có lỗi: unwrap và expect

Sử dụng match hoạt động khá tốt, nhưng có thể hơi dài dòng và không phải lúc nào cũng truyền đạt ý định rõ ràng. Kiểu Result<T, E> có nhiều phương thức trợ giúp được định nghĩa trên nó để thực hiện các tác vụ khác nhau, cụ thể hơn. Phương thức unwrap là một phương thức viết tắt được triển khai giống như biểu thức match mà chúng ta đã viết trong Listing 9-4. Nếu giá trị Result là biến thể Ok, unwrap sẽ trả về giá trị bên trong Ok. Nếu Result là biến thể Err, unwrap sẽ gọi macro panic! cho chúng ta. Đây là một ví dụ về unwrap đang hoạt động:

use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt").unwrap();
}

Nếu chúng ta chạy mã này mà không có tập tin hello.txt, chúng ta sẽ thấy một thông báo lỗi từ lời gọi panic! mà phương thức unwrap thực hiện:

thread 'main' panicked at src/main.rs:4:49:
called `Result::unwrap()` on an `Err` value: Os { code: 2, kind: NotFound, message: "No such file or directory" }

Tương tự, phương thức expect cho phép chúng ta chọn thông báo lỗi panic!. Sử dụng expect thay vì unwrap và cung cấp thông báo lỗi tốt có thể truyền đạt ý định của bạn và làm cho việc theo dõi nguồn gốc của một panic dễ dàng hơn. Cú pháp của expect trông như thế này:

use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt")
        .expect("hello.txt should be included in this project");
}

Chúng ta sử dụng expect theo cách tương tự như unwrap: để trả về handle tập tin hoặc gọi macro panic!. Thông báo lỗi được sử dụng bởi expect trong lời gọi của nó đến panic! sẽ là tham số mà chúng ta truyền cho expect, thay vì thông báo panic! mặc định mà unwrap sử dụng. Đây là cách nó trông:

thread 'main' panicked at src/main.rs:5:10:
hello.txt should be included in this project: Os { code: 2, kind: NotFound, message: "No such file or directory" }

Trong mã chất lượng sản xuất, hầu hết các Rustacean chọn expect thay vì unwrap và cung cấp thêm ngữ cảnh về lý do tại sao thao tác được mong đợi sẽ luôn thành công. Bằng cách đó, nếu giả định của bạn được chứng minh là sai, bạn có thêm thông tin để sử dụng trong việc gỡ lỗi.

Lan truyền lỗi

Khi triển khai của một hàm gọi thứ gì đó có thể thất bại, thay vì xử lý lỗi bên trong chính hàm, bạn có thể trả về lỗi cho mã gọi hàm đó để nó có thể quyết định phải làm gì. Điều này được gọi là lan truyền lỗi và cung cấp nhiều quyền kiểm soát hơn cho mã gọi hàm, nơi có thể có nhiều thông tin hoặc logic hơn để quyết định cách xử lý lỗi so với những gì bạn có sẵn trong ngữ cảnh của mã của bạn.

Ví dụ, Listing 9-6 hiển thị một hàm đọc tên người dùng từ một tập tin. Nếu tập tin không tồn tại hoặc không thể đọc được, hàm này sẽ trả về những lỗi đó cho mã đã gọi hàm.

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let username_file_result = File::open("hello.txt");

    let mut username_file = match username_file_result {
        Ok(file) => file,
        Err(e) => return Err(e),
    };

    let mut username = String::new();

    match username_file.read_to_string(&mut username) {
        Ok(_) => Ok(username),
        Err(e) => Err(e),
    }
}
}

Hàm này có thể được viết theo cách ngắn gọn hơn nhiều, nhưng chúng ta sẽ bắt đầu bằng cách làm nhiều thao tác thủ công để khám phá việc xử lý lỗi; cuối cùng, chúng ta sẽ hiển thị cách viết ngắn gọn hơn. Hãy xem xét kiểu trả về của hàm trước: Result<String, io::Error>. Điều này có nghĩa là hàm đang trả về một giá trị thuộc kiểu Result<T, E>, trong đó tham số generic T đã được điền với kiểu cụ thể String và kiểu generic E đã được điền với kiểu cụ thể io::Error.

Nếu hàm này thành công mà không có bất kỳ vấn đề nào, mã gọi hàm này sẽ nhận được một giá trị Ok chứa một String—tên người dùng mà hàm này đã đọc từ tập tin. Nếu hàm này gặp bất kỳ vấn đề nào, mã gọi sẽ nhận được một giá trị Err chứa một instance của io::Error có chứa thêm thông tin về những vấn đề đã xảy ra. Chúng ta đã chọn io::Error làm kiểu trả về của hàm này vì đó là kiểu của giá trị lỗi được trả về từ cả hai thao tác mà chúng ta đang gọi trong thân hàm có thể thất bại: hàm File::open và phương thức read_to_string.

Thân hàm bắt đầu bằng cách gọi hàm File::open. Sau đó, chúng ta xử lý giá trị Result với một match tương tự như match trong Listing 9-4. Nếu File::open thành công, handle tập tin trong biến mẫu file sẽ trở thành giá trị trong biến có thể thay đổi username_file và hàm tiếp tục. Trong trường hợp Err, thay vì gọi panic!, chúng ta sử dụng từ khóa return để thoát sớm khỏi hàm hoàn toàn và truyền giá trị lỗi từ File::open, hiện đang nằm trong biến mẫu e, trở lại cho mã gọi như là giá trị lỗi của hàm này.

Vì vậy, nếu chúng ta có một handle tập tin trong username_file, hàm tiếp theo sẽ tạo một String mới trong biến username và gọi phương thức read_to_string trên handle tập tin trong username_file để đọc nội dung của tập tin vào username. Phương thức read_to_string cũng trả về một Result vì nó có thể thất bại, ngay cả khi File::open đã thành công. Vì vậy, chúng ta cần một match khác để xử lý Result đó: nếu read_to_string thành công, thì hàm của chúng ta đã thành công, và chúng ta trả về tên người dùng từ tập tin hiện đang nằm trong username được bọc trong một Ok. Nếu read_to_string thất bại, chúng ta trả về giá trị lỗi theo cách tương tự như cách chúng ta trả về giá trị lỗi trong match đã xử lý giá trị trả về của File::open. Tuy nhiên, chúng ta không cần nói return một cách rõ ràng, vì đây là biểu thức cuối cùng trong hàm.

Mã gọi mã này sẽ xử lý việc nhận giá trị Ok chứa tên người dùng hoặc giá trị Err chứa một io::Error. Mã gọi quyết định phải làm gì với những giá trị này. Nếu mã gọi nhận được giá trị Err, nó có thể gọi panic! và làm crash chương trình, sử dụng một tên người dùng mặc định, hoặc tìm kiếm tên người dùng từ một nơi khác ngoài tập tin, ví dụ vậy. Chúng ta không có đủ thông tin về những gì mã gọi thực sự đang cố gắng làm, vì vậy chúng ta lan truyền tất cả thông tin thành công hoặc lỗi lên trên để nó xử lý một cách phù hợp.

Mẫu lan truyền lỗi này rất phổ biến trong Rust đến nỗi Rust cung cấp toán tử dấu hỏi ? để làm điều này dễ dàng hơn.

Một cách viết tắt để lan truyền lỗi: Toán tử ?

Listing 9-7 hiển thị một triển khai của read_username_from_file có cùng chức năng như trong Listing 9-6, nhưng triển khai này sử dụng toán tử ?.

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username_file = File::open("hello.txt")?;
    let mut username = String::new();
    username_file.read_to_string(&mut username)?;
    Ok(username)
}
}

Dấu ? được đặt sau một giá trị Result được định nghĩa để hoạt động theo cách gần như giống như các biểu thức match mà chúng ta đã định nghĩa để xử lý các giá trị Result trong Listing 9-6. Nếu giá trị của Result là Ok, giá trị bên trong Ok sẽ được trả về từ biểu thức này, và chương trình sẽ tiếp tục. Nếu giá trị là Err, Err sẽ được trả về từ toàn bộ hàm như thể chúng ta đã sử dụng từ khóa return để giá trị lỗi được lan truyền đến mã gọi.

Có một sự khác biệt giữa những gì mà biểu thức match từ Listing 9-6 làm và những gì toán tử ? làm: các giá trị lỗi mà toán tử ? được gọi trên chúng đi qua hàm from, được định nghĩa trong trait From trong thư viện chuẩn, được sử dụng để chuyển đổi giá trị từ một kiểu sang một kiểu khác. Khi toán tử ? gọi hàm from, kiểu lỗi nhận được được chuyển đổi thành kiểu lỗi được định nghĩa trong kiểu trả về của hàm hiện tại. Điều này hữu ích khi một hàm trả về một kiểu lỗi để đại diện cho tất cả các cách mà một hàm có thể thất bại, ngay cả khi các phần có thể thất bại vì nhiều lý do khác nhau.

Ví dụ, chúng ta có thể thay đổi hàm read_username_from_file trong Listing 9-7 để trả về một kiểu lỗi tùy chỉnh có tên OurError mà chúng ta định nghĩa. Nếu chúng ta cũng định nghĩa impl From<io::Error> for OurError để xây dựng một instance của OurError từ một io::Error, thì các lời gọi toán tử ? trong thân của read_username_from_file sẽ gọi from và chuyển đổi các kiểu lỗi mà không cần thêm bất kỳ mã nào vào hàm.

Trong ngữ cảnh của Listing 9-7, dấu ? ở cuối của lời gọi File::open sẽ trả về giá trị bên trong Ok cho biến username_file. Nếu xảy ra lỗi, toán tử ? sẽ thoát sớm khỏi toàn bộ hàm và đưa bất kỳ giá trị Err nào cho mã gọi. Điều tương tự cũng áp dụng cho dấu ? ở cuối lời gọi read_to_string.

Toán tử ? loại bỏ rất nhiều mã soạn sẵn và làm cho triển khai của hàm này đơn giản hơn. Chúng ta thậm chí có thể làm cho mã này ngắn gọn hơn nữa bằng cách nối các lời gọi phương thức ngay sau ?, như trong Listing 9-8.

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username = String::new();

    File::open("hello.txt")?.read_to_string(&mut username)?;

    Ok(username)
}
}

Chúng ta đã di chuyển việc tạo String mới trong username lên đầu hàm; phần đó không thay đổi. Thay vì tạo biến username_file, chúng ta đã nối lời gọi đến read_to_string trực tiếp vào kết quả của File::open("hello.txt")?. Chúng ta vẫn có một dấu ? ở cuối lời gọi read_to_string, và chúng ta vẫn trả về một giá trị Ok chứa username khi cả File::open và read_to_string đều thành công thay vì trả về lỗi. Chức năng một lần nữa giống như trong Listing 9-6 và Listing 9-7; đây chỉ là một cách viết khác, phong cách hơn.

Listing 9-9 hiển thị một cách để làm cho nó thậm chí còn ngắn gọn hơn bằng cách sử dụng fs::read_to_string.

#![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")
}
}

Đọc một tập tin vào một chuỗi là một hoạt động khá phổ biến, vì vậy thư viện chuẩn cung cấp hàm fs::read_to_string thuận tiện để mở tập tin, tạo một String mới, đọc nội dung của tập tin, đưa nội dung vào String đó, và trả về nó. Tất nhiên, sử dụng fs::read_to_string không cho chúng ta cơ hội để giải thích tất cả việc xử lý lỗi, vì vậy chúng ta đã làm nó theo cách dài dòng hơn trước.

Toán tử ? có thể được sử dụng ở đâu

Toán tử ? chỉ có thể được sử dụng trong các hàm có kiểu trả về tương thích với giá trị mà ? được sử dụng trên đó. Điều này là vì toán tử ? được định nghĩa để thực hiện việc trả về sớm một giá trị từ hàm, theo cùng cách như biểu thức match mà chúng ta đã định nghĩa trong Listing 9-6. Trong Listing 9-6, match đang sử dụng một giá trị Result, và nhánh trả về sớm trả về một giá trị Err(e). Kiểu trả về của hàm phải là một Result để nó tương thích với return này.

Trong Listing 9-10, hãy xem lỗi mà chúng ta sẽ nhận được nếu chúng ta sử dụng toán tử ? trong một hàm main với kiểu trả về không tương thích với kiểu của giá trị mà chúng ta sử dụng ? trên đó:

use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt")?;
}

Mã này mở một tập tin, điều này có thể thất bại. Toán tử ? theo sau giá trị Result được trả về bởi File::open, nhưng hàm main này có kiểu trả về là (), không phải Result. Khi chúng ta biên dịch mã này, chúng ta nhận được thông báo lỗi sau:

$ 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:48
  |
3 | fn main() {
  | --------- this function should return `Result` or `Option` to accept `?`
4 |     let greeting_file = File::open("hello.txt")?;
  |                                                ^ cannot use the `?` operator in a function that returns `()`
  |
  = help: the trait `FromResidual<Result<Infallible, std::io::Error>>` is not implemented for `()`
help: consider adding return type
  |
3 ~ fn main() -> Result<(), Box<dyn std::error::Error>> {
4 |     let greeting_file = File::open("hello.txt")?;
5 +     Ok(())
  |

For more information about this error, try `rustc --explain E0277`.
error: could not compile `error-handling` (bin "error-handling") due to 1 previous error

Lỗi này chỉ ra rằng chúng ta chỉ được phép sử dụng toán tử ? trong một hàm trả về Result, Option, hoặc một kiểu khác mà có triển khai FromResidual.

Để sửa lỗi, bạn có hai lựa chọn. Một lựa chọn là thay đổi kiểu trả về của hàm để tương thích với giá trị mà bạn đang sử dụng toán tử ? trên đó miễn là bạn không có hạn chế nào ngăn bạn làm điều đó. Lựa chọn khác là sử dụng match hoặc một trong các phương thức của Result<T, E> để xử lý Result<T, E> theo cách phù hợp.

Thông báo lỗi cũng đề cập rằng ? có thể được sử dụng với các giá trị Option<T> cũng như. Như với việc sử dụng ? trên Result, bạn chỉ có thể sử dụng ? trên Option trong một hàm trả về một Option. Hành vi của toán tử ? khi được gọi trên một Option<T> tương tự như hành vi của nó khi được gọi trên một Result<T, E>: nếu giá trị là None, None sẽ được trả về sớm từ hàm tại điểm đó. Nếu giá trị là Some, giá trị bên trong Some là giá trị kết quả của biểu thức, và hàm tiếp tục. Listing 9-11 có một ví dụ về một hàm tìm ký tự cuối cùng của dòng đầu tiên trong văn bản đã cho.

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);
}

Hàm này trả về Option<char> vì có thể có một ký tự ở đó, nhưng cũng có thể không có. Mã này nhận tham số slice chuỗi text và gọi phương thức lines trên nó, trả về một iterator trên các dòng trong chuỗi. Vì hàm này muốn kiểm tra dòng đầu tiên, nó gọi next trên iterator để lấy giá trị đầu tiên từ iterator. Nếu text là chuỗi rỗng, lời gọi này đến next sẽ trả về None, trong trường hợp đó chúng ta sử dụng ? để dừng và trả về None từ last_char_of_first_line. Nếu text không phải là chuỗi rỗng, next sẽ trả về một giá trị Some chứa một slice chuỗi của dòng đầu tiên trong text.

Dấu ? trích xuất slice chuỗi, và chúng ta có thể gọi chars trên slice chuỗi đó để lấy một iterator của các ký tự của nó. Chúng ta quan tâm đến ký tự cuối cùng trong dòng đầu tiên này, vì vậy chúng ta gọi last để trả về mục cuối cùng trong iterator. Đây là một Option vì có thể dòng đầu tiên là chuỗi rỗng; ví dụ, nếu text bắt đầu bằng một dòng trống nhưng có các ký tự trên các dòng khác, như trong "\nhi". Tuy nhiên, nếu có một ký tự cuối cùng trên dòng đầu tiên, nó sẽ được trả về trong biến thể Some. Toán tử ? ở giữa cung cấp cho chúng ta một cách súc tích để biểu thị logic này, cho phép chúng ta triển khai hàm trong một dòng. Nếu chúng ta không thể sử dụng toán tử ? trên Option, chúng ta sẽ phải triển khai logic này bằng cách sử dụng nhiều lời gọi phương thức hơn hoặc một biểu thức match.

Lưu ý rằng bạn có thể sử dụng toán tử ? trên một Result trong một hàm trả về Result, và bạn có thể sử dụng toán tử ? trên một Option trong một hàm trả về Option, nhưng bạn không thể kết hợp và phù hợp. Toán tử ? sẽ không tự động chuyển đổi một Result thành một Option hoặc ngược lại; trong những trường hợp đó, bạn có thể sử dụng các phương thức như phương thức ok trên Result hoặc phương thức ok_or trên Option để thực hiện chuyển đổi một cách rõ ràng.

Cho đến nay, tất cả các hàm main mà chúng ta đã sử dụng đều trả về (). Hàm main rất đặc biệt vì nó là điểm vào và điểm ra của một chương trình thực thi, và có các hạn chế về kiểu trả về của nó để chương trình hoạt động như mong đợi.

May mắn thay, main cũng có thể trả về một Result<(), E>. Listing 9-12 có mã từ Listing 9-10, nhưng chúng ta đã thay đổi kiểu trả về của main thành Result<(), Box<dyn Error>> và đã thêm một giá trị trả về Ok(()) vào cuối. Mã này sẽ biên dịch bây giờ.

use std::error::Error;
use std::fs::File;

fn main() -> Result<(), Box<dyn Error>> {
    let greeting_file = File::open("hello.txt")?;

    Ok(())
}

Kiểu Box<dyn Error> là một trait object, chúng ta sẽ nói về nó trong "Sử dụng các Trait Object cho phép các giá trị của các kiểu khác nhau" trong Chương 18. Hiện tại, bạn có thể đọc Box<dyn Error> như là "bất kỳ loại lỗi nào." Sử dụng ? trên một giá trị Result trong một hàm main với kiểu lỗi Box<dyn Error> được cho phép vì nó cho phép bất kỳ giá trị Err nào được trả về sớm. Mặc dù thân của hàm main này sẽ chỉ trả về các lỗi của kiểu std::io::Error, nhưng bằng cách chỉ định Box<dyn Error>, chữ ký này sẽ tiếp tục chính xác ngay cả khi thêm mã trả về các lỗi khác được thêm vào thân của main.

Khi một hàm main trả về một Result<(), E>, chương trình thực thi sẽ thoát với giá trị 0 nếu main trả về Ok(()) và sẽ thoát với giá trị khác 0 nếu main trả về một giá trị Err. Các chương trình thực thi được viết bằng C trả về số nguyên khi chúng thoát: các chương trình thoát thành công trả về số nguyên 0, và các chương trình bị lỗi trả về một số nguyên khác 0. Rust cũng trả về số nguyên từ các chương trình thực thi để tương thích với quy ước này.

Hàm main có thể trả về bất kỳ kiểu nào triển khai trait std::process::Termination, chứa một hàm report trả về một ExitCode. Tham khảo tài liệu của thư viện chuẩn để biết thêm thông tin về việc triển khai trait Termination cho các kiểu của riêng bạn.

Bây giờ chúng ta đã thảo luận về chi tiết của việc gọi panic! hoặc trả về Result, hãy quay lại chủ đề về cách quyết định sử dụng cái nào trong trường hợp nào.

panic! Hay Không panic!

Vậy làm thế nào để quyết định khi nào nên gọi panic! và khi nào nên trả về Result? Khi code panic, không có cách nào để phục hồi. Bạn có thể gọi panic! cho bất kỳ tình huống lỗi nào, dù có cách phục hồi hay không, nhưng như vậy bạn đang đưa ra quyết định rằng một tình huống là không thể khôi phục thay mặt cho mã gọi. Khi bạn chọn trả về giá trị Result, bạn đang cung cấp cho mã gọi các lựa chọn. Mã gọi có thể chọn thử phục hồi theo cách phù hợp với tình huống của nó, hoặc có thể quyết định rằng giá trị Err trong trường hợp này là không thể khôi phục, vì vậy nó có thể gọi panic! và biến lỗi có thể khôi phục thành không thể khôi phục. Do đó, việc trả về Result là lựa chọn mặc định tốt khi bạn định nghĩa một hàm có thể thất bại.

Trong các tình huống như ví dụ, mã nguyên mẫu và kiểm thử, thì việc viết mã panic thay vì trả về Result là phù hợp hơn. Hãy tìm hiểu lý do tại sao, sau đó thảo luận về các tình huống mà trình biên dịch không thể biết thất bại là không thể, nhưng bạn với tư cách là con người thì có thể biết. Chương này sẽ kết thúc với một số hướng dẫn chung về cách quyết định liệu có nên panic trong mã thư viện hay không.

Ví dụ, Mã Nguyên mẫu và Kiểm thử

Khi bạn đang viết một ví dụ để minh họa một khái niệm nào đó, việc thêm vào mã xử lý lỗi mạnh mẽ có thể làm cho ví dụ kém rõ ràng hơn. Trong các ví dụ, mọi người hiểu rằng việc gọi một phương thức như unwrap có thể panic là nhằm làm giữ chỗ cho cách bạn muốn ứng dụng của mình xử lý lỗi, điều này có thể khác nhau dựa trên những gì phần còn lại của mã bạn đang làm.

Tương tự, các phương thức unwrap và expect rất tiện lợi khi tạo nguyên mẫu, trước khi bạn sẵn sàng quyết định cách xử lý lỗi. Chúng để lại các dấu hiệu rõ ràng trong mã của bạn cho khi bạn sẵn sàng làm cho chương trình của mình mạnh mẽ hơn.

Nếu một lệnh gọi phương thức thất bại trong một bài kiểm thử, bạn muốn toàn bộ bài kiểm thử thất bại, ngay cả khi phương thức đó không phải là chức năng đang được kiểm thử. Bởi vì panic! là cách mà một bài kiểm thử được đánh dấu là thất bại, việc gọi unwrap hoặc expect chính xác là điều nên xảy ra.

Các trường hợp mà bạn có nhiều thông tin hơn trình biên dịch

Việc gọi unwrap hoặc expect cũng thích hợp khi bạn có một số logic khác đảm bảo rằng Result sẽ có giá trị Ok, nhưng logic đó không phải là điều mà trình biên dịch hiểu được. Bạn vẫn sẽ có một giá trị Result mà bạn cần xử lý: bất kỳ hoạt động nào bạn đang gọi vẫn có khả năng thất bại nói chung, mặc dù về mặt logic điều đó là không thể trong tình huống cụ thể của bạn. Nếu bạn có thể đảm bảo bằng cách kiểm tra mã theo cách thủ công rằng bạn sẽ không bao giờ có biến thể Err, thì hoàn toàn có thể chấp nhận được việc gọi unwrap, và thậm chí tốt hơn là ghi lại lý do tại sao bạn nghĩ rằng bạn sẽ không bao giờ có biến thể Err trong văn bản expect. Đây là một ví dụ:

fn main() {
    use std::net::IpAddr;

    let home: IpAddr = "127.0.0.1"
        .parse()
        .expect("Hardcoded IP address should be valid");
}

Chúng ta đang tạo một thể hiện IpAddr bằng cách phân tích một chuỗi được mã hóa cứng. Chúng ta có thể thấy rằng 127.0.0.1 là một địa chỉ IP hợp lệ, vì vậy việc sử dụng expect là chấp nhận được ở đây. Tuy nhiên, việc có một chuỗi hợp lệ được mã hóa cứng không thay đổi kiểu trả về của phương thức parse: chúng ta vẫn nhận được một giá trị Result, và trình biên dịch sẽ vẫn yêu cầu chúng ta xử lý Result như thể biến thể Err là một khả năng bởi vì trình biên dịch không đủ thông minh để thấy rằng chuỗi này luôn là một địa chỉ IP hợp lệ. Nếu chuỗi địa chỉ IP đến từ người dùng thay vì được mã hóa cứng vào chương trình và do đó có khả năng thất bại, chúng ta chắc chắn sẽ muốn xử lý Result bằng một cách mạnh mẽ hơn. Việc đề cập đến giả định rằng địa chỉ IP này được mã hóa cứng sẽ nhắc nhở chúng ta thay đổi expect thành mã xử lý lỗi tốt hơn nếu trong tương lai, chúng ta cần lấy địa chỉ IP từ một nguồn khác thay vì mã hóa cứng.

Hướng dẫn cho việc xử lý lỗi

Nên cho phép code của bạn panic khi có khả năng code của bạn có thể kết thúc trong một trạng thái xấu. Trong ngữ cảnh này, một trạng thái xấu là khi một số giả định, đảm bảo, hợp đồng, hoặc bất biến đã bị phá vỡ, chẳng hạn như khi các giá trị không hợp lệ, giá trị mâu thuẫn nhau, hoặc giá trị bị thiếu được truyền vào code của bạn—cộng với một hoặc nhiều điều kiện sau:

• Trạng thái xấu là điều không mong đợi, trái ngược với điều gì đó có thể xảy ra thỉnh thoảng, như người dùng nhập dữ liệu sai định dạng.
• Code của bạn sau điểm này cần dựa vào việc không ở trong trạng thái xấu này, thay vì kiểm tra vấn đề ở từng bước.
• Không có cách tốt để mã hóa thông tin này trong các kiểu dữ liệu bạn sử dụng. Chúng ta sẽ nghiên cứu một ví dụ về ý nghĩa của điều này trong "Mã hóa Trạng thái và Hành vi như Kiểu dữ liệu" trong Chương 18.

Nếu ai đó gọi code của bạn và truyền vào các giá trị không hợp lý, tốt nhất là trả về một lỗi nếu bạn có thể để người dùng thư viện có thể quyết định họ muốn làm gì trong trường hợp đó. Tuy nhiên, trong các trường hợp mà việc tiếp tục có thể không an toàn hoặc có hại, lựa chọn tốt nhất có thể là gọi panic! và cảnh báo người sử dụng thư viện của bạn về lỗi trong code của họ để họ có thể sửa nó trong quá trình phát triển. Tương tự, panic! thường là lựa chọn phù hợp nếu bạn đang gọi code bên ngoài mà bạn không kiểm soát được và nó trả về một trạng thái không hợp lệ mà bạn không có cách nào để sửa chữa.

Tuy nhiên, khi thất bại là điều được mong đợi, thì việc trả về Result sẽ phù hợp hơn là gọi panic!. Ví dụ bao gồm một trình phân tích cú pháp được cung cấp dữ liệu không đúng định dạng hoặc một yêu cầu HTTP trả về trạng thái chỉ ra rằng bạn đã đạt đến giới hạn tỷ lệ. Trong những trường hợp này, việc trả về Result cho biết rằng thất bại là một khả năng được mong đợi mà mã gọi phải quyết định cách xử lý.

Khi code của bạn thực hiện một hoạt động có thể gây rủi ro cho người dùng nếu nó được gọi bằng các giá trị không hợp lệ, code của bạn nên xác minh các giá trị hợp lệ trước và panic nếu các giá trị không hợp lệ. Điều này chủ yếu là vì lý do an toàn: cố gắng hoạt động trên dữ liệu không hợp lệ có thể làm lộ code của bạn trước các lỗ hổng. Đây là lý do chính khiến thư viện tiêu chuẩn sẽ gọi panic! nếu bạn cố gắng truy cập bộ nhớ ngoài giới hạn: việc cố gắng truy cập bộ nhớ không thuộc về cấu trúc dữ liệu hiện tại là một vấn đề bảo mật phổ biến. Các hàm thường có hợp đồng: hành vi của chúng chỉ được đảm bảo nếu đầu vào đáp ứng các yêu cầu cụ thể. Việc panic khi hợp đồng bị vi phạm là hợp lý vì vi phạm hợp đồng luôn chỉ ra lỗi ở phía gọi, và không phải là loại lỗi mà bạn muốn mã gọi phải xử lý một cách rõ ràng. Trên thực tế, không có cách hợp lý nào để mã gọi có thể khôi phục; lập trình viên gọi cần sửa mã. Các hợp đồng cho một hàm, đặc biệt là khi vi phạm sẽ gây ra panic, nên được giải thích trong tài liệu API cho hàm đó.

Tuy nhiên, việc có nhiều kiểm tra lỗi trong tất cả các hàm của bạn sẽ dài dòng và phiền toái. May mắn thay, bạn có thể sử dụng hệ thống kiểu của Rust (và do đó việc kiểm tra kiểu được thực hiện bởi trình biên dịch) để thực hiện nhiều kiểm tra cho bạn. Nếu hàm của bạn có một kiểu cụ thể làm tham số, bạn có thể tiếp tục với logic mã của bạn, biết rằng trình biên dịch đã đảm bảo bạn có một giá trị hợp lệ. Ví dụ, nếu bạn có một kiểu thay vì một Option, chương trình của bạn mong đợi có cái gì đó chứ không phải không có gì. Mã của bạn sau đó không phải xử lý hai trường hợp cho các biến thể Some và None: nó sẽ chỉ có một trường hợp cho việc chắc chắn có một giá trị. Mã cố gắng truyền không vào hàm của bạn sẽ thậm chí không biên dịch được, vì vậy hàm của bạn không phải kiểm tra trường hợp đó trong thời gian chạy. Một ví dụ khác là sử dụng kiểu số nguyên không dấu như u32, điều này đảm bảo tham số không bao giờ âm.

Tạo kiểu tùy chỉnh để xác thực

Hãy phát triển ý tưởng sử dụng hệ thống kiểu của Rust để đảm bảo chúng ta có một giá trị hợp lệ thêm một bước nữa và xem xét việc tạo một kiểu tùy chỉnh để xác thực. Hãy nhớ lại trò chơi đoán số ở Chương 2 trong đó mã của chúng ta yêu cầu người dùng đoán một số từ 1 đến 100. Chúng ta chưa bao giờ xác thực rằng số đoán của người dùng nằm giữa các số đó trước khi kiểm tra nó với số bí mật của chúng ta; chúng ta chỉ xác thực rằng số đoán là dương. Trong trường hợp này, hậu quả không quá nghiêm trọng: kết quả "Quá cao" hoặc "Quá thấp" của chúng ta vẫn sẽ chính xác. Nhưng sẽ là một cải tiến hữu ích để hướng dẫn người dùng đưa ra các đoán hợp lệ và có các hành vi khác nhau khi người dùng đoán một số ngoài phạm vi so với khi người dùng nhập, ví dụ, các chữ cái thay vì số.

Một cách để làm điều này là phân tích số đoán dưới dạng i32 thay vì chỉ là u32 để cho phép các số âm tiềm năng, và sau đó thêm một kiểm tra xem số có nằm trong phạm vi hay không, như sau:

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;
            }
        }
    }
}

Biểu thức if kiểm tra xem giá trị của chúng ta có ngoài phạm vi không, thông báo cho người dùng về vấn đề, và gọi continue để bắt đầu vòng lặp tiếp theo và yêu cầu một đoán khác. Sau biểu thức if, chúng ta có thể tiếp tục với các so sánh giữa guess và số bí mật, biết rằng guess là từ 1 đến 100.

Tuy nhiên, đây không phải là một giải pháp lý tưởng: nếu điều quan trọng tuyệt đối là chương trình chỉ hoạt động trên các giá trị từ 1 đến 100, và nó có nhiều hàm với yêu cầu này, việc có một kiểm tra như thế này trong mọi hàm sẽ là tẻ nhạt (và có thể ảnh hưởng đến hiệu suất).

Thay vào đó, chúng ta có thể tạo một kiểu mới trong một module chuyên dụng và đặt các xác thực vào một hàm để tạo một thể hiện của kiểu thay vì lặp lại các xác thực ở khắp mọi nơi. Bằng cách này, sẽ an toàn cho các hàm sử dụng kiểu mới trong chữ ký của chúng và tự tin sử dụng các giá trị chúng nhận được. Listing 9-13 cho thấy một cách để định nghĩa một kiểu Guess sẽ chỉ tạo một thể hiện của Guess nếu hàm new nhận một giá trị từ 1 đến 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
    }
}
}

Đầu tiên chúng ta tạo một module mới có tên guessing_game. Tiếp theo chúng ta định nghĩa một cấu trúc trong module đó có tên Guess có một trường có tên value chứa một i32. Đây là nơi số sẽ được lưu trữ.

Sau đó chúng ta thực hiện một hàm liên kết có tên new trên Guess tạo các thể hiện của giá trị Guess. Hàm new được định nghĩa có một tham số có tên value kiểu i32 và trả về một Guess. Mã trong thân hàm new kiểm tra value để đảm bảo nó nằm trong khoảng từ 1 đến 100. Nếu value không vượt qua bài kiểm tra này, chúng ta thực hiện lệnh gọi panic!, điều này sẽ cảnh báo lập trình viên đang viết mã gọi rằng họ có lỗi cần sửa, vì việc tạo một Guess với value nằm ngoài phạm vi này sẽ vi phạm hợp đồng mà Guess::new đang dựa vào. Các điều kiện trong đó Guess::new có thể panic nên được thảo luận trong tài liệu API hướng đến công chúng của nó; chúng ta sẽ đề cập đến các quy ước tài liệu chỉ ra khả năng của một panic! trong tài liệu API mà bạn tạo trong Chương 14. Nếu value vượt qua bài kiểm tra, chúng ta tạo một Guess mới với trường value được thiết lập thành tham số value và trả về Guess.

Tiếp theo, chúng ta thực hiện một phương thức có tên value mượn self, không có bất kỳ tham số nào khác, và trả về một i32. Loại phương thức này đôi khi được gọi là getter vì mục đích của nó là lấy một số dữ liệu từ các trường của nó và trả về nó. Phương thức công khai này là cần thiết vì trường value của cấu trúc Guess là private. Điều quan trọng là trường value phải private để mã sử dụng cấu trúc Guess không được phép đặt value trực tiếp: mã bên ngoài module guessing_game phải sử dụng hàm Guess::new để tạo một thể hiện của Guess, từ đó đảm bảo không có cách nào để Guess có một value chưa được kiểm tra bởi các điều kiện trong hàm Guess::new.

Một hàm có tham số hoặc chỉ trả về số từ 1 đến 100 có thể khai báo trong chữ ký của nó rằng nó nhận hoặc trả về một Guess thay vì một i32 và sẽ không cần thực hiện bất kỳ kiểm tra bổ sung nào trong nội dung của nó.

Tóm tắt

Các tính năng xử lý lỗi của Rust được thiết kế để giúp bạn viết mã mạnh mẽ hơn. Macro panic! báo hiệu rằng chương trình của bạn đang ở trạng thái mà nó không thể xử lý và cho phép bạn yêu cầu quá trình dừng thay vì cố gắng tiếp tục với các giá trị không hợp lệ hoặc không chính xác. Enum Result sử dụng hệ thống kiểu của Rust để chỉ ra rằng các hoạt động có thể thất bại theo cách mà mã của bạn có thể khôi phục từ đó. Bạn có thể sử dụng Result để nói với mã gọi mã của bạn rằng nó cần xử lý khả năng thành công hoặc thất bại. Sử dụng panic! và Result trong các tình huống thích hợp sẽ làm cho mã của bạn đáng tin cậy hơn đối mặt với các vấn đề không thể tránh khỏi.

Bây giờ bạn đã thấy những cách hữu ích mà thư viện tiêu chuẩn sử dụng generics với các enum Option và Result, chúng ta sẽ nói về cách thức hoạt động của generics và cách bạn có thể sử dụng chúng trong mã của mình.

Các Kiểu Generic, Traits và Lifetimes

Mọi ngôn ngữ lập trình đều có công cụ để xử lý hiệu quả sự trùng lặp của các khái niệm. Trong Rust, một công cụ như vậy là generics: các đại diện trừu tượng cho các kiểu dữ liệu cụ thể hoặc các thuộc tính khác. Chúng ta có thể biểu đạt hành vi của generics hoặc cách chúng liên quan đến các generics khác mà không cần biết cái gì sẽ ở vị trí của chúng khi biên dịch và chạy mã.

Các hàm có thể nhận tham số của một số kiểu generic, thay vì một kiểu cụ thể như i32 hoặc String, theo cách tương tự như chúng nhận tham số với giá trị không xác định để chạy cùng một mã trên nhiều giá trị cụ thể. Thực tế, chúng ta đã sử dụng generics trong Chương 6 với Option<T>, trong Chương 8 với Vec<T> và HashMap<K, V>, và trong Chương 9 với Result<T, E>. Trong chương này, bạn sẽ khám phá cách định nghĩa các kiểu, hàm và phương thức của riêng mình với generics!

Đầu tiên chúng ta sẽ xem xét cách trích xuất một hàm để giảm sự trùng lặp mã. Sau đó chúng ta sẽ sử dụng cùng một kỹ thuật để tạo một hàm generic từ hai hàm mà chỉ khác nhau về kiểu của các tham số của chúng. Chúng ta cũng sẽ giải thích cách sử dụng các kiểu generic trong định nghĩa struct và enum.

Sau đó, bạn sẽ học cách sử dụng traits để định nghĩa hành vi theo cách generic. Bạn có thể kết hợp traits với các kiểu generic để ràng buộc một kiểu generic chỉ chấp nhận những kiểu có một hành vi cụ thể, trái ngược với việc chấp nhận bất kỳ kiểu nào.

Cuối cùng, chúng ta sẽ thảo luận về lifetimes: một loại generics cung cấp cho trình biên dịch thông tin về cách các tham chiếu liên quan đến nhau. Lifetimes cho phép chúng ta cung cấp cho trình biên dịch đủ thông tin về các giá trị được mượn để nó có thể đảm bảo các tham chiếu sẽ hợp lệ trong nhiều tình huống hơn so với khi không có sự trợ giúp của chúng ta.

Loại bỏ sự trùng lặp bằng cách trích xuất một hàm

Generics cho phép chúng ta thay thế các kiểu cụ thể bằng một giữ chỗ đại diện cho nhiều kiểu để loại bỏ sự trùng lặp mã. Trước khi đi sâu vào cú pháp generics, hãy xem trước cách loại bỏ sự trùng lặp theo cách không liên quan đến các kiểu generic bằng cách trích xuất một hàm thay thế các giá trị cụ thể bằng một giữ chỗ đại diện cho nhiều giá trị. Sau đó chúng ta sẽ áp dụng cùng một kỹ thuật để trích xuất một hàm generic! Bằng cách xem xét cách nhận biết mã trùng lặp mà bạn có thể trích xuất vào một hàm, bạn sẽ bắt đầu nhận ra mã trùng lặp có thể sử dụng generics.

Chúng ta sẽ bắt đầu với một chương trình ngắn trong Listing 10-1 tìm số lớn nhất trong một danh sách.

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);
}

Chúng ta lưu trữ một danh sách các số nguyên trong biến number_list và đặt một tham chiếu tới số đầu tiên trong danh sách vào một biến có tên largest. Sau đó chúng ta lặp qua tất cả các số trong danh sách, và nếu số hiện tại lớn hơn số được lưu trữ trong largest, chúng ta thay thế tham chiếu trong biến đó. Tuy nhiên, nếu số hiện tại nhỏ hơn hoặc bằng số lớn nhất đã thấy cho đến nay, biến không thay đổi, và mã chuyển sang số tiếp theo trong danh sách. Sau khi xem xét tất cả các số trong danh sách, largest sẽ tham chiếu đến số lớn nhất, trong trường hợp này là 100.

Giờ đây chúng ta được giao nhiệm vụ tìm số lớn nhất trong hai danh sách khác nhau của các số. Để làm điều đó, chúng ta có thể chọn sao chép mã trong Listing 10-1 và sử dụng cùng một logic tại hai vị trí khác nhau trong chương trình, như được hiển thị trong Listing 10-2.

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}");
}

Mặc dù mã này hoạt động, việc sao chép mã là tẻ nhạt và dễ gây lỗi. Chúng ta cũng phải nhớ cập nhật mã ở nhiều vị trí khi chúng ta muốn thay đổi nó.

Để loại bỏ sự trùng lặp này, chúng ta sẽ tạo một sự trừu tượng bằng cách định nghĩa một hàm hoạt động trên bất kỳ danh sách số nguyên nào được truyền vào dưới dạng tham số. Giải pháp này làm cho mã của chúng ta rõ ràng hơn và cho phép chúng ta biểu đạt khái niệm tìm số lớn nhất trong một danh sách một cách trừu tượng.

Trong Listing 10-3, chúng ta trích xuất mã tìm số lớn nhất vào một hàm có tên là largest. Sau đó chúng ta gọi hàm để tìm số lớn nhất trong hai danh sách từ Listing 10-2. Chúng ta cũng có thể sử dụng hàm này trên bất kỳ danh sách giá trị i32 nào khác mà chúng ta có thể có trong tương lai.

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);
}

Hàm largest có một tham số gọi là list, đại diện cho bất kỳ slice cụ thể nào của các giá trị i32 mà chúng ta có thể truyền vào hàm. Kết quả là, khi chúng ta gọi hàm, mã chạy trên các giá trị cụ thể mà chúng ta truyền vào.

Tóm lại, đây là các bước chúng ta đã thực hiện để thay đổi mã từ Listing 10-2 sang Listing 10-3:

1. Xác định mã trùng lặp.
2. Trích xuất mã trùng lặp vào thân hàm, và chỉ định các đầu vào và giá trị trả về của mã đó trong chữ ký hàm.
3. Cập nhật hai trường hợp của mã trùng lặp để gọi hàm thay thế.

Tiếp theo, chúng ta sẽ sử dụng các bước tương tự với generics để giảm sự trùng lặp mã. Cùng cách mà thân hàm có thể hoạt động trên một list trừu tượng thay vì các giá trị cụ thể, generics cho phép mã hoạt động trên các kiểu trừu tượng.

Ví dụ, giả sử chúng ta có hai hàm: một hàm tìm phần tử lớn nhất trong một slice của các giá trị i32 và một hàm tìm phần tử lớn nhất trong một slice của các giá trị char. Làm thế nào để chúng ta loại bỏ sự trùng lặp đó? Hãy tìm hiểu!

Các Kiểu Dữ Liệu Generic

Chúng ta sử dụng generics để tạo các định nghĩa cho các thành phần như chữ ký hàm hoặc structs, mà sau đó chúng ta có thể sử dụng với nhiều kiểu dữ liệu cụ thể khác nhau. Hãy xem trước cách định nghĩa các hàm, structs, enums và phương thức sử dụng generics. Sau đó chúng ta sẽ thảo luận về cách generics ảnh hưởng đến hiệu năng mã.

Trong Định Nghĩa Hàm

Khi định nghĩa một hàm sử dụng generics, chúng ta đặt generics vào chữ ký của hàm nơi mà chúng ta thường xác định kiểu dữ liệu của các tham số và giá trị trả về. Làm như vậy giúp mã của chúng ta linh hoạt hơn và cung cấp nhiều chức năng hơn cho người gọi hàm của chúng ta đồng thời ngăn chặn trùng lặp mã.

Tiếp tục với hàm largest của chúng ta, Listing 10-4 hiển thị hai hàm mà cả hai đều tìm giá trị lớn nhất trong một slice. Sau đó chúng ta sẽ kết hợp chúng thành một hàm duy nhất sử dụng generics.

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');
}

Hàm largest_i32 là hàm chúng ta đã trích xuất trong Listing 10-3 để tìm giá trị i32 lớn nhất trong một slice. Hàm largest_char tìm giá trị char lớn nhất trong một slice. Phần thân của hai hàm có cùng mã nguồn, vì vậy hãy loại bỏ sự trùng lặp bằng cách giới thiệu một tham số kiểu generic trong một hàm duy nhất.

Để tham số hóa các kiểu trong một hàm đơn lẻ mới, chúng ta cần đặt tên cho tham số kiểu, giống như chúng ta làm cho các tham số giá trị cho một hàm. Bạn có thể sử dụng bất kỳ định danh nào làm tên tham số kiểu. Nhưng chúng ta sẽ sử dụng T vì, theo quy ước, tên tham số kiểu trong Rust thường ngắn, thường chỉ một chữ cái, và quy ước đặt tên kiểu của Rust là CamelCase. Viết tắt của type, T là lựa chọn mặc định của hầu hết lập trình viên Rust.

Khi chúng ta sử dụng một tham số trong thân hàm, chúng ta phải khai báo tên tham số trong chữ ký để trình biên dịch biết tên đó có ý nghĩa gì. Tương tự, khi chúng ta sử dụng tên tham số kiểu trong chữ ký hàm, chúng ta phải khai báo tên tham số kiểu trước khi sử dụng nó. Để định nghĩa hàm generic largest, chúng ta đặt khai báo tên kiểu bên trong dấu ngoặc nhọn, <>, giữa tên của hàm và danh sách tham số, như sau:

fn largest<T>(list: &[T]) -> &T {

Chúng ta đọc định nghĩa này là: hàm largest là generic trên một số kiểu T. Hàm này có một tham số tên là list, là một slice của các giá trị của kiểu T. Hàm largest sẽ trả về một tham chiếu đến một giá trị cùng kiểu T.

Listing 10-5 hiển thị định nghĩa hàm largest kết hợp sử dụng kiểu dữ liệu generic trong chữ ký của nó. Listing này cũng cho thấy cách chúng ta có thể gọi hàm với một slice của các giá trị i32 hoặc giá trị char. Lưu ý rằng mã này sẽ không biên dịch được.

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}");
}

Nếu chúng ta biên dịch mã này ngay bây giờ, chúng ta sẽ nhận được lỗi này:

$ 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` with trait `PartialOrd`
  |
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` (bin "chapter10") due to 1 previous error

Văn bản trợ giúp đề cập đến std::cmp::PartialOrd, đó là một trait, và chúng ta sẽ nói về traits trong phần tiếp theo. Hiện tại, hãy biết rằng lỗi này cho biết rằng phần thân của largest sẽ không hoạt động cho tất cả các kiểu có thể của T. Bởi vì chúng ta muốn so sánh các giá trị của kiểu T trong phần thân, chúng ta chỉ có thể sử dụng các kiểu mà các giá trị của nó có thể được sắp xếp theo thứ tự. Để cho phép so sánh, thư viện tiêu chuẩn có trait std::cmp::PartialOrd mà bạn có thể thực hiện trên các kiểu (xem Phụ lục C để biết thêm về trait này). Để sửa mã ví dụ trên, chúng ta sẽ cần phải làm theo gợi ý của văn bản trợ giúp và giới hạn các kiểu hợp lệ cho T chỉ với những kiểu thực hiện PartialOrd. Ví dụ này sau đó sẽ biên dịch, vì thư viện tiêu chuẩn đã thực hiện PartialOrd cho cả i32 và char.

Trong Định Nghĩa Struct

Chúng ta cũng có thể định nghĩa structs để sử dụng tham số kiểu generic trong một hoặc nhiều trường bằng cách sử dụng cú pháp <>. Listing 10-6 định nghĩa một struct Point<T> để chứa các giá trị tọa độ x và y của bất kỳ kiểu nào.

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 };
}

Cú pháp để sử dụng generics trong các định nghĩa struct tương tự với cú pháp được sử dụng trong các định nghĩa hàm. Đầu tiên chúng ta khai báo tên của tham số kiểu bên trong dấu ngoặc nhọn ngay sau tên của struct. Sau đó chúng ta sử dụng kiểu generic trong định nghĩa struct ở những vị trí mà chúng ta muốn chỉ định kiểu dữ liệu cụ thể.

Lưu ý rằng vì chúng ta chỉ sử dụng một kiểu generic để định nghĩa Point<T>, nên định nghĩa này nói rằng struct Point<T> là generic trên một số kiểu T, và các trường x và y đều có cùng kiểu đó, bất kể kiểu đó là gì. Nếu chúng ta tạo một thể hiện của Point<T> có giá trị của các kiểu khác nhau, như trong Listing 10-7, mã của chúng ta sẽ không biên dịch.

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let wont_work = Point { x: 5, y: 4.0 };
}

Trong ví dụ này, khi chúng ta gán giá trị số nguyên 5 cho x, chúng ta cho trình biên dịch biết rằng kiểu generic T sẽ là một số nguyên cho thể hiện này của Point<T>. Sau đó khi chúng ta chỉ định 4.0 cho y, mà chúng ta đã định nghĩa là có cùng kiểu với x, chúng ta sẽ nhận được lỗi không khớp kiểu như sau:

$ 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` (bin "chapter10") due to 1 previous error

Để định nghĩa một struct Point trong đó x và y đều là generics nhưng có thể có các kiểu khác nhau, chúng ta có thể sử dụng nhiều tham số kiểu generic. Ví dụ, trong Listing 10-8, chúng ta thay đổi định nghĩa của Point để generic trên các kiểu T và U trong đó x có kiểu T và y có kiểu U.

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 };
}

Bây giờ tất cả các thể hiện của Point được hiển thị đều được cho phép! Bạn có thể sử dụng nhiều tham số kiểu generic trong một định nghĩa tùy thích, nhưng việc sử dụng quá nhiều sẽ làm cho mã của bạn khó đọc. Nếu bạn thấy mình cần nhiều kiểu generic trong mã của mình, điều đó có thể chỉ ra rằng mã của bạn cần được cấu trúc lại thành các phần nhỏ hơn.

Trong Định Nghĩa Enum

Như chúng ta đã làm với structs, chúng ta có thể định nghĩa enums để giữ các kiểu dữ liệu generic trong các biến thể của chúng. Hãy xem lại enum Option<T> mà thư viện tiêu chuẩn cung cấp, mà chúng ta đã sử dụng trong Chương 6:

#![allow(unused)]
fn main() {
enum Option<T> {
    Some(T),
    None,
}
}

Định nghĩa này bây giờ nên có ý nghĩa hơn với bạn. Như bạn có thể thấy, enum Option<T> là generic trên kiểu T và có hai biến thể: Some, mà giữ một giá trị của kiểu T, và một biến thể None không giữ bất kỳ giá trị nào. Bằng cách sử dụng enum Option<T>, chúng ta có thể biểu đạt khái niệm trừu tượng của một giá trị tùy chọn, và vì Option<T> là generic, chúng ta có thể sử dụng sự trừu tượng này bất kể kiểu của giá trị tùy chọn là gì.

Enums cũng có thể sử dụng nhiều kiểu generic. Định nghĩa của enum Result mà chúng ta đã sử dụng trong Chương 9 là một ví dụ:

#![allow(unused)]
fn main() {
enum Result<T, E> {
    Ok(T),
    Err(E),
}
}

Enum Result là generic trên hai kiểu, T và E, và có hai biến thể: Ok, giữ một giá trị của kiểu T, và Err, giữ một giá trị của kiểu E. Định nghĩa này giúp thuận tiện để sử dụng enum Result ở bất kỳ nơi nào chúng ta có một hoạt động có thể thành công (trả về một giá trị của một số kiểu T) hoặc thất bại (trả về một lỗi của một số kiểu E). Trên thực tế, đây là những gì chúng ta đã sử dụng để mở một tệp trong Listing 9-3, trong đó T được điền với kiểu std::fs::File khi tệp được mở thành công và E được điền với kiểu std::io::Error khi có vấn đề khi mở tệp.

Khi bạn nhận ra các tình huống trong mã của mình với nhiều định nghĩa struct hoặc enum khác nhau chỉ ở kiểu của các giá trị mà chúng chứa, bạn có thể tránh trùng lặp bằng cách sử dụng các kiểu generic thay thế.

Trong Định Nghĩa Phương Thức

Chúng ta có thể triển khai các phương thức trên structs và enums (như chúng ta đã làm trong Chương 5) và sử dụng các kiểu generic trong các định nghĩa của chúng. Listing 10-9 hiển thị struct Point<T> mà chúng ta đã định nghĩa trong Listing 10-6 với một phương thức có tên x được triển khai trên nó.

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());
}

Ở đây, chúng ta đã định nghĩa một phương thức có tên x trên Point<T> trả về một tham chiếu đến dữ liệu trong trường x.

Lưu ý rằng chúng ta phải khai báo T ngay sau impl để chúng ta có thể sử dụng T để chỉ định rằng chúng ta đang triển khai các phương thức trên kiểu Point<T>. Bằng cách khai báo T như là một kiểu generic sau impl, Rust có thể xác định rằng kiểu trong dấu ngoặc nhọn trong Point là một kiểu generic chứ không phải là một kiểu cụ thể. Chúng ta có thể đã chọn một tên khác cho tham số generic này so với tham số generic đã khai báo trong định nghĩa struct, nhưng việc sử dụng cùng một tên là quy ước. Nếu bạn viết một phương thức trong một impl khai báo một kiểu generic, phương thức đó sẽ được định nghĩa trên bất kỳ thể hiện nào của kiểu, bất kể kiểu cụ thể nào cuối cùng thay thế cho kiểu generic.

Chúng ta cũng có thể chỉ định các ràng buộc trên các kiểu generic khi định nghĩa các phương thức trên kiểu. Chúng ta có thể, ví dụ, triển khai các phương thức chỉ trên các thể hiện Point<f32> thay vì trên các thể hiện Point<T> với bất kỳ kiểu generic nào. Trong Listing 10-10, chúng ta sử dụng kiểu cụ thể f32, nghĩa là chúng ta không khai báo bất kỳ kiểu nào sau impl.

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());
}

Mã này có nghĩa là kiểu Point<f32> sẽ có phương thức distance_from_origin; các thể hiện khác của Point<T> mà T không phải là kiểu f32 sẽ không có phương thức này được định nghĩa. Phương thức đo lường khoảng cách từ điểm của chúng ta đến điểm có tọa độ (0.0, 0.0) và sử dụng các phép toán toán học là chỉ có sẵn cho các kiểu số thực.

Các tham số kiểu generic trong định nghĩa struct không phải lúc nào cũng giống với các tham số bạn sử dụng trong chữ ký phương thức của cùng một struct đó. Listing 10-11 sử dụng các kiểu generic X1 và Y1 cho struct Point và X2 Y2 cho chữ ký phương thức mixup để làm cho ví dụ rõ ràng hơn. Phương thức tạo một thể hiện Point mới với giá trị x từ Point self (kiểu X1) và giá trị y từ Point được truyền vào (kiểu Y2).

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);
}

Trong main, chúng ta đã định nghĩa một Point có một i32 cho x (với giá trị 5) và một f64 cho y (với giá trị 10.4). Biến p2 là một struct Point có một string slice cho x (với giá trị "Hello") và một char cho y (với giá trị c). Gọi mixup trên p1 với đối số p2 cho chúng ta p3, sẽ có một i32 cho x vì x đến từ p1. Biến p3 sẽ có một char cho y vì y đến từ p2. Lời gọi macro println! sẽ in ra p3.x = 5, p3.y = c.

Mục đích của ví dụ này là để chứng minh một tình huống trong đó một số tham số generic được khai báo với impl và một số được khai báo với định nghĩa phương thức. Ở đây, các tham số generic X1 và Y1 được khai báo sau impl vì chúng đi với định nghĩa struct. Các tham số generic X2 và Y2 được khai báo sau fn mixup vì chúng chỉ liên quan đến phương thức.

Hiệu Năng của Mã Sử Dụng Generics

Bạn có thể tự hỏi liệu có chi phí thời gian chạy khi sử dụng các tham số kiểu generic không. Tin tốt là việc sử dụng các kiểu generic sẽ không làm cho chương trình của bạn chạy chậm hơn so với sử dụng các kiểu cụ thể.

Rust thực hiện điều này bằng cách thực hiện monomorphization của mã sử dụng generics tại thời điểm biên dịch. Monomorphization là quá trình chuyển đổi mã generic thành mã cụ thể bằng cách điền các kiểu cụ thể được sử dụng khi biên dịch. Trong quá trình này, trình biên dịch làm ngược lại các bước chúng ta đã sử dụng để tạo hàm generic trong Listing 10-5: trình biên dịch xem xét tất cả các nơi mã generic được gọi và tạo mã cho các kiểu cụ thể mà mã generic được gọi với.

Hãy xem cách hoạt động của nó bằng cách sử dụng enum generic Option<T> của thư viện tiêu chuẩn:

#![allow(unused)]
fn main() {
let integer = Some(5);
let float = Some(5.0);
}

Khi Rust biên dịch mã này, nó thực hiện monomorphization. Trong quá trình đó, trình biên dịch đọc các giá trị đã được sử dụng trong các thể hiện Option<T> và xác định hai loại Option<T>: một là i32 và loại kia là f64. Như vậy, nó mở rộng định nghĩa generic của Option<T> thành hai định nghĩa chuyên biệt cho i32 và f64, từ đó thay thế định nghĩa generic bằng các định nghĩa cụ thể.

Phiên bản monomorphized của mã trông tương tự như sau (trình biên dịch sử dụng các tên khác với những gì chúng ta đang sử dụng ở đây để minh họa):

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);
}

Option<T> generic được thay thế bằng các định nghĩa cụ thể được tạo bởi trình biên dịch. Bởi vì Rust biên dịch mã generic thành mã chỉ định kiểu trong mỗi thể hiện, chúng ta không phải trả chi phí thời gian chạy cho việc sử dụng generics. Khi mã chạy, nó hoạt động giống như nếu chúng ta đã sao chép từng định nghĩa bằng tay. Quá trình monomorphization làm cho generics của Rust cực kỳ hiệu quả trong thời gian chạy.

Traits: Định Nghĩa Hành Vi Được Chia Sẻ

Một trait định nghĩa chức năng mà một kiểu cụ thể có và có thể chia sẻ với các kiểu khác. Chúng ta có thể sử dụng traits để định nghĩa hành vi được chia sẻ theo cách trừu tượng. Chúng ta có thể sử dụng trait bounds để chỉ định rằng một kiểu generic có thể là bất kỳ kiểu nào có hành vi nhất định.

Lưu ý: Traits tương tự với một tính năng thường được gọi là interfaces trong các ngôn ngữ khác, mặc dù có một số khác biệt.

Định Nghĩa một Trait

Hành vi của một kiểu bao gồm các phương thức mà chúng ta có thể gọi trên kiểu đó. Các kiểu khác nhau chia sẻ cùng một hành vi nếu chúng ta có thể gọi các phương thức giống nhau trên tất cả các kiểu đó. Định nghĩa trait là một cách để nhóm các chữ ký phương thức lại với nhau để định nghĩa một tập hợp các hành vi cần thiết để hoàn thành một mục đích nào đó.

Ví dụ, giả sử chúng ta có nhiều struct chứa các loại và số lượng văn bản khác nhau: một struct NewsArticle chứa một câu chuyện tin tức được lưu trữ ở một vị trí cụ thể và một SocialPost có thể có, nhiều nhất là 280 ký tự cùng với metadata cho biết liệu đó là một bài viết mới, một bài đăng lại, hoặc một trả lời cho bài viết khác.

Chúng ta muốn tạo một thư viện tổng hợp phương tiện có tên là aggregator có thể hiển thị tóm tắt dữ liệu có thể được lưu trữ trong một thể hiện NewsArticle hoặc SocialPost. Để làm điều này, chúng ta cần một bản tóm tắt từ mỗi loại, và chúng ta sẽ yêu cầu bản tóm tắt đó bằng cách gọi phương thức summarize trên một thể hiện. Listing 10-12 hiển thị định nghĩa của một trait Summary công khai thể hiện hành vi này.

pub trait Summary {
    fn summarize(&self) -> String;
}

Ở đây, chúng ta khai báo một trait bằng cách sử dụng từ khóa trait và sau đó là tên của trait, là Summary trong trường hợp này. Chúng ta cũng khai báo trait là pub để các crate phụ thuộc vào crate này cũng có thể sử dụng trait này, như chúng ta sẽ thấy trong một vài ví dụ. Bên trong dấu ngoặc nhọn, chúng ta khai báo các chữ ký phương thức mô tả các hành vi của các kiểu thực hiện trait này, trong trường hợp này là fn summarize(&self) -> String.

Sau chữ ký phương thức, thay vì cung cấp một triển khai trong dấu ngoặc nhọn, chúng ta sử dụng dấu chấm phẩy. Mỗi kiểu triển khai trait này phải cung cấp hành vi tùy chỉnh riêng của nó cho phần thân của phương thức. Trình biên dịch sẽ áp dụng rằng bất kỳ kiểu nào có trait Summary sẽ phải có phương thức summarize được định nghĩa với chữ ký này một cách chính xác.

Một trait có thể có nhiều phương thức trong thân: các chữ ký phương thức được liệt kê mỗi phương thức một dòng, và mỗi dòng kết thúc bằng dấu chấm phẩy.

Triển Khai một Trait trên một Kiểu

Bây giờ chúng ta đã định nghĩa các chữ ký mong muốn của các phương thức của trait Summary, chúng ta có thể triển khai nó trên các kiểu trong trình tổng hợp phương tiện của chúng ta. Listing 10-13 hiển thị một triển khai của trait Summary trên struct NewsArticle sử dụng tiêu đề, tác giả và vị trí để tạo giá trị trả về của summarize. Đối với struct SocialPost, chúng ta định nghĩa summarize là tên người dùng theo sau là toàn bộ văn bản của bài viết, giả định rằng nội dung bài viết đã giới hạn ở 280 ký tự.

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 SocialPost {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub repost: bool,
}

impl Summary for SocialPost {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

Triển khai một trait trên một kiểu tương tự như triển khai các phương thức thông thường. Sự khác biệt là sau impl, chúng ta đặt tên trait mà chúng ta muốn triển khai, sau đó sử dụng từ khóa for, và sau đó chỉ định tên của kiểu mà chúng ta muốn triển khai trait cho. Trong khối impl, chúng ta đặt các chữ ký phương thức mà định nghĩa trait đã định nghĩa. Thay vì thêm dấu chấm phẩy sau mỗi chữ ký, chúng ta sử dụng dấu ngoặc nhọn và điền vào phần thân phương thức với hành vi cụ thể mà chúng ta muốn các phương thức của trait có đối với kiểu cụ thể.

Bây giờ thư viện đã triển khai trait Summary trên NewsArticle và SocialPost, người dùng của crate có thể gọi các phương thức trait trên các thể hiện của NewsArticle và SocialPost giống như cách chúng ta gọi các phương thức thông thường. Sự khác biệt duy nhất là người dùng phải đưa trait vào phạm vi cũng như các kiểu. Đây là một ví dụ về cách một binary crate có thể sử dụng thư viện aggregator của chúng ta:

use aggregator::{SocialPost, Summary};

fn main() {
    let post = SocialPost {
        username: String::from("horse_ebooks"),
        content: String::from(
            "of course, as you probably already know, people",
        ),
        reply: false,
        repost: false,
    };

    println!("1 new social post: {}", post.summarize());
}

Mã này in ra 1 new post: horse_ebooks: of course, as you probably already know, people.

Các crate khác phụ thuộc vào crate aggregator cũng có thể đưa trait Summary vào phạm vi để triển khai Summary trên các kiểu riêng của họ. Một hạn chế cần lưu ý là chúng ta chỉ có thể triển khai một trait trên một kiểu nếu hoặc trait hoặc kiểu, hoặc cả hai, là local đối với crate của chúng ta. Ví dụ, chúng ta có thể triển khai các trait của thư viện tiêu chuẩn như Display trên một kiểu tùy chỉnh như SocialPost như một phần của chức năng crate aggregator của chúng ta vì kiểu SocialPost là local đối với crate aggregator của chúng ta. Chúng ta cũng có thể triển khai Summary trên Vec<T> trong crate aggregator của chúng ta vì trait Summary là local đối với crate aggregator của chúng ta.

Nhưng chúng ta không thể triển khai các trait bên ngoài trên các kiểu bên ngoài. Ví dụ, chúng ta không thể triển khai trait Display trên Vec<T> trong crate aggregator của chúng ta vì Display và Vec<T> đều được định nghĩa trong thư viện tiêu chuẩn và không local đối với crate aggregator của chúng ta. Hạn chế này là một phần của thuộc tính được gọi là coherence, và cụ thể hơn là quy tắc mồ côi, được đặt tên như vậy bởi vì kiểu cha không có mặt. Quy tắc này đảm bảo rằng mã của người khác không thể phá vỡ mã của bạn và ngược lại. Nếu không có quy tắc này, hai crate có thể triển khai cùng một trait cho cùng một kiểu, và Rust sẽ không biết triển khai nào để sử dụng.

Các Triển Khai Mặc Định

Đôi khi việc có hành vi mặc định cho một số hoặc tất cả các phương thức trong một trait thay vì yêu cầu triển khai cho tất cả các phương thức trên mọi kiểu là hữu ích. Sau đó, khi chúng ta triển khai trait trên một kiểu cụ thể, chúng ta có thể giữ nguyên hoặc ghi đè hành vi mặc định của từng phương thức.

Trong Listing 10-14, chúng ta chỉ định một chuỗi mặc định cho phương thức summarize của trait Summary thay vì chỉ định nghĩa chữ ký phương thức, như chúng ta đã làm trong Listing 10-12.

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 SocialPost {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub repost: bool,
}

impl Summary for SocialPost {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

Để sử dụng một triển khai mặc định để tóm tắt các thể hiện của NewsArticle, chúng ta chỉ định một khối impl trống với impl Summary for NewsArticle {}.

Mặc dù chúng ta không còn định nghĩa phương thức summarize trên NewsArticle trực tiếp, chúng ta đã cung cấp một triển khai mặc định và chỉ định rằng NewsArticle triển khai trait Summary. Kết quả là, chúng ta vẫn có thể gọi phương thức summarize trên một thể hiện của NewsArticle, như thế này:

use aggregator::{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());
}

Mã này in ra New article available! (Read more...).

Việc tạo một triển khai mặc định không yêu cầu chúng ta thay đổi bất cứ điều gì về việc triển khai Summary trên SocialPost trong Listing 10-13. Lý do là cú pháp để ghi đè một triển khai mặc định giống với cú pháp để triển khai một phương thức trait không có triển khai mặc định.

Các triển khai mặc định có thể gọi các phương thức khác trong cùng trait, ngay cả khi những phương thức khác đó không có triển khai mặc định. Bằng cách này, một trait có thể cung cấp nhiều chức năng hữu ích và chỉ yêu cầu những người triển khai chỉ định một phần nhỏ của nó. Ví dụ, chúng ta có thể định nghĩa trait Summary có một phương thức summarize_author mà triển khai của nó là bắt buộc, và sau đó định nghĩa một phương thức summarize có triển khai mặc định gọi phương thức summarize_author:

pub trait Summary {
    fn summarize_author(&self) -> String;

    fn summarize(&self) -> String {
        format!("(Read more from {}...)", self.summarize_author())
    }
}

pub struct SocialPost {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub repost: bool,
}

impl Summary for SocialPost {
    fn summarize_author(&self) -> String {
        format!("@{}", self.username)
    }
}

Để sử dụng phiên bản này của Summary, chúng ta chỉ cần định nghĩa summarize_author khi triển khai trait trên một kiểu:

pub trait Summary {
    fn summarize_author(&self) -> String;

    fn summarize(&self) -> String {
        format!("(Read more from {}...)", self.summarize_author())
    }
}

pub struct SocialPost {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub repost: bool,
}

impl Summary for SocialPost {
    fn summarize_author(&self) -> String {
        format!("@{}", self.username)
    }
}

Sau khi chúng ta định nghĩa summarize_author, chúng ta có thể gọi summarize trên các thể hiện của struct SocialPost, và triển khai mặc định của summarize sẽ gọi định nghĩa của summarize_author mà chúng ta đã cung cấp. Bởi vì chúng ta đã triển khai summarize_author, trait Summary đã cung cấp cho chúng ta hành vi của phương thức summarize mà không yêu cầu chúng ta viết thêm bất kỳ mã nào. Đây là cách nó hoạt động:

use aggregator::{self, SocialPost, Summary};

fn main() {
    let post = SocialPost {
        username: String::from("horse_ebooks"),
        content: String::from(
            "of course, as you probably already know, people",
        ),
        reply: false,
        repost: false,
    };

    println!("1 new social post: {}", post.summarize());
}

Mã này in ra 1 new post: (Read more from @horse_ebooks...).

Lưu ý rằng không thể gọi triển khai mặc định từ một triển khai ghi đè của cùng một phương thức.

Traits như Tham Số

Bây giờ bạn đã biết cách định nghĩa và triển khai traits, chúng ta có thể khám phá cách sử dụng traits để định nghĩa các hàm chấp nhận nhiều kiểu khác nhau. Chúng ta sẽ sử dụng trait Summary mà chúng ta đã triển khai trên các kiểu NewsArticle và SocialPost trong Listing 10-13 để định nghĩa một hàm notify gọi phương thức summarize trên tham số item của nó, là một kiểu nào đó triển khai trait Summary. Để làm điều này, chúng ta sử dụng cú pháp impl Trait, như thế này:

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 SocialPost {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub repost: bool,
}

impl Summary for SocialPost {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

pub fn notify(item: &impl Summary) {
    println!("Breaking news! {}", item.summarize());
}

Thay vì một kiểu cụ thể cho tham số item, chúng ta chỉ định từ khóa impl và tên trait. Tham số này chấp nhận bất kỳ kiểu nào triển khai trait được chỉ định. Trong thân của notify, chúng ta có thể gọi bất kỳ phương thức nào trên item mà đến từ trait Summary, chẳng hạn như summarize. Chúng ta có thể gọi notify và truyền vào bất kỳ thể hiện nào của NewsArticle hoặc SocialPost. Mã gọi hàm với bất kỳ kiểu nào khác, chẳng hạn như String hoặc i32, sẽ không biên dịch vì các kiểu đó không triển khai Summary.

Cú Pháp Trait Bound

Cú pháp impl Trait hoạt động cho các trường hợp đơn giản nhưng thực sự là cú pháp đường tắt cho một hình thức dài hơn được gọi là trait bound; nó trông như thế này:

pub fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}

Hình thức dài hơn này tương đương với ví dụ trong phần trước nhưng dài dòng hơn. Chúng ta đặt các trait bound với khai báo của tham số kiểu generic sau dấu hai chấm và bên trong dấu ngoặc nhọn.

Cú pháp impl Trait thuận tiện và tạo ra mã ngắn gọn hơn trong các trường hợp đơn giản, trong khi cú pháp trait bound đầy đủ hơn có thể biểu đạt phức tạp hơn trong các trường hợp khác. Ví dụ, chúng ta có thể có hai tham số triển khai Summary. Thực hiện điều này với cú pháp impl Trait trông như thế này:

pub fn notify(item1: &impl Summary, item2: &impl Summary) {

Sử dụng impl Trait là phù hợp nếu chúng ta muốn hàm này cho phép item1 và item2 có các kiểu khác nhau (miễn là cả hai kiểu đều triển khai Summary). Nếu chúng ta muốn buộc cả hai tham số phải có cùng kiểu, tuy nhiên, chúng ta phải sử dụng một trait bound, như thế này:

pub fn notify<T: Summary>(item1: &T, item2: &T) {

Kiểu generic T được chỉ định làm kiểu của các tham số item1 và item2 ràng buộc hàm sao cho kiểu cụ thể của giá trị được truyền dưới dạng đối số cho item1 và item2 phải giống nhau.

Chỉ Định Nhiều Trait Bounds với Cú Pháp +

Chúng ta cũng có thể chỉ định nhiều hơn một trait bound. Giả sử chúng ta muốn notify sử dụng định dạng hiển thị cũng như summarize trên item: chúng ta chỉ định trong định nghĩa notify rằng item phải triển khai cả Display và Summary. Chúng ta có thể làm như vậy bằng cách sử dụng cú pháp +:

pub fn notify(item: &(impl Summary + Display)) {

Cú pháp + cũng hợp lệ với trait bounds trên các kiểu generic:

pub fn notify<T: Summary + Display>(item: &T) {

Với hai trait bounds đã được chỉ định, thân của notify có thể gọi summarize và sử dụng {} để định dạng item.

Trait Bounds Rõ Ràng Hơn với Mệnh Đề where

Việc sử dụng quá nhiều trait bounds có nhược điểm. Mỗi generic có trait bound riêng của nó, vì vậy các hàm với nhiều tham số kiểu generic có thể chứa rất nhiều thông tin trait bound giữa tên của hàm và danh sách tham số của nó, làm cho chữ ký hàm khó đọc. Vì lý do này, Rust có cú pháp thay thế để chỉ định trait bounds bên trong một mệnh đề where sau chữ ký hàm. Vì vậy, thay vì viết như thế này:

fn some_function<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {

chúng ta có thể sử dụng một mệnh đề where, như thế này:

fn some_function<T, U>(t: &T, u: &U) -> i32
where
    T: Display + Clone,
    U: Clone + Debug,
{
    unimplemented!()
}

Chữ ký của hàm này ít rối hơn: tên hàm, danh sách tham số, và kiểu trả về ở gần nhau, tương tự như một hàm không có nhiều trait bounds.

Trả Về các Kiểu Triển Khai Traits

Chúng ta cũng có thể sử dụng cú pháp impl Trait ở vị trí trả về để trả về một giá trị của một số kiểu triển khai một trait, như được hiển thị ở đây:

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 SocialPost {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub repost: bool,
}

impl Summary for SocialPost {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

fn returns_summarizable() -> impl Summary {
    SocialPost {
        username: String::from("horse_ebooks"),
        content: String::from(
            "of course, as you probably already know, people",
        ),
        reply: false,
        repost: false,
    }
}

Bằng cách sử dụng impl Summary cho kiểu trả về, chúng ta chỉ định rằng hàm returns_summarizable trả về một số kiểu triển khai trait Summary mà không cần đặt tên kiểu cụ thể. Trong trường hợp này, returns_summarizable trả về một SocialPost, nhưng mã gọi hàm này không cần biết điều đó.

Khả năng chỉ định một kiểu trả về chỉ bằng trait mà nó triển khai đặc biệt hữu ích trong ngữ cảnh của closures và iterators, mà chúng ta sẽ đề cập trong Chương 13. Closures và iterators tạo ra các kiểu mà chỉ trình biên dịch biết hoặc các kiểu rất dài để chỉ định. Cú pháp impl Trait cho phép bạn ngắn gọn chỉ định rằng một hàm trả về một số kiểu triển khai trait Iterator mà không cần viết ra một kiểu rất dài.

Tuy nhiên, bạn chỉ có thể sử dụng impl Trait nếu bạn đang trả về một kiểu duy nhất. Ví dụ, mã này trả về một NewsArticle hoặc một SocialPost với kiểu trả về được chỉ định là impl Summary sẽ không hoạt động:

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 SocialPost {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub repost: bool,
}

impl Summary for SocialPost {
    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 {
        SocialPost {
            username: String::from("horse_ebooks"),
            content: String::from(
                "of course, as you probably already know, people",
            ),
            reply: false,
            repost: false,
        }
    }
}

Việc trả về một NewsArticle hoặc một SocialPost không được phép do các hạn chế xung quanh cách cú pháp impl Trait được triển khai trong trình biên dịch. Chúng ta sẽ đề cập đến cách viết một hàm với hành vi này trong phần "Sử dụng Trait Objects Cho Phép các Giá Trị của Các Kiểu Khác Nhau" của Chương 18.

Sử Dụng Trait Bounds để Triển Khai Các Phương Thức Có Điều Kiện

Bằng cách sử dụng một trait bound với một khối impl sử dụng các tham số kiểu generic, chúng ta có thể triển khai các phương thức có điều kiện cho các kiểu triển khai các traits được chỉ định. Ví dụ, kiểu Pair<T> trong Listing 10-15 luôn triển khai hàm new để trả về một thể hiện mới của Pair<T> (nhớ lại từ phần "Định Nghĩa Phương Thức" của Chương 5 rằng Self là một bí danh kiểu cho kiểu của khối impl, trong trường hợp này là Pair<T>). Nhưng trong khối impl tiếp theo, Pair<T> chỉ triển khai phương thức cmp_display nếu kiểu bên trong T của nó triển khai trait PartialOrd cho phép so sánh và trait Display cho phép in.

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);
        }
    }
}

Chúng ta cũng có thể triển khai có điều kiện một trait cho bất kỳ kiểu nào triển khai một trait khác. Việc triển khai một trait trên bất kỳ kiểu nào thỏa mãn các trait bounds được gọi là blanket implementations và được sử dụng rộng rãi trong thư viện tiêu chuẩn Rust. Ví dụ, thư viện tiêu chuẩn triển khai trait ToString trên bất kỳ kiểu nào triển khai trait Display. Khối impl trong thư viện tiêu chuẩn trông tương tự như mã này:

impl<T: Display> ToString for T {
    // --snip--
}

Bởi vì thư viện tiêu chuẩn có blanket implementation này, chúng ta có thể gọi phương thức to_string được định nghĩa bởi trait ToString trên bất kỳ kiểu nào triển khai trait Display. Ví dụ, chúng ta có thể chuyển các số nguyên thành các giá trị String tương ứng của chúng như thế này vì số nguyên triển khai Display:

#![allow(unused)]
fn main() {
let s = 3.to_string();
}

Các blanket implementation xuất hiện trong tài liệu của trait trong phần "Implementors".

Traits và trait bounds cho phép chúng ta viết mã sử dụng các tham số kiểu generic để giảm sự trùng lặp nhưng cũng chỉ định cho trình biên dịch rằng chúng ta muốn kiểu generic có hành vi cụ thể. Trình biên dịch sau đó có thể sử dụng thông tin trait bound để kiểm tra rằng tất cả các kiểu cụ thể được sử dụng với mã của chúng ta cung cấp hành vi chính xác. Trong các ngôn ngữ kiểu động, chúng ta sẽ gặp lỗi tại thời điểm chạy nếu chúng ta gọi một phương thức trên một kiểu không định nghĩa phương thức đó. Nhưng Rust chuyển các lỗi này sang thời điểm biên dịch để chúng ta buộc phải sửa các vấn đề trước khi mã của chúng ta thậm chí có thể chạy. Ngoài ra, chúng ta không phải viết mã kiểm tra hành vi tại thời điểm chạy vì chúng ta đã kiểm tra tại thời điểm biên dịch. Làm như vậy cải thiện hiệu suất mà không phải từ bỏ tính linh hoạt của generics.

Xác thực tham chiếu với Lifetimes

Lifetimes (thời gian sống) là một loại generic khác mà chúng ta đã sử dụng. Thay vì đảm bảo rằng một kiểu có hành vi chúng ta mong muốn, lifetimes đảm bảo rằng các tham chiếu hợp lệ miễn là chúng ta cần chúng.

Một chi tiết chúng ta chưa thảo luận trong phần "Tham chiếu và Mượn" ở Chương 4 là mỗi tham chiếu trong Rust có một lifetime, là phạm vi mà tham chiếu đó có hiệu lực. Hầu hết thời gian, lifetimes được ngầm định và suy luận, giống như hầu hết thời gian, các kiểu được suy luận. Chúng ta chỉ phải chú thích kiểu khi nhiều kiểu có thể áp dụng. Tương tự, chúng ta phải chú thích lifetimes khi lifetimes của các tham chiếu có thể liên quan theo một số cách khác nhau. Rust yêu cầu chúng ta chú thích các mối quan hệ bằng các tham số lifetime generic để đảm bảo các tham chiếu thực tế được sử dụng trong thời gian chạy chắc chắn sẽ hợp lệ.

Việc chú thích lifetimes thậm chí không phải là một khái niệm mà hầu hết các ngôn ngữ lập trình khác có, vì vậy điều này sẽ cảm thấy không quen thuộc. Mặc dù chúng ta sẽ không bao quát lifetimes một cách đầy đủ trong chương này, chúng ta sẽ thảo luận về các cách phổ biến mà bạn có thể gặp cú pháp lifetime để bạn có thể làm quen với khái niệm này.

Ngăn chặn Dangling References (Tham chiếu treo) với Lifetimes

Mục đích chính của lifetimes là ngăn chặn dangling references, gây ra cho chương trình tham chiếu đến dữ liệu khác với dữ liệu mà nó dự định tham chiếu. Hãy xem xét chương trình trong Listing 10-16, có một phạm vi ngoài và một phạm vi trong.

fn main() {
    let r;

    {
        let x = 5;
        r = &x;
    }

    println!("r: {r}");
}

Lưu ý: Các ví dụ trong Listings 10-16, 10-17, và 10-23 khai báo các biến mà không cung cấp giá trị ban đầu, vì vậy tên biến tồn tại trong phạm vi ngoài. Thoạt nhìn, điều này có thể xuất hiện mâu thuẫn với việc Rust không có giá trị null. Tuy nhiên, nếu chúng ta cố gắng sử dụng một biến trước khi gán giá trị cho nó, chúng ta sẽ nhận được lỗi biên dịch, điều này cho thấy rằng Rust thực sự không cho phép giá trị null.

Phạm vi ngoài khai báo một biến tên r không có giá trị ban đầu, và phạm vi trong khai báo một biến tên x với giá trị ban đầu là 5. Bên trong phạm vi trong, chúng ta cố gắng đặt giá trị của r là một tham chiếu đến x. Sau đó phạm vi trong kết thúc, và chúng ta cố gắng in giá trị trong r. Mã này sẽ không biên dịch vì giá trị mà r đang tham chiếu đã ra khỏi phạm vi trước khi chúng ta cố gắng sử dụng nó. Đây là thông báo lỗi:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0597]: `x` does not live long enough
 --> src/main.rs:6:13
  |
5 |         let x = 5;
  |             - binding `x` declared here
6 |         r = &x;
  |             ^^ borrowed value does not live long enough
7 |     }
  |     - `x` dropped here while still borrowed
8 |
9 |     println!("r: {r}");
  |                  --- borrow later used here

For more information about this error, try `rustc --explain E0597`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error

Thông báo lỗi nói rằng biến x "không sống đủ lâu." Lý do là x sẽ ra khỏi phạm vi khi phạm vi trong kết thúc ở dòng 7. Nhưng r vẫn hợp lệ cho phạm vi ngoài; vì phạm vi của nó lớn hơn, chúng ta nói rằng nó "sống lâu hơn." Nếu Rust cho phép mã này hoạt động, r sẽ tham chiếu đến bộ nhớ đã bị giải phóng khi x ra khỏi phạm vi, và bất cứ điều gì chúng ta cố gắng làm với r sẽ không hoạt động đúng. Vậy làm thế nào Rust xác định rằng mã này không hợp lệ? Nó sử dụng một borrow checker.

Borrow Checker (Kiểm tra Mượn)

Trình biên dịch Rust có một borrow checker so sánh phạm vi để xác định liệu tất cả các mượn có hợp lệ hay không. Listing 10-17 hiển thị cùng một mã như Listing 10-16 nhưng có chú thích hiển thị lifetimes của các biến.

fn main() {
    let r;                // ---------+-- 'a
                          //          |
    {                     //          |
        let x = 5;        // -+-- 'b  |
        r = &x;           //  |       |
    }                     // -+       |
                          //          |
    println!("r: {r}");   //          |
}                         // ---------+

Ở đây, chúng ta đã chú thích lifetime của r với 'a và lifetime của x với 'b. Như bạn có thể thấy, khối 'b bên trong nhỏ hơn nhiều so với khối lifetime 'a bên ngoài. Tại thời điểm biên dịch, Rust so sánh kích thước của hai lifetimes và thấy rằng r có lifetime là 'a nhưng nó tham chiếu đến bộ nhớ với lifetime là 'b. Chương trình bị từ chối vì 'b ngắn hơn 'a: chủ thể của tham chiếu không sống lâu bằng tham chiếu.

Listing 10-18 sửa mã để nó không có dangling reference và nó biên dịch mà không có bất kỳ lỗi nào.

fn main() {
    let x = 5;            // ----------+-- 'b
                          //           |
    let r = &x;           // --+-- 'a  |
                          //   |       |
    println!("r: {r}");   //   |       |
                          // --+       |
}                         // ----------+

Ở đây, x có lifetime 'b, trong trường hợp này lớn hơn 'a. Điều này có nghĩa là r có thể tham chiếu x vì Rust biết rằng tham chiếu trong r sẽ luôn hợp lệ trong khi x hợp lệ.

Bây giờ bạn đã biết lifetimes của tham chiếu ở đâu và cách Rust phân tích lifetimes để đảm bảo tham chiếu sẽ luôn hợp lệ, hãy khám phá generic lifetimes của tham số và giá trị trả về trong bối cảnh của các hàm.

Generic Lifetimes trong Hàm

Chúng ta sẽ viết một hàm trả về slice chuỗi dài hơn trong hai slice chuỗi. Hàm này sẽ nhận hai slice chuỗi và trả về một slice chuỗi. Sau khi chúng ta đã triển khai hàm longest, mã trong Listing 10-19 sẽ in ra The longest string is abcd.

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {result}");
}

Lưu ý rằng chúng ta muốn hàm nhận slice chuỗi, là tham chiếu, thay vì chuỗi, vì chúng ta không muốn hàm longest lấy quyền sở hữu các tham số của nó. Tham khảo "String Slices as Parameters" trong Chương 4 để biết thêm thảo luận về lý do tại sao các tham số chúng ta sử dụng trong Listing 10-19 là những tham số mà chúng ta muốn.

Nếu chúng ta cố gắng triển khai hàm longest như trong Listing 10-20, nó sẽ không biên dịch.

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {result}");
}

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() { x } else { y }
}

Thay vào đó, chúng ta nhận được lỗi sau nói về lifetimes:

$ cargo run
   Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0106]: missing lifetime specifier
 --> src/main.rs:9:33
  |
9 | fn longest(x: &str, y: &str) -> &str {
  |               ----     ----     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `x` or `y`
help: consider introducing a named lifetime parameter
  |
9 | fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
  |           ++++     ++          ++          ++

For more information about this error, try `rustc --explain E0106`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error

Văn bản trợ giúp tiết lộ rằng kiểu trả về cần một tham số lifetime generic vì Rust không thể biết liệu tham chiếu được trả về tham chiếu đến x hay y. Thực tế, chúng ta cũng không biết, vì khối if trong thân của hàm này trả về một tham chiếu đến x và khối else trả về một tham chiếu đến y!

Khi chúng ta định nghĩa hàm này, chúng ta không biết các giá trị cụ thể sẽ được truyền vào hàm này, vì vậy chúng ta không biết liệu trường hợp if hay trường hợp else sẽ được thực thi. Chúng ta cũng không biết lifetimes cụ thể của các tham chiếu sẽ được truyền vào, vì vậy chúng ta không thể xem xét phạm vi như chúng ta đã làm trong Listing 10-17 và 10-18 để xác định liệu tham chiếu chúng ta trả về sẽ luôn hợp lệ hay không. Borrow checker cũng không thể xác định điều này, bởi vì nó không biết lifetimes của x và y liên quan đến lifetime của giá trị trả về như thế nào. Để sửa lỗi này, chúng ta sẽ thêm tham số lifetime generic xác định mối quan hệ giữa các tham chiếu để borrow checker có thể thực hiện phân tích của nó.

Cú pháp Chú thích Lifetime

Chú thích lifetime không thay đổi thời gian tồn tại của bất kỳ tham chiếu nào. Thay vào đó, chúng mô tả mối quan hệ của lifetimes của nhiều tham chiếu với nhau mà không ảnh hưởng đến lifetimes. Giống như các hàm có thể chấp nhận bất kỳ kiểu nào khi chữ ký chỉ định một tham số kiểu generic, các hàm có thể chấp nhận tham chiếu với bất kỳ lifetime nào bằng cách chỉ định một tham số lifetime generic.

Chú thích lifetime có cú pháp hơi khác thường: tên của tham số lifetime phải bắt đầu bằng dấu nháy đơn (') và thường đều viết thường và rất ngắn, giống như các kiểu generic. Hầu hết mọi người sử dụng tên 'a cho chú thích lifetime đầu tiên. Chúng ta đặt chú thích tham số lifetime sau dấu & của tham chiếu, sử dụng khoảng cách để phân tách chú thích khỏi kiểu của tham chiếu.

Đây là một số ví dụ: một tham chiếu đến i32 không có tham số lifetime, một tham chiếu đến i32 có tham số lifetime tên 'a, và một tham chiếu có thể thay đổi đến i32 cũng có lifetime 'a.

&i32        // một tham chiếu
&'a i32     // một tham chiếu với lifetime rõ ràng
&'a mut i32 // một tham chiếu có thể thay đổi với lifetime rõ ràng

Một chú thích lifetime tự nó không có nhiều ý nghĩa vì các chú thích được dùng để nói với Rust cách các tham số lifetime generic của nhiều tham chiếu liên quan đến nhau. Hãy xem xét cách chú thích lifetime liên quan đến nhau trong bối cảnh của hàm longest.

Chú thích Lifetime trong Chữ ký Hàm

Để sử dụng chú thích lifetime trong chữ ký hàm, chúng ta cần khai báo các tham số lifetime generic bên trong dấu ngoặc nhọn giữa tên hàm và danh sách tham số, giống như chúng ta đã làm với tham số kiểu generic.

Chúng ta muốn chữ ký thể hiện ràng buộc sau: tham chiếu trả về sẽ hợp lệ miễn là cả hai tham số đều hợp lệ. Đây là mối quan hệ giữa lifetimes của tham số và giá trị trả về. Chúng ta sẽ đặt tên lifetime là 'a và sau đó thêm nó vào mỗi tham chiếu, như trong Listing 10-21.

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {result}");
}

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}