Kodexempel

Låt oss titta på hur Rust-kod ser ut jämfört med Python som du redan känner till.

Grundläggande syntax

// En enkel funktion i Rust - jämför med def i Python
fn hej(namn: &str) -> String {  // Här visar vi att funktionen tar en textsträng och returnerar en String
    format!("Hej, {}!", namn)   // Detta motsvarar Python's f"Hej, {namn}!"
}

fn main() {  // Alla Rust-program börjar med en main-funktion - som en startpunkt
    let mitt_namn = "Värld";    // Variabeldeklaration med "let" (som i JavaScript)
    println!("{}", hej(mitt_namn));  // println! är en makro - lite som Pythons print()
}

Vad är annorlunda från Python?

• Du måste deklarera funktioner med fn istället för def
• Du måste ange vilken typ av data en funktion tar och returnerar (&str och String)
• Semikolon (;) används för att avsluta de flesta rader (som i C#, JavaScript)
• Kommentarer börjar med // istället för #

Ägandeskap och lån

Detta koncept är unikt för Rust och finns inte i Python eller JavaScript:

fn main() {
    // Ägandeskap - tänk på det som "vem som äger data"
    let s1 = String::from("hej");  // s1 "äger" denna sträng 
    let s2 = s1;                   // Här flyttas ägandeskapet till s2!
    
    // Detta skulle ge kompileringsfel eftersom s1 inte längre "äger" datan:
    // println!("{}", s1);
    
    // I Python/JavaScript skulle båda variablerna ha tillgång till samma data
    // Men i Rust måste det finnas exakt EN ägare åt gången
    
    // Lån istället - som att låna en bok från ett bibliotek
    let s3 = String::from("hej igen");
    let s4 = &s3;  // s4 "lånar" från s3 (notera &-tecknet)
    
    // Nu är båda giltiga eftersom s4 bara lånar, inte tar över
    println!("{} {}", s3, s4);
    
    // Detta är hur Rust förhindrar buggar som uppstår när flera delar av 
    // programmet ändrar samma data samtidigt
}

Hur skiljer sig detta från Python?

• I Python kan många variabler peka på samma objekt och ändra det, vilket kan leda till svårhittade buggar
• Rust tvingar dig att vara tydlig med vem som "äger" data och vem som bara "lånar", vilket förhindrar många buggar

Enum och mönstermatchning

Detta liknar if-satser i Python, men mycket kraftfullare:

// Enum är som en specialversion av klasser i Python
enum Result {
    Success(String),  // En variant som innehåller en sträng
    Failure(String),  // En annan variant som också innehåller en sträng
}

fn operation() -> Result {
    // Simulerar en operation som kan lyckas eller misslyckas
    Result::Success(String::from("Det fungerade!"))
}

fn main() {
    // Match är som en superkraftig "switch" eller "if/elif/else"
    // Du måste hantera ALLA möjliga fall!
    match operation() {
        Result::Success(meddelande) => {
            println!("Lyckades: {}", meddelande)
        }
        Result::Failure(fel) => {
            println!("Misslyckades: {}", fel)
        }
    }
    
    // I Unity/Godot skulle detta likna en State Machine
    // I Python skulle du använda if/elif/else och behöva testa typer manuellt
}

Fördelar jämfört med Python:

• Kompilatorn kontrollerar att du hanterat alla möjliga fall - inget glöms bort
• Du kan direkt "packa upp" data inuti varianter (som i Success(meddelande))
• Detta gör felhantering mycket mer robust än att använda try/except i Python

Dessa grundläggande koncept gör Rust-kod mer robust och förutsägbar, vilket är viktigt när du bygger större system som spel eller webbservrar!