Rust Zelfstudie
Aan de slag met Rust

Opmerkingen

versies

Geavanceerd gebruik van println!

println! (en de broer of zus, print! ) biedt een handig mechanisme voor het produceren en afdrukken van tekst die dynamische gegevens bevat, vergelijkbaar met de printf familie van functies in veel andere talen. Het eerste argument is een opmaakreeks , die bepaalt hoe de andere argumenten als tekst moeten worden afgedrukt. De opmaakreeks kan tijdelijke aanduidingen bevatten (ingesloten in {} ) om aan te geven dat een vervanging moet plaatsvinden:

// 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

Op dit punt kunt u zich afvragen: hoe heeft println! weet om de booleaanse waarde true af te drukken als de string "true"? {} is echt een instructie voor de formatter dat de waarde moet worden geconverteerd naar tekst met behulp van de eigenschap Display . Deze eigenschap is geïmplementeerd voor de meeste primitieve Rust-typen (tekenreeksen, getallen, Booleans, enz.) En is bedoeld voor "gebruikersgerichte uitvoer". Het getal 42 zal dus worden afgedrukt in decimaal als 42, en niet, bijvoorbeeld, in binair getal. Zo wordt het intern opgeslagen.

Hoe kunnen we typen afdrukken die geen Display implementeren, zoals Slices ( [i32] ), vectoren ( Vec<i32> ) of opties ( Option<&str> )? Er is geen duidelijke gebruikersgerichte tekstuele weergave hiervan (dwz een die u triviaal in een zin zou kunnen invoegen). Om het afdrukken van dergelijke waarden te vergemakkelijken, heeft Rust ook de eigenschap Debug en de bijbehorende {:?} aanduiding. Uit de documentatie: " Debug moet de uitvoer in een programmeergerichte, foutopsporingscontext formatteren." Laten we enkele voorbeelden bekijken:

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 ook een ingebouwd mooi printmechanisme, dat je kunt inschakelen met de modifier # na de dubbele punt:

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

Met de indelingsreeksen kunt u vrij complexe vervangingen uitdrukken:

// 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! en vrienden zullen je ook waarschuwen als je iets probeert te doen dat niet werkt, in plaats van te crashen tijdens runtime:

// 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));

In de kern zijn de Rust-afdrukmacro's eenvoudig omwikkeld met het format! macro, waarmee een tekenreeks kan worden gemaakt door tekstrepresentaties van verschillende gegevenswaarden aan elkaar te naaien. Dus voor alle bovenstaande voorbeelden kunt u println! vervangen println! voor format! om de opgemaakte tekenreeks op te slaan in plaats van deze af te drukken:

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

Console-uitvoer zonder macro's

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

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

• De std::io::Write eigenschap is ontworpen voor objecten die bytestreams accepteren. In dit geval wordt een ingang naar standaarduitvoer verkregen met std::io::stdout() .

• Write::write() accepteert een byte-segment ( &[u8] ), die is gemaakt met een letterlijke byte-string ( b"<string>" ). Write::write() retourneert een Result<usize, IoError> , dat het aantal geschreven bytes (bij succes) of een foutwaarde (bij mislukking) bevat.

• De aanroep naar Result::unwrap() geeft aan dat de aanroep naar verwachting zal slagen ( Result<usize, IoError> -> usize ) en de waarde wordt genegeerd.

Minimaal voorbeeld

Om het traditionele Hello World-programma in Rust te schrijven, maakt u een tekstbestand met de naam hello.rs met de volgende broncode:

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

Dit definieert een nieuwe functie genaamd main , die geen parameters accepteert en geen gegevens retourneert. Dit is waar uw programma wordt uitgevoerd wanneer het wordt uitgevoerd. Daarin zit een println! , wat een macro is die tekst in de console afdrukt.

Om een binaire toepassing te genereren, roept u de Rust-compiler op door deze de naam van het bronbestand te geven:

$ rustc hello.rs

Het resulterende uitvoerbare bestand heeft dezelfde naam als de hoofdbronmodule. Voer het volgende uit om het programma op een Linux- of MacOS-systeem uit te voeren:

$ ./hello
Hello World!

Voer op een Windows-systeem het volgende uit:

C:\Rust> hello.exe
Hello World!

Ermee beginnen

installeren

Voordat u iets kunt doen met de programmeertaal Rust, moet u deze aanschaffen - voor Windows of door uw terminal te gebruiken op Unix-achtige systemen, waarbij $ invoer in de terminal symboliseert:

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

Hiermee worden de vereiste bestanden opgehaald en de nieuwste versie van Rust voor u ingesteld, ongeacht het systeem dat u gebruikt. Voor meer informatie, zie projectpagina .

Opmerking: sommige Linux-distributies (bijv. Arch Linux ) bieden rustup als een pakket, dat in plaats daarvan kan worden geïnstalleerd. En hoewel veel Unix-achtige systemen rustc en cargo als afzonderlijke pakketten leveren, wordt het toch aangeraden om in plaats daarvan rustup gebruiken, omdat het veel eenvoudiger is om meerdere rustup te beheren en cross-compilatie te doen.

Roestcompiler

We kunnen nu controleren of Rust daadwerkelijk op onze computers is geïnstalleerd door de volgende opdracht uit te voeren in onze terminal (indien op UNIX) of op de opdrachtprompt (indien op Windows):

$ rustc --version

Als deze opdracht succesvol is, wordt de versie van de compiler van Rust die op onze computers is geïnstalleerd, voor onze ogen weergegeven.

Lading

Met Rust komt Cargo , een bouwtool die wordt gebruikt voor het beheer van uw Rust- pakketten en -projecten. Om er zeker van te zijn dat ook dit aanwezig is op uw computer, voert u het volgende uit in de console — console verwijst naar een terminal of opdrachtprompt, afhankelijk van het systeem dat u gebruikt:

$ cargo --version

Net als het equivalente commando voor de Rust- compiler, zal dit terugkeren en de huidige versie van Cargo weergeven .

Om uw eerste Cargo-project te maken, kunt u naar Cargo gaan .

Als alternatief kun je programma's direct compileren met behulp van rustc zoals getoond in Minimaal voorbeeld .