Exécuter avec `cargo run`

Simplifier le cycle de développement avec `cargo run`

Dans le flux de travail quotidien d'un développeur Rust, la capacité à tester rapidement les modifications apportées au code est primordiale. La commande `cargo run` est un outil essentiel fourni par Cargo, le gestionnaire de projet et de construction de Rust, qui rationalise ce processus. Elle combine intelligemment les étapes de compilation et d'exécution de votre projet en une seule commande, vous faisant gagner du temps et simplifiant votre interaction avec l'écosystème Rust.

Au lieu d'exécuter `cargo build` pour compiler, puis de naviguer manuellement vers le répertoire `target/` pour lancer votre exécutable, `cargo run` s'occupe de tout. Il vérifie si des changements ont été faits depuis la dernière compilation, recompile si nécessaire, puis lance immédiatement le binaire principal de votre projet. Cette fluidité est particulièrement appréciable lors des phases de développement itératif où les cycles de test sont fréquents.

Ce guide vous expliquera en détail comment utiliser `cargo run`, comment il interagit avec les profils de compilation (debug et release), comment exécuter des binaires ou des exemples spécifiques, et comment passer des arguments à votre programme, afin que vous puissiez intégrer efficacement cette commande dans votre routine de développement.

Fonctionnement de base et profils de compilation

La forme la plus simple de la commande est `cargo run` exécutée à la racine de votre projet Rust :

# Compile (si des modifications ont été apportées) et exécute le binaire principal
$ cargo run

Par défaut, `cargo run` effectue plusieurs actions :

1. Il vérifie si le code source ou les dépendances ont été modifiés depuis la dernière compilation.
2. Si des modifications sont détectées (ou si aucune compilation n'a encore eu lieu), il compile le projet en utilisant le profil debug. Cela signifie que les optimisations sont minimales pour une compilation rapide, et que les informations de débogage sont incluses. Les artéfacts sont placés dans `target/debug/`.
3. Une fois la compilation terminée avec succès, il exécute le binaire principal du projet. Si votre projet a un `src/main.rs`, c'est cet exécutable qui sera lancé.

Tout comme avec `cargo build`, vous pouvez demander à `cargo run` de compiler et d'exécuter votre projet en mode release, ce qui active les optimisations pour de meilleures performances. Pour cela, utilisez l'option `--release` :

# Compile (si nécessaire) en mode release et exécute le binaire principal
$ cargo run --release

L'utilisation de `--release` avec `cargo run` est recommandée lorsque vous souhaitez tester les performances de votre application ou son comportement dans des conditions optimisées, bien que pour des benchmarks formels, il soit souvent préférable de séparer la compilation (`cargo build --release`) de l'exécution manuelle pour un contrôle plus fin.

Si aucune modification n'a été apportée au code source ou aux dépendances depuis la dernière compilation réussie avec le même profil, `cargo run` ne recompilera pas le projet et exécutera directement le binaire existant, ce qui rend les exécutions répétées très rapides.

Exécuter des binaires spécifiques et des exemples

Un projet Rust peut contenir plusieurs cibles exécutables. En plus du binaire principal défini par `src/main.rs`, vous pouvez avoir des binaires supplémentaires dans le répertoire `src/bin/` ou des exemples dans le répertoire `examples/`. `cargo run` vous permet de spécifier quelle cible exécuter.

Si votre projet a un `src/main.rs` et, par exemple, un fichier `src/bin/outil_special.rs`, `cargo run` sans arguments supplémentaires exécutera le binaire issu de `src/main.rs`. Pour exécuter `outil_special`, vous devez utiliser l'option `--bin` :

# Exécute le binaire nommé 'outil_special' (défini dans src/bin/outil_special.rs)
$ cargo run --bin outil_special

De même, pour exécuter un exemple situé dans `examples/mon_exemple.rs`, vous utiliserez l'option `--example` :

# Exécute l'exemple nommé 'mon_exemple' (défini dans examples/mon_exemple.rs)
$ cargo run --example mon_exemple

Ces options peuvent bien sûr être combinées avec `--release` si vous souhaitez exécuter une cible spécifique en mode optimisé :

$ cargo run --bin outil_special --release
$ cargo run --example mon_exemple --release

Cette flexibilité est cruciale pour les projets qui fournissent plusieurs outils CLI ou qui ont une suite d'exemples pour démontrer différentes fonctionnalités de la bibliothèque. `cargo run` simplifie le lancement de n'importe lequel de ces exécutables sans avoir à se souvenir de leurs chemins exacts dans le répertoire `target/`.

Passer des arguments à votre programme

Très souvent, les applications en ligne de commande (CLI) ou même d'autres types de programmes ont besoin de recevoir des arguments lors de leur lancement. `cargo run` facilite la transmission de ces arguments à votre exécutable.

Pour passer des arguments à votre programme via `cargo run`, vous devez d'abord ajouter un séparateur spécial `--` après toutes les options de `cargo run` (comme `--release`, `--bin`, etc.). Tous les arguments qui suivent ce séparateur `--` seront transmis directement à votre programme et ne seront pas interprétés par Cargo lui-même.

Par exemple, supposons que votre application `mon_app` (définie dans `src/main.rs`) accepte un nom de fichier en argument et une option `-v` pour la verbosité :

# Exécute mon_app en lui passant 'mon_fichier.txt' et '-v' comme arguments
$ cargo run -- mon_fichier.txt -v

Si vous souhaitez exécuter cela en mode release :

# Exécute mon_app en mode release, en lui passant les mêmes arguments
$ cargo run --release -- mon_fichier.txt -v

Et si `mon_app` était un binaire spécifique `outil_cli` :

# Exécute le binaire 'outil_cli' en lui passant les arguments
$ cargo run --bin outil_cli -- mon_fichier.txt -v

Le séparateur `--` est crucial. Sans lui, Cargo essaierait d'interpréter `mon_fichier.txt` ou `-v` comme des options pour `cargo run` lui-même, ce qui entraînerait probablement une erreur. A l'intérieur de votre code Rust, vous accéderiez à ces arguments via les fonctions du module `std::env`, typiquement `std::env::args()` ou en utilisant une crate populaire de parsing d'arguments comme `clap`.

Voici un exemple simple de programme Rust qui affiche ses arguments :

// src/main.rs
use std::env;

fn main() {
    println!("Arguments reçus :");
    for (i, arg) in env::args().enumerate() {
        println!("Argument {}: {}", i, arg);
    }
}

Si vous compilez et exécutez ceci avec `cargo run -- arg1 --flag value`, la sortie ressemblerait à :

Arguments reçus :
Argument 0: target/debug/nom_du_projet
Argument 1: arg1
Argument 2: --flag
Argument 3: value

(Notez que le premier argument, `args().nth(0)`, est généralement le chemin vers l'exécutable lui-même).

`cargo run` est donc un outil polyvalent et indispensable pour le développeur Rust, offrant un moyen rapide et pratique de compiler, exécuter et tester des programmes avec différentes configurations et entrées.