Rust Executor

Run and test Rust code directly in the browser.

Version

Sample

💡 Rust Basics Guide

1. Declaring Variables and Constants

Use let to declare variables. Use const for constants and mut for mutable variables.

let x = 10;
let pi: f64 = 3.14;
let name = "Alice";
let is_active = true;

const MAX_USERS: u32 = 100;

2. Conditionals (if / match)

Rust uses if for conditions and match for pattern matching.

let x = 2;
if x == 1 {
    println!("One");
} else if x == 2 {
    println!("Two");
} else {
    println!("Other");
}

match x {
    1 => println!("One"),
    2 => println!("Two"),
    _ => println!("Other"),
}

3. Loops

Rust supports for, while, and infinite loop.

for i in 0..3 {
    println!("{}", i);
}

let mut n = 3;
while n > 0 {
    println!("{}", n);
    n -= 1;
}

4. Arrays

Fixed-size arrays in Rust use square brackets. Use slices for views.

let nums = [10, 20, 30];
println!("{}", nums[1]);

5. Vectors (Dynamic Arrays)

Vec is used for dynamic arrays.

let mut fruits = vec!["apple", "banana"];
fruits.push("cherry");
fruits.pop();

for fruit in &fruits {
    println!("{}", fruit);
}

6. Console Input/Output

Use println! for output and std::io for input.

use std::io;

let mut name = String::new();
println!("Enter your name:");
io::stdin().read_line(&mut name).unwrap();
println!("Hello, {}", name.trim());

Rust Basics Guide

7. Functions

Functions use fn and can return values using ->.

fn greet(name: &str) -> String {
    format!("Hello, {}", name)
}

println!("{}", greet("Alice"));

8. HashMaps

Use std::collections::HashMap for key-value data.

use std::collections::HashMap;

let mut person = HashMap::new();
person.insert("name", "Bob");
println!("{}", person["name"])

9. Error Handling

Rust handles errors using Result and match or unwrap().

fn fail() -> Result<(), String> {
    Err("Something went wrong".to_string())
}

match fail() {
    Ok(_) => println!("Success"),
    Err(e) => println!("{}", e),
}

10. File I/O

Use std::fs to read and write files.

use std::fs;

fs::write("file.txt", "Hello File").unwrap();
let content = fs::read_to_string("file.txt").unwrap();
println!("{}", content);

11. String Manipulation

Strings in Rust are heap-allocated and support many methods.

let mut text = String::from(" Hello Rust ");
println!("{}", text.trim());
println!("{}", text.to_uppercase());
text = text.replace("Hello", "Hi");
println!("{}", text);

12. Structs & Methods

Rust uses struct for data types and impl for methods.

struct Person {
    name: String,
}

impl Person {
    fn greet(&self) -> String {
        format!("Hi, I'm {}", self.name)
    }
}

let p = Person { name: "Alice".to_string() };
println!("{}", p.greet());

13. References & Borrowing

Rust uses & to borrow values and &mut for mutable references.

fn update(x: &mut i32) {
    *x += 1;
}

let mut value = 10;
update(&mut value);
println!("{}", value);