Rust Samouczek
Pierwsze kroki z Rustem

Uwagi

Wersje

Zaawansowane wykorzystanie println!

println! (i jego rodzeństwo, print! ) zapewnia wygodny mechanizm do tworzenia i drukowania tekstu zawierającego dane dynamiczne, podobny do rodziny funkcji printf w wielu innych językach. Pierwszym argumentem jest ciąg formatu , który określa, jak inne argumenty powinny być drukowane jako tekst. Łańcuch formatu może zawierać symbole zastępcze (zawarte w {} ), aby określić, że powinno nastąpić podstawienie:

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

W tym momencie możesz zapytać: Jak to się println! wiedzieć, aby wydrukować wartość logiczną true jako ciąg „true”? {} jest tak naprawdę instrukcją dla formatyzatora, że wartość należy przekonwertować na tekst za pomocą cechy Display . Ta cecha została zaimplementowana dla większości prymitywnych typów rdzy (łańcuchy, liczby, booleany itp.) I jest przeznaczona do „wyjścia użytkownika”. Dlatego liczba 42 zostanie wydrukowana dziesiętnie jako 42, a nie, powiedzmy, w systemie binarnym, czyli w jaki sposób jest przechowywana wewnętrznie.

Jak zatem drukujemy typy, które nie implementują Display , przykładami są plastry ( [i32] ), wektory (w Vec<i32> ) lub opcje (w Option<&str> )? Nie ma wyraźnej reprezentacji tekstowej dla użytkownika (tzn. Takiej, którą można w prosty sposób wstawić do zdania). Aby ułatwić drukowanie takich wartości, Rust ma również cechę Debug i odpowiedni symbol zastępczy {:?} . Z dokumentacji: „ Debug powinno sformatować dane wyjściowe w kontekście debugowania skierowanym do programisty”. Zobaczmy kilka przykładów:

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 ma również wbudowany mechanizm ładnego drukowania, który można włączyć za pomocą modyfikatora # po dwukropku:

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

Ciągi formatujące pozwalają wyrazić dość złożone podstawienia :

// 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! a przyjaciele będą Cię ostrzegać, jeśli próbujesz zrobić coś, co nie zadziała, zamiast zawieszać się w czasie wykonywania:

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

U ich podstaw makra drukujące Rust są po prostu owijkami wokół format! makro, które pozwala na konstruowanie łańcucha poprzez połączenie tekstowych reprezentacji różnych wartości danych. Dlatego we wszystkich powyższych przykładach możesz zastąpić println! dla format! aby zapisać sformatowany ciąg zamiast go wydrukować:

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

Dane wyjściowe konsoli bez makr

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

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

• Cecha std::io::Write jest przeznaczona dla obiektów, które akceptują strumienie bajtów. W takim przypadku uchwyt standardowego wyjścia jest uzyskiwany za pomocą std::io::stdout() .

• Write::write() akceptuje kawałek bajtu ( &[u8] ), który jest tworzony za pomocą literału bajtu-ciągu ( b"<string>" ). Write::write() zwraca Result<usize, IoError> , który zawiera albo liczbę zapisanych bajtów (w przypadku powodzenia), albo wartość błędu (w przypadku niepowodzenia).

• Wywołanie Result::unwrap() wskazuje, że oczekuje się, że wywołanie zakończy się powodzeniem ( Result<usize, IoError> -> usize ), a wartość zostanie odrzucona.

Minimalny przykład

Aby napisać tradycyjny program Hello World w Rust, utwórz plik tekstowy o nazwie hello.rs zawierający następujący kod źródłowy:

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

Definiuje to nową funkcję o nazwie main , która nie przyjmuje parametrów i nie zwraca danych. W tym miejscu program rozpoczyna wykonywanie po uruchomieniu. Wewnątrz masz println! , czyli makro, które drukuje tekst w konsoli.

Aby wygenerować aplikację binarną, wywołaj kompilator Rust, przekazując mu nazwę pliku źródłowego:

$ rustc hello.rs

Wynikowy plik wykonywalny będzie miał taką samą nazwę jak główny moduł źródłowy, więc aby uruchomić program w systemie Linux lub MacOS, uruchom:

$ ./hello
Hello World!

W systemie Windows uruchom:

C:\Rust> hello.exe
Hello World!

Pierwsze kroki

Instalowanie

Zanim będziesz mógł cokolwiek zrobić przy użyciu języka programowania Rust, musisz go nabyć - dla Windows lub przy użyciu terminala w systemach uniksowych , gdzie $ symbolizuje wejście do terminala:

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

Spowoduje to pobranie wymaganych plików i skonfigurowanie najnowszej wersji Rust, bez względu na to, jaki system używasz. Aby uzyskać więcej informacji, zobacz stronę projektu .

Uwaga: Niektóre dystrybucje Linuksa (np. Arch Linux ) zapewniają rustup jako pakiet, który można zamiast tego zainstalować. I chociaż wiele systemów uniksowych zapewnia rustc i cargo jako osobne pakiety, nadal zaleca się stosowanie rustup zamiast tego, ponieważ znacznie ułatwia zarządzanie wieloma kanałami wydania i kompilację krzyżową.

Kompilator rdzy

Możemy teraz sprawdzić, czy Rust rzeczywiście został pomyślnie zainstalowany na naszych komputerach, uruchamiając następujące polecenie w naszym terminalu - jeśli w systemie UNIX - lub w wierszu polecenia - w systemie Windows:

$ rustc --version

Polecenie to powinno być udane, wersja kompilatora Rust „s zainstalowane na naszych komputerach pojawi się na naszych oczach.

Ładunek

Wraz z Rustem pojawia się Cargo , narzędzie do kompilacji używane do zarządzania pakietami i projektami Rust . Aby upewnić się, że to również jest obecne na komputerze, uruchom następujące polecenie w konsoli - konsolę odnoszącą się do terminala lub wiersza polecenia, w zależności od używanego systemu:

$ cargo --version

Podobnie jak równoważne polecenie kompilatora Rust , spowoduje to powrót i wyświetlenie bieżącej wersji Cargo .

Aby stworzyć swój pierwszy projekt Cargo, możesz udać się do Cargo .

Alternatywnie, możesz kompilować programy bezpośrednio przy użyciu rustc jak pokazano w przykładzie Minimal .