最新章節(jié)
- Summary
- Other resources for learning Rust
- OS and embedded system development
- Graphics and games
- Web development
- File formats and databases
品牌：中圖公司
上架時(shí)間：2021-07-02 12:43:33
出版社：Packt Publishing
本書數(shù)字版權(quán)由中圖公司提供，并由其授權(quán)上海閱文信息技術(shù)有限公司制作發(fā)行
- Summary 更新時(shí)間：2021-07-02 15:31:03
- Other resources for learning Rust
- OS and embedded system development
- Graphics and games
- Web development
- File formats and databases
- Working with dates and times
- The ecosystem of crates
- The Ecosystem of Crates
- Summary
- Using Rust without the Standard Library
- Filesystem operations
- Error-handling with try!
- Writing a file
- Buffered reading
- Error-handling with try!
- Reading a file
- Paths
- Working with files
- Collections - using hashmaps and hashsets
- Exploring std and the prelude module
- Exploring the Standard Library
- Summary
- Calling Rust from other languages
- Inlining assembly code
- Using a C library
- Interfacing with C
- Raw pointers
- Using std::mem
- When is code unsafe
- Programming at the Boundaries
- Summary
- Synchronous and asynchronous
- Sending references over a channel
- Sending struct values over a channel
- Making a channel
- Sending and receiving data
- Communication through channels
- The Sync trait
- Shared mutable states
- Thread safety
- Panicking threads
- Starting a number of threads
- Setting the thread's stack size
- Creating threads
- Concurrency and threads
- Concurrency - Coding for Multicore Execution
- Summary
- Some other built-in macros
- Using macros from crates
- Some other examples
- Creating a new function
- Repetition
- Developing macros
- Why macros?
- Macros
- Working with random numbers
- Adding external crates to a project
- Exporting a public interface
- Importing external crates
- Importing modules and file hierarchy
- Visibility of items
- Defining a module
- Building crates
- Modules and crates
- Organizing Code and Macros
- Summary
- Overview of pointers
- Reference counting
- Boxes
- Moving closure
- Implementing the Drop trait
- Borrowing a value
- Moving a value
- Ownership
- Ownership and borrowing
- Match struct and ref
- References
- Pointers
- Let's summarize
- Copying and moving values - The copy trait
- Lifetimes
- Stack and heap
- Pointers and references
- Ensuring Memory Safety and Pointers
- Summary
- Using the visitor pattern
- Inheritance with traits
- OOP in Rust
- Built-in traits and operator overloading
- Static and dynamic dispatch
- Using trait constraints
- Traits
- Methods on tuples and enums
- Using a builder pattern
- Using a constructor pattern
- Methods on structs
- Associated functions on structs
- Using Traits and OOP in Rust
- Summary
- The try! macro and the ? operator
- Some more examples of error-handling
- Testing for failure
- Panics
- Error-handling
- Generic data structures and functions
- Consumers and adapters
- Iterators
- Higher order functions and closures
- Higher Order Functions and Error-Handling
- Summary
- Program arguments
- Matching patterns
- Getting input from the console
- Result and Option
- Enums
- Structs
- Tuples
- Strings and arrays
- Slices
- Vectors
- Arrays vectors and slices
- Strings
- Structuring Data and Matching Patterns
- Summary
- The tests module
- Testing with cargo
- Testing
- Conditional compilation
- Attributes
- Documenting a function
- Functions
- Looping
- Branching on a condition
- Using Functions and Control Structures
- Summary
- The stack and the heap
- Expressions
- Aliasing
- Type checking and conversions
- Scope of a variable and shadowing
- Mutable and immutable variables
- Binding variables to values
- Consulting Rust documentation
- Values and primitive types
- Printing with string interpolation
- Global constants
- Comments
- Using Variables and Types
- Summary
- The Standard Library
- Using Sublime Text
- Developer tools
- Working with Cargo
- Our first program
- rustc--the Rust compiler
- Installing Rust
- Servo
- Where to use Rust
- The success of Rust
- The stability of Rust and its evolution
- Comparison with other languages
- The trifecta of Rust - safe fast and concurrent
- The advantages of Rust
- Starting with Rust
- Questions
- Piracy
- Errata
- Downloading the example code
- Customer support
- Conventions
- Who this book is for
- What you need for this book
- What this book covers
- Preface
- Customer Feedback
- Why subscribe?
- www.PacktPub.com
- About the Reviewer
- About the Author
- Credits
- Second Edition
- Rust Essentials
- Copyright
- Second Edition
- Title Page
- coverpage
- coverpage
- Title Page
- Second Edition
- Copyright
- Rust Essentials
- Second Edition
- Credits
- About the Author
- About the Reviewer
- www.PacktPub.com
- Why subscribe?
- Customer Feedback
- Preface
- What this book covers
- What you need for this book
- Who this book is for
- Conventions
- Customer support
- Downloading the example code
- Errata
- Piracy
- Questions
- Starting with Rust
- The advantages of Rust
- The trifecta of Rust - safe fast and concurrent
- Comparison with other languages
- The stability of Rust and its evolution
- The success of Rust
- Where to use Rust
- Servo
- Installing Rust
- rustc--the Rust compiler
- Our first program
- Working with Cargo
- Developer tools
- Using Sublime Text
- The Standard Library
- Summary
- Using Variables and Types
- Comments
- Global constants
- Printing with string interpolation
- Values and primitive types
- Consulting Rust documentation
- Binding variables to values
- Mutable and immutable variables
- Scope of a variable and shadowing
- Type checking and conversions
- Aliasing
- Expressions
- The stack and the heap
- Summary
- Using Functions and Control Structures
- Branching on a condition
- Looping
- Functions
- Documenting a function
- Attributes
- Conditional compilation
- Testing
- Testing with cargo
- The tests module
- Summary
- Structuring Data and Matching Patterns
- Strings
- Arrays vectors and slices
- Vectors
- Slices
- Strings and arrays
- Tuples
- Structs
- Enums
- Result and Option
- Getting input from the console
- Matching patterns
- Program arguments
- Summary
- Higher Order Functions and Error-Handling
- Higher order functions and closures
- Iterators
- Consumers and adapters
- Generic data structures and functions
- Error-handling
- Panics
- Testing for failure
- Some more examples of error-handling
- The try! macro and the ? operator
- Summary
- Using Traits and OOP in Rust
- Associated functions on structs
- Methods on structs
- Using a constructor pattern
- Using a builder pattern
- Methods on tuples and enums
- Traits
- Using trait constraints
- Static and dynamic dispatch
- Built-in traits and operator overloading
- OOP in Rust
- Inheritance with traits
- Using the visitor pattern
- Summary
- Ensuring Memory Safety and Pointers
- Pointers and references
- Stack and heap
- Lifetimes
- Copying and moving values - The copy trait
- Let's summarize
- Pointers
- References
- Match struct and ref
- Ownership and borrowing
- Ownership
- Moving a value
- Borrowing a value
- Implementing the Drop trait
- Moving closure
- Boxes
- Reference counting
- Overview of pointers
- Summary
- Organizing Code and Macros
- Modules and crates
- Building crates
- Defining a module
- Visibility of items
- Importing modules and file hierarchy
- Importing external crates
- Exporting a public interface
- Adding external crates to a project
- Working with random numbers
- Macros
- Why macros?
- Developing macros
- Repetition
- Creating a new function
- Some other examples
- Using macros from crates
- Some other built-in macros
- Summary
- Concurrency - Coding for Multicore Execution
- Concurrency and threads
- Creating threads
- Setting the thread's stack size
- Starting a number of threads
- Panicking threads
- Thread safety
- Shared mutable states
- The Sync trait
- Communication through channels
- Sending and receiving data
- Making a channel
- Sending struct values over a channel
- Sending references over a channel
- Synchronous and asynchronous
- Summary
- Programming at the Boundaries
- When is code unsafe
- Using std::mem
- Raw pointers
- Interfacing with C
- Using a C library
- Inlining assembly code
- Calling Rust from other languages
- Summary
- Exploring the Standard Library
- Exploring std and the prelude module
- Collections - using hashmaps and hashsets
- Working with files
- Paths
- Reading a file
- Error-handling with try!
- Buffered reading
- Writing a file
- Error-handling with try!
- Filesystem operations
- Using Rust without the Standard Library
- Summary
- The Ecosystem of Crates
- The ecosystem of crates
- Working with dates and times
- File formats and databases
- Web development
- Graphics and games
- OS and embedded system development
- Other resources for learning Rust
- Summary 更新時(shí)間：2021-07-02 15:31:03
