Apprendre Rust en 2022


  • FrançaisFrançais


  • Les bases de la base pour commencer et apprendre Rust.

    Le fait d’apprendre Rust permet d’appréhender de nouveaux langages pour améliorer ses capacités de développeurs. Rust est un langage de programmation relativement nouveau, et il est déjà populaire auprès des programmeurs de tous les secteurs. Pourtant, c’est aussi un langage qui s’appuie sur tout ce qui a précédé. Rust n’a pas été créé en un jour, après tout, donc même s’il existe des concepts dans Rust qui semblent très différents de ce que vous auriez pu apprendre de Python, Java, C++, etc., ils ont tous une base dans le même CPU et l’architecture NUMA avec laquelle vous avez toujours (que vous le sachiez ou non) interagi, et donc certaines des nouveautés de Rust semblent en quelque sorte familières.

    Maintenant, je ne suis pas un programmeur de métier. Je suis impatient mais obsessionnel. Si un langage ne m’aide pas à obtenir les résultats que je souhaite relativement rapidement, je me trouve rarement inspiré pour l’utiliser lorsque j’ai besoin de faire quelque chose. Le fait d’apprendre Rust permet d’équilibrer deux choses contradictoires : le besoin de code sécurisé et structuré de l’ordinateur moderne et le désir du programmeur moderne de faire moins de travail tout en obtenant plus de succès.

    Installer Rust

    Le site rust-lang.org contient une excellente documentation sur l’installation et apprendre Rust, mais généralement, c’est aussi simple que de télécharger le script sh.rustup.rs et l’exécuter.

    $ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs

    $ less sh.rustup.sh

    $ sh ./sh.rustup.rs

    
    

    Pas de classes pour apprendre Rust

    Rust n’a pas de classes et n’utilise pas le mot-clé class. Rust possède type de données struct, cependant, son objectif est de servir de modèle pour une collection de données. Ainsi, au lieu de créer une classe pour représenter un objet virtuel, vous pouvez utiliser une structure :

    struct Penguin {
        genus: String,
        species: String,
        extinct: bool,
        classified: u64,
    }

    
    

    Vous pouvez l’utiliser de la même manière qu’une classe. Par exemple, une fois que le struct Penguinest défini, vous pouvez en créer des instances et interagir avec cette instance :

    struct Penguin {

        genus: String,


        species: String,


        extinct: bool,


        classified: u64,


    }

    fn main() {
        let p = Penguin { genus: "Pygoscelis".to_owned(),
             species: "R adeliæ".to_owned(), 
             extinct: false, 
             classified: 1841 };

        println!("Species: {}", p.species);    
        println!("Genus: {}", p.genus);
        println!("Classified in {}", p.classified);
        if p.extinct == true {
            println!("Sadly this penguin has been made extinct.");
        }
        
    }

    
    

    En utilisant le type de données implen conjonction avec le type de données struct, vous pouvez implémenter une structure contenant des fonctions et vous pouvez ajouter l’héritage et d’autres fonctionnalités de type classe.

    Les fonctions pour apprendre Rust

    Les fonctions dans Rust ressemblent beaucoup aux fonctions dans d’autres langages. Chacun représente un ensemble discret de tâches auxquelles vous pouvez faire appel en cas de besoin. La fonction principale doit être appelée main.

    Les fonctions sont déclarées à l’aide du mot-clé fn, suivi du nom de la fonction et de tout paramètre accepté par la fonction.

    fn foo() {
      let n = 8;
      println!("Eight is written as {}", n);
    }

    
    

    La transmission d’informations d’une fonction à une autre se fait avec des paramètres. Par exemple, j’ai déjà créé une classe Penguin, et j’ai une instance d’un pingouin commep, donc en passant les attributs de p d’une fonction à l’autre m’oblige à préciser p en tant que typePenguin pour sa fonction de destination.

    fn main() {

      let p = Penguin { genus: "Pygoscelis".to_owned(), 


        species: "R adeliæ".to_owned(), 


        extinct: false, classified: 1841 };


      printer(p);


    }

    fn printer(p: Penguin) {
      println!("Species: {}", p.species);    
      println!("Genus: {}", p.genus);
      println!("Classified in {}", p.classified);
      if p.extinct == true {
          println!("Sadly this penguin has been made extinct.");
      }
    }

    
    

    Les variables dans Rust

    Rust crée des variables immuables par défaut. Cela signifie qu’une variable que vous créez ne peut pas être modifiée ultérieurement. Ce code, aussi humble soit-il, ne peut pas être compilé :

    fn main() {
     let n = 6;
     let n = 5;
     }

    
    

    Cependant, vous pouvez déclarer une variable mutable avec le mot-clé mut, donc ce code se compile avec succès :

    fn main() {
     let mut n = 6;
     println!("Value is {}", n);
     n = 5;
     println!("Value is {}", n);
    }

    
    

    Le compilateur dans Rust

    Le compilateur Rust, du moins en termes de messages d’erreur, est l’un des meilleurs compilateurs disponibles. Lorsque vous vous trompez dans Rust, le compilateur fait un effort sincère pour vous dire ce que vous avez mal fait. C’est un énorme gain de temps pour apprendre Rust dans son coin. J’ai en fait appris de nombreuses nuances de Rust (dans la mesure où je comprends n’importe quelle nuance de Rust) simplement en apprenant des messages d’erreur du compilateur. Même lorsqu’un message d’erreur est trop obscur pour être appris directement, il suffit presque toujours d’une recherche sur Internet pour l’expliquer.

    Le moyen le plus simple de démarrer un programme Rust est d’utiliser cargo, le système de gestion et de construction de paquets Rust.

    $ mkdir myproject
    $ cd myproject
    $ cargo init 

    
    

    Cela crée l’infrastructure de base d’un projet, notamment un main.rs dossier dans le src sous-répertoire. Ouvrez ce fichier et collez-y l’exemple de code que j’ai généré pour cet article :

    struct Penguin {

        genus: String,


        species: String,


        extinct: bool,


        classified: u64,


    }

    fn main() {
        let p = Penguin { genus: "Pygoscelis".to_owned(), species: "R adeliæ".to_owned(), extinct: false, classified: 1841 };
        printer(p);
        foo();
    }

    fn printer(p: Penguin) {
        println!("Species: {}", p.species);    
        println!("Genus: {}", p.genus);
        println!("Classified in {}", p.classified);
        if p.extinct == true {
            println!("Sadly this penguin has been made extinct.");
        }
    }

    fn foo() {
         let mut n = 6;
     println!("Value is {}", n);
     n = 8;
      println!("Eight is written as {}", n);
    }

    
    

    Pour compiler, utilisez la commandecargo build:

    $ cargo build

    Pour exécuter votre projet, exécutez le binaire dans le sous-répertoire target, ou bien utilisez simplement cargo run:

    $ cargo run
    Species: R adeliæ
    Genus: Pygoscelis
    Classified in 1841
    Value is 6
    Eight is written as 8

    
    

    Les Crates pour apprendre Rust

    Une grande partie de la commodité de n’importe quel langage provient de ses bibliothèques ou de ses modules. Dans Rust, les bibliothèques sont distribuées et suivies en tant que “crates”. le site crates.io est un bon registre de crates communautaires.

    Pour ajouter une crate à votre projet Rust, listez-les dans le fichier Cargo.toml. Par exemple, pour installer une fonction de nombre aléatoire, j’utilise la craterand, avec * servant de caractère générique pour m’assurer que j’obtiens la dernière version au moment de la compilation :

    [package]

    name = "myproject"


    version = "0.1.0"


    authors = ["Seth <seth@opensource.com>"]


    edition = "2022"

    [dependencies]
    rand = "*"

    
    

    L’utiliser dans le code Rust nécessite un use déclaration en haut :

    use rand::Rng;

    Un exemple de code qui crée une graine aléatoire, puis une plage aléatoire :

    fn foo() {

        let mut rng = rand::thread_rng();


        let mut n = rng.gen_range(1..99);

        println!("Value is {}", n);
        n = rng.gen_range(1..99);
        println!("Value is {}", n);
    }

    
    

    Vous pouvez utiliser cargo run pour l’exécuter, qui détecte le changement de code et déclenche une nouvelle génération. Le processus de construction télécharge la crate rand et tous les crates dont il dépend à son tour, compile le code, puis l’exécute :

    $ cargo run

    Updating crates.io index


    Downloaded ppv-lite86 v0.2.16


    Downloaded 1 crate (22.2 KB) in 1.40s


     Compiling libc v0.2.112


     Compiling cfg-if v1.0.0


     Compiling ppv-lite86 v0.2.16


     Compiling getrandom v0.2.3


     Compiling rand_core v0.6.3


     Compiling rand_chacha v0.3.1


     Compiling rand v0.8.4


     Compiling rustpenguin v0.1.0 (/home/sek/Demo/rustpenguin)


     Finished dev [unoptimized + debuginfo] target(s) in 13.97s


     Running `target/debug/rustpenguin`

    Species: R adeliæ
    Genus: Pygoscelis
    Classified in 1841
    Value is 70
    Value is 35

    
    

    Aide-mémoire sur Rust

    Rust est un langage extrêmement agréable. Grâce à son intégration avec les registres en ligne, son compilateur utile et sa syntaxe presque intuitive, il se sent convenablement moderne.

    Les bases de la base pour commencer et apprendre Rust.

    La Timeline du développement de Rust – Crédit : https://evrone.com/rust-vs-c

    Ne vous méprenez pas, cependant, c’est aussi un langage complexe, avec des types de données stricts, des variables fortement délimitées et de nombreuses méthodes intégrées. Plus tôt vous commencerez, plus tôt vous connaîtrez Rust. Et, bien sûr, vous devriez vous entraîner souvent pour éviter de vous rouiller.

    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.