Những Khái Niệm Lập Trình Cơ Bản - The Rust Programming Language

1. The Rust Programming Language
2. Foreword
3. Introduction
4. 1. Bắt đầu với Rust
5. 1. 1.1. Cài đặt
   2. 1.2. Hello, World!
   3. 1.3. Hello, Cargo!
6. 2. Lập trình game đoán số
7. 3. Những khái niệm lập trình cơ bản
8. 1. 3.1. Biến và tính khả biến
   2. 3.2. Kiểu dữ liệu
   3. 3.3. Hàm
   4. 3.4. Comments
   5. 3.5. Luồng điều khiển
9. 4. Hiểu về Ownership
10. 1. 4.1. Ownership là gì?
    2. 4.2. Tham chiếu và vay mượn
    3. 4.3. The Slice Type
11. 5. Using Structs to Structure Related Data
12. 1. 5.1. Defining and Instantiating Structs
    2. 5.2. An Example Program Using Structs
    3. 5.3. Method Syntax
13. 6. Enums and Pattern Matching
14. 1. 6.1. Defining an Enum
    2. 6.2. The match Control Flow Operator
    3. 6.3. Concise Control Flow with if let
15. 7. Managing Growing Projects with Packages, Crates, and Modules
16. 1. 7.1. Packages and Crates
    2. 7.2. Defining Modules to Control Scope and Privacy
    3. 7.3. Paths for Referring to an Item in the Module Tree
    4. 7.4. Bringing Paths Into Scope with the use Keyword
    5. 7.5. Separating Modules into Different Files
17. 8. Common Collections
18. 1. 8.1. Storing Lists of Values with Vectors
    2. 8.2. Storing UTF-8 Encoded Text with Strings
    3. 8.3. Storing Keys with Associated Values in Hash Maps
19. 9. Error Handling
20. 1. 9.1. Unrecoverable Errors with panic!
    2. 9.2. Recoverable Errors with Result
    3. 9.3. To panic! or Not to panic!
21. 10. Generic Types, Traits, and Lifetimes
22. 1. 10.1. Generic Data Types
    2. 10.2. Traits: Defining Shared Behavior
    3. 10.3. Validating References with Lifetimes
23. 11. Writing Automated Tests
24. 1. 11.1. How to Write Tests
    2. 11.2. Controlling How Tests Are Run
    3. 11.3. Test Organization
25. 12. An I/O Project: Building a Command Line Program
26. 1. 12.1. Accepting Command Line Arguments
    2. 12.2. Reading a File
    3. 12.3. Refactoring to Improve Modularity and Error Handling
    4. 12.4. Developing the Library’s Functionality with Test Driven Development
    5. 12.5. Working with Environment Variables
    6. 12.6. Writing Error Messages to Standard Error Instead of Standard Output
27. 13. Functional Language Features: Iterators and Closures
28. 1. 13.1. Closures: Anonymous Functions that Can Capture Their Environment
    2. 13.2. Processing a Series of Items with Iterators
    3. 13.3. Improving Our I/O Project
    4. 13.4. Comparing Performance: Loops vs. Iterators
29. 14. More about Cargo and Crates.io
30. 1. 14.1. Customizing Builds with Release Profiles
    2. 14.2. Publishing a Crate to Crates.io
    3. 14.3. Cargo Workspaces
    4. 14.4. Installing Binaries from Crates.io with cargo install
    5. 14.5. Extending Cargo with Custom Commands
31. 15. Smart Pointers
32. 1. 15.1. Using Box to Point to Data on the Heap
    2. 15.2. Treating Smart Pointers Like Regular References with the Deref Trait
    3. 15.3. Running Code on Cleanup with the Drop Trait
    4. 15.4. Rc, the Reference Counted Smart Pointer
    5. 15.5. RefCell and the Interior Mutability Pattern
    6. 15.6. Reference Cycles Can Leak Memory
33. 16. Fearless Concurrency
34. 1. 16.1. Using Threads to Run Code Simultaneously
    2. 16.2. Using Message Passing to Transfer Data Between Threads
    3. 16.3. Shared-State Concurrency
    4. 16.4. Extensible Concurrency with the Sync and Send Traits
35. 17. Object Oriented Programming Features of Rust
36. 1. 17.1. Characteristics of Object-Oriented Languages
    2. 17.2. Using Trait Objects That Allow for Values of Different Types
    3. 17.3. Implementing an Object-Oriented Design Pattern
37. 18. Patterns and Matching
38. 1. 18.1. All the Places Patterns Can Be Used
    2. 18.2. Refutability: Whether a Pattern Might Fail to Match
    3. 18.3. Pattern Syntax
39. 19. Advanced Features
40. 1. 19.1. Unsafe Rust
    2. 19.2. Advanced Traits
    3. 19.3. Advanced Types
    4. 19.4. Advanced Functions and Closures
    5. 19.5. Macros
41. 20. Final Project: Building a Multithreaded Web Server
42. 1. 20.1. Building a Single-Threaded Web Server
    2. 20.2. Turning Our Single-Threaded Server into a Multithreaded Server
    3. 20.3. Graceful Shutdown and Cleanup
43. 21. Appendix
44. 1. 21.1. A - Keywords
    2. 21.2. B - Operators and Symbols
    3. 21.3. C - Derivable Traits
    4. 21.4. D - Useful Development Tools
    5. 21.5. E - Editions
    6. 21.6. F - Translations of the Book
    7. 21.7. G - How Rust is Made and “Nightly Rust”

• Light (default)
• Rust
• Coal
• Navy
• Ayu

The Rust Programming Language Những khái niệm lập trình cơ bản

Chương này đề cập đến những 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 cốt lõi chung. Không có khái niệm nào trong chương này là độc nhất ở Rust, nhưng chúng ta sẽ thảo luận về chúng trong ngữ cảnh của Rust và giải thích những quy ước xung quanh việc sử dụng những khái niệm này.

Đặc biệt, bạn sẽ học về biến, những kiểu cơ bản, hàm, comment và luồng điều khiển. Những điều này sẽ nằm trong mọi chương trình Rust, và học chúng sớm sẽ cho bạn một nền móng vững chắc để bắt đầu.

Từ khóa

Ngôn ngữ Rust có một bộ các từ khóa (keyword) được dành riêng và chỉ được sử dụng bới ngôn ngữ, giống như trong những ngôn ngữ khác. Hãy luôn nhớ rằng bạn không thể dùng những từ này cho tên biến hay tên hàm. Hầu hết các từ khóa có ý nghĩa đặc biệt, bạn sẽ dùng chúng để làm nhiều loại tác vụ trong chương trình Rust của bạn; một vài từ khóa hiện tại chưa có tính năng liên quan nhưng sẽ được sử dụng trong tương lai. Bạn có thể xem danh sách từ khóa ở Phụ lục A.