Rust Handledning
Komma igång med Rust

Anmärkningar

versioner

Avancerad användning av println!

println! (och dess syskon, print! ) ger en bekväm mekanism för att producera och skriva ut text som innehåller dynamiska data, liknande den printf familj av funktioner som finns på många andra språk. Det första argumentet är en formatsträng som dikterar hur de andra argumenten ska skrivas ut som text. Formatsträngen kan innehålla platshållare (medföljande i {} ) för att ange att en ersättning ska ske:

// No substitution -- the simplest kind of format string
println!("Hello World");
// Output: Hello World

// The first {} is substituted with a textual representation of
// the first argument following the format string. The second {}
// is substituted with the second argument, and so on.
println!("{} {} {}", "Hello", true, 42);
// Output: Hello true 42

Vid den här punkten kanske du frågar: Hur gjorde println! vet du att skriva ut det booleska värdet true som strängen "sant"? {} är verkligen en instruktion till formateraren att värdet ska konverteras till text med hjälp av Display drag. Denna egenskap är implementerad för de flesta primitiva rosttyper (strängar, siffror, booléer, etc.) och är avsedd för "användarvänt utgång". Därför kommer numret 42 att skrivas ut i decimal som 42 och inte, säg, binärt, vilket är hur det lagras internt.

Hur skriver vi ut typer som inte implementerar Display , exempelvis skivor ( [i32] ), vektorer ( Vec<i32> ) eller alternativ ( Option<&str> )? Det finns ingen tydlig användarvänlig textrepresentation av dessa (dvs en som du trivialt kan infoga i en mening). För att underlätta utskriften av sådana värden har Rust också Debug och motsvarande {:?} Platshållare. Från dokumentationen: " Debug ska formatera utdata i ett programmerare-vänd, felsökningssammanhang." Låt oss se några exempel:

println!("{:?}", vec!["a", "b", "c"]);
// Output: ["a", "b", "c"]

println!("{:?}", Some("fantastic"));
// Output: Some("fantastic")

println!("{:?}", "Hello");
// Output: "Hello"
// Notice the quotation marks around "Hello" that indicate
// that a string was printed.

Debug har också en inbyggd ganska utskriftsmekanism som du kan aktivera genom att använda modifieraren # efter kolon:

println!("{:#?}", vec![Some("Hello"), None, Some("World")]);
// Output: [
//    Some(
//        "Hello"
//    ),
//    None,
//    Some(
//        "World"
//    )
// ]

Formatsträngarna låter dig uttrycka ganska komplexa ersättningar :

// You can specify the position of arguments using numerical indexes.
println!("{1} {0}", "World", "Hello");
// Output: Hello World

// You can use named arguments with format
println!("{greeting} {who}!", greeting="Hello", who="World");
// Output: Hello World

// You can mix Debug and Display prints:
println!("{greeting} {1:?}, {0}", "and welcome", Some(42), greeting="Hello");
// Output: Hello Some(42), and welcome

println! och vänner varnar dig också om du försöker göra något som inte fungerar, snarare än att krascha vid körning:

// This does not compile, since we don't use the second argument.
println!("{}", "Hello World", "ignored");

// This does not compile, since we don't give the second argument.
println!("{} {}", "Hello");

// This does not compile, since Option type does not implement Display
println!("{}", Some(42));

I sin kärna är Rust-utskriftsmakroerna helt enkelt omslag i format! makro, som gör det möjligt att konstruera en sträng genom att sy samman textrepresentation av olika datavärden. Således kan du ersätta println! för alla exemplen ovan println! för format! att lagra den formaterade strängen istället för att skriva ut den:

let x: String = format!("{} {}", "Hello", 42);
assert_eq!(x, "Hello 42");

Konsolutgång utan makron

// use Write trait that contains write() function
use std::io::Write;

fn main() {
    std::io::stdout().write(b"Hello, world!\n").unwrap();
}

• std::io::Write är utformat för objekt som accepterar byte-strömmar. I detta fall förvärvas ett handtag till standardutgång med std::io::stdout() .

• Write::write() accepterar en byteskiva ( &[u8] ), som skapas med en byte-sträng bokstavs ( b"<string>" ). Write::write() returnerar ett Result<usize, IoError> , som antingen innehåller antalet skrivna byte (om framgång) eller ett felvärde (vid fel).

• Samtalet till Result::unwrap() indikerar att samtalet förväntas lyckas ( Result<usize, IoError> -> usize ) och värdet tas bort.

Minimalt exempel

För att skriva det traditionella Hello World-programmet i Rust skapar du en textfil som heter hello.rs innehåller följande källkod:

fn main() {
    println!("Hello World!");
}

Detta definierar en ny funktion som kallas main , som inte tar några parametrar och returnerar inga data. Det är här programmet startar körning när den körs. Inne i det har du ett println! , som är ett makro som skriver ut text i konsolen.

För att generera en binär applikation, anropa Rust-kompilatorn genom att lämna den namnet på källfilen:

$ rustc hello.rs

Den resulterande körbara har samma namn som huvudkällmodulen, så för att köra programmet på ett Linux- eller MacOS-system, kör:

$ ./hello
Hello World!

Kör på ett Windows-system:

C:\Rust> hello.exe
Hello World!

Komma igång

installera

Innan du kan göra något med programmeringsspråket Rust, kommer du att behöva skaffa det - antingen för Windows eller genom att använda din terminal på Unix-liknande system, där $ symboliserar ingång till terminalen:

$ curl https://sh.rustup.rs -sSf | sh

Detta hämtar de nödvändiga filerna och ställer in den senaste versionen av Rust åt dig, oavsett vilket system du använder. För mer information, se projektsidan .

Obs: Vissa Linux-distributioner (t.ex. Arch Linux ) ger rustup som ett paket som kan installeras istället. Och även om många Unix-liknande system ger rustc och cargo som separata paket, rekommenderas det fortfarande att använda rustup istället eftersom det gör det mycket enklare att hantera flera frigörande kanaler och göra korssammanställning.

Rust Compiler

Vi kan nu kontrollera om Rust faktiskt framgångsrikt installerades på våra datorer genom att köra följande kommando antingen i vår terminal - om på UNIX - eller kommandotolken - om i Windows:

$ rustc --version

Om detta kommando lyckas kommer versionen av Rusts kompilator installerad på våra datorer att visas inför våra ögon.

Frakt

Med Rust kommer Cargo , som är ett byggverktyg som används för att hantera dina Rust- paket och projekt. För att säkerställa att detta också finns på din dator, kör följande inuti konsolen - konsol som refererar till antingen terminal eller kommandotolk beroende på vilket system du använder:

$ cargo --version

Precis som det motsvarande kommandot för Rust- kompilatorn kommer detta att återgå och visa den aktuella versionen av Cargo .

För att skapa ditt första Cargo-projekt kan du gå till Cargo .

Alternativt kan du sammanställa program direkt med hjälp av rustc som visas i Minimal exempel .