Apprendre Rust en déboguant Rust


  • FrançaisFrançais



  • Dans mon article précédent sur rustup, je vous ai montré comment installer la chaîne d’outils Rust. Eh bien, à quoi sert la chaîne d’outils si vous ne l’utilisez pas pour vous familiariser avec Rust ? Apprendre n’importe quel langage implique de lire le code existant et d’écrire de nombreux exemples de programmes. C’est un bon moyen de maîtriser une langue. Cependant, il existe une troisième voie : le débogage du code.

    L’apprentissage par le débogage implique d’essayer de compiler un exemple de programme pré-écrit (bogué), de comprendre les erreurs générées par le compilateur, de corriger l’exemple de code, puis de le recompiler. Répétez ce processus jusqu’à ce que le code se compile et s’exécute avec succès.

    Bruissements est un projet open source de l’équipe Rust qui vous aide à apprendre Rust à travers le processus de débogage. Il vous fournit également de nombreux conseils en cours de route. Si vous êtes un débutant à Rust et que vous avez commencé ou terminé la lecture du livre Rust, alors les bruissements sont la prochaine étape idéale. Rustlings vous aide à appliquer ce que vous avez appris du livre et à passer à des projets plus importants.

    Pose de bruissements

    J’utilise (et recommande) une machine Fedora pour essayer les bruissements, mais n’importe quelle distribution Linux fonctionne. Pour installer des bruissements, vous devez télécharger et exécuter son script d’installation. Il est recommandé de le faire en tant qu’utilisateur normal (pas root) sans aucun privilège spécial.

    N’oubliez pas que pour pouvoir utiliser les bruissements, vous avez besoin de la chaîne d’outils Rust disponible sur votre système. Si vous ne l’avez pas déjà, veuillez vous référer à mon article sur Rustup.

    Une fois que vous êtes prêt, téléchargez le script d’installation :

    $ curl -L https://raw.githubusercontent.com/rust-lang/rustlings/main/install.sh  > rustlings_install.sh
    $ file rustlings_install.sh
    rustlings_install.sh: Bourne-Again shell script, ASCII text executable

    Inspectez le script pour savoir ce qu’il fait :

    $ less rustlings_install.sh

    Et puis lancez-le pour installer:

    $ bash rustlings_install.sh
    [...]
    Installing /home/tux/.cargo/bin/rustlings
    Installed package `rustlings v4.8.0 (/home/tux/rustlings)` (executable `rustlings`)
    All done!

    Exécutez « bruissements » pour commencer.

    Exercices de bruissements

    L’installation vous offre la rustlings commande. Exécutez-le avec le --help drapeau pour voir quelles options sont disponibles.

    $ rustlings --help

    Le script d’installation clone également le référentiel Git de rustlings et installe toutes les dépendances requises pour exécuter les exemples de programmes. Vous pouvez consulter les exemples de programmes dans le répertoire des exercices sous rustlings:

    $ cd rustlings
    $ pwd
    /home/tux/rustlings
    $ ls
    AUTHORS.md  Cargo.toml        CONTRIBUTING.md  info.toml install.sh README.md  target Cargo.lock  CHANGELOG.md  exercises install.ps1  LICENSE src tests
    $ ls -m exercises/
    advanced_errors, clippy, collections, conversions, enums, error_handling, functions, generics, if, intro, macros, mod.rs,
    modules, move_semantics, option, primitive_types, quiz1.rs, quiz2.rs, quiz3.rs, quiz4.rs, README.md,
    standard_library_types, strings, structs, tests, threads, traits, variables

    Lister tous les exercices depuis la ligne de commande

    La rustlings commande vous fournit un list commande qui affiche chaque exemple de programme, son chemin d’accès complet et son état (qui par défaut est en attendant.)

    $ rustlings list
    Name         Path                                 Status
    intro1       exercises/intro/intro1.rs            Pending
    intro2       exercises/intro/intro2.rs            Pending
    variables1   exercises/variables/variables1.rs    Pending
    variables2   exercises/variables/variables2.rs    Pending
    variables3   exercises/variables/variables3.rs    Pending
    [...]

    Vers la fin de la sortie, vous recevez un rapport d’avancement afin que vous puissiez suivre votre travail.

    Progress: You completed 0 / 84 exercises (0.00 %).

    Voir des exemples de programmes

    La rustings list La commande vous montre quels programmes sont disponibles, donc à tout moment vous pouvez voir le code de ces programmes en copiant les chemins complets dans votre terminal comme argument pour les commandes cat ou less :

    $ cat exercises/intro/intro1.rs

    Vérifiez vos programmes

    Vous pouvez maintenant commencer à déboguer les programmes. Vous pouvez le faire en utilisant le verify commande. Notez que bruissements choisit le premier programme de la liste (intro1.rs), tente de le compiler et réussit :

    $ rustlings verify
    Progress: [-----------------------------------] 0/84
    ✅ Successfully ran exercises/intro/intro1.rs!

    You can keep working on this exercise,
    or jump into the next one by removing the `I AM NOT DONE` comment:

     6 |  // Execute the command `rustlings hint intro1` for a hint.
     7 |  
     8 |  // I AM NOT DONE
     9 |

    Comme vous pouvez le voir sur la sortie, même si l’exemple de code se compile, il reste du travail à faire. Chaque exemple de programme a le commentaire suivant dans son fichier source :

    $ grep "NOT DONE" exercises/intro/intro1.rs
    // I AM NOT DONE

    Bien que la compilation du premier programme ait bien fonctionné, les bruissements ne passeront pas au programme suivant tant que vous n’aurez pas supprimé le I AM NOT DONE commentaire.

    Programmation et développement

    Passer à l’exercice suivant

    Une fois que vous avez supprimé le commentaire de intro1.rsvous pouvez passer à l’exercice suivant en exécutant le rustlings verify commander à nouveau. Cette fois, vous remarquerez peut-être que les bruissements tentent de compiler le programme suivant (intro2.rs) dans la série, mais rencontre une erreur. Vous êtes censé déboguer ce problème, le résoudre, puis aller de l’avant. Il s’agit d’une étape critique, vous permettant de comprendre pourquoi Rust dit qu’un programme a des bogues.

    $ rustlings verify
    Progress: [>------------------------] 1/84
    ⚠️  Compiling of exercises/intro/intro2.rs failed! Please try again. Here's the output:
    error: 1 positional argument in format string, but no arguments were given
     --> exercises/intro/intro2.rs:8:21
      |
    8 |         println!("Hello {}!");
      |                         ^^

    error: aborting due to previous error

    Obtenir un indice

    Rustlings a une pratique hint argument, qui vous indique exactement ce qui ne va pas avec l’exemple de programme et comment le réparer. Vous pouvez le considérer comme une option d’aide complémentaire, en plus de ce que vous indique le message d’erreur du compilateur.

    $ rustlings hint intro2
    Add an argument after the format string.

    Sur la base de l’indice ci-dessus, la réparation du programme est facile. Tout ce que vous avez à faire est d’ajouter un argument supplémentaire à la println déclaration. Ce diff devrait vous aider à comprendre les changements :

    < println!("Hello {}!", "world");
    ---
    > println!("Hello {}!");

    Une fois que vous avez fait ce changement et supprimé le NOT DONE commentaire du code source, vous pouvez exécuter rustlings verify à nouveau pour compiler et exécuter le code.

    $ rustlings verify
    Progress: [>-------------------------------------] 1/84
    ✅ Successfully ran exercises/intro/intro2.rs!

    Suivre le progrès

    Vous n’allez pas terminer tous les exercices en une journée et il est facile de perdre de vue où vous vous êtes arrêté. Vous pouvez exécuter le list commande pour voir l’état de votre travail.

    $ rustlings list
    Name         Path                                  Status
    intro1       exercises/intro/intro1.rs             Done  
    intro2       exercises/intro/intro2.rs             Done  
    variables1   exercises/variables/variables1.rs     Pending
    variables2   exercises/variables/variables2.rs     Pending
    variables3   exercises/variables/variables3.rs     Pending
    [...]

    Exécuter des exercices spécifiques

    Si vous ne voulez pas recommencer depuis le début et sauter quelques exercices, les bruissements vous permettent de vous concentrer sur des exercices spécifiques en utilisant le rustlings run commande. Cela exécute un programme spécifique sans nécessiter la vérification de la leçon précédente. Par exemple:

    $ rustlings run intro2
    Hello world!
    ✅ Successfully ran exercises/intro/intro2.rs
    $ rustlings run variables1

    Taper des noms d’exercices peut devenir fastidieux, mais les bruissements vous offrent un moyen pratique next commande afin que vous puissiez passer à l’exercice suivant de la série.

    $ rustlings run next

    Commande de montre alternative

    Si vous ne voulez pas continuer à taper verify après chaque modification que vous apportez, vous pouvez exécuter le watch commande dans une fenêtre de terminal, puis continuez à modifier le code source pour résoudre les problèmes. La watch La commande détecte ces modifications et continue de recompiler le programme pour voir si le problème a été résolu.

    $ rustlings watch

    Apprendre en déboguant

    Le compilateur Rust est connu pour fournir des messages d’erreur très significatifs, ce qui vous aide à comprendre les problèmes de votre code. Cela conduit généralement à un débogage plus rapide. Rustlings est un excellent moyen de pratiquer Rust, de s’habituer à lire les messages d’erreur et de comprendre le langage Rust. Découvrez les fonctionnalités récentes de Rustlings 5.0.0 sur GitHub.

    [ Practice programming with Rust. Download our Rust cheat sheet. ]

    Source

    N'oubliez pas de voter pour cet article !
    1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
    Loading...

    La Rédaction

    L'équipe rédactionnnelle du site

    Pour contacter personnellement le taulier :

    Laisser un commentaire

    Votre adresse e-mail ne sera pas publiée.