Variables et types de données Dart

Les variables sont les unités de base pour stocker des données dans un programme, et les types de données déterminent quelles valeurs une variable peut stocker.

Ce chapitre présente les méthodes de déclaration de variables, les types de données de base et le mécanisme important de null safety en Dart.


Méthodes de déclaration de variables : var, final, const

Dart fournit trois mots-clés pour déclarer des variables, chacun adapté à des scénarios différents.

Comprendre leurs différences est la première étape pour bien apprendre Dart.

var — Variables à type inféré

Les variables déclarées avec var ont leur type automatiquement inféré à partir de la valeur initiale, et une fois le type déterminé, il ne peut pas être modifié.

Exemple

void main() {
  // Inférence de type : le type de name est inféré en String
  var name = 'EXAMPLE';

  // Inférence de type : le type de age est inféré en int
  var age = 10;

  print('$name a déjà $age ans');

  // Le code suivant provoquera une erreur — une fois le type déterminé, vous ne pouvez pas assigner une valeur d'un autre type
  // name = 123; // Erreur : impossible d'assigner int à String
}
EXAMPLE 已经 10 年了

var n'est pas « non typé » ou « dynamic » ; son type est fixé au moment de l'assignation. Ceci est complètement différent de var en JavaScript.

final — constante d'exécution

Les variables déclarées avec final ne peuvent être assignées qu'une seule fois, mais le moment de l'assignation peut être retardé jusqu'à l'exécution.

Exemple

void main() {
  // variable final : une fois assignée, ne peut pas être modifiée
  final currentTime = DateTime.now();
  print('Heure actuelle : $currentTime');

  // L'assignation différée est également autorisée
  final String greeting;
  greeting = 'Bonjour, EXAMPLE!';  // Première assignation OK
  // greeting = 'Hello again'; // Erreur : variable final ne peut pas être réassignée

  print(greeting);
}
当前时间: 2026-06-12 10:30:00.000
Hello, EXAMPLE!

const — Constantes à la compilation

const est plus strict que final : sa valeur doit être déterminable à la compilation.

Exemple

void main() {
  // const doit être déterminé à la compilation
  const siteName = 'EXAMPLE';
  const maxUsers = 100;

  print('Site : $siteName, nombre maximal d’utilisateurs : $maxUsers');

  // Ce qui suit provoquera une erreur : DateTime.now() est une valeur qui ne peut être déterminée qu’à l’exécution
  // const currentTime = DateTime.now(); // Erreur !
}
站点: EXAMPLE, 最大用户数: 100

Résumé comparatif des trois

Mots-clésModifiableMoment de l’affectationScénarios typiques
varOuiAnyVariables ordinaires dont les valeurs peuvent changer
finalNon modifiableExécutionConfiguration récupérée depuis une API, l'heure actuelle.
constNon modifiableAu moment de la compilationConstantes mathématiques, configurations fixes, valeurs de couleur

Un conseil pratique : utilisez final par défaut. Lorsque vous constatez que vous devez le modifier, remplacez-le par var. Cette habitude rend le code plus sûr et réduit les bogues causés par des modifications accidentelles.


Types numériques : int et double

Les types numériques de Dart se divisent en deux catégories : int (entier) et double (nombre à virgule flottante).

Leur classe parente commune est num.

Exemple

void main() {
  // int : entier, plage de -2^63 à 2^63-1
  int viewCount = 10000;
  int negativeNumber = -42;

  // double : nombre à virgule flottante à double précision
  double price = 9.99;
  double pi = 3.1415926;

  // num peut accepter à la fois int et double
  num someNumber = 10;
  someNumber = 10.5;  // Valide

  print(Nombre de vues : $viewCount);
  print(Prix : ¥$price);
  print('Pi: $pi');
}
浏览次数: 10000
Price: ¥9.99
圆周率: 3.1415926

Méthodes courantes pour les nombres

Exemple

import 'dart:math';  // Importer la bibliothèque mathématique

void main() {
  int a = -10;
  double b = 3.7;

  // Valeur absolue
  print(Valeur absolue de a : ${a.abs()});   // 10

  // Arrondir à l'entier le plus proche
  print(b arrondi : ${b.round()});  // 4

  // Arrondir vers le bas
  print(b arrondi vers le bas : ${b.floor()});  // 3

  // Arrondir au supérieur
  print(b ceil: ${b.ceil()});   // 4

  // Convertir une chaîne en nombre
  int parsed = int.parse('42');
  double parsedDouble = double.parse('3.14');
  print(Résultat analysé : $parsed, $parsedDouble);

  // Générer un nombre aléatoire (nécessite l'importation de 'dart:math')
  var random = Random().nextInt(100);
  print(Nombre aléatoire (0-99) : $random);
}
a 的绝对值: 10
b 四舍五入: 4
b 向下取整: 3
b 向上取整: 4
解析结果: 42, 3.14
随机数(0-99): 67

String : String et syntaxe d'interpolation.

String est utilisé pour représenter du texte. Les chaînes Dart prennent en charge à la fois les guillemets simples et doubles.

L'interpolation de chaînes est l'une des fonctionnalités les plus pratiques de Dart.

Exemple

void main() {
  // Les chaînes de caractères peuvent utiliser des guillemets simples ou doubles
  String singleQuoted = 'Hello';
  String doubleQuoted = "World";

  // Chaînes de caractères multilignes : utilisez des guillemets triples
  String multiLine = '''
This is the first line
This is the second line
This is the third line - EXAMPLE
  '
'';

  // Interpolation de chaînes : utilisez $variableName ou ${expression}
  String site = 'EXAMPLE';
  int years = 10;

  // $variableName : référence directement la variable
  print(Bienvenue sur $site);

  // ${expression} : intégrer des expressions complexes
  print($site nous accompagne depuis ${years + 1} ans);

  // Caractères d'échappement
  print('Caractère de saut de ligne : première ligne\ndeuxième ligne');
  print('Tabulation : Colonne 1\tcolonne 2');
}
欢迎来到 EXAMPLE
EXAMPLE 已经陪伴我们 11 年了
换行符: 第一行
第二行
制表符: 列1    列2

Méthodes courantes pour les chaînes de caractères

Exemple

void main() {
  Texte de chaîne = ' Hello, EXAMPLE! ';

  // Supprimer les espaces de début et de fin
  print('trim : [${text.trim()}]');

  // Convertir en majuscules / minuscules
  print('Majuscules : ${text.toUpperCase()}');
  print('Minuscules: ${text.toLowerCase()}');

  // S'il contient une sous-chaîne
  print('Contient EXAMPLE? ${text.contains('EXAMPLE')}');

  // S'il commence/se termine par une certaine chaîne
  print(Commence par un espace? ${text.startsWith(' ')}');
  print('Se termine par !? ${text.trim().endsWith('!')}');

  // Remplacement de chaîne
  print(Remplacer: ${text.replaceAll(EXAMPLE', 'DART')}');

  // Découpage de chaîne
  String csv = 'Dart,Flutter,Google';
  List<String> items = csv.split(',');
  print(Résultat du découpage: $items);

  // Concaténation de chaînes de caractères
  print(Concaténation : + 'Hello' + ', ' + 'World');
}
trim: [Hello, EXAMPLE!]
大写:   HELLO, EXAMPLE!
小写:   hello, example!
包含 EXAMPLE? true
以空格开头? true
以!结尾? true
替换:   Hello, DART!
分割结果: [Dart, Flutter, Google]
拼接: Hello, World

Valeur booléenne bool

Le type bool n'a que deux valeurs : true et false.

Il est principalement utilisé pour les tests conditionnels, avec les instructions if.

Exemple

void main() {
  bool isLoggedIn = true;
  bool hasPermission = false;

  // Expression booléenne
  bool canAccess = isLoggedIn && hasPermission;  // ET : les deux valent true
  bool isGuest = !isLoggedIn;                    // NON : négation

  print(Peut accéder : $canAccess);
  print(Est invité : $isGuest);

  // Les opérations de comparaison produisent des valeurs booléennes.
  int age = 20;
  bool isAdult = age >= 18;
  print(Est adulte : $isAdult);

  // Utilisé directement pour l'évaluation de condition
  if (isAdult) {
    print(Bienvenue à EXAMPLE);
  }
}
可以访问: false
是访客: false
是否成年: true
欢迎访问 EXAMPLE

Dart est un langage fortement typé, et les jugements conditionnels n'acceptent que le type bool. Ceci est différent de JavaScript—en Dart, écrire des choses comme if(0) ou if('') provoquera directement une erreur.


Sécurité null

La sécurité null est la fonctionnalité la plus importante introduite dans Dart 2.12.

Son idée centrale est : par défaut, toutes les variables ne peuvent pas être null, sauf si vous le déclarez explicitement.

Types nullables et non-nullables

L'ajout de ? après le type indique que la variable peut être null.

Exemple

void main() {
  // Type non-null : impossible d'assigner null
  String name = 'EXAMPLE';
  // name = null; // Erreur ! name ne peut pas être null

  // Type nullable : peut être null
  String? nickname;
  nickname = null;  // Correct
  nickname = 'R';   // Aussi correct

  print('Surnom : $nickname');

  // int? peut aussi être null
  int? score;
  print('Score : $score');  // Affiche null
}
昵称: R
分数: null

Opérateur de gestion de null

ManipulateursDescriptionExemple
??Si le côté gauche est null, utilisez la valeur du côté droit.name ?? 'nom par défaut'
??=Si la variable est null, affectez la valeur du côté droit.name ??= 'default name'
?.Accès sécurisé : ignorer l'appel lorsque l'objet est null.user?.name
!Assertion non nulle (à utiliser avec prudence)name!

Exemple

void main() {
  String? username;

  // opérateur ?? : si username est null, utiliser la valeur par défaut
  String displayName = username ?? 'EXAMPLE Visitor';
  print(displayName);  // EXAMPLE Visitor

  // opérateur ??= : si null, assigner la valeur
  username ??= 'New user';
  print(username);  // New user

  // ?. accès sécurisé : appeler uniquement si non null
  String? maybeNull;
  print(maybeNull?.length);  // null (pas d'erreur)

  maybeNull = 'Hello';
  print(maybeNull?.length);  // 5

  // ! Assertion : je suis sûr qu'il n'est pas null (lève une exception lorsqu'il est null)
  String definitelyNotNull = 'EXAMPLE';
  print(definitelyNotNull!.length);  // 6
}
EXAMPLE 访客
新用户
null
5
6

Essayez d'éviter d'utiliser l'opérateur d'assertion !. Si vous utilisez ! fréquemment, cela indique un problème possible avec la conception de votre type. Préférez utiliser ??, ??= et ?. pour gérer les valeurs null en toute sécurité.


Conversion de type

En Dart, des valeurs de types différents peuvent être converties entre elles.

Exemple

void main() {
  // Nombre → String
  int count = 42;
  String countStr = count.toString();
  print('Nombre en chaîne : $countStr (type : ${countStr.runtimeType})');

  // String → Nombre
  String priceStr = '19.99';
  double price = double.parse(priceStr);
  print('String en nombre : ¥$price');

  // int &#x2194; double
  int integer = 10;
  double decimal = integer.toDouble();
  print(int en double : $decimal);

  double pi = 3.14;
  int piInt = pi.toInt();  // Tronquer la partie fractionnaire
  print(double en int (tronqué) : $piInt);

  // Toute valeur → chaîne
  bool flag = true;
  print⟦⟧bool en chaîne : ${flag.toString()}(bool to string: ${flag.toString()});

  // String → bool (nécessite un jugement manuel)
  String boolStr = 'true';
  bool parsed = boolStr == 'true';
  print(String en bool : $parsed);
}
数字转字符串: 42 (类型: String)
字符串转数字: ¥19.99
int 转 double: 10.0
double 转 int (截断): 3
bool 转字符串: true
字符串转 bool: true
autres extensions