Why Front‑End Developers Should Learn Rust: A Quick Overview of Its Core Features

1. What is Rust

Rust is a general‑purpose compiled language led by Mozilla, designed for safety, concurrency, and practicality, supporting functional, concurrent, procedural, and object‑oriented programming styles.

2. Language Features

Rust’s syntax is close to Haskell; every part of a function body is an expression, even control‑flow operators.

Memory safety: no null pointers, dangling pointers, or data races; values must be initialized before use.

Memory management: uses RAII instead of automatic garbage collection, with optional reference counting.

Ownership: each value has a unique owner, and the value’s lifetime matches the owner’s scope.

Type polymorphism: Rust’s trait system, inspired by Haskell, provides ad‑hoc polymorphism.

3. Data Types

Rust includes integer, floating‑point, boolean, character, and compound types.

Integer types: signed (i8, i16, i32, i64, i128) and unsigned (u8, u16, u32, u64, u128). The default integer type is i32.

let a = 10; // i32
let b: i64 = 20; // i64

Floating‑point types: f32 and f64, with f64 as the default.

let a = 10.0; // f64
let b: f32 = 20.0; // f32

Boolean type (bool) holds true or false.

Character type (char) is a 4‑byte Unicode scalar value. let c = 'a'; Compound types include arrays (fixed length), tuples, and structs.

let arr = [1, 2, 3, 4, 5];
let tup: (i32, f32, char) = (10, 20.0, 'a');

4. Structs

Structs are similar to TypeScript interfaces.

struct Person {
    name: String,
    sex: String,
    age: u32,
}
let p1 = Person { name: String::from("abc"), sex: String::from("male"), age: 18 };
let p2 = Person { name: String::from("123"), ..p1 };

5. Enums

enum Phone { IPhone, Huawei }

Enums are used with match statements for pattern matching, similar to a switch.

enum Phone {
    IPhone(u32),
    Huawei { url: String },
}
let phone = Phone::IPhone(123);
match phone {
    Phone::IPhone(i) => println!("{}", i),
    Phone::Huawei { url } => println!("{}", url),
}

6. Ownership

Ownership is Rust’s compile‑time memory‑management mechanism.

// Move
let s1 = String::from("hello");
let s2 = s1; // s1 is now invalid
// Clone
let s1 = String::from("hello");
let s2 = s1.clone();
println!("s1 = {}, s2 = {}", s1, s2);