Programmation en RUST

Le Langage Idéal pour les Jeux et Applications Web

Bases de la Programmation et Bases de Données4.9(70)6h 22min40 leçons8 sections

Ce que vous apprendrez

  • Installer les outils Rust et créer son premier projet
  • Utiliser Cargo
  • Comprendre les types de données, les variables et les constantes
  • Utiliser les opérations arithmétiques, logiques et de comparaison
  • Écrire des instructions de prise de décision
  • Utiliser les boucles
  • Créer et utiliser des fonctions
  • Travailler avec les possibilités et les données textuelles
  • Organiser et stocker les données
  • Réaliser une application pratique complète en Rust

À propos du cours

Ce cours enseigne la programmation en langage Rust à partir de zéro. Il commence par l'introduction du cours, l'installation des outils, la création de votre premier projet et l'utilisation de Cargo, puis les commentaires, les types de données, la création et la manipulation des variables, et les constantes. Ensuite, vous apprenez les opérations arithmétiques, les opérations de comparaison et les opérations logiques, puis la prise de décision, les boucles et les fonctions, chacune sur plusieurs parties avec des exercices et des codes à télécharger. Vous passez à la gestion des possibilités, à l'organisation et au stockage des données et au traitement des données textuelles, puis vous appliquez ce que vous avez appris dans une application pratique complète en cinq parties. Le cours convient à toute personne qui veut apprendre un langage de programmation moderne adapté aux jeux, aux applications web et aux logiciels système, débutante en programmation ou déjà expérimentée dans un autre langage. Aucune expérience préalable n'est nécessaire, car le cours part de l'installation des outils. Il présente chaque notion par une explication simple puis par la pratique en code, pour que vous suiviez les étapes et essayiez par vous-même. À la fin, vous saurez écrire des programmes en Rust, organiser votre code en fonctions et créer vous-même une application pratique.

Résultats attendus

  • Capacité à écrire des programmes en RUST de manière efficace et sécurisée.
  • Compréhension de la façon de gérer et d'organiser les données à l'aide de variables et de constantes.
  • Création de fonctions et de programmes avancés à l'aide de boucles itératives.
  • Mise en œuvre de projets pratiques en utilisant des outils avancés dans RUST.

Avis des apprenants

Ces avis proviennent d'apprenants qui ont acheté le contenu et en ont complété au moins 50% — il n'y a aucun avis de personnes n'ayant pas suivi le contenu.
4.9
★★★★★
70 avis
5★
63
4★
6
3★
1
2★
0
1★
0

    Contenu du cours

    1

    Installation des outils

    4 leçons
    1. Introduction au coursPrésente le cours Rust : l'origine du langage, ses atouts en vitesse et en gestion de la mémoire, et le programme, de l'installation, Cargo et des bases jusqu'aux fonctions, enums et un projet pratique.2:17
    2. Installation des outilsExplique l'installation des outils Rust : Rustup pour gérer et mettre à jour les versions, les outils de build de Visual Studio, Cargo comme gestionnaire de paquets, puis Visual Studio Code comme éditeur.11:53
    3. Premier projetExplique la création d'un premier projet Rust qui affiche Hello World, en écrivant un fichier main.rs avec une fonction main et println!, puis en le compilant et en l'exécutant depuis le terminal.13:01
    4. Utilisation de CargoExplique l'utilisation de Cargo en Rust à la place de la méthode manuelle : créer un projet avec new, le compiler, l'exécuter et le vérifier, ainsi que le rôle de Cargo.toml, Cargo.lock et du dossier target.16:30
    2

    Fondamentaux

    5 leçons
    1. CommentairesExplique les commentaires en Rust, sur une ligne ou plusieurs lignes, leur rôle pour documenter le code pour soi-même et pour l'équipe, et le fait que le Compiler les ignore totalement à l'exécution.9:51
    2. Types de donnéesExplique les types de données de base en Rust : Integer, Float, Char, String et Boolean, et comment les afficher avec println!.13:22
    3. Création des variablesExplique la variable en Rust comme un emplacement nommé en mémoire qui stocke des données, comment la créer avec let, appeler sa valeur et l'afficher, et qu'elle ne change pas sauf déclaration particulière.9:16
    4. Travail avec les variablesExplique le travail avec les variables en Rust : préciser explicitement le type, les types entier, flottant, f32, f64 et char, les règles de nommage, et rendre une variable modifiable avec le mot-clé mut.13:46
    5. ConstantesExplique les constantes en Rust avec const : le type de données obligatoire, l'impossibilité de changer leur valeur, la différence avec let, et la redéfinition d'une variable du même nom dans le même bloc.11:50
    3

    Processus

    3 leçons
    1. Opérations arithmétiquesExplique les opérateurs arithmétiques en Rust : addition, soustraction, multiplication, division et reste (Modulus), avec un exemple de code et la différence entre division et reste.6:17
    2. Opérations de comparaisonExplique les opérateurs de comparaison en Rust (supérieur, inférieur, égal, différent), qui renvoient une valeur Boolean true ou false, avec des exemples de code.10:17
    3. Opérations logiquesExplique les opérateurs logiques en Rust (and, or, not), comment ils combinent plusieurs conditions de comparaison en une seule expression retournant true ou false, en préparation à la prise de décision.8:01
    4

    Prise de décision

    4 leçons
    1. Étapes de prise de décision (Partie 1)Introduit la prise de décision en Rust avec l'instruction if, dont le bloc de code ne s'exécute que si la condition est true, avec des exemples de comparaison de variables et de conditions combinées.10:32
    2. Étapes de prise de décision (Partie 2)Explique l'instruction if else en Rust, où le bloc else s'exécute lorsque la condition du if vaut false, avec un exemple comparant deux nombres et affichant un résultat différent selon la condition.5:55
    3. Étapes de prise de décision (Partie 3)Explique else if en Rust comme troisième étape de la prise de décision, pour ajouter une nouvelle condition quand la première échoue, avec un exemple déterminant si un nombre est supérieur, inférieur ou égal à un autre.7:29
    4. Étapes de prise de décision (Partie 4)Explique l'utilisation du mot-clé match en Rust comme alternative à une chaîne if et else if, en comparant une variable à plusieurs motifs et en exécutant le cas correspondant, avec un cas par défaut.12:29
    5

    Boucles itératives

    4 leçons
    1. Boucles Itératives (Partie Un)Explique les boucles en Rust en commençant par while, avec une variable mutable et une condition qui reste true, pour afficher un message plusieurs fois au lieu de répéter le code à la main.12:08
    2. Boucles Itératives (Partie Deux)Poursuit les boucles en Rust avec la boucle for et Range, en utilisant break pour sortir de la boucle et continue pour ignorer certaines valeurs, avec un exercice d'affichage des nombres pairs.7:43
    3. Boucles Itératives (Partie Trois)Explique les boucles imbriquées et compare for, while et loop en Rust, comment créer une boucle avec un compteur, la boucle infinie et son arrêt avec une condition if et break.4:11
    4. Boucles Itératives (Partie Quatre)Explique les mots-clés continue et break dans les boucles Rust : continue saute l'itération courante quand une condition est vraie, break arrête toute la boucle, avec un exemple de for et range.4:35
    6

    Fonctions

    6 leçons
    1. Fonctions (Partie 1)Explique la définition des fonctions en Rust avec le mot-clé fn, un nom, des parenthèses et un bloc de code, et comment appeler une fonction depuis main pour exécuter son contenu, en lien avec main elle-même.9:35
    2. Fonctions (Partie 2)Explique le passage de données aux fonctions Rust via des paramètres entre parenthèses, la déclaration de leur type, leur ordre, et l'erreur quand le nombre de paramètres ne correspond pas aux arguments de l'appel.13:59
    3. Fonctions (Partie 3)Explique les fonctions qui retournent une valeur en Rust : préciser le type retourné, utiliser return, stocker le résultat dans une variable et passer la valeur retournée à une autre fonction.10:17
    4. Fonctions (Partie 4)Explique println! en Rust et le sens du point d'exclamation dans une macro, l'affichage des valeurs dans les différents formats, et son usage pour le débogage, à retirer de la version finale.7:07
    5. ExerciceExercice pratique FizzBuzz en Rust : une boucle for sur une plage de nombres, test de divisibilité par le reste pour afficher Fizz, Buzz et FizzBuzz, puis déplacement de la logique dans une fonction à paramètres.13:48
    6. Téléchargement des codes
    7

    Tâches avancées

    8 leçons
    1. Gestion des ProbabilitésExplique l'Enum en Rust pour définir un ensemble de valeurs possibles pour un type comme Gender, et comment traiter ses valeurs avec match dans une fonction, y compris les cas non couverts.13:03
    2. ExerciceExercice pratique sur les Enums en Rust qui définit les niveaux d'accès Admin, Manager, User et Guest et utilise match pour décider qui peut accéder à un fichier privé, avec le cas par défaut pour les autres.5:01
    3. Organisation des Données (Partie Un)Explique le struct en Rust pour regrouper des données liées sous un seul nom, comme le nom, l'âge et le genre d'un employé, créer des instances et accéder aux champs avec un point, avec un rappel sur enum.11:23
    4. Organisation des Données (Partie Deux)Explique l'ajout de méthodes à un struct en Rust avec impl, comment accéder aux champs de l'instance à l'intérieur, appeler les méthodes sur l'objet et modifier un champ comme l'âge.15:43
    5. Stockage des Données (Partie Un)Explique le tuple en Rust pour stocker plusieurs valeurs de types différents dans une seule variable, l'afficher, accéder à ses éléments par index comme .0, ou le déstructurer en variables séparées.13:41
    6. Stockage des Données (Partie Deux)Explique le tableau array en Rust et sa différence avec le tuple, qui ne contient qu'un seul type, la définition de son type et de sa taille, la modification des éléments par index, et son passage à une fonction et son retour.22:02
    7. Gestion des Données TextuellesExplique la manipulation du texte en Rust : la différence entre string literal et string object, la création d'une chaîne vide, la conversion d'un literal en object, et l'usage de méthodes comme replace, trim et len.14:44
    8. Téléchargement de Code
    8

    Application pratique complète

    6 leçons
    1. Application Pratique (Partie Un)Lance le projet pratique du jeu de devinette en Rust, qui utilise l'entrée utilisateur Input et une bibliothèque externe pour le nombre aléatoire, avec la création du projet via Cargo et son exécution.5:42
    2. Application Pratique (Partie Deux)Explique la lecture de l'entrée utilisateur dans le jeu de devinette en Rust avec la bibliothèque io, une variable String vide mutable et read_line pour stocker ce que l'utilisateur saisit dans le terminal.9:50
    3. Application Pratique (Partie Trois)Explique la génération d'un nombre aléatoire dans le jeu de devinette en Rust en ajoutant la bibliothèque externe rand à Cargo.toml, en la compilant avec Cargo et en utilisant le générateur rng.10:47
    4. Application Pratique (Partie Quatre)Explique la comparaison de la proposition de l'utilisateur avec le nombre aléatoire dans le jeu de devinettes : conversion du texte saisi en entier avec parse, gestion de l'erreur par un message et comparaison avec des if.7:05
    5. Application Pratique (Partie Cinq)Termine le jeu de devinettes en Rust : comparer les deux nombres avec l'enum Ordering et match au lieu de if, puis placer la saisie dans une boucle qui se répète jusqu'à ce que l'utilisateur trouve le nombre.7:41
    6. Téléchargement de Code

    Formateur

    Ing. Amr Abdel Fattah

    Ing. Amr Abdel Fattah

    Ingénieur en systèmes informatiques spécialisé dans le développement d'applications mobiles et de sites Web, avec une expérience dans la création de plateformes et d'applications Web populaires.
    49.3K vues20 cours

    Cours similaires