Rust Nybegynnerguide: Fra spill til programmering, raskt innblikk i Rust-økosystemet

Rust er i rask utvikling, og det er ikke bare et programmeringsspråk, men også et levende økosystem. Fra overlevelsesspill til høytytende systemprogrammering, Rust er overalt. Denne artikkelen vil ta utgangspunkt i diskusjoner på X/Twitter og gi en rask innføring for Rust-nybegynnere, som dekker Rusts bruksområder, læringsressurser og noen praktiske verktøy.

I. Hva er Rust? Hvorfor er det verdt å lære?

Rust er et systemprogrammeringsspråk som fokuserer på sikkerhet, hastighet og samtidighet. Det er designet for å løse vanlige minnesikkerhetsproblemer i C og C++, samtidig som det gir ytelse som er lik eller bedre enn disse språkene.

Rusts fordeler:

• Minnesikkerhet: Rusts eierskapssystem og lånekontrollør kan forhindre problemer som nullpekerfeil og datakonkurranse ved kompilering.
• Høy ytelse: Rust kompileres til effektiv maskinkode og har kraftige abstraksjonsmuligheter uten kostnad.
• Samtidighetssikkerhet: Rusts typesystem kan sikre sikkerheten til samtidig kode og unngå datakonkurranse.
• Kryssplattform: Rust støtter flere operativsystemer og arkitekturer, inkludert Windows, Linux, macOS, WebAssembly osv.
• Aktivt fellesskap: Rust har et levende fellesskap som tilbyr et bredt spekter av biblioteker, verktøy og støtte.

Rusts bruksområder:

• Operativsystemer og innebygde systemer: På grunn av sin høye ytelse og sikkerhet er Rust svært godt egnet for utvikling av operativsystemkjerner, drivere og programvare for innebygde enheter.
• WebAssembly (Wasm): Rust kan kompileres til Wasm, slik at du kan kjøre høytytende kode i nettleseren.
• Kommandolinjeverktøy: Rust tilbyr kraftige rammeverk for utvikling av kommandolinjeverktøy, som clap og structopt.
• Nettverksprogrammering: Rusts tokio-bibliotek tilbyr en asynkron kjøretid, noe som gjør det enklere å skrive høytytende nettverksapplikasjoner.
• Spillutvikling: Selv om det ikke er like utbredt som C++, er Rust i ferd med å gjøre seg bemerket innen spillutvikling. For eksempel er det åpne overlevelsesspillet Rust i seg selv utviklet med Unity-motoren og C#, men deler av serverlogikken kan optimaliseres med Rust for bedre ytelse.

II. Fra spillet Rust til programmeringsspråket Rust

Diskusjonen på X/Twitter nevnte overlevelsesspillet Rust, som har en sterk tilknytning til programmeringsspråket Rust. Selv om de bruker samme navn, er de forskjellige ting. Rust-spillet er et online overlevelsesspill for flere spillere, mens Rust er et programmeringsspråk som brukes til å bygge ulike typer programvare.

Spillet Rust:

• Er et online overlevelsesspill for flere spillere der spillerne må overleve i villmarken, bygge baser og samhandle med andre spillere.
• Er utviklet med Unity-motoren og C#.
• Kan kjøpes på Steam og har ofte kampanjer.

Programmeringsspråket Rust:

• Brukes til å utvikle ulike typer programvare, inkludert operativsystemer, nettlesermotorer, nettverksservere, spill osv.
• Er åpen kildekode og kryssplattform.
• Har et kraftig typesystem og minnesikkerhetsfunksjoner.

Hvis du er en Rust-spiller og ønsker å lære programmeringsspråket Rust, kan du vurdere følgende trinn:

1. Installer Rust-verktøykjeden: Last ned og installer rustup fra , det er Rusts versjonsadministrasjonsverktøy.
2. Lær grunnleggende Rust-kunnskaper: Les den offisielle veiledningen "The Rust Programming Language" (også kjent som "The Book") for å lære om Rusts grunnleggende syntaks, eierskapssystem, lånekontrollør osv.
3. Praktiske prosjekter: Styrk kunnskapen din ved å skrive enkle kommandolinjeverktøy, webservere eller spill.
4. Delta i fellesskapet: Bli med i Rust-fellesskapet, kommuniser med andre Rust-utviklere og lær av deres erfaringer.## III. Oppsett av Rust-utviklingsmiljø

Det er veldig enkelt å sette opp et Rust-utviklingsmiljø, du trenger bare å installere rustup. rustup vil automatisk installere Rust-kompilatoren, standardbiblioteket og andre nødvendige verktøy.

Fremgangsmåte:

1. Last ned rustup: Gå til og last ned den tilsvarende rustup-installasjonsprogrammet for ditt operativsystem.
2. Kjør installasjonsprogrammet: Følg instruksjonene i installasjonsprogrammet.
3. Konfigurer miljøvariabler: rustup vil automatisk konfigurere miljøvariabler, men du kan også konfigurere dem manuelt.
4. Bekreft installasjonen: Åpne terminalen og kjør rustc --version og cargo --version. Hvis versjonsnummeret vises korrekt, betyr det at installasjonen er vellykket.

Kodeeksempel:

rustc --version  # Sjekk Rust-kompilatorversjonen
cargo --version  # Sjekk Cargo-pakkebehandlerversjonen

IV. Rask innføring i grunnleggende Rust-syntaks

Her er noen grunnleggende Rust-syntakser som kan hjelpe deg raskt i gang:

• Variabeldeklarasjon:

  let x = 5;          // Immutable variabel (kan ikke endres)
  let mut y = 10;     // Mutabel variabel (kan endres)
  const PI: f64 = 3.1415926; // Konstant
  

• Datatyper:

  • Heltall: i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, isize, usize

  • Flyttall: f32, f64

  • Boolsk: bool (true, false)

  • Karakter: char (Unicode-karakter)

  • Streng: String, &str

  • Tupler: (i32, f64, char)

  • Arrays: [i32; 5]

  • Slices: &[i32]

  • Struktur:

    struct Point {
        x: i32,
        y: i32,
    }
    

  • Enum:

enum Color { Red, Green, Blue, }

*   **Funksjoner:**

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

*   **Kontrollflyt:**

    *   `if`-setning:

        ```rust
        if x > 5 {
            println!("x is greater than 5");
        } else if x == 5 {
            println!("x is equal to 5");
        } else {
            println!("x is less than 5");
        }
        ```

    *   `loop`-løkke:

        ```rust
        loop {
            println!("This will loop forever");
            break; // Avslutt løkken
        }
        ```*   `while`-løkke:

        ```rust
        let mut i = 0;
        while i < 5 { // Fortsett å kjøre løkken så lenge i er mindre enn 5
            println!("verdien er: {}", i);
            i = i + 1; // Øk i med 1 for hver iterasjon
        }
        ```

*   `for`-løkke:

        ```rust
        let a = [10, 20, 30, 40, 50];

        for element in a.iter() { // Iterer gjennom hvert element i arrayet a
            println!("verdien er: {}", element);
        }
        ```

*   `loop`-løkke:

        ```rust
        let mut counter = 0;

        let result = loop { // En uendelig løkke som må brytes manuelt
            counter += 1;

            if counter == 10 {
                break counter * 2; // Bryt løkken og returner counter * 2
            }
        };

        println!("Resultatet er {}", result);
        ```

## Tre. Eierskap og Låning

Rusts eierskapssystem er en av dens mest unike og kraftfulle funksjoner. Det tillater Rust å garantere minnesikkerhet uten behov for en søppeloppsamler.

*   **Eierskap:** Hver verdi i Rust har en variabel som kalles dens *eier*. Det kan bare være én eier om gangen. Når eieren går ut av scope, vil verdien bli droppet (frigjort).
*   **Låning:** Låning tillater flere referanser til data uten å ta eierskap. Det finnes to typer lån: *immutable* lån (`&`) og *mutable* lån (`&mut`). Det kan være flere immutable lån, men bare ett mutable lån om gangen.

    ```rust
    fn main() {
        let s1 = String::from("hello");
        let s2 = &s1; // immutable lån

        println!("s1 is: {}, s2 is: {}", s1, s2);

        let mut s3 = String::from("hello");
        let s4 = &mut s3; // mutable lån
        s4.push_str(", world!");

        println!("s3 is: {}, s4 is: {}", s3, s4);
    }
    ```

## Fire. Feilhåndtering

Rust bruker et `Result`-enum for å håndtere feil. `Result` har to varianter: `Ok(T)` som representerer en suksessfull operasjon, og `Err(E)` som representerer en feil.

*   **`Result` Enum:**

    ```rust
    enum Result {
        Ok(T),
        Err(E),
    }
    ```

*   **Håndtering av `Result`:**

    ```rust
    use std::fs::File;
    use std::io::ErrorKind;

    fn main() {
        let f = File::open("hello.txt");

        let f = match f { // Bruk match for å håndtere Result
            Ok(file) => file,
            Err(error) => match error.kind() {
                ErrorKind::NotFound => match File::create("hello.txt") {
                    Ok(fc) => fc,
                    Err(e) => panic!("Problem creating the file: {:?}", e),
                },
                other_error => {
                    panic!("Problem opening the file: {:?}", other_error)
                }
            },
        };
    }
    ```

## Fem. Praktiske Verktøy og Læringsressurser

*   **Cargo:** Rusts pakkebehandler og byggeverktøy, brukt for å administrere avhengigheter, bygge prosjekter og kjøre tester.
*   **Rust Analyzer:** En kraftig Rust-språkserver som tilbyr kodefullføring, syntakssjekk, refaktorering og mer. Anbefales å installere den tilhørende plugin-en i VS Code.
*   **Clippy:** Et statisk analyseverktøy for Rust-kode som kan sjekke koden for potensielle problemer og gi forbedringsforslag.
*   **crates.io:** Rusts pakkelager, lignende npm (JavaScript) eller PyPI (Python).
*   **Offisiell dokumentasjon:** Inneholder komplett dokumentasjon for Rust-språket.
*   **Rust by Example:** Tilbyr et stort antall Rust-kodeeksempler.
*   **The Rust Programming Language (The Book):** Rusts offisielle opplæring, sterkt anbefalt å lese.
*   **Rustlings:** Et interaktivt Rust-læringsverktøy som lærer Rust ved å løse en rekke øvelser.
*   **Online kurs:** Plattformer som Udemy, Coursera osv. har mange Rust-onlinekurs.

## Seks. Dybdelæringsretninger

*   **Asynkron programmering (async/await):** Bruk `tokio` eller `async-std` for å skrive høyytelses samtidige programmer.
*   **WebAssembly (Wasm):** Kompiler Rust-kode til Wasm for å kjøre i nettleseren.
*   **Innebygd utvikling:** Bruk Rust til å utvikle programvare for innebygde systemer.
*   **Blokkjedeutvikling:** Bruk Rust til å utvikle blokkjedeapplikasjoner, for eksempel Solana sin smartkontraktutvikling.

## Syv. OppsummeringRust er et programmeringsspråk som er både utfordrende og svært verdifullt. Det tilbyr kraftig sikkerhet og ytelse, og har et aktivt fellesskap. Gjennom denne introduksjonen håper vi å hjelpe deg raskt i gang med Rust, og starte din Rust-programmeringsreise. Utforsk mysteriene til programmeringsspråket Rust, med utgangspunkt i spillet `Rust`, og du vil oppdage en helt ny verden.