Rust Tutoriel
Démarrer avec Rust

Remarques

Versions

Utilisation avancée de println!

println! (et ses frères et sœurs, print! ) fournit un mécanisme pratique pour produire et imprimer du texte contenant des données dynamiques, similaire à la famille de fonctions printf dans de nombreux autres langages. Son premier argument est une chaîne de format qui dicte comment les autres arguments doivent être imprimés en tant que texte. La chaîne de format peut contenir des espaces réservés (entourés de {} ) pour indiquer qu'une substitution doit avoir lieu:

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

À ce stade, vous demandez peut-être: comment est-ce que println! savoir imprimer la valeur booléenne true comme la chaîne "true"? {} est vraiment une instruction au formateur que la valeur doit être convertie en texte en utilisant le trait d' Display . Ce trait est implémenté pour la plupart des types de rouille primitifs (chaînes, nombres, booléens, etc.) et est destiné à la "sortie de l’utilisateur". Par conséquent, le nombre 42 sera imprimé en décimal sous la forme 42, et non, par exemple, en binaire, ce qui correspond à la manière dont il est stocké en interne.

Comment pouvons-nous imprimer les types qui n'implémentent pas Display , par exemple les Slices ( [i32] ), les vecteurs ( Vec<i32> ) ou les options ( Option<&str> )? Il n'y a pas de représentation textuelle claire de celles-ci (c.-à-d. Que vous pourriez insérer dans une phrase). Pour faciliter l'impression de telles valeurs, Rust possède également le trait Debug et l'espace réservé {:?} Correspondant. Dans la documentation: "Le Debug doit formater la sortie dans un contexte de débogage orienté programmeur." Voyons quelques exemples:

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 possède également un mécanisme de jolie impression intégré, que vous pouvez activer en utilisant le modificateur # après les deux points:

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

Les chaînes de format permettent d'exprimer des substitutions assez complexes :

// 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! et vos amis vous avertiront également si vous essayez de faire quelque chose qui ne fonctionnera pas, plutôt que de vous écraser à l'exécution:

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

À la base, les macros d’impression Rust sont simplement des wrappers autour du format! macro, qui permet de construire une chaîne en assemblant des représentations textuelles de différentes valeurs de données. Ainsi, pour tous les exemples ci-dessus, vous pouvez remplacer println! pour le format! stocker la chaîne formatée au lieu de l'imprimer:

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

Sortie de console sans macros

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

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

• Le trait std::io::Write est conçu pour les objets qui acceptent les flux d'octets. Dans ce cas, un handle vers la sortie standard est acquis avec std::io::stdout() .

• Write::write() accepte une tranche d'octets ( &[u8] ), qui est créée avec un littéral d'octet ( b"<string>" ). Write::write() renvoie un Result<usize, IoError> , qui contient soit le nombre d'octets écrits (en cas de succès), soit une valeur d'erreur (en cas d'échec).

• L'appel à Result::unwrap() indique que l'appel est censé réussir ( Result<usize, IoError> -> usize ) et que la valeur est ignorée.

Exemple minimal

Pour écrire le programme Hello World traditionnel dans Rust, créez un fichier texte appelé hello.rs contenant le code source suivant:

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

Ceci définit une nouvelle fonction appelée main , qui ne prend aucun paramètre et ne renvoie aucune donnée. C'est là que votre programme démarre l'exécution lorsqu'il est exécuté. A l'intérieur, vous avez une println! , qui est une macro qui imprime du texte dans la console.

Pour générer une application binaire, appelez le compilateur Rust en lui transmettant le nom du fichier source:

$ rustc hello.rs

L'exécutable résultant aura le même nom que le module source principal, donc pour exécuter le programme sur un système Linux ou MacOS, exécutez:

$ ./hello
Hello World!

Sur un système Windows, exécutez:

C:\Rust> hello.exe
Hello World!

Commencer

Installation

Avant de pouvoir faire quoi que ce soit en utilisant le langage de programmation Rust, vous devrez l’acquérir - soit pour Windows, soit en utilisant votre terminal sur des systèmes de type Unix, où $ symbolise l’entrée dans le terminal:

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

Cela permettra de récupérer les fichiers requis et de configurer la dernière version de Rust pour vous, quel que soit le système sur lequel vous vous trouvez. Pour plus d'informations, voir la page du projet .

Note: Certaines distributions Linux (par exemple Arch Linux ) fournissent un rustup tant que paquet pouvant être installé à la place. Et bien que de nombreux systèmes de type Unix fournissent du rustc et du cargo comme paquets séparés, il est toujours recommandé d'utiliser plutôt rustup car il est beaucoup plus facile de gérer plusieurs canaux de version et de faire de la compilation croisée.

Compilateur de rouille

Nous pouvons maintenant vérifier si Rust a bien été installé sur nos ordinateurs en exécutant la commande suivante dans notre terminal - sous UNIX - ou à l'invite de commande - sous Windows:

$ rustc --version

Si cette commande réussit, la version du compilateur Rust installé sur nos ordinateurs sera affichée sous nos yeux.

Cargaison

Avec Rust vient Cargo , qui est un outil de construction utilisé pour gérer vos packages et vos projets Rust . Pour vous assurer que ceci est également présent sur votre ordinateur, exécutez la commande suivante dans la console: console faisant référence à un terminal ou à une invite de commande selon le système sur lequel vous vous trouvez:

$ cargo --version

Tout comme la commande équivalente pour le compilateur Rust , cela renverra et affichera la version actuelle de Cargo .

Pour créer votre premier projet Cargo, vous pouvez vous rendre à Cargo .

Alternativement, vous pouvez compiler des programmes directement en utilisant rustc comme indiqué dans Exemple minimal .