KaiserY/trpl-zh-cn

Features

• Chinese Language Translations - Provides a comprehensive translation of official Rust language guides and technical specifications into Simplified Chinese.
• Rust Resources - Provides educational materials and technical guides for mastering the Rust programming language in Simplified Chinese.
• Rust - Provides a comprehensive educational resource and localized guide for learning the Rust programming language.
• Variant Data Association - Describes the capability to attach varying types and quantities of data directly to enum variants.
• Data Structure Definitions - Covers the definition of named types and structures to group related data.
• Fixed-Size Collections - Provides instruction on using stack-allocated arrays of constant length.
• Technical Documentation Localizations - Translates technical guides and professional resources from English to Simplified Chinese to increase global accessibility.
• Ownership-Based Memory Management - Rust enforces rules that ensure each value has a single owner and is cleaned up when it leaves scope.
• Composite Types - Guides the use of tuples to group multiple values of different types into a single structure.
• Conditional Logic - Instructs on using boolean expressions to control the execution flow of code blocks.
• Conditional Loop Execution - Teaches the use of infinite, conditional, and for loops for repetitive code execution.
• Primitive Data Types - Rust uses primitive scalars and compound types to categorize data and ensure type safety during computation.
• Dynamic String Management - Explains the initialization and management of growable, mutable UTF-8 strings.
• String Slices - Provides comprehensive guides on utilizing non-owning string slices for efficient memory management.
• Enumeration Definitions - Explains how to define custom enumeration types to represent a set of predefined variants.
• Equality Comparisons - Instructs on using equality operators to compare field values and variant types.
• Scalar Type Declarations - Covers the declaration and usage of boolean truth values in conditional expressions.
• Numeric Computation Execution - Explains the execution of basic mathematical calculations across all numeric types.
• Ordering Comparisons - Teaches the use of comparison operators to determine relative order for sorting and range operations.
• Ownership Transfer Mechanisms - Rust transfers ownership of heap-allocated data from one variable to another to prevent double-free errors.
• Pattern-Based Value Comparison - Describes the use of pattern-based branching with compiler-enforced exhaustiveness.
• Pattern Matching - Explains how to use pattern matching to execute specific logic branches based on data shape.
• Reference Lifetime Management - Rust provides the compiler with information about reference relationships to ensure they remain valid during execution.
• Reference-Based Data Access - Rust accesses a value stored by another variable without taking ownership of it.
• Stack Data Copying - Rust duplicates simple scalar values with a fixed size without invalidating the original variable.
• Integer Overflow Detections - Describes how the language handles integer overflows via panics, wrapping, or checked methods.
• Variable Mutability Controls - Guides users on controlling variable mutability and immutability within the language.
• Variable Shadowing - Teaches how to transform values while maintaining immutability through variable shadowing.
• Floating-Point Types - Details the use of signed 32-bit and 64-bit floating-point numeric types.
• Value Duplication - Rust creates copies of a value through deep copy processes or fast bitwise copies.
• PDF Exports - Produces portable PDF versions of technical guides for offline reading.
• Static Markdown Documentation - Utilizes a markdown-based system to generate static HTML pages for web hosting.
• EPUB Authoring Tools - Implements a build process to transform technical documentation into EPUB electronic book formats.
• Multi-Format Document Exports - Supports exporting technical documentation into multiple formats including PDF and EPUB for offline use.
• Static Site Generators - Implements a system to convert markdown source files into static HTML pages for documentation hosting.
• Technical Content Organizers - Organizes technical definitions and instructional content into a hierarchical modular structure for better readability.
• Collection Iteration - Provides guidance on traversing elements within arrays or slices using immutable or mutable references.
• Struct Visibility Control - Details how to create public structures with selectively public fields or fully exposed enumerations.
• Key Retrievals - Describes looking up values associated with specific keys and returning them as optional references.
• Debug Formatting - Explains how to produce programmer-readable representations of type instances for debugging.
• Language Servers - Describes the integration of the Language Server Protocol to provide IDE features like autocompletion.
• Toolchain Versioning - Details how to manage and switch between different Rust release channels and toolchain versions.
• Automatic Reference Coercions - Describes how Rust automatically adds or removes references to match the required signature of a method receiver.
• Compile-Time Constants - Instructs on defining immutable constants at compile time that remain valid for the entire program duration.
• Custom Type Grouping - Teaches how to bundle related values into custom types to improve code readability and intent.
• Debug Formatting - Rust outputs the internal state of a custom type to the console using developer-friendly formatting.
• Dynamic Array Storage - Explains the use of growable sequences on the heap that can change size during execution.
• Dynamic Strings - Details the use of heap-allocated dynamic strings that can be modified at runtime.
• String Mutation - Describes adding string slices or characters to the end of an existing string to increase its length.
• Panic Triggers - Details how to halt program execution immediately when a result contains an unrecoverable error.
• Generic Types - Covers the use of type parameters to create structures and functions that work across multiple types.
• Trait-Based Polymorphism - Explains how to specify sets of methods that different types must implement to enable generic code restrictions.
• Getter Method Patterns - Explains creating methods that share names with internal fields to provide controlled access to private data.
• Hash Map Implementation - Covers associating specific keys with corresponding values using hash maps for efficient retrieval.
• Identifier Escaping - Describes the use of raw identifier symbols to use reserved keywords as valid names.
• Instance Method Definitions - Instructs on creating functions bound to object instances that operate on instance state using self.
• Ownership-Based Race Prevention - Rust enforces rules where only one mutable reference or multiple immutable references can exist at once.
• Mutable Reference Updates - Rust updates a borrowed value using a mutable reference if the original variable is mutable.
• Ownership Transfer - Rust moves a value into a function as an argument or transfers ownership back via a return value.
• Named Type Aliases - Provides instructional content on creating named type aliases to provide unique identities to groups of values.
• Associated Functions - Explains the creation of functions namespaced to a type that serve as constructors.
• String Iterators - Details the process of traversing a string by accessing individual Unicode scalar values or bytes.
• Slices and Sequence Referencing - Teaches how to create references to contiguous sequences of elements using slices.
• String Concatenation Operations - Explains combining multiple strings into one using operators or formatting macros.
• String-to-Numeric Conversions - Provides instructions on parsing strings and converting them into specified integer types.
• Type-Specific Method Implementation - Teaches how to define associated functions and methods to specify the logic a specific data structure can perform.
• Unrecoverable Error Management - Covers strategies for utilizing panics to handle critical system failures and unrecoverable errors.
• Data Type Validation - Demonstrates how to encapsulate validation logic within type constructors to ensure data integrity.
• Default Type Instances - Demonstrates how to generate standard default instances of a type using the Default trait.
• Error Propagation Systems - Instructs on mechanisms for handling and propagating errors through application hierarchies in Rust.
• Question Mark Error Propagation - Explains the use of the ? operator for concise error propagation from Result types.
• Error Variant Matching - Teaches how to inspect the kind of error returned to execute specific recovery logic based on the cause.
• Item Visibility Control - Rust restricts access to code by defaulting items to private and selectively marking them public.
• Lifetime-Based Reference Validation - Rust guarantees that references always point to valid memory by blocking code where data is dropped too early.
• Enum Method Implementations - Teaches how to define reusable logic on an enumeration type to perform actions based on the enum value.
• Optional Value Types - Explains the use of optional value types to explicitly handle the presence or absence of data and prevent null-pointer errors.
• Collection Indexing - Covers retrieving values from collections via direct indexing or safe methods that return optional values.
• Stack Trace Generation - Rust generates a call stack backtrace to identify the specific line of code that triggered a crash.
• Typed Error Management - Provides guidance on using type-safe mechanisms like Result to manage recoverable errors.
• Static HTML Generators - Converts source markdown files into static HTML pages for web-based documentation hosting.

Star history