Module Dart.3 – Types

Objectif

Maîtriser le typage fort de Dart et le null safety pour éviter les erreurs de null et créer du code robuste.

Théorie

Typage fort

Dart est un langage à typage statique avec inférence de type.

Types primitifs

int : Entiers

int age = 25;
int negatif = -10;
int hexa = 0xFF;        // 255 en hexadécimal
int binaire = 0b1010;   // 10 en binaire

double : Nombres décimaux

double prix = 19.99;
double scientifique = 1.5e3;  // 1500.0

num : Type parent de int et double

num nombre = 42;    // Peut être int ou double
nombre = 3.14;      // OK : peut changer de type

String : Chaînes de caractères

String nom = 'Jean';
String message = "Bonjour";
String multiLigne = '''
Ligne 1
Ligne 2
''';

bool : Booléens

bool estActif = true;
bool estVide = false;

Inférence de type

Dart infère automatiquement le type.

var age = 25;        // int
var prix = 19.99;     // double
var nom = 'Jean';     // String
var actif = true;     // bool

Type explicite vs inféré :

int age1 = 25;        // Type explicite
var age2 = 25;        // Type inféré (int)
// Les deux sont équivalents

Null safety

Depuis Dart 2.12, null safety est activé par défaut.

Principe

Par défaut, les variables ne peuvent pas être null.

String nom = 'Jean';
// nom = null;  // Erreur : ne peut pas être null

Types nullable

Ajouter ? pour permettre null.

String? nomNullable = null;  // Peut être null
String nom = 'Jean';          // Ne peut pas être null

nomNullable = 'Marie';  // OK
nomNullable = null;     // OK

Vérification null

if null check :

String? nom = null;

if (nom != null) {
    print(nom.length);  // OK : Dart sait que nom n'est pas null
}

Null-aware operators :

?? (null coalescing) : Valeur par défaut si null

String? nom = null;
String resultat = nom ?? 'Inconnu';  // 'Inconnu'

??= (null-aware assignment) : Assigner seulement si null

String? nom;
nom ??= 'Par défaut';  // Assigné seulement si null

?. (null-aware access) : Accès sécurisé

String? nom = null;
int? longueur = nom?.length;  // null (pas d'erreur)
String majuscules = nom?.toUpperCase() ?? 'Vide';

! (null assertion) : Forcer non-null (dangereux)

String? nom = obtenirNom();
String force = nom!;  // Force non-null (crash si null)

Promotion de type

Dart promeut automatiquement les types nullable vers non-nullable après vérification.

String? nom = obtenirNom();

if (nom != null) {
    // Ici, nom est promu en String (non-nullable)
    print(nom.length);  // Pas besoin de ?
}

Types dynamiques

dynamic : Désactive le typage statique (à éviter sauf cas spécifiques).

dynamic variable = 42;
variable = 'texte';    // OK : dynamic permet tout
variable = true;       // OK

Object? : Type de base de tous les objets (peut être null).

Object? objet = 42;
objet = 'texte';
objet = null;

Vérification de types

is : Vérifie le type

var valeur = 42;

if (valeur is int) {
    print('C\'est un int');
}

if (valeur is! String) {
    print('Ce n\'est pas un String');
}

as : Cast de type

Object objet = 'texte';
String texte = objet as String;  // Cast explicite

runtimeType : Type à l'exécution

var valeur = 42;
print(valeur.runtimeType);  // int

Conversions de types

Vers String :

int age = 30;
String ageStr = age.toString();
String ageStr2 = '$age';  // Interpolation

Depuis String :

String nombre = '42';
int i = int.parse(nombre);
double d = double.parse('3.14');

Gestion d'erreurs :

String? nombre = '42';
int? i = int.tryParse(nombre ?? '0');  // null si échec

Exercice

1. Types primitifs

   • Testez tous les types primitifs
   • Comprenez les limites
   • Testez les conversions

2. Null safety

   • Créez des variables nullable
   • Testez les null-aware operators
   • Comprenez la promotion de type

3. Vérifications

   • Utilisez is et as
   • Testez runtimeType
   • Vérifiez les types dynamiquement

4. Conversions

   • Convertissez entre types
   • Utilisez parse et tryParse
   • Gèrez les erreurs

5. Cas pratiques

   • Créez un système avec null safety
   • Utilisez les opérateurs appropriés
   • Évitez les erreurs de null

Quiz

1. Que signifie String? ?

   • String obligatoire
   • String ou null
   • String avec valeur par défaut

2. Que fait l'opérateur ?? ?

   • Compare deux valeurs
   • Valeur par défaut si null
   • Force non-null

3. Que fait ?. ?

   • Accès normal
   • Accès sécurisé (retourne null si null)
   • Force l'accès

4. Que signifie is en Dart ?

   • Conversion de type
   • Vérification de type
   • Assignation

5. Comment convertir String en int de manière sécurisée ?

   • int.parse()
   • int.tryParse() (retourne null si échec)
   • (int) string

Mini défi

Mission : Créer un système de validation de types

Créez des fonctions qui valident et convertissent les types :

Fonctions :

1. Validation (estNombre, estEntier, estChaine)
2. Conversion sécurisée (versInt, versDouble avec défaut)
3. Gestion null (valeurs nullable, opérateurs null-aware)
4. Tests complets avec cas limites

Critères :

• ✅ Utilisation correcte du null safety
• ✅ Opérateurs null-aware appropriés
• ✅ Gestion d'erreurs complète
• ✅ Code robuste

Objectif : Maîtriser le typage fort et null safety pour créer du code robuste.

---

Validation : Vous pouvez passer au module suivant quand vous maîtrisez les types et null safety.