dart:async propose les fonctionnalités centrales de la programmation asynchrone Dart : Future, Stream.

1. L’utilisation de Future / Stream ne nécessite pas forcément d’importer manuellement dart:async, car dart:core l’exporte déjà ;
2. Si vous voulez utiliser des types comme StreamController, StreamSubscription, ParallelWaitError, vous devez réaliser un import explicite :

import 'dart:async';

Deux concepts fondamentaux :

• Future : représente un résultat asynchrone unique (une seule valeur ou une seule erreur produite à un moment ultérieur)
• Stream : représente une série continue de données asynchrones (produit plusieurs valeurs successivement, comparable à un flux d’événements)

Future

1. async / await

Méthode à privilégier, plus lisible que les appels chaînés .then()

• Toute fonction marquée async renvoie un Future ;
• await attend la fin du Future et suspend l’exécution du code courant jusqu’à réception du résultat ;
• Utilisez try-catch pour intercepter les exceptions asynchrones.

// async 函数返回 Future
Future<String> findEntryPoint() async => "main.dart";
Future<int> runExecutable(String entry, List args) async => 0;
Future<void> flushThenExit(int code) async {}

// await 写法（推荐）
Future<void> runUsingAsyncAwait() async {
  try {
    var entryPoint = await findEntryPoint();
    var exitCode = await runExecutable(entryPoint, []);
    await flushThenExit(exitCode);
  } catch (e) {
    // 统一捕获异常
    print("出错：$e");
  }
}

2. .then() / .catchError() : syntaxe chaînée traditionnelle

• .then() : exécute un rappel quand le Future se termine avec succès ; renvoie un nouveau Future pour continuer la chaîne
• .catchError() : intercepte les erreurs ; doit être chaîné sur le retour de then, sinon les erreurs à l’intérieur du then ne seront pas capturées

void runUsingFuture() {
  findEntryPoint()
      .then((entryPoint) {
        return runExecutable(entryPoint, []);
      })
      .then(flushThenExit)
      .catchError((e) {
        print("异常：$e");
      });
}

3. Attendre plusieurs Futures exécutés en parallèle

① Future.wait()

Attend que toutes les tâches soient terminées ; si un seul Future échoue, l’ensemble échoue immédiatement

Future<void> task1() async {}
Future<void> task2() async {}
Future<void> task3() async {}

void testWait() async {
  await Future.wait([
    task1(),
    task2(),
    task3(),
  ]);
  print("全部任务执行完成");
}

② List.wait / Record.wait (nouvelle fonctionnalité, gestion fine des erreurs concurrentes)

Lève une ParallelWaitError qui permet de distinguer quelles tâches ont réussi et lesquelles ont échoué, sans blocage mutuel.

Future<int> delete() async => 1;
Future<String> copy() async => "ok";
Future<bool> errorTask() async {
  throw Exception("任务失败");
}

void main() async {
  try {
    // 列表形式
    var results = await [delete(), copy(), errorTask()].wait;
  } on ParallelWaitError<List<Object?>, List<AsyncError?>> catch (e) {
    print(e.values);   // 成功有值，失败为null
    print(e.errors);   // 成功为null，失败存放错误信息
  }

  // Record元组形式：支持不同类型Future
  try {
    final (resInt, resStr, resBool) = await (delete(), copy(), errorTask()).wait;
  } on ParallelWaitError<(int?, String?, bool?), (AsyncError?, AsyncError?, AsyncError?)> catch(e) {

  }
}

Stream

Un Stream représente un flux continu de données asynchrones (lecture ligne par ligne d’un fichier, événements de clic sur interface, flux de données réseau).

Deux modes d’utilisation

1 : await for boucle asynchrone (lisible, comparable à une itération synchrone)

Adapté aux flux de données finis ; déconseillé pour des flux d’événements infinis (clics d’interface), car il bloque le reste du code.

import 'dart:io';

Future<void> readFileByAwaitFor() async {
  var file = File("config.txt");
  Stream<List<int>> input = file.openRead();
  var lines = input
      .transform(utf8.decoder)
      .transform(const LineSplitter());

  try {
    await for (final line in lines) {
      print("读取一行：$line");
    }
    print("文件读取完毕");
  } catch (e) {
    print("读取异常 $e");
  }
}

2 .listen() abonnement à l’écoute (adapté aux flux infinis)

inputStream.listen(
  (data) {
    // 收到数据回调
  },
  onError: (err) {
    // 发生错误
  },
  onDone: () {
    // 流正常关闭完成
  },
);

listen renvoie un StreamSubscription sur lequel vous pouvez appeler .cancel() pour annuler l’abonnement.

Méthodes courantes de manipulation de Stream

• Filtrage : where()
• Limitation : take()、takeWhile()
• Saut d’éléments : skip()、skipWhile()
• Récupération d’un seul élément : first、last、single、firstWhere()

Transformation des données Stream avec transform()

Modifie le type des données du flux grâce à un transformateur (cas typique : convertir un flux binaire en chaîne de caractères)

var lines = inputStream
    .transform(utf8.decoder)       // List<int> → String
    .transform(const LineSplitter()); // String → 逐行字符串

Conseil de choix : listen() vs await for

1. Lecture de fichiers, flux de séquences finies → await for
2. Événements d’interface, messages continus et autres flux infinis → .listen()
3. Une fois démarré, await for attend indéfiniment la fin du flux ; un flux infini provoquera un blocage du programme

Bibliothèque dart:async

import 'dart:io';

Attention

dart:io ne fonctionne pas sur la plateforme Web !
Prise en charge : programmes en ligne de commande Dart, serveurs, applications Flutter hors Web (Android/iOS/Windows/macOS/Linux).

Opérations sur les fichiers et répertoires

FileSystemEntity est la classe parente ; File (fichier) et Directory (répertoire) en héritent.

1. Lecture de fichier

Lecture complète (adaptée aux petits fichiers)

void main() async {
  var file = File("config.txt");
  try {
    // Lecture complète sous forme de chaîne (UTF-8)
    String content = await file.readAsString();
    // Lecture complète, découpage par lignes dans un tableau de chaînes
    List<String> lines = await file.readAsLines();
    // Lecture binaire sous forme de tableau d'octets List<int>
    List<int> bytes = await file.readAsBytes();
  } catch (e) {
    print("Échec de la lecture : $e");
  }
}

Exemple complet

Créez préalablement un fichier txt, puis adaptez le chemin ci-dessous : D:/dartdemo/firstdart/bin/config.txt

import 'dart:io';

void main() async {
  var file = File("D:/dartdemo/firstdart/bin/config.txt");
  try {
    // Lecture complète sous forme de chaîne (UTF-8)
    String content = await file.readAsString();
    print("===== readAsString Texte complet =====");
    print(content);

    // Lecture complète, découpage par lignes dans un tableau de chaînes
    List<String> lines = await file.readAsLines();
    print("\n===== readAsLines Lecture ligne par ligne =====");
    for (var line in lines) {
      print(line);
    }

    // Lecture binaire sous forme de tableau d'octets List<int>
    List<int> bytes = await file.readAsBytes();
    print("\n===== readAsBytes Tableau d'octets (30 premiers) =====");
    print(bytes.take(30).toList());
    print("Nombre total d'octets du fichier : ${bytes.length}");
  } catch (e) {
    print("Échec de la lecture : $e");
  }
}

Résultat d’exécution

D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
===== readAsString Texte complet =====
The minimal requirements for a library are:

pubspec file
The pubspec.yaml file for a library is the same as for an application package
—there is no special designation to indicate that the package is a library.

lib directory
As you might expect, the library code lives under the lib directory and is public to other packages. You can create any hierarchy under lib, as needed. By convention, implementation code is placed under lib/src. Code under lib/src is considered private; other packages should never need to import src/.... To make APIs under lib/src public, you can export lib/src files from a file that's directly under lib.

===== readAsLines Lecture ligne par ligne =====
The minimal requirements for a library are:

pubspec file
The pubspec.yaml file for a library is the same as for an application package
—there is no special designation to indicate that the package is a library.

lib directory
As you might expect, the library code lives under the lib directory and is public to other packages. You can create any hierarchy under lib, as needed. By convention, implementation code is placed under lib/src. Code under lib/src is considered private; other packages should never need to import src/.... To make APIs under lib/src public, you can export lib/src files from a file that's directly under lib.

===== readAsBytes Tableau d'octets (30 premiers) =====
[84, 104, 101, 32, 109, 105, 110, 105, 109, 97, 108, 32, 114, 101, 113, 117, 105, 114, 101, 109, 101, 110, 116, 115, 32, 102, 111, 114, 32, 97]
Nombre total d'octets du fichier : 644

Lecture en flux

Recommandé pour les gros fichiers : traitement au fur et à mesure de la lecture

À associer au décodeur de dart:convert, renvoie un Stream<List<int>>

import 'dart:io';
import 'dart:convert';

void main() async {
  var file = File("D:/dartdemo/firstdart/bin/config.txt");
  Stream<List<int>> stream = file.openRead();

  var lineStream = stream
      .transform(utf8.decoder)          // Flux d'octets → flux de chaînes
      .transform(const LineSplitter());  // Chaîne → séparation par lignes

  try {
    await for (var line in lineStream) {
      print(line);
    }
    print("Lecture terminée");
  } catch (e) {
    print(e);
  }
}

Résultat d’exécution

D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
The minimal requirements for a library are:

pubspec file
The pubspec.yaml file for a library is the same as for an application package
—there is no special designation to indicate that the package is a library.

lib directory
As you might expect, the library code lives under the lib directory and is public to other packages. 
You can create any hierarchy under lib, as needed. By convention, implementation code is placed under lib/src.
 Code under lib/src is considered private; other packages should never need to import src/.... To make APIs under lib/src public,
 you can export lib/src files from a file that's directly under lib.
Lecture terminée

2. Écriture de fichier (IOSink)

import 'dart:io';

void main() async {
  var logFile = File("log.txt");
  // FileMode.write : écrase le contenu existant (valeur par défaut)
  var sink = logFile.openWrite(mode: FileMode.write);

  sink.write("Contenu du journal\n");
  sink.add([48,49]); // Écriture d'octets binaires

  await sink.flush(); // Vider le tampon
  await sink.close(); // Fermeture obligatoire

  // Mode d'ajout
  // var sink = logFile.openWrite(mode: FileMode.append);
}

Après exécution

Un fichier log.txt est créé dans le dossier du projet D:\dartdemo\firstdart

Modes disponibles :

• FileMode.write : création avec écrasement
• FileMode.append : ajout à la fin du fichier
• FileMode.writeOnly / readWrite modes lecture-écriture

3. Parcours de répertoire

Directory.list() renvoie un Stream pour parcourir tous les fichiers et dossiers du répertoire

void main() async {
  var dir = Directory("./tmp");
  try {
    var entityStream = dir.list();
    await for (FileSystemEntity entity in entityStream) {
      if (entity is File) {
        print("Fichier : ${entity.path}");
      } else if (entity is Directory) {
        print("Répertoire : ${entity.path}");
      }
    }
  } catch (e) {
    print(e);
  }
}

4. Opérations courantes sur fichiers / répertoires

var f = File("test.txt");
await f.create();          // Créer un fichier
await f.delete();          // Supprimer un fichier
await f.length();          // Obtenir la taille du fichier en octets

var d = Directory("data");
await d.create(recursive: true); // Créer récursivement des sous-répertoires
await d.delete(recursive: true);  // Supprimer récursivement un répertoire

Serveur HTTP HttpServer

Permet de mettre en place un serveur Web Dart, d’écouter un port et de traiter les requêtes.

void main() async {
  // Lier l'adresse et le port
  HttpServer server = await HttpServer.bind("localhost", 8888);
  print("Serveur démarré http://localhost:8888");

  await for (HttpRequest request in server) {
    handleRequest(request);
  }
}

void handleRequest(HttpRequest req) {
  HttpResponse res = req.response;
  if (req.uri.path == "/dart") {
    res.headers.contentType = ContentType.text;
    res.write("Hello Dart HttpServer");
  } else {
    res.statusCode = HttpStatus.notFound;
  }
  res.close(); // Fermer la réponse obligatoirement pour envoyer les données
}

Exemple concret

import 'dart:io';

void main() async {
  // Lier l'adresse et le port
  HttpServer server = await HttpServer.bind("localhost", 8888);
  print("Serveur démarré http://localhost:8888");
  print("Adresse d'accès : http://localhost:8888/dart");

  await for (HttpRequest request in server) {
    handleRequest(request);
  }
}

void handleRequest(HttpRequest req) {
  HttpResponse res = req.response;
  // Vérifier le chemin de la requête
  if (req.uri.path == "/dart") {
    res.headers.contentType = ContentType.text;
    res.write("Hello Dart HttpServer");
  } else if (req.uri.path == "/") {
    res.headers.contentType = ContentType.text;
    res.write("Page d'accueil ! Veuillez accéder à /dart");
  } else {
    res.statusCode = HttpStatus.notFound;
    res.write("404 Not Found");
  }
  res.close(); // Fermer la réponse obligatoirement pour envoyer les données
}

Accédez avec votre navigateur à localhost:8888/dart

Client HTTP HttpClient

Conseil officiel important : évitez d’utiliser directement HttpClient !
HttpClient dépend de dart:io dans son implémentation, sa compatibilité multiplateforme est limitée. Pour les projets, préférez le paquet tiers package:http.

Exemple simplifié à titre informatif :

void main() async {
  var client = HttpClient();
  try {
    var req = await client.getUrl(Uri.parse("https://foxdevelop.com"));
    var res = await req.close();
    await for(var chunk in res) {
      // Recevoir le flux d'octets de la réponse
    }
  } finally {
    client.close();
  }
}

Voici un exemple exécutable

import 'dart:io';
import 'dart:convert';

void main() async {
  var client = HttpClient();
  try {
    var req = await client.getUrl(Uri.parse("https://foxdevelop.com"));
    var res = await req.close();

    // Collecter tous les fragments binaires
    List<int> allBytes = [];
    await for (var chunk in res) {
      allBytes.addAll(chunk);
    }
    // Convertir le tableau d'octets en HTML UTF8
    String html = utf8.decode(allBytes);
    print(html);
  } finally {
    client.close();
  }
}

dart:io

La bibliothèque dart:core est la bibliothèque standard principale de Dart, importée implicitement et automatiquement. Elle fournit les fonctionnalités de base indispensables du langage. Voici ses fonctionnalités principales et des exemples de code classés par module.

Autrement dit, le développeur n’a pas besoin d’écrire d’instruction d’import ; elle se charge par défaut automatiquement.

I. Affichage console

Fonction de premier niveau print() : appelle automatiquement la méthode toString() de l’objet pour afficher du texte.

void main() {
  var tea = "milk tea";
  print(tea);
  print('I drink $tea.');
}

II. Types numériques : num / int / double

1. Relation d’héritage : int et double héritent de num
2. Conversion chaîne vers nombre : parse() ; le type int accepte le paramètre radix pour préciser la base numérique
3. Conversion nombre vers chaîne :

• toString() : conversion simple
• toStringAsFixed(n) : conserve n chiffres après la virgule
• toStringAsPrecision(n) : n chiffres significatifs

void main() {
  // Conversion chaîne vers nombre
  assert(int.parse('42') == 42);
  assert(int.parse('42', radix:16) == 66);
  assert(double.parse('0.5') == 0.5);

  // Conversion nombre vers chaîne
  assert(123.456.toStringAsFixed(2) == '123.46');
  assert(123.456.toStringAsPrecision(2) == '1.2e+2');
}

III. Chaînes String & expressions régulières RegExp

• Les objets String sont immuables (toutes les méthodes de modification renvoient une nouvelle chaîne) ; ils stockent des unités de code UTF-16
• Méthodes courantes : recherche, extraction, découpage, mise en majuscules/minuscules, suppression des espaces

void main() {
  var str = 'Never odd or even';
  // Recherche
  assert(str.contains('odd'));
  assert(str.startsWith('Never'));
  assert(str.endsWith('even'));
  assert(str.indexOf('odd') == 6);

  // Extraction et découpage
  assert(str.substring(6,9) == 'odd');
  var parts = 'a b c'.split(' ');

  // Suppression espaces et vérification vide
  assert('  abc  '.trim() == 'abc');
  assert(''.isEmpty);
  assert('  '.isNotEmpty);

  // Changement de casse
  assert('dart'.toUpperCase() == 'DART');

  // Privilégier StringBuffer pour concaténation (meilleure performance)
  var sb = StringBuffer();
  sb.write('Hello ');
  sb.writeAll(['A','B','C'], ',');
  print(sb.toString());
}

Expressions régulières RegExp

void main() {
  var reg = RegExp(r'\d+'); // Correspond à une suite de chiffres
  var text = 'llamas live 15 to 20 years';

  assert(reg.hasMatch(text));
  // Parcours de toutes les correspondances globales
  for(var m in reg.allMatches(text)){
    print(m.group(0));
  }
  // Remplacement
  var res = text.replaceAll(reg, 'XX');
  print(res);
}

Remarque : une unité de code ne correspond pas forcément à un caractère visible pour l’utilisateur. Pour les caractères Unicode complexes (combinaisons d’emojis), utilisez le paquet externe characters.

IV. Collections (List / Set / Map)

1. List : ordonnée, accepte les doublons, accès par index

void main() {
  var fruits = ['apple','orange'];
  fruits.add('kiwi');
  fruits.addAll(['grape']);
  fruits.removeAt(0);
  fruits.sort((a,b)=>a.compareTo(b)); // Tri des éléments

  // Contrainte générique
  var strList = <String>[];
}

2. Set : non ordonnée, éléments uniques, pas d’accès par index

void main() {
  var set = <String>{};
  set.addAll(['gold','xenon']);
  set.add('gold'); // Ajout d’un doublon sans effet
  assert(set.contains('xenon'));

  // Opération d’intersection
  var set2 = Set.from(['xenon','argon']);
  var inter = set.intersection(set2);
}

3. Map : collection de paires clé-valeur ; les clés sont uniques

void main() {
  var map = {54: 'xenon'};
  print(map[54]);
  assert(map.containsKey(54));
  map.remove(54);

  // Affecte seulement si la clé n’existe pas
  map.putIfAbsent('name', () => 'Dart');

  // Parcours des entrées
  map.forEach((k,v)=>print('$k:$v'));
}

4. Opérations génériques Iterable (List et Set implémentent Iterable)

Méthodes d’ordre supérieur habituelles : forEach, map, where, any, every

void main() {
  var list = ['green','black','chamomile'];
  list.forEach(print);

  // map est évalué paresseusement, toList force l’exécution
  var upperList = list.map((e)=>e.toUpperCase()).toList();

  // Filtrer les éléments
  var filter = list.where((e)=>e == 'chamomile');
  assert(list.any((e)=>e == 'chamomile'));
  assert(!list.every((e)=>e.contains('tea')));
}

V. Gestion des URI (Uri)

Utilisé pour l’encodage, le décodage, l’analyse et la construction d’URL

1. encodeFull : encode uniquement les espaces et caractères similaires, conserve les symboles URL / : ? &
2. encodeComponent : échappe tous les caractères spéciaux (adapté pour encoder les valeurs des paramètres)

void main() {
  // Analyser une url
  var uri = Uri.parse('https://example.org:8080/foo?lang=dart#frag');
  print(uri.scheme);
  print(uri.host);
  print(uri.queryParameters);

  // Construire une url
  var newUri = Uri.https('example.org','/foo', {'lang':'dart'});
}

VI. Dates et heures DateTime & Duration

• DateTime : instant temporel, prend en charge l’heure locale et l’UTC
• Duration : intervalle temporel, pour ajouter/soustraire des instants et calculer des écarts

void main() {
  var now = DateTime.now();
  var y2k = DateTime.utc(2000);

  // Ajout et soustraction temporelle
  var nextYear = y2k.add(const Duration(days:366));
  var diff = nextYear.difference(y2k);
  print(diff.inDays);

  // Horodatage (millisecondes depuis l’époque Unix 1970-01-01 UTC)
  print(y2k.millisecondsSinceEpoch);
}

Attention : les décalages par jour peuvent entraîner des erreurs avec le changement d’heure été/hiver. Privilégiez l’heure UTC.

VII. Interfaces utiles et classes de base

1. Comparable : permet de comparer des objets pour le tri

class Line implements Comparable<Line> {
  final int length;
  const Line(this.length);
  @override
  int compareTo(Line other) => length - other.length;
}

2. Clés personnalisées pour Map : redéfinir == et hashCode

Règle : des objets égaux doivent posséder le même hashCode

class Person {
  final String first, last;
  Person(this.first,this.last);

  @override
  int get hashCode => Object.hash(first, last);

  @override
  bool operator ==(Object other) =>
      other is Person && other.first == first && other.last == other.last;
}

• 3. Iterable + Iterator

Implémenter Iterable permet d’utiliser des boucles for-in avec une logique de parcours personnalisée.

VIII. Gestion des exceptions

• Error : erreur grave, généralement non interceptée (ex: NoSuchMethodError)
• Exception : anomalie prévisible pouvant être interceptée ; vous pouvez créer vos propres exceptions

class FooException implements Exception {
  final String? msg;
  const FooException([this.msg]);
  @override
  String toString() => msg ?? 'FooException';
}

IX. Références faibles et finaliseurs

• WeakReference : référence faible, n’empêche pas le ramasse-miettes de libérer l’objet
• Finalizer / NativeFinalizer : exécute un rappel quand l’objet est libéré, pour libérer des ressources natives
• Finalizable : évite que l’objet soit collecté prématurément par le GC

Bibliothèque principale dart:core

JSON : format textuel léger destiné à représenter des objets et collections structurés.

UTF-8 : codage à largeur variable capable de représenter tous les caractères de l’ensemble Unicode.

import 'dart:convert';

Encodage et décodage JSON

jsonDecode() : Chaîne JSON → Objet Dart

Décode une chaîne au format JSON en un objet Dart.

Attention : les chaînes JSON doivent utiliser des guillemets doubles " ; les apostrophes simples ' ne sont pas autorisées. Ce texte est du JSON, pas du code Dart.

import 'dart:convert';

void main() {
	var jsonString = '''
	  [
		{"score": 40},
		{"score": 80}
	  ]
	''';

	var scores = jsonDecode(jsonString);
	assert(scores is List);

	var firstScore = scores[0];
	assert(firstScore is Map);
	assert(firstScore['score'] == 40);
}

jsonEncode() : Objet Dart → Chaîne JSON

Encode des objets Dart sérialisables en chaîne JSON :

import 'dart:convert';

void main() {
	var scores = [
	  {'score': 40},
	  {'score': 80},
	  {'score': 100, 'overtime': true, 'special_guest': null},
	];

	var jsonText = jsonEncode(scores);
	assert(
	  jsonText ==
		  '[{"score":40},{"score":80},'
			  '{"score":100,"overtime":true,'
			  '"special_guest":null}]',
	);
}

Types pris en charge nativement par JSON

Seuls les types suivants peuvent être directement encodés en JSON :

int, double, String, bool, null, List, Map dont les clés sont des String

List et Map encodent récursivement leurs éléments internes.

Encodage et décodage de caractères UTF-8

utf8.decode() : Tableau d’octets UTF-8 → Chaîne Dart

import 'dart:convert';

void main() {
	List<int> utf8Bytes = [
	  0xc3, 0x8e, 0xc3, 0xb1, 0xc5, 0xa3, 0xc3, 0xa9,
	  0x72, 0xc3, 0xb1, 0xc3, 0xa5, 0xc5, 0xa3, 0xc3,
	  0xae, 0xc3, 0xb6, 0xc3, 0xb1, 0xc3, 0xa5, 0xc4,
	  0xbc, 0xc3, 0xae, 0xc5, 0xbe, 0xc3, 0xa5, 0xc5,
	  0xa3, 0xc3, 0xae, 0xe1, 0xbb, 0x9d, 0xc3, 0xb1,
	];

	var funnyWord = utf8.decode(utf8Bytes);

	assert(funnyWord == 'Îñţérñåţîöñåļîžåţîờñ');
}

Décodage UTF-8 en continu (pour fichiers / flux réseau)

Utilisez utf8.decoder associé à Stream.transform(). Ajoutez LineSplitter pour lire le contenu ligne par ligne :

var lines = utf8.decoder.bind(inputStream).transform(const LineSplitter());
try {
  await for (final line in lines) {
    print('Got ${line.length} characters from stream');
  }
  print('file is now closed');
} catch (e) {
  print(e);
}

utf8.encode() : Chaîne → Tableau d’octets UTF-8 (Uint8List)

Uint8List encoded = utf8.encode('Îñţérñåţîöñåļîžåţîờñ');

assert(encoded.length == utf8Bytes.length);
for (int i = 0; i < encoded.length; i++) {
  assert(encoded[i] == utf8Bytes[i]);
}

Bibliothèque dart:convert

import 'dart:math';

Constantes courantes

print(pi);      // 3,141592653589793 nombre pi
print(e);       // 2,718281828459045 nombre d'Euler
print(sqrt2);   // √2 ≈1,4142

Fonctions trigonométriques

sin() cos() tan() Paramètres : radians. Conversion degrés radians : radians = degrés × pi / 180

void trigDemo() {
  assert(cos(pi) == -1.0);

  int degrees = 30;
  double radians = degrees * pi / 180;
  double result = sin(radians);
  // Ne pas comparer directement les nombres à virgule flottante avec ==, utilisez la valeur absolue de la différence
  assert((result - 0.5).abs() < 0.01);
}

Valeur maximale / minimale

assert(max(1, 1000) == 1000);
assert(min(1, -1000) == -1000);

Nombres aléatoires Random

void randomDemo() {
  final rand = Random();
  double d = rand.nextDouble();   // [0.0, 1.0)
  int i = rand.nextInt(10);       // 0 ~ 9
  bool b = rand.nextBool();       // true / false

  // Générateur sécurisé pour mots de passe et clés cryptographiques
  final secureRand = Random.secure();
}

Fonctions usuelles

sqrt(9);      // Racine carrée 3.0
pow(2, 3);    // Puissance 2^3=8.0
log(e);       // Logarithme népérien
atan2(y, x);  // Arc tangente, utile pour calculer des angles dans un repère

Exemple complet

import 'dart:math';

void main() {
  // Constantes
  print('pi = $pi');
  print('e = $e');

  // Fonctions trigonométriques
  final rad30 = 30 * pi / 180;
  print('sin30° = ${sin(rad30)}');

  // max min
  print('max(2,9) = ${max(2,9)}');
  print('min(2,9) = ${min(2,9)}');

  // Valeurs aléatoires
  final r = Random();
  print('Entier aléatoire 0~9：${r.nextInt(10)}');
  print('[0,1) flottant：${r.nextDouble()}');
  print('Booléen aléatoire：${r.nextBool()}');
}

Exécuter l’exemple

D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
pi = 3.141592653589793
e = 2.718281828459045
sin30° = 0.49999999999999994
max(2,9) = 9
min(2,9) = 2
Entier aléatoire 0~9：9
[0,1) flottant：0.08331912429354282
Booléen aléatoire：false

La bibliothèque dart:math

Ordre des modificateurs [abstract] [base/interface/final/sealed] [mixin] class ; certains modificateurs sont mutuellement exclusifs

1. Sans modificateur

Toute bibliothèque peut instancier, hériter ou implémenter

// a.dart
class Vehicle {
  void move() {}
}

// b.dart
import 'a.dart';
Vehicle v = Vehicle();
class Car extends Vehicle {}
class Mock implements Vehicle {}

2. abstract classe abstraite

Impossible à instancier ; le code externe peut utiliser extends /implements

abstract class Vehicle {
  void move(); // méthode abstraite
}

// Valide
class Car extends Vehicle {
  @override void move() {}
}

class Mock implements Vehicle {
  @override void move() {}
}

// Vehicle(); // Erreur, instanciation interdite

3. base class

√ Autorisé new｜√ extends externe autorisé｜× implements externe interdit

Garantit que les sous-classes héritent bien de l’implémentation de la classe parente et empêche les fausses implémentations externes

// lib/a.dart
base class Vehicle {
  void move() => print("move");
}

// main.dart
import 'a.dart';
Vehicle v = Vehicle();

base class Car extends Vehicle {} // √ Héritage nécessite base/final/sealed

// class Mock implements Vehicle {} // × Implémentation externe interdite

4. interface class

√ Autorisé new｜× extends externe interdit｜√ implements externe autorisé

// a.dart
interface class Vehicle {
  void move() => print("move");
}

// main.dart
import 'a.dart';
Vehicle v = Vehicle();

// class Car extends Vehicle {} // × Héritage externe interdit
class Mock implements Vehicle { // √ Implémentation autorisée
  @override void move() {}
}

abstract interface

Interface pure, très utilisée

Ne peut pas être instanciée ; seul implements est autorisé depuis l’extérieur

abstract interface class Vehicle {
  void move();
}
class Mock implements Vehicle {
  @override void move() {}
}

5. final class

√ Autorisé new｜× extends externe interdit｜× implements externe interdit

Aucune dérivation externe possible, garantit une API publique stable

// a.dart
final class Vehicle {}

// main.dart
import 'a.dart';
Vehicle v = Vehicle();
// class Car extends Vehicle {}    // 
// class Mock implements Vehicle{} // 

6. sealed class (classe scellée)

× Interdit new｜× extends/implements externes interdits ; les sous-classes doivent figurer dans le même fichier

Le compilateur identifie toutes les sous-classes directes et impose une correspondance exhaustive dans les switch

sealed class Vehicle {}

class Car extends Vehicle {}
class Bike extends Vehicle {}

void test(Vehicle v) {
  switch(v) {
    case Car(): print("car");
    case Bike(): print("bike");
  }
}
// Vehicle(); //  sealed est implicitement abstract, instanciation impossible

Exclusions mutuelles

1. sealed + abstract : sealed comporte déjà abstract, combinaison interdite
2. interface/final/sealed + mixin : association impossible
3. Impossible de déclarer simultanément base /interface/final /sealed au même niveau

Class Modifiers Modificateurs de classe

Différence avec les Extensions classiques : les extensions standards ajoutent des méthodes à toutes les instances du type de base ; un Extension Type ne s’applique que quand le type statique correspond à ce type d’extension.

// int est le type de représentation, id désigne la valeur brute sous-jacente
extension type IdNumber(int id) {
  operator <(IdNumber other) => id < other.id;
}

Éléments générés automatiquement :

1. Constructeur implicite IdNumber(int id)
2. Getter : int get id

Deux modes principaux (les plus utilisés)

1) Mode opaque

Interface isolée｜Conseillé pour les contraintes métier

Ne pas écrire le mot-clé implements

Masque les méthodes du type sous-jacent pour appliquer des restrictions d’interface

Aucune affectation directe autorisée entre ce type et le type de base

extension type IdNumber(int id) {
  operator <(IdNumber other) => id < other.id;
}

void main() {
  final id = IdNumber(100);
  id + 5;          // Erreur compilation : pas d'opérateur +, l'addition int est masquée
  final int raw = id; // Erreur, affectation directe interdite
  final int raw = id as int; // Cast explicite pour récupérer la valeur brute
}

2) Mode transparent

implements type-de-représentation

Hérite automatiquement de tous les membres du type sous-jacent ; seul l’ajout ou la redéfinition de méthodes est permis

extension type Num(int v) implements int {
  Num square() => Num(v * v);
}

void main() {
  final n = Num(5);
  print(n.isNegative); // Les méthodes natives de int sont directement exploitables
}

Utilisation des constructeurs

Le paramètre entre parenthèses constitue le constructeur par défaut, il peut être masqué en mode privé grâce à ._

extension type Id._(int _raw) {
  // Le code externe ne peut utiliser que ce constructeur nommé ; appel direct Id(xxx) interdit
  Id.create(int value) : _raw = value;
}

Éléments autorisés : méthodes, getters, setters, opérateurs

Éléments interdits : variables d’instance, membres abstraits

Extension Types

Vous ne pouvez pas modifier les API fournies par des tiers, mais vous aimeriez ajouter des méthodes utilitaires pratiques.

Exemple de besoin : utiliser '42'.parseInt() au lieu de int.parse('42').

Structure syntaxique

extension NomExtension? on TypeCible {
  // Méthodes, getters, setters, opérateurs, membres statiques
}

Exemple

// Mettez tout dans un seul fichier, aucune séparation requise, main s’exécute directement
extension NumberParsing on String {
  int parseInt() {
    return int.parse(this);
  }

  double parseDouble() {
    return double.parse(this);
  }
}

void main() {
  print('42'.parseInt());       // 42
  print('3.14'.parseDouble());  // 3.14
  print('100'.padLeft(6));      // Comparaison avec une méthode native de String
}

Résultat de l’exécution

D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
42
3.14
   100

Le nom de l’extension est facultatif ; this représente l’instance qui appelle l’extension.

Types de membres pris en charge par les extensions

Dans une extension, vous pouvez définir : méthodes d’instance, getters, setters, opérateurs et membres statiques.

extension StringExt on String {
  // getter
  bool get isEmptyOrBlank => trim().isEmpty;

  // Méthode d’instance
  String repeat(int count) => List.filled(count, this).join();

  // Surcharge d’opérateur
  String operator *(int count) => repeat(count);

  // Membre statique (accessible via le nom de l’extension)
  static String emptyStr = '';
  static void printTip() => print("Méthode statique de l’extension chaîne");
}

void main() {
  var str = " dart ";
  print(str.isEmptyOrBlank);
  print("hi" * 3);
  print("hello".repeat(2));

  // Accès aux membres statiques
  print(StringExt.emptyStr);
  StringExt.printTip();
}

Résultat de l’exécution

D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
false
hihihi
hellohello

Méthode statique de l’extension chaîne

Extensions sans nom (extensions anonymes)

Si vous ne spécifiez pas de nom d’extension, celle-ci n’est visible qu’au sein de la bibliothèque actuelle. Les conflits ne peuvent pas être résolus par appel explicite.

Il est impossible de l’appeler depuis l’extérieur avec la syntaxe NomExtension(instance).

extension on String {
  bool get isBlank => trim().isEmpty;
}

void main() {
  print("   ".isBlank); // true
}

Les membres statiques d’une extension anonyme ne sont utilisables qu’à l’intérieur de cette extension.

Extensions génériques (Generic extensions)

Vous pouvez créer des extensions pour des types génériques, par exemple List<T>

extension MyFancyList<T> on List<T> {
  int get doubleLength => length * 2;
  List<T> operator -() => reversed.toList();
  List<List<T>> split(int at) => [sublist(0, at), sublist(at)];
}

void main() {
  List<int> list = [1, 2, 3, 4];
  print(list.doubleLength);          // 8
  print(-list);                      // [4,3,2,1]
  print(list.split(2));              // [[1,2],[3,4]]
}

Résultat de l’exécution

D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
8
[4, 3, 2, 1]
[[1, 2], [3, 4]]

Type statique static vs dynamic

Les variables dynamic ne peuvent pas appeler les méthodes d’extension

Les méthodes d’extension sont résolues de manière statique. Une variable dynamic dont le type n’est déterminé qu’à l’exécution ne parvient pas à trouver l’extension :

void main() {
  dynamic d = '2';
  // print(d.parseInt()); // Erreur NoSuchMethodError à l’exécution

  var v = '2';
  print(v.parseInt()); // Le type est déduit comme String, fonctionne normalement
}

extension NumberParsing on String {
  int parseInt() => int.parse(this);
}

Cause : les méthodes d’extension sont liées au moment de la compilation selon le type statique de la variable, pas par recherche à l’exécution.

Solutions aux conflits de noms d’API

Trois solutions existent lorsque plusieurs extensions possèdent des membres de même nom.

1 : Masquer les extensions conflictuelles avec show / hide lors de l’import

// string_apis.dart contient NumberParsing
// string_apis_2.dart contient NumberParsing2 qui définit aussi parseInt
import 'string_apis.dart';
import 'string_apis_2.dart' hide NumberParsing2;

void main() {
  print('42'.parseInt()); // Utilise l’implémentation de string_apis.dart
}

2 : Appel explicite de l’extension (syntaxe d’encapsulation)

import 'string_apis.dart';    // NumberParsing
import 'string_apis_2.dart';  // NumberParsing2

void main() {
  // print('42'.parseInt()); // Conflit, erreur de compilation
  print(NumberParsing('42').parseInt());
  print(NumberParsing2('42').parseInt());
}

3 : Importer la bibliothèque avec un préfixe

Utilisez un préfixe pour distinguer deux extensions portant exactement le même nom :

import 'string_apis.dart';
import 'string_apis_3.dart' as rad;

void main() {
  print(NumberParsing('42').parseInt());
  print(rad.NumberParsing('42').parseInt());

  // Les méthodes d’extension sans conflit restent appelables implicitement
  print('42'.parseNum());
}

Méthodes d’extension (Extension methods)

En résumé : l’abréviation par point autorise les expressions débutant sous ces formes, sur lesquelles on peut chaîner d’autres opérations :

• Identifiant .myValue
• Constructeur .new()
• Création de constante const .myValue()

Exemples

enum Status { none, running, stopped, paused }

class Point {
  final int x, y;
  Point(this.x, this.y);
  Point.origin() : x = 0, y = 0;
}


void main() {
    // Abréviation pour constructeur nommé
    Point origin = .origin(); // Équivaut à Point.origin()
  
    // Abréviation pour énumération
	Status currentStatus = .running; // Équivaut à Status.running

	// Abréviation pour méthode statique
	int port = .parse('8080'); // Équivaut à int.parse('8080')

}

Type contextuel (Context type)

L’abréviation par point repose sur letype contextuel afin que le compilateur déduise le membre de type correspondant.

Type contextuel : c’est le type que Dart attend à cet emplacement, selon la position de l’expression.

Exemple : Status currentStatus = .running

Le compilateur sait que la variable doit être de type Status, il interprète donc .running comme Status.running.

Structure lexicale et syntaxe

L’abréviation des membres statiques est une expressioncommençant par .. Quand le contexte permet de déterminer le type, on peut accéder de manière abrégée aux membres statiques, constructeurs et constantes d’énumération.

Cas d’utilisation

1. Énumérations

Lors des affectations ou des correspondances switch, le type d’énumération est bien défini, c’est un cas idéal pour cette abréviation :

enum LogLevel { debug, info, warning, error }

String colorCode(LogLevel level) {
  return switch (level) {
    .debug => 'gray',
    .info => 'blue',
    .warning => 'orange',
    .error => 'red',
  };
}

void main() {
   // Appel
   String warnColor = colorCode(.warning); // Reconnaît automatiquement LogLevel.warning
}

2. Constructeur nommé / constructeur usine

Prend en charge le passage des paramètres de type aux constructeurs de classes génériques :

class Point {
  final double x, y;
  const Point(this.x, this.y);
  const Point.origin() : x = 0, y = 0;

  factory Point.fromList(List<double> list) => Point(list[0], list[1]);
}



void main() {
    Point origin = .origin();
	Point p1 = .fromList([1.0, 2.0]);

	// Classe générique
	List<int> intList = .filled(5, 0); // List.filled(5,0)
}

3. Constructeur sans paramètre .new

.new permet d’appeler de manière abrégée le constructeur anonyme par défaut de la classe. Pratique pour initialiser de nombreux champs dans des classes d’état, et déduit automatiquement les paramètres génériques :

// Sans abréviation
late final AnimationController _animationController = AnimationController(vsync: this);
final ScrollController _scrollController = ScrollController();

// Avec abréviation
late final AnimationController _animationController = .new(vsync: this);
final ScrollController _scrollController = .new();
final GlobalKey<ScaffoldMessengerState> scaffoldKey = .new();
Map<String, Map<String, bool>> properties = .new();

4 Membres statiques (méthodes statiques, champs statiques)

int httpPort = .parse('80');        // int.parse('80')
BigInt bigIntZero = .zero;          // BigInt.zero

5 Expressions constantes

Dans un contexte constant, l’abréviation fonctionne si le membre cible est une constante de compilation :

enum Status { none, running }
class Point {
  final double x, y;
  const Point(this.x, this.y);
  const Point.origin() : x = 0.0, y = 0.0;
}

const Status defaultStatus = .running;
const Point myOrigin = .origin();
const List<Point> keyPoints = [.origin(), .new(1.0, 1.0)];

Chaînage d’appels

Vous pouvez chaîner des méthodes ou propriétés d’instance après une abréviation. Le compilateur résout d’abord la cible de l’abréviation grâce au contexte, et la valeur renvoyée par les appels chaînés doit être compatible au niveau du type :

String lowerH = .fromCharCode(72).toLowerCase();
// String.fromCharCode(72).toLowerCase()
print(lowerH); // h

void main() {
    String lowerH = .fromCharCode(72).toLowerCase();
	// String.fromCharCode(72).toLowerCase()
	print(lowerH); // h
}

D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
h

Dot shorthands (abréviations par point)

Toutes les énumérations héritent automatiquement de la classe Enum. Par ailleurs, une énumération est un type scellé (sealed) : il ne peut pas être hérité, implémenté, mixé, ni instancié explicitement manuellement.

Les classes abstraites et les mixins peuvent implémenter ou hériter explicitement de Enum, mais il est impossible de créer des instances concrètes de ces classes ou mixins, à moins qu’une énumération ne déclare leur implémentation ou leur intégration.

Utilisez le mot-clé enum et listez toutes les constantes de l’énumération pour définir une énumération simple :

enum Color { red, green, blue }

Une virgule finale est autorisée lors de la déclaration d’une énumération ; cela facilite le copier-coller et limite les erreurs de code.

Énumérations améliorées (Enhanced enums)

Dart prend en charge les énumérations améliorées. Vous pouvez y définir des champs membres, des méthodes et des constructeurs constants comme dans une classe classique, mais ses instances ne peuvent être que les constantes fixes prédéfinies.

La déclaration d’une énumération améliorée est soumise à un ensemble de règles obligatoires :

1. Les variables d’instance doivent être déclarées final (y compris celles provenant des mixins)
2. Tous les constructeurs générateurs doivent porter le marqueur const
3. Les constructeurs d’usine ne peuvent renvoyer que des instances constantes déjà définies au sein de l’énumération
4. Il est interdit d’hériter explicitement d’une autre classe (l’héritage de Enum se fait automatiquement)
5. Il est impossible de redéfinir index, hashCode et l’opérateur d’égalité ==
6. Aucun membre nommé values ne peut être déclaré dans une énumération, car cela entrerait en conflit avec l’accesseur statique values généré automatiquement
7. Toutes les instances de l’énumération doivent figurer au tout début de sa définition, et au moins une instance est requise
8. Dans les méthodes d’instance d’une énumération améliorée, vous pouvez utiliser this pour faire référence à la constante d’énumération actuelle

Exemple

enum Vehicle implements Comparable<Vehicle> {
  car(tires: 4, passengers: 5, carbonPerKilometer: 400),
  bus(tires: 6, passengers: 50, carbonPerKilometer: 800),
  bicycle(tires: 2, passengers: 1, carbonPerKilometer: 0);

  const Vehicle({
    required this.tires,
    required this.passengers,
    required this.carbonPerKilometer,
  });

  final int tires;
  final int passengers;
  final int carbonPerKilometer;

  // Getter
  int get carbonFootprint => (carbonPerKilometer / passengers).round();
  bool get isTwoWheeled => this == Vehicle.bicycle;

  @override
  int compareTo(Vehicle other) => carbonFootprint - other.carbonFootprint;
}

À partir de Dart 3.13+, les constructeurs principaux simplifient la syntaxe des énumérations améliorées :

enum Vehicle(
  final int tires,
  final int passengers,
  final int carbonPerKilometer,
) implements Comparable<Vehicle> {
  car(4, 5, 400),
  bus(6, 50, 800),
  bicycle(2, 1, 0);

  int get carbonFootprint => (carbonPerKilometer / passengers).round();
  bool get isTwoWheeled => this == Vehicle.bicycle;

  @override
  int compareTo(Vehicle other) => carbonFootprint - other.carbonFootprint;
}

Utiliser une énumération

L’accès aux constantes d’énumération s’effectue de la même manière que pour les variables statiques :

final favoriteColor = Color.blue;
if (favoriteColor == Color.blue) {
  print('Votre couleur favorite est le bleu !');
}

Propriété index

Chaque constante d’énumération possède une propriété index qui renvoie son numéro d’ordre commençant à 0 dans la définition de l’énumération :

assert(Color.red.index == 0);
assert(Color.green.index == 1);
assert(Color.blue.index == 2);

Constante statique values

Récupérez la liste regroupant toutes les valeurs de l’énumération via NomEnumeration.values :

List<Color> colors = Color.values;
assert(colors[2] == Color.blue);

Associer une énumération à l’instruction switch

Lorsque vous utilisez une énumération dans un switch, le compilateur affichera un avertissement si vous ne couvrez pas toutes les branches possibles. Vous pouvez utiliser une clause default pour gérer les cas restants.

var aColor = Color.blue;

switch (aColor) {
  case Color.red:
    print('Rouge comme une rose !');
  case Color.green:
    print('Vert comme l\'herbe !');
  default:
    print(aColor); // Color.blue
}

Propriété name

Obtenez le nom de chaîne correspondant à une constante d’énumération grâce à .name :

print(Color.blue.name); // Affiche "blue"

Accéder aux membres personnalisés de l’énumération

Sur une énumération améliorée, vous pouvez accéder aux champs, getters et méthodes personnalisés exactement comme sur un objet classique :

print(Vehicle.car.carbonFootprint);

Voici un exemple complet de cette leçon : nous allons créer une énumération pour les mois et mettre en pratique toutes les notions abordées.

enum Month implements Comparable<Month> {
  january(1, '一月', days: 31),
  february(2, '二月', days: 28),
  march(3, '三月', days: 31),
  april(4, '四月', days: 30),
  may(5, '五月', days: 31),
  june(6, '六月', days: 30),
  july(7, '七月', days: 31),
  august(8, '八月', days: 31),
  september(9, '九月', days: 30),
  october(10, '十月', days: 31),
  november(11, '十一月', days: 30),
  december(12, '十二月', days: 31);

  const Month(this.monthNumber, this.cnName, {required this.days});

  /// Numéro du mois du calendrier grégorien, de 1 à 12
  final int monthNumber;

  /// Nom
  final String cnName;

  /// Nombre de jours en année normale
  final int days;

  /// Getter : appartient au premier trimestre ?
  bool get isFirstQuarter => monthNumber <= 3;

  /// Getter : mois à 31 jours ?
  bool get has31Days => days == 31;

  /// Méthode personnalisée : vérifie si février est le mois d’une année bissextile
  bool isLeapYearFebruary(int year) {
    if (this != Month.february) return false;
    return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
  }

  /// Implémentation de Comparable pour autoriser le tri
  @override
  int compareTo(Month other) {
    return monthNumber - other.monthNumber;
  }
}

void main() {
  // 1. Accès basique aux constantes d’énumération
  Month current = Month.august;
  print('Énumération actuelle : $current');
  print('Propriété name de l\'énumération : ${current.name}');
  print('Mois : ${current.cnName}');
  print('Numéro du mois (1~12) : ${current.monthNumber}');
  print('Nombre de jours en année normale : ${current.days}');
  print('Est-ce un mois à 31 jours ? ${current.has31Days}');
  print('Appartient au premier trimestre ? ${current.isFirstQuarter}');

  // 2. Propriété index (indice de définition de l’énumération, débute à 0)
  print('\n${Month.january.name} index = ${Month.january.index}');
  print('${Month.december.name} index = ${Month.december.index}');

  // 3. values pour récupérer la liste complète des énumérations
  List<Month> allMonths = Month.values;
  print('\nIl y a au total ${allMonths.length} mois');

  // 4. Utilisation d’un switch avec une énumération
  print('\n==== Test switch ====');
  switch (current) {
    case Month.january:
      print('Début de l\'année');
    case Month.february:
      print('Peut comporter un jour supplémentaire en année bissextile');
    case Month.march:
    case Month.april:
    case Month.may:
      print('Printemps');
    case Month.june:
    case Month.july:
    case Month.august:
      print('Été');
    case Month.september:
    case Month.october:
    case Month.november:
      print('Automne');
    case Month.december:
      print('Fin de l\'année, hiver');
  }

  // 5. Appel de la méthode personnalisée
  Month feb = Month.february;
  print('\nFévrier 2024 est-il dans une année bissextile ? ${feb.isLeapYearFebruary(2024)}');
  print('Février 2025 est-il dans une année bissextile ? ${feb.isLeapYearFebruary(2025)}');

  // 6. Tri des énumérations (via l’interface Comparable)
  var selected = [Month.october, Month.january, Month.july];
  selected.sort();
  print('\nMois triés : ${selected.map((m) => m.cnName).toList()}');
}

Résultat de l’exécution

D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
Énumération actuelle : Month.august
Propriété name de l'énumération : august
Mois : 八月
Numéro du mois (1~12) : 8
Nombre de jours en année normale : 31
Est-ce un mois à 31 jours ? true
Appartient au premier trimestre ? false

january index = 0
december index = 11

Il y a au total 12 mois

==== Test switch ====
Été

Février 2024 est-il dans une année bissextile ? true
Février 2025 est-il dans une année bissextile ? false

Mois triés : [一月, 七月, 十月]

Énumérations