Aller au contenu principal

Module Dart.2 – Syntaxe & bases

Objectif​

Maîtriser la syntaxe fondamentale de Dart : structure main(), print, déclaration de variables avec var/final/const pour créer vos premiers programmes.

Théorie​

main()​

Point d'entrée de toute application Dart.

Structure de base :

void main() {
    print('Bonjour le monde');
}

Avec paramètres :

void main(List<String> args) {
    print('Arguments : ${args.length}');
    for (var arg in args) {
        print(arg);
    }
}

Top-level functions : En Dart, les fonctions peuvent être définies au niveau supérieur (pas besoin de classe).

void saluer() {
    print('Bonjour');
}

void main() {
    saluer();  // Appelle la fonction top-level
}

print​

Affiche du texte dans la console.

Utilisation de base :

print('Message simple');
print('Variable : $variable');
print('Plusieurs valeurs : $a, $b, $c');

String interpolation :

String nom = 'Jean';
int age = 30;

print('Bonjour $nom');                    // Bonjour Jean
print('Bonjour ${nom.toUpperCase()}');     // Bonjour JEAN
print('$nom a $age ans');                 // Jean a 30 ans
print('Dans 10 ans, ${nom} aura ${age + 10} ans');

Formatage :

double prix = 19.99;
print('Prix : ${prix.toStringAsFixed(2)}');  // Prix : 19.99

Variables​

Déclaration avec type explicite​

int age = 25;
String nom = 'Jean';
double prix = 19.99;
bool estActif = true;

var (inférence de type)​

Dart infère automatiquement le type.

var age = 25;        // Type inféré : int
var nom = 'Jean';     // Type inféré : String
var prix = 19.99;     // Type inféré : double
var estActif = true;  // Type inféré : bool

// Une fois déclaré, le type est fixe
var nombre = 42;
// nombre = 'texte';  // Erreur : ne peut pas changer de type

final​

Variable qui ne peut être assignée qu'une seule fois (runtime constant).

final age = 25;
final String nom = 'Jean';

// age = 30;  // Erreur : ne peut pas réassigner

// Utile pour valeurs calculées
final dateActuelle = DateTime.now();  // Calculée à l'exécution

Caractéristiques :

  • Assignée une seule fois
  • Peut être calculée à l'exécution
  • Type peut être inféré ou explicite

const​

Constante de compilation (valeur connue à la compilation).

const pi = 3.14159;
const String siteName = 'Mon Site';
const maxUsers = 100;

// const date = DateTime.now();  // Erreur : pas connu à la compilation

Caractéristiques :

  • Valeur connue à la compilation
  • Plus performant (optimisé)
  • Ne peut pas être calculée à l'exécution

Comparaison var/final/const​

var variable = 42;           // Modifiable, type inféré
final finale = 42;           // Non modifiable, calculée à runtime
const constante = 42;        // Non modifiable, valeur compile-time

variable = 50;               // OK
// finale = 50;              // Erreur
// constante = 50;           // Erreur

Quand utiliser :

  • var : Variable modifiable, type évident
  • final : Variable non modifiable, valeur runtime
  • const : Constante, valeur compile-time

Règles de nommage​

Variables et fonctions : camelCase

var nomUtilisateur = 'Jean';
void calculerMoyenne() {}

Classes : PascalCase

class Personne {}
class GestionnaireUtilisateurs {}

Constantes : lowerCamelCase ou UPPER_SNAKE_CASE

const maxSize = 100;
const MAX_SIZE = 100;  // Alternative

Commentaires​

// Commentaire sur une ligne

/* Commentaire
   sur plusieurs
   lignes */

/// Documentation (dartdoc)
/// Description de la fonction
/// 
/// [nom] Le nom de la personne
void saluer(String nom) {
    print('Bonjour $nom');
}

Exercice​

  1. Programme de base

    • Créez un programme avec main()
    • Utilisez print avec interpolation
    • Testez différents formats

  2. Variables

    • Déclarez des variables avec types explicites
    • Utilisez var pour inférence
    • Testez final et const

  3. Comparaison

    • Comparez var, final, const
    • Testez les limitations de chacun
    • Comprenez quand utiliser quoi

  4. Arguments

    • Créez un programme qui utilise args
    • Passez des arguments à l'exécution
    • Affichez tous les arguments

  5. Formatage

    • Utilisez l'interpolation de chaînes
    • Formatez des nombres
    • Créez des messages complexes

Quiz​

  1. Quel est le point d'entrée en Dart ?

    • start()
    • main()
    • run()

  2. Quelle est la différence entre final et const ?

    • Aucune différence
    • final = runtime, const = compile-time
    • const est plus rapide

  3. Que fait var en Dart ?

    • Crée une variable globale
    • Infère le type automatiquement
    • Rend la variable constante

  4. Comment interpoler une variable dans une chaîne ?

    • ${variable}
    • $variable ou ${expression}
    • %variable

  5. Peut-on réassigner une variable final ?

    • Oui
    • Non, seulement une fois
    • Seulement si const

Mini défi​

Mission : Créer une application console interactive

Créez un programme interaction.dart qui :

  1. Demande des informations

    • Utilisez args ou simulez avec des valeurs
    • Demandez nom, age, ville

  2. Affiche un message personnalisé

    • Utilisez l'interpolation de chaînes
    • Formatez avec print
    • Ajoutez des sauts de ligne

  3. Calculs

    • Calculez l'année de naissance
    • Affichez avec formatage

  4. Constantes

    • Utilisez const pour des valeurs fixes
    • Utilisez final pour des valeurs calculées
    • Affichez les constantes

Exemple de sortie :

========================================
     INFORMATIONS PERSONNELLES
========================================
Nom          : Jean
Age          : 30 ans
Ville        : Paris
Année naiss. : 1996
========================================

Critères :

  • ✅ Utilisation correcte de main()
  • ✅ Variables bien typées (var, final, const)
  • ✅ Interpolation de chaînes
  • ✅ Code propre et commenté
  • ✅ Formatage clair

Objectif : Maîtriser la syntaxe de base de Dart et créer des programmes console interactifs.

Validation : Vous pouvez passer au module suivant quand vous maîtrisez main(), print, variables et pouvez créer des programmes console simples.