Découvrez l’essentiel de la programmation Dart !

Dans cette vidéo, je vous présente

l’importance de ce langage, tout en vous proposant un cours express de 2 heures pour
apprendre les bases.

Que vous soyez débutant ou que vous souhaitiez actualiser vos compétences, plongez dans le
Dart et développez vos connaissances en un temps record.

Et ce n’est pas tout ! Si vous êtes passionné par le développement mobile, ne manquez pas
le programme gratuit de Flutter Révolution

1. Introduction au Dart
 Présentation de Dart:

Le Dart se distingue par sa syntaxe claire et lisible, adaptée aux débutants comme aux experts.
Sa polyvalence le rend idéal pour créer diverses applications, allant des applications web aux
mobiles et aux applications de bureau.

Avantages et usages:

Le Dart est reconnu pour sa rapidité d'exécution grâce à son moteur JIT et AOT. C'est aussi le
langage phare de Flutter, idéal pour créer des interfaces fluides et interactives.

Installation et configuration:

Pour commencer, installez le Dart SDK, puis configurez votre environnement de développement
(IDE). Choisissez parmi des options comme Visual Studio Code, IntelliJ IDEA ou Android Studio.
Prêt à plonger dans la programmation Dart ? Commencez le programme gratuit de Flutter
Révolution pour accéder à toutes ces étapes d'installation de Dart et Flutter.

2. Les variables en Dart

Variables et types de données en programmation

Les variables jouent un rôle fondamental en programmation en permettant aux développeurs

de stocker et de manipuler des données de manière dynamique. Une variable peut être considérée
comme une "boîte" où vous pouvez stocker différentes valeurs, et ces valeurs peuvent changer
au cours de l'exécution du programme. Les variables permettent de rendre les programmes plus
flexibles et réutilisables en manipulant les données de manière abstraite.

Types de données de base en Dart

En Dart, un langage de programmation développé par Google, il existe plusieurs types de

données de base:

1. Entiers (int): Les entiers représentent des nombres entiers sans partie décimale. Ils peuvent
être positifs, négatifs ou nuls. Par exemple, 5, -10 et 0 sont des entiers en Dart.
2. Décimaux (double): Les décimaux sont utilisés pour représenter des nombres avec une partie
décimale. Ils peuvent également représenter des nombres entiers. Par exemple, 3.14, -
0.5 et 10.0 sont des décimaux en Dart.
3. Chaînes de caractères (String): Les chaînes de caractères sont utilisées pour représenter du
texte. Elles sont entourées de guillemets simples ('') ou doubles (""). Par exemple, "Hello,
world !" est une chaîne de caractères en Dart.
4. Booléens (bool): Les booléens sont utilisés pour représenter des valeurs binaires,
généralement vrai true ou faux false. Ils sont essentiels pour les structures de contrôle, telles
que les instructions conditionnelles. Par exemple, true et false sont des valeurs booléennes en
Dart.
Déclaration et utilisation des variables en Dart

Pour déclarer une variable en Dart, vous devez spécifier son type et lui attribuer une valeur
initiale. Voilà comment on fait en Dart:

Dart

// Déclaration d'une variable entière

int age = 27;
 // Déclaration d'une variable décimale
double prix = 19.99;

// Déclaration d'une variable chaîne de caractères

String nom = "Driss";

// Déclaration d'une variable booléenne

bool estMajeur = true;

Une fois déclarées, vous pouvez utiliser ces variables dans votre code pour effectuer des
opérations, des comparaisons ou les afficher à l'écran:

Dart

// Utilisation des variables

print("Bonjour, je m'appelle $nom et j'ai $age ans.");
if (estMajeur) {
print("Je suis majeur(e) !");
} else {
print("Je ne suis pas encore majeur(e).");
}

En résumé, les variables sont essentielles pour stocker et manipuler des données en
programmation. En Dart, vous pouvez utiliser différents types de données de base tels que les
entiers, les décimaux, les chaînes de caractères et les booléens. La déclaration et l'utilisation de
variables en Dart vous permettent de créer des programmes dynamiques et interactifs.

3. Structures de contrôle en Dart

Structures de contrôle en programmation

Les structures de contrôle sont des éléments essentiels en programmation qui permettent de gérer
le flux d'exécution d'un programme. Elles permettent de prendre des décisions
conditionnelles et d'itérer sur des données à l'aide de boucles. Voici comment elles fonctionnent :

Utilisation des structures conditionnelles (if, else, else if)

Les structures conditionnelles permettent d'exécuter différentes parties de code en fonction

de conditions spécifiques. En Dart, les structures conditionnelles les plus couramment utilisées
sont les suivantes :

1. if: Exécute un bloc de code si la condition est vraie (true).

Dart

if (condition) {
// Code à exécuter si la condition est vraie
} else {
// Code à exécuter si la condition est fausse
}
2. else if: Permet de tester plusieurs conditions en série.
 Dart

if (condition1) {
// Code à exécuter si condition1 est vraie
} else if (condition2) {
// Code à exécuter si condition2 est vraie
} else {
// Code à exécuter si aucune condition n'est vraie
}

Utilisation des boucles (for, while) pour itérer sur des données

Les boucles permettent d'exécuter un bloc de code plusieurs fois, en fonction d'une condition.
En Dart, les boucles les plus courantes sont les suivantes:

1. for: Utilisé pour itérer un nombre spécifique de fois.

Dart

for (int i = 0; i < 5; i++) {

// Code à exécuter à chaque itération
}
2. while: Utilisé pour itérer tant qu'une condition est vraie.
Dart

while (condition) {
// Code à exécuter tant que la condition est vraie
}

Utilisation des structures de contrôle pour gérer le flux d'exécution du programme

Les structures de contrôle permettent de gérer le flux d'exécution d'un programme en prenant
des décisions et en contrôlant les itérations. Elles sont essentielles pour rendre les programmes
dynamiques et interactifs. Par exemple, vous pouvez utiliser une combinaison de structures
conditionnelles et de boucles pour gérer différentes situations, telles que des interactions
utilisateur, des calculs complexes, etc.

Voici un exemple d'utilisation combinée de structures conditionnelles et de boucles pour illustrer

le concept :

Dart
 int nombre = 10;

if (nombre > 0) {
for (int i = 0; i < nombre; i++) {
print("Itération $i");
}
} else {
print("Le nombre est négatif ou nul.");
}

Dans cet exemple, le programme affiche une série de messages d'itération si le nombre est
positif, sinon il affiche un message indiquant que le nombre est négatif ou nul.

En résumé, les structures de contrôle en programmation, telles que les structures conditionnelles
(if, else, else if) et les boucles (for, while), sont utilisées pour prendre des décisions et itérer sur
des données. Elles permettent de contrôler le flux d'exécution du programme et de créer des
logiques complexes et interactives.

4. Les fonctions en Dart

Fonctions en programmation Dart

Les fonctions sont des blocs de code réutilisables qui permettent d'organiser et de structurer un
programme en effectuant une tâche spécifique. Elles favorisent la modularité et la réutilisabilité
du code en le divisant en petites parties autonomes. En Dart, les fonctions jouent un rôle essentiel
dans le développement logiciel.

Déclaration et utilisation des fonctions

Pour déclarer une fonction en Dart, vous spécifiez son nom, les éventuels paramètres qu'elle
prend et le type de valeur qu'elle renvoie (si elle renvoie une valeur). Voici la syntaxe de base:

Dart

typeDeRenvoi nomDeLaFonction(paramètres) {
// Code à exécuter
// ...
return valeur; // (si la fonction renvoie une valeur)
}

Pour utiliser une fonction, vous appelez simplement son nom suivi des parenthèses, en
fournissant les arguments nécessaires si la fonction prend des paramètres.

Passage de paramètres et retour de valeurs

Les paramètres sont des valeurs que vous passez à une fonction pour qu'elle les utilise dans
son traitement. Il existe deux types de paramètres en Dart: les paramètres requis et les
paramètres optionnels.

1. Paramètres requis: Ces paramètres doivent être fournis lors de l'appel de la fonction.
Dart
 void hello(String nom) {
print("Bonjour, $nom !");
}

// Appel de la fonction
hello("Driss"); // Affiche : Bonjour, Driss !
2. Paramètres optionnels: Ces paramètres peuvent être omis lors de l'appel de la fonction, et
vous pouvez définir une valeur par défaut.
Dart

void afficherDetails(String nom, {int age = 0, String pays = "Inconnu"}) {

print("Nom: $nom, Age: $age, Pays: $pays");
}

// Appel de la fonction
afficherDetails("Driss", age: 27); // Affiche : Nom: Driss, Age: 27, Pays: Inconnu
Pour renvoyer une valeur à partir d'une fonction, utilisez le mot-clé return.
Dart

int somme(int a, int b) {

return a + b;
}

// Appel de la fonction
int resultat = somme(5, 3);
print("La somme est : $resultat"); // Affiche : La somme est : 8

En résumé, les fonctions en Dart sont des blocs de code réutilisables qui effectuent des tâches
spécifiques. Vous pouvez définir des fonctions avec des paramètres requis ou optionnels, ainsi
qu'avec ou sans valeur de renvoi. Les fonctions favorisent la modularité, la réutilisabilité et
la clarté du code.

5. Collections de données en Dart

Collections de données en Dart

En Dart, les collections de données sont des structures qui vous permettent de stocker et de gérer
plusieurs valeurs de manière organisée. Les trois types de collections de données les plus
courants sont les listes, les ensembles et les cartes.

1. Listes: Les listes sont des collections ordonnées d'éléments, où chaque élément peut être
répété et identifié par son index. Elles permettent d'accéder aux éléments en fonction de leur
position dans la liste.
2. Ensembles: Les ensembles sont des collections non ordonnées d'éléments uniques. Ils
garantissent que chaque élément ne peut apparaître qu'une seule fois dans l'ensemble.
3. Maps: Les maps sont des collections d'éléments associés à des clés uniques. Chaque élément
est stocké avec une clé qui permet de le retrouver rapidement.
Manipulation des listes:
 Création d'une liste:
Dart

List<int> nombres = [1, 2, 3, 4, 5];

 Ajout d'éléments à la fin de la liste:
Dart

[Link](6);
 Suppression d'un élément:
Dart

[Link](3); // Supprime l'élément 3

 Recherche d'un élément:
Dart

int index = [Link](4); // Donne l'index de l'élément 4

Manipulation des ensembles:

 Création d'un ensemble:

Dart

Set<String> pays = {"USA", "Canada", "France"};

 Ajout d'éléments:
Dart

[Link]("Allemagne");
 Suppression d'éléments:
Dart
 [Link]("Canada");

Manipulation d'une Map:

 Création d'une Map:

Dart

Map<String, String> capitales = {

"France": "Paris",
"Allemagne": "Berlin",
"Espagne": "Madrid"
};
 Ajout d'éléments:
Dart

capitales["Italie"] = "Rome";
 Suppression d'éléments:
Dart

[Link]("Allemagne");

En résumé, les collections de données en Dart (listes, ensembles et cartes) offrent des moyens
flexibles et puissants pour stocker et gérer des données de différentes manières. Vous pouvez
ajouter, supprimer et rechercher des éléments dans ces collections, ce qui facilite la manipulation
des données dans vos programmes.

6. Classes et objets en Dart

Attention: Mise à jour du code source dans cette partie, pour la syntaxe du constructeur, pour plus
d'informations: prefer_initializing_formals

Classes et objets en programmation orientée objet en Dart

La programmation orientée objet (POO) est un paradigme de programmation qui repose sur
la création de classes et d'objets pour organiser et structurer le code de manière plus modulaire
et orientée vers les concepts du monde réel. En Dart, la POO est largement utilisée pour créer des
systèmes complexes et interconnectés.

Déclaration de classes et création d'objets

Une classe est un modèle pour créer des objets. Elle définit les propriétés (attributs) et les
comportements (méthodes) que les objets auront. Voici comment déclarer une classe en Dart:

Dart

class Personne {
String nom;
int age;

// Constructeur
Personne([Link], [Link]);
}
}

Pour créer un objet à partir de cette classe, utilisez le constructeur :

Dart

Personne personne1 = Personne("Driss", 27);

Personne personne2 = Personne("Alice", 30);

Utilisation des propriétés et des méthodes des objets

Les propriétés (attributs) d'un objet sont des variables associées à cet objet, tandis que
les méthodes sont des fonctions associées à cet objet. Vous pouvez accéder aux propriétés et
appeler les méthodes d'un objet de la manière suivante:

Dart

print([Link]); // Affiche : Driss

print([Link]); // Affiche : 30

class Personne {
String nom;
int age;

// Constructeur
Personne([Link], [Link]);

// Méthode
void sePresenter() {
print("Bonjour, je m'appelle $nom et j'ai $age ans.");
}
}

[Link](); // Affiche : Bonjour, je m'appelle Driss et j'ai 27 ans.

[Link](); // Affiche : Bonjour, je m'appelle Alice et j'ai 30 ans.

Encapsulation et méthodes d'accès

En Dart, vous pouvez définir des méthodes d'accès (getters et setters) pour contrôler l'accès aux
propriétés privées d'une classe et pour encapsuler la logique d'accès. Par exemple:

Dart

class CompteBancaire {
double _solde = 0;

// Méthode getter
double get solde {
return _solde;
}

// Méthode setter
set solde(double montant) {
if (montant >= 0) {
_solde = montant;
}
}
}

CompteBancaire compte = CompteBancaire();

[Link] = 1000; // Utilisation du setter
print([Link]); // Utilisation du getter

En résumé, la programmation orientée objet en Dart repose sur les classes et les objets. Les
classes définissent les propriétés et les méthodes, et les objets sont des instances de ces classes.
Vous pouvez créer, manipuler et interagir avec des objets en utilisant leurs propriétés et leurs
méthodes. L'encapsulation permet de contrôler l'accès aux propriétés privées, et les méthodes
d'accès (getters et setters) peuvent être utilisées pour encapsuler la logique d'accès.

7. Gestion des erreurs en Dart

Gestion des erreurs en Dart

La gestion des erreurs est une partie cruciale de la programmation, car elle permet de
détecter, signaler et gérer les problèmes qui peuvent survenir lors de l'exécution d'un programme.
En Dart, les erreurs sont gérées à l'aide de mécanismes de gestion d'exceptions.

Utilisation des blocs try-catch pour capturer et gérer les exceptions

Les exceptions sont des situations anormales ou des erreurs qui se produisent pendant
l'exécution d'un programme. Les blocs try et catch sont utilisés pour gérer les exceptions en Dart:
Dart

try {
// Code susceptible de générer une exception
} catch (exception) {
// Code de gestion de l'exception
}
Dans ce bloc, le code à l'intérieur du bloc try est exécuté. Si une exception est repérée pendant
cette exécution, le code à l'intérieur du bloc catch est exécuté pour gérer l'exception.
Dart

try {
var resultat = 10 ~/ 0; // Division par zéro
} catch (e) {
print("Une exception s'est produite : $e");
}

Utilisation des exceptions personnalisées

En plus des exceptions intégrées, vous pouvez également créer vos propres
exceptions personnalisées en définissant des classes qui héritent de la classe Exception ou
d'autres classes liées aux exceptions. Cela peut être utile lorsque vous souhaitez gérer
des situations spécifiques de manière plus détaillée.
Dart

class MonException implements Exception {

String message;

MonException([Link]);

@override
String toString() {
return "MonException : $message";
}
}

void exemple() {
try {
throw MonException("Ceci est mon exception personnalisée");
} catch (e) {
print(e);
}
}
Dans cet exemple, une exception personnalisée MonException est créée en implémentant
l'interface Exception. Lorsque cette exception est lancée et capturée, son message spécifié est
affiché.
En résumé, la gestion des erreurs en Dart est réalisée à l'aide des blocs try et catch, où le code
pouvant générer des exceptions est placé dans le bloc try, et le code pour gérer les exceptions est
placé dans le bloc catch. Vous pouvez également créer des exceptions personnalisées pour
gérer des situations spécifiques de manière plus précise.

8. Programmation asynchrone en Dart

Programmation asynchrone en Dart
La programmation asynchrone est utilisée pour gérer des opérations qui prennent du temps à
s'exécuter, comme les appels réseau, les accès à la base de données ou d'autres opérations E/S.
Elle permet au programme de continuer à s'exécuter pendant que ces opérations sont en cours,
évitant ainsi de bloquer le thread principal et améliorant la réactivité de l'application.

Utilisation des futures et des promesses pour gérer les opérations asynchrones

En Dart, les futures et les promesses sont utilisées pour gérer les opérations asynchrones.
Un futur est une référence à une valeur qui peut ne pas être encore disponible, tandis
qu'une promesse est l'objet qui produit cette valeur à un moment donné.

Dart

Future<String> obtenirDonnees() {
return [Link](Duration(seconds: 2), () => "Données reçues");
}
Pour utiliser le résultat d'un futur, vous pouvez utiliser la méthode .then() :
Dart

obtenirDonnees().then((resultat) {
print(resultat); // Affiche : Données reçues
});

Utilisation de l'opérateur async/await pour simplifier la programmation asynchrone

L'opérateur async est utilisé pour marquer une fonction comme asynchrone, ce qui signifie qu'elle
peut contenir des opérations asynchrones. L'opérateur await est utilisé à l'intérieur de fonctions
asynchrones pour attendre la résolution d'un futur ou d'une promesse.
Dart

Future<void> exempleAsynchrone() async {

try {
var resultat = await obtenirDonnees();
print(resultat); // Affiche : Données reçues
} catch (erreur) {
print("Une erreur s'est produite : $erreur");
}
}
Dans cet exemple, await obtenirDonnees() attend que la fonction obtenirDonnees() renvoie une
valeur avant de continuer. Si une exception est levée dans le futur, elle est capturée et
gérée dans le bloc catch.
L'opérateur async/await rend la programmation asynchrone plus lisible et plus semblable à la
programmation synchrone, ce qui facilite la gestion des opérations asynchrones dans votre
code.
En résumé, la programmation asynchrone en Dart est utilisée pour gérer les opérations qui
prennent du temps à s'exécuter. Les futures et les promesses sont utilisées pour représenter les
valeurs futures, tandis que les opérateurs async et await simplifient la gestion des opérations
asynchrones en les rendant plus lisibles et similaires à la programmation synchrone.
 Conclusion
Dans cette vidéo, nous avons exploré les concepts clés de la programmation en Dart, un langage
de programmation polyvalent développé par Google. Voici un récapitulatif des principaux points
abordés:

 Variables et types de données: Les variables sont utilisées pour stocker et manipuler des
données. Les types de données de base comprennent les entiers, les décimaux, les chaînes de
caractères et les booléens.
 Structures de contrôle: Les structures conditionnelles (if, else, else if) et les boucles (for,
while) permettent de prendre des décisions et d'itérer sur des données pour gérer le flux
d'exécution du programme.
 Fonctions: Les fonctions sont des blocs de code réutilisables qui effectuent des tâches
spécifiques. Vous pouvez définir des fonctions avec des paramètres et des valeurs de renvoi.
 Collections de données: Les listes, les ensembles et les cartes sont utilisés pour stocker et
manipuler des données de différentes manières, facilitant la gestion des informations dans vos
programmes.
 Classes et objets: La programmation orientée objet en Dart repose sur les classes et les
objets. Les classes définissent les propriétés et les méthodes, et les objets sont des instances de
ces classes.
 Gestion des erreurs: Les blocs try-catch sont utilisés pour capturer et gérer les exceptions,
permettant de gérer les erreurs de manière contrôlée.
 Programmation asynchrone: La programmation asynchrone est utilisée pour gérer les
opérations qui prennent du temps à s'exécuter. Les futures, les promesses, et les opérateurs
async/await sont utilisés pour gérer ces opérations de manière efficace.
Approfondir ses connaissances en Dart

La programmation est une compétence qui s'améliore avec la pratique constante. Continuez à
écrire du code, à résoudre des problèmes et à explorer de nouveaux concepts en Dart. Explorez
des projets plus complexes, participez à des communautés de développeurs et consultez
la documentation officielle de Dart pour approfondir vos connaissances.

La maîtrise de Dart vous ouvrira des portes vers la création d'applications mobiles avec
Flutter, le développement côté serveur, les applications web et bien plus encore. Continuez à
construire, à apprendre et à grandir en tant que développeur Dart pour réaliser des projets
passionnants et innovants. Bonne programmation !

Articles similaires