Introduction à Dart
Dart est un langage de programmation moderne développé par Google, optimisé pour créer des applications multiplateformes. Dart est le langage principal utilisé pour développer des applications Flutter.
⚙️ Qu'est-ce que Dart ?
Dart est un langage de programmation orienté objet, type-safe, et compilé. Dart peut être compilé en JavaScript pour le web ou en code natif pour mobile et desktop.
💡 Pourquoi Dart est si important ?
- Flutter - Langage principal pour le développement Flutter (mobile, web, desktop)
- Multiplateforme - Un seul codebase pour iOS, Android, Web, Windows, macOS, Linux
- Performance - Compilation native pour des performances optimales
- Hot Reload - Développement rapide avec rechargement instantané
- Google - Supporté et développé activement par Google
- Croissance - Adoption rapide dans l'industrie mobile
🚀 Pourquoi apprendre Dart ?
Dart est le langage de l'avenir pour le développement multiplateforme. Voici pourquoi vous devriez apprendre Dart :
- ✅ Flutter - Développement d'applications mobiles natives avec Flutter
- ✅ Multiplateforme - Un seul code pour toutes les plateformes
- ✅ Performance - Applications rapides et fluides
- ✅ UI moderne - Création d'interfaces utilisateur modernes et attrayantes
- ✅ Carrière - Forte demande pour les développeurs Flutter/Dart
- ✅ Écosystème - Communauté active et bibliothèques riches
📋 Prérequis pour apprendre Dart
Pour apprendre Dart efficacement, il est recommandé d'avoir une base en programmation (variables, conditions, boucles).
- ✅ Base en programmation - Comprendre les concepts de base (variables, conditions, boucles)
- ✅ Programmation orientée objet (optionnel) - Avoir des bases en OOP facilite l'apprentissage
- ✅ Flutter SDK - Pour développer des applications Flutter
💡 Note importante : Pour compiler du code Dart, vous avez besoin du Dart SDK. Téléchargez-le depuis le site officiel de Dart. Pour Flutter, installez Flutter SDK qui inclut Dart.
🎯 Cas d'utilisation de Dart
Dart est utilisé dans de nombreux domaines :
- 📱 Applications mobiles - Flutter pour iOS et Android
- 🌐 Applications web - Flutter Web pour applications web
- 🖥️ Applications desktop - Flutter Desktop pour Windows, macOS, Linux
- ⚡ Applications performantes - Compilation native pour performances optimales
- 🔄 Hot Reload - Développement rapide avec rechargement instantané
- 📦 Multiplateforme - Un seul codebase pour toutes les plateformes
- 🎨 UI moderne - Création d'interfaces utilisateur modernes
- 🚀 Croissance rapide - Adoption rapide dans l'industrie mobile
📝 Syntaxe de base
Dart est un langage de programmation moderne. Dart utilise des accolades {} pour définir les blocs de code et nécessite un point-virgule ; à la fin de chaque instruction (optionnel mais recommandé).
// Premier programme C
#include
int main() {
printf("Bonjour, monde !\n");
return 0;
}
// Variables
int age = 25;
char nom[] = "NiangProgrammeur";
// Affichage formaté
printf("Je m'appelle %s et j'ai %d ans\n", nom, age);
// Opérations simples
int resultat = 10 + 5;
printf("10 + 5 = %d\n", resultat);
} 💡 Points importants sur la syntaxe Dart :
- Dart utilise des accolades
{}pour définir les blocs de code - Les commentaires utilisent
//pour une ligne ou/* */pour plusieurs lignes - Point-virgule optionnel mais recommandé
;à la fin de chaque instruction - Les chaînes utilisent des guillemets simples
'ou doubles" - Chaque programme Dart a une fonction
main() - Les noms de classes commencent par une majuscule (convention PascalCase)
🔍 Exemple de syntaxe détaillée
Voici un exemple complet montrant plusieurs aspects de la syntaxe Dart :
// Définition d'une fonction
double calculerMoyenne(List nombres) {
if (nombres.isEmpty) {
return 0;
}
int somme = 0;
for (int n in nombres) {
somme += n;
}
return somme / nombres.length;
}
// Fonction principale
void main() {
List notes = [15, 18, 12, 20, 16];
double moyenne = calculerMoyenne(notes);
print('La moyenne est : $moyenne');
} 🔤 Variables
En Dart, les variables peuvent être déclarées avec un type explicite ou avec var (inférence de type). Dart est un langage à typage optionnel.
#include
int main() {
// Déclaration de variables
int age = 30; // Entier
float prix = 19.99f; // Nombre décimal (simple précision)
double decimal = 3.14159; // Nombre décimal (double précision)
char lettre = 'A'; // Caractère unique
char nom[] = "C"; // Chaîne de caractères (tableau)
// Affichage avec printf
printf("Age: %d\n", age);
printf("Prix: %.2f\n", prix);
printf("Decimal: %lf\n", decimal);
printf("Lettre: %c\n", lettre);
printf("Nom: %s\n", nom);
// Déclaration puis assignation
int nombre;
nombre = 10;
printf("Nombre: %d\n", nombre);
// Constantes avec #define
#define PI 3.14159
#define MAX_SIZE 100
// Constantes avec const
const int TAILLE = 50;
const char* MESSAGE = "Bonjour";
// Noms de variables valides
int age_utilisateur = 25;
char nom_utilisateur[] = "Bassirou";
float _prive = 3.14; // Possible mais non recommandé
return 0;
} 📌 Règles pour les noms de variables :
- Doivent commencer par une lettre ou un underscore
_ - Peuvent contenir des lettres, chiffres et underscores
- Ne peuvent pas contenir d'espaces ou de caractères spéciaux
- Sont sensibles à la casse (
age≠Age) - Ne peuvent pas être des mots-clés Dart (
if,for,int,class, etc.) - Convention : utilisez
camelCasepour les variables locales,PascalCasepour les classes
📊 Types de données
Dart a plusieurs types de données de base (primitifs). Voici les principaux types disponibles en Dart :
#include
#include // Pour le type bool
int main() {
// Types entiers
char c = 'A'; // 1 octet (-128 à 127 ou 0 à 255)
short s = 100; // 2 octets (-32768 à 32767)
int i = 1000; // 4 octets (généralement)
long l = 100000L; // 4 ou 8 octets
long long ll = 1000000LL; // 8 octets
// Types entiers non signés
unsigned char uc = 200;
unsigned int ui = 5000;
unsigned long ul = 100000UL;
// Types décimaux
float f = 3.14f; // 4 octets (simple précision)
double d = 3.14159; // 8 octets (double précision)
long double ld = 3.141592653589793L; // 10 ou 16 octets
// Type booléen (C99+)
bool est_vrai = true;
bool est_faux = false;
// Chaînes de caractères (tableaux de char)
char chaine[] = "Hello"; // Tableau de caractères
char* pointeur = "World"; // Pointeur vers une chaîne
// Affichage avec printf
printf("char: %c\n", c);
printf("int: %d\n", i);
printf("float: %.2f\n", f);
printf("double: %lf\n", d);
printf("bool: %d\n", est_vrai);
printf("chaine: %s\n", chaine);
// Taille des types (en octets)
printf("Taille de int: %zu octets\n", sizeof(int));
printf("Taille de float: %zu octets\n", sizeof(float));
printf("Taille de double: %zu octets\n", sizeof(double));
return 0;
} 📚 Types de données Dart :
- int - Entier
- double - Nombre décimal
- String - Chaîne de caractères
- bool - Booléen (true/false)
- List - Liste (tableau dynamique)
- Map - Dictionnaire (clé-valeur)
- Set - Ensemble (valeurs uniques)
- dynamic - Type dynamique
- var - Inférence de type
🔢 Opérateurs
Dart supporte les opérateurs arithmétiques, de comparaison, logiques, d'assignation et de null-safety :
#include
#include // Pour pow()
int main() {
int a = 10, b = 3;
// Opérateurs arithmétiques
printf("%d + %d = %d\n", a, b, a + b); // Addition: 13
printf("%d - %d = %d\n", a, b, a - b); // Soustraction: 7
printf("%d * %d = %d\n", a, b, a * b); // Multiplication: 30
printf("%d / %d = %d\n", a, b, a / b); // Division entière: 3
printf("%d %% %d = %d\n", a, b, a % b); // Modulo (reste): 1
// Division avec float
float resultat = (float)a / b;
printf("%d / %d = %.2f\n", a, b, resultat); // Division: 3.33
// Puissance (nécessite math.h)
double puissance = pow(a, b);
printf("%d^%d = %.0f\n", a, b, puissance); // Puissance: 1000
// Opérateurs de comparaison
printf("%d > %d = %d\n", a, b, a > b); // 1 (true)
printf("%d < %d = %d\n", a, b, a < b); // 0 (false)
printf("%d >= %d = %d\n", a, b, a >= b); // 1 (true)
printf("%d <= %d = %d\n", a, b, a <= b); // 0 (false)
printf("%d == %d = %d\n", a, b, a == b); // 0 (false)
printf("%d != %d = %d\n", a, b, a != b); // 1 (true)
// Opérateurs logiques
int x = 1, y = 0; // 1 = true, 0 = false
printf("%d && %d = %d\n", x, y, x && y); // ET logique: 0
printf("%d || %d = %d\n", x, y, x || y); // OU logique: 1
printf("!%d = %d\n", x, !x); // NON logique: 0
// Opérateurs d'assignation
int c = 5;
c += 3; // Équivalent à c = c + 3 (c devient 8)
c -= 2; // Équivalent à c = c - 2 (c devient 6)
c *= 2; // Équivalent à c = c * 2 (c devient 12)
c /= 3; // Équivalent à c = c / 3 (c devient 4)
c %= 3; // Équivalent à c = c % 3 (c devient 1)
// Opérateurs d'incrémentation/décrémentation
int i = 5;
printf("i = %d\n", i++); // Post-incrémentation: affiche 5, puis i = 6
printf("i = %d\n", ++i); // Pré-incrémentation: i = 7, puis affiche 7
return 0;
} 🔀 Structures conditionnelles
Le langage Dart utilise if, else if et else pour les conditions. Les blocs de code sont délimités par des accolades {}.
# Structure if simple
age = 20
if age >= 18:
print("Vous êtes majeur")
else:
print("Vous êtes mineur")
# Structure if/elif/else
age = 15
if age >= 18:
print("Vous êtes majeur")
print("Vous pouvez voter")
elif age >= 13:
print("Vous êtes adolescent")
elif age >= 6:
print("Vous êtes enfant")
else:
print("Vous êtes un bébé")
# Conditions multiples
note = 85
if note >= 90:
mention = "Excellent"
elif note >= 80:
mention = "Très bien"
elif note >= 70:
mention = "Bien"
elif note >= 60:
mention = "Assez bien"
else:
mention = "Insuffisant"
print(f"Votre mention : {mention}")
# Opérateur ternaire (expression conditionnelle)
age = 20
statut = "Majeur" if age >= 18 else "Mineur"
print(statut)
# Conditions avec and/or
age = 25
permis = True
if age >= 18 and permis:
print("Vous pouvez conduire")
else:
print("Vous ne pouvez pas conduire")🔄 Boucles
Le langage Dart propose plusieurs types de boucles : for (pour itérer un nombre défini de fois), while (pour répéter tant qu'une condition est vraie), do-while (exécute au moins une fois) et for-in (pour parcourir des collections) :
# Boucle for avec range()
for i in range(5):
print(i) # Affiche 0, 1, 2, 3, 4
# range() avec début et fin
for i in range(1, 6):
print(i) # Affiche 1, 2, 3, 4, 5
# range() avec pas
for i in range(0, 10, 2):
print(i) # Affiche 0, 2, 4, 6, 8
# Boucle for avec liste
fruits = ["pomme", "banane", "orange"]
for fruit in fruits:
print(f"J'aime les {fruit}")
# Boucle for avec index (enumerate)
fruits = ["pomme", "banane", "orange"]
for index, fruit in enumerate(fruits):
print(f"{index}: {fruit}")
# Boucle while
compteur = 0
while compteur < 5:
print(compteur)
compteur += 1
# Boucle while avec break
compteur = 0
while True:
print(compteur)
compteur += 1
if compteur >= 5:
break # Sortir de la boucle
# continue (passer à l'itération suivante)
for i in range(10):
if i % 2 == 0: # Si i est pair
continue # Passer au suivant
print(i) # Affiche seulement les impairs: 1, 3, 5, 7, 9
# Boucle for avec else
for i in range(5):
print(i)
else:
print("Boucle terminée") # Exécuté si la boucle se termine normalement⚙️ Fonctions
Les fonctions permettent de réutiliser du code. En Dart, on définit une fonction avec son type de retour (optionnel), son nom et ses paramètres. Les fonctions peuvent prendre des paramètres et retourner des valeurs avec return.
# Fonction simple (sans paramètres)
def dire_bonjour():
print("Bonjour !")
dire_bonjour() # Appel de la fonction
# Fonction avec paramètres
def saluer(nom):
return f"Bonjour, {nom} !"
message = saluer("Python")
print(message) # "Bonjour, Python !"
# Fonction avec plusieurs paramètres
def additionner(a, b):
return a + b
resultat = additionner(5, 3)
print(resultat) # 8
# Fonction avec paramètres par défaut
def saluer_personne(nom, message="Bonjour"):
return f"{message}, {nom} !"
print(saluer_personne("Bassirou")) # "Bonjour, Bassirou !"
print(saluer_personne("Bassirou", "Salut")) # "Salut, Bassirou !"
# Fonction avec arguments nommés
def creer_personne(nom, age, ville="Dakar"):
return f"{nom}, {age} ans, habite à {ville}"
print(creer_personne("Bassirou", 25))
print(creer_personne(age=25, nom="Bassirou", ville="Thiès"))
# Fonction avec *args (arguments variables)
def additionner_nombres(*args):
return sum(args)
print(additionner_nombres(1, 2, 3, 4, 5)) # 15
# Fonction avec **kwargs (arguments nommés variables)
def afficher_info(**kwargs):
for cle, valeur in kwargs.items():
print(f"{cle}: {valeur}")
afficher_info(nom="Bassirou", age=25, ville="Dakar")
# Fonction lambda (fonction anonyme)
carre = lambda x: x ** 2
print(carre(5)) # 25
# Utilisation de lambda avec map()
nombres = [1, 2, 3, 4, 5]
carres = list(map(lambda x: x ** 2, nombres))
print(carres) # [1, 4, 9, 16, 25]🏛️ Classes et objets
En Dart, tout est orienté objet. Les classes permettent de créer des types personnalisés avec des propriétés et des méthodes.
// Définition d'une classe
class Personne {
// Propriétés
String nom;
int age;
double taille;
// Constructeur
Personne(this.nom, this.age, this.taille);
// Méthode
void afficher() {
print('Nom: $nom, Age: $age, Taille: ${taille}m');
}
}
void main() {
// Création d'objets
Personne p1 = Personne('Bassirou', 25, 1.75);
Personne p2 = Personne('Aminata', 30, 1.65);
p1.afficher();
p2.afficher();
}🔀 Mixins
Les mixins permettent de réutiliser du code dans plusieurs classes sans héritage.
// Définition d'un mixin
mixin Voler {
void voler() {
print('Je vole !');
}
}
mixin Nager {
void nager() {
print('Je nage !');
}
}
class Oiseau with Voler {
String nom;
Oiseau(this.nom);
}
class Canard with Voler, Nager {
String nom;
Canard(this.nom);
}
void main() {
Oiseau oiseau = Oiseau('Aigle');
oiseau.voler();
Canard canard = Canard('Colvert');
canard.voler();
canard.nager();
}⚡ Futures et async/await
Dart supporte la programmation asynchrone avec Futures et async/await pour les opérations non-bloquantes.
import 'dart:async';
// Fonction asynchrone
Future téléchargerDonnées() async {
await Future.delayed(Duration(seconds: 2));
return 'Données téléchargées';
}
void main() async {
print('Début du téléchargement...');
String données = await téléchargerDonnées();
print(données);
// Utilisation de then()
téléchargerDonnées().then((données) {
print('Avec then(): $données');
});
} 🌊 Streams
Les Streams permettent de gérer des séquences de données asynchrones.
import 'dart:async';
Stream compter() async* {
for (int i = 1; i <= 5; i++) {
await Future.delayed(Duration(seconds: 1));
yield i;
}
}
void main() async {
await for (int nombre in compter()) {
print('Nombre: $nombre');
}
} 📱 Flutter - Introduction
Flutter utilise Dart pour créer des applications multiplateformes avec un seul codebase.
import 'package:flutter/material.dart';
void main() {
runApp(MyApp());
}
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Mon App',
home: Scaffold(
appBar: AppBar(
title: Text('Bienvenue'),
),
body: Center(
child: Text('Hello Flutter!'),
),
),
);
}
}💡 Note importante : Dart utilise un garbage collector (GC) pour gérer automatiquement la mémoire. Vous n'avez pas besoin de libérer manuellement la mémoire comme en C/C++. Le GC s'occupe de libérer les objets non utilisés automatiquement.
🎓 Prochaines étapes
Félicitations ! Vous avez maintenant une solide base en Dart.
✅ Ce que vous avez appris :
- Syntaxe Dart et variables
- Types de données (int, double, String, bool, List, Map)
- Opérateurs (arithmétiques, comparaison, logiques, null-safety)
- Structures conditionnelles (if, else if, else, switch)
- Boucles (for, while, do-while, for-in)
- Fonctions (définition, paramètres, return, arrow functions)
- Classes et objets (encapsulation, constructeurs)
- Mixins et héritage
- Futures et async/await
- Streams
- Flutter - Widgets et State Management
🚀 Pour aller plus loin :
- 📚 Flutter avancé - Navigation, State Management, Animations
- 🔧 Packages Dart - Utilisation de packages pub.dev
- 📦 Flutter Web - Développement d'applications web
- 🌐 Flutter Desktop - Applications desktop multiplateformes
- 📊 State Management - Provider, Riverpod, Bloc
- 🤖 API et HTTP - Consommation d'API REST