Zero To Mastery: Rust 101 Crash Course: Learn Rust (6 HOURS!) + 19 Practice Exercises | Zero To Mastery

Welcome to the Rust 101 crash course by Jason Lennon, brought to you by Zero to Mastery. Jason brings a unique perspective as a self-taught developer turned university student, enabling him to simplify complex topics effectively.

Jason emphasizes learning by doing, starting from Rust fundamentals with 19 activities in this course. For deeper learning, his Rust Bootcamp offers advanced topics and two major projects: a billing app and a clipboard web service.

Rust combines high-level language features with no performance penalties. Its compiler enforces program behavior, enhancing reliability. It has built-in dependency management like npm and a welcoming developer community.

Key Rust features include first-class multi-threading with compiler checks for safe data access, an advanced type system for catching bugs early, and a flexible module system. Adding dependencies is simple, and tools help generate docs and format code.

Rust requires a clean slate approach to learning: avoid assumptions from other languages to prevent frustrating errors. The course builds concepts gradually with over 40 coding exercises to solidify understanding.

Data types in Rust include Boolean, integers, floating points, characters, and strings. Memory stores binary data, but Rust abstracts this so programmers work at a higher level, defining what the binary represents.

Variables in Rust assign data to memory locations. By default, variables are immutable for safety and performance, but can be made mutable with 'mut'. Variables simplify memory management by abstracting address handling.

Functions encapsulate code functionality, accept parameters, and optionally return data. Rust functions start with 'fn', have named parameters with types, and use '->' to specify return types. Function bodies are enclosed in curly braces.

The println! macro prints to the terminal and differs from functions by expanding into code. It supports debug printing with {:?} and can include variables directly in strings for developer-friendly output.

Control flow in Rust uses if, else if, and else statements to branch execution based on conditions. Conditions evaluate to true or false, guiding which code blocks run. Nested if-else allows complex decision trees.

Loops enable repetition: 'loop' creates infinite loops requiring manual breaks, while 'while' loops run while a condition is true. Loops simplify tasks like counting or processing collections.

Setting up Rust involves installing rustup, Visual Studio Code, and build tools. rustup manages Rust versions, VS Code is a compatible IDE, and build tools compile Rust code. Installation steps vary by OS but are straightforward.

Code comments in Rust use '//' for single lines and '///' for documentation comments. Comments improve code readability and maintainability, explaining intent without cluttering logic. Use descriptive variable names to reduce the need for comments.

Rust supports arithmetic operators: addition, subtraction, multiplication, division, and remainder. Functions can perform operations, returning results with explicit types, making math in Rust clear and type-safe.

Structs group related data into a single type with named fields. Each field must be initialized. Structs improve code organization by bundling data logically, accessed via dot notation.

Tuples store fixed-size collections of heterogeneous data without named fields. Useful for returning multiple values from functions and destructuring into variables. Keep tuples concise to maintain code clarity.

Ownership in Rust ensures memory safety without a garbage collector. Variables own data; ownership can be moved or borrowed. Borrowing with '&' allows multiple references without transferring ownership, preventing use-after-free errors.

Vectors are growable arrays storing elements of the same type. Use Vec macro to create, push to add elements, pop to remove, and iterate with for-in loops. Vectors maintain insertion order.

Strings in Rust come as owned String or borrowed string slices (&str). Use owned Strings in structs and slices for function parameters. Convert slices to owned Strings with to_owned() or String::from().

Enums define types that can be one of several variants, optionally holding data. Combined with match expressions, enums enable robust, exhaustive handling of all cases, improving code safety and clarity.

The Option type represents optional values: Some(T) for present data or None for absence. Useful for nullable fields or fallible operations. Match on Option to handle presence or absence explicitly.

The Result type models success or failure with Ok(T) and Err(E). Used for fallible functions like file I/O or network calls. Match on Result to handle errors gracefully or use the '?' operator for concise error propagation.

HashMaps store key-value pairs for fast lookup by key. Use insert to add entries, get to retrieve values, and iterate over keys, values, or entries. Keys must be unique; values can be any type.