Rust Programming Language Cheatsheet

Rust is a powerful and modern programming language known for its focus on performance, memory safety, and zero-cost abstractions. Whether you’re a seasoned Rust developer or just getting started, having a handy cheat sheet can be incredibly useful. This cheat sheet aims to provide a quick reference guide to essential Rust concepts, syntax, and common patterns.

1. Hello, Rust!

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

• fn: Keyword for defining a function.
• main(): The entry point of every Rust program.
• println!: A macro for printing to the console.

2. Variables and Data Types

let x = 5;                // Immutable variable
let mut y = 10;            // Mutable variable
let message = "Hello";     // String
let is_true = true;        // Boolean
let count: u32 = 100;       // Unsigned 32-bit integer

• let: Keyword for variable binding.
• mut: Keyword for declaring a mutable variable.
• Data types include integers (i32, u64), floating-point (f64), booleans (bool), and strings (&str, String).

3. Control Flow

Conditional Statements

let number = 7;

if number > 5 {
    println!("Number is greater than 5");
} else if number == 5 {
    println!("Number is 5");
} else {
    println!("Number is less than 5");
}

Loops

// While loop
let mut counter = 0;
while counter < 5 {
    println!("Counter: {}", counter);
    counter += 1;
}

// For loop
for i in 0..5 {
    println!("Index: {}", i);
}

4. Functions

fn add(x: i32, y: i32) -> i32 {
    x + y
}

let result = add(3, 5);
println!("Result: {}", result);

• Functions are defined using the fn keyword.
• Parameters and return types are specified with type annotations.

5. Ownership and Borrowing

// Ownership
let s1 = String::from("Hello");
let s2 = s1; // s1 is no longer valid, ownership transferred to s2

// Borrowing
let s3 = String::from("World");
let len = calculate_length(&s3); // Pass a reference to s3
println!("Length of '{}' is: {}", s3, len);

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

• Rust’s ownership system prevents data races and memory issues.
• References (&) are used to borrow data without transferring ownership.

6. Structs and Enums

// Struct
struct Point {
    x: f64,
    y: f64,
}

let origin = Point { x: 0.0, y: 0.0 };

// Enum
enum Direction {
    Up,
    Down,
    Left,
    Right,
}

let player_direction = Direction::Right;

• struct defines a structure with named fields.
• enum creates a type with multiple possible values.

7. Error Handling

// Result type
fn divide(x: f64, y: f64) -> Result<f64, &'static str> {
    if y == 0.0 {
        Err("Cannot divide by zero")
    } else {
        Ok(x / y)
    }
}

match divide(10.0, 2.0) {
    Ok(result) => println!("Result: {}", result),
    Err(err) => println!("Error: {}", err),
}

• Result type is commonly used for functions that can return an error.

8. Modules and Packages

// Module in a separate file (math.rs)
pub mod math {
    pub fn square(x: i32) -> i32 {
        x * x
    }
}

// Main file
use math::square;

let result = square(5);
println!("Square: {}", result);

• Rust uses modules to organize code, and packages to distribute code.

This cheat sheet provides a glimpse into the key aspects of Rust programming. Remember that Rust encourages a strong understanding of ownership, borrowing, and lifetimes to write safe and performant code. Keep this cheat sheet close as you explore the depths of Rust and build robust applications.

This cheatsheet covers some of the fundamental concepts in Rust. Make sure to refer to the official Rust documentation for more in-depth information and advanced features.

FAQ