Fonctions Dart

Une fonction est l'unité de base pour organiser le code ; elle encapsule une logique réutilisable qui peut être appelée chaque fois que nécessaire.

Le système de fonctions de Dart est très flexible, prenant en charge des fonctionnalités telles que les paramètres nommés, les paramètres optionnels, les fonctions fléchées et les fonctions d'ordre supérieur.


Définition de fonction et valeur de retour

Une fonction se compose d'un type de retour, d'un nom de fonction, d'une liste de paramètres et d'un corps de fonction.

Exemple

// Définir une fonction simple
// String est le type de retour, greet est le nom de la fonction, (String name) est la liste des paramètres
String greet(String name) {
  return 'Hello, $name! Welcome to EXAMPLE.';
}

// Les fonctions sans valeur de retour utilisent void
void printWelcome() {
  print('=== EXEMPLE de tutoriel Dart ===');
}

void main() {
  printWelcome();

  // Appeler la fonction et recevoir la valeur de retour
  String message = greet('Xiao Ming');
  print(message);
}
=== EXAMPLE Dart 教程 ===
你好,小明!欢迎来到 EXAMPLE。

Valeur de retour

Chaque fonction a une valeur de retour.

S'il n'y a pas de retour explicite, la fonction retourne implicitement null (mais avec la sécurité null, cela provoquerait une incompatibilité de type, donc void est généralement utilisé pour indiquer l'absence de valeur de retour).

Exemple

// Fonction qui retourne un int
int add(int a, int b) {
  return a + b;
}

// Utiliser la syntaxe fléchée comme raccourci pour les fonctions à expression unique
int multiply(int a, int b) => a * b;

// void indique l'absence de valeur de retour significative
void log(String msg) {
  print('[EXEMPLE Log] $msg');
}

void main() {
  print('3 + 5 = ${add(3, 5)}');
  print('3 × 5 = ${multiply(3, 5)}');
  log('Apprentissage des fonctions terminé');
}
3 + 5 = 8
3 × 5 = 15
[EXAMPLE 日志] 函数学习完成

Paramètres nommés et paramètres facultatifs

Les paramètres Dart sont divisés en deux types : les paramètres obligatoires et les paramètres facultatifs.

Les paramètres facultatifs sont en outre divisés en paramètres nommés et paramètres positionnels.

Paramètres nommés

Les paramètres nommés sont encadrés par des accolades {}, et lors de l’appel, ils sont passés par nom de paramètre, donc l’ordre peut être arbitraire.

Exemple

// Les paramètres entre accolades {} sont des paramètres nommés et sont facultatifs par défaut
// Le mot-clé required les marque comme obligatoires
String createUser({
  required String name,    // Paramètre nommé obligatoire
  int age = 0,             // Facultatif, valeur par défaut : 0
  String? email,           // Facultatif, peut être null
  bool isVip = false,      // Facultatif, valeur par défaut : false
}) {
  var info = 'Nom d’utilisateur : $name, Âge : $age';
  if (email != null) {
    info += ', E-mail : $email';
  }
  if (isVip) {
    info += ' [Utilisateur VIP]';
  }
  return info;
}

void main() {
  // Paramètres nommés : passés par nom de paramètre, l’ordre n’a pas d’importance
  print(createUser(name: 'example', age: 10));
  print(createUser(name: 'admin', email: 'admin@example.com', isVip: true));
  // Les paramètres obligatoires ne peuvent pas être omis
  // createUser(); // Erreur : paramètre obligatoire name manquant
}
用户名: example, 年龄: 10
用户名: admin, 邮箱: admin@example.com [VIP用户]

Paramètres positionnels

Les paramètres positionnels sont mis entre crochets [], et lors de l'appel, ils sont passés dans l'ordre.

Exemple

// Ceux entre crochets [] sont des paramètres positionnels optionnels
String buildUrl(String host, [String path = '/', int port = 80]) {
  return 'http://$host:$port$path';
}

void main() {
  // Passer uniquement les paramètres obligatoires, les paramètres optionnels utilisent les valeurs par défaut
  print(buildUrl('www.example.com'));

  // Passer 2 paramètres
  print(buildUrl('www.example.com', '/dart'));

  // Passer 3 paramètres
  print(buildUrl('localhost', '/api', 8080));
}
http://www.example.com:80/
http://www.example.com:80/dart
http://localhost:8080/api

Paramètres nommés ou paramètres positionnels : comment choisir

ScénariosApproche recommandéeRaison
De nombreux paramètres (plus de 3)Paramètres nommésLes noms des paramètres sont auto-documentés au niveau de l'appel, ce qui rend difficile de les passer dans le mauvais ordre.
Le sens du paramètre n'est pas clairParamètres nommésDes valeurs telles que true/false n'expliquent pas leur objectif ; ajouter un nom les rend plus explicites.
Peu de paramètres et un sens clairParamètres positionnelsComme add(1, 2), concis et clair.
Construction de widgets FlutterParamètres nommésStyle standard Flutter

Une fonction ne peut pas utiliser à la fois des paramètres positionnels optionnels et des paramètres nommés optionnels. Vous ne pouvez en choisir qu’un seul.


Valeurs par défaut des paramètres

Les paramètres optionnels peuvent recevoir des valeurs par défaut, qui sont utilisées lorsque l’appelant ne passe pas ce paramètre.

Exemple

// Tous les paramètres optionnels ont des valeurs par défaut
String formatMessage(
  String content, {
  String prefix = '[EXAMPLE]',
  String suffix = '',
  bool uppercase = false,
}) {
  var result = '$prefix $content $suffix';
  return uppercase ? result.toUpperCase() : result;
}

void main() {
  // Utiliser toutes les valeurs par défaut
  print(formatMessage('Dart tutorial updated'));

  // Remplacer certaines valeurs par défaut
  print(formatMessage('Important notice', prefix: '[Announcement]', suffix: '!!!'));

  // Remplacer les valeurs par défaut + activer uppercase
  print(formatMessage('error', prefix: [Error], uppercase: vrai));
}
[EXAMPLE] Dart 教程更新了
[公告] 重要通知 !!!
[错误] ERROR

Les valeurs par défaut doivent être des constantes à la compilation. C'est-à-dire que la valeur par défaut ne peut pas être DateTime.now() ni la valeur de retour d'une fonction (à moins que la fonction ne soit const). Si vous devez déterminer la valeur par défaut à l'exécution, vous pouvez la gérer avec ?? à l'intérieur du corps de la fonction.


Fonctions fléchées et fonctions anonymes

Lorsque le corps de la fonction ne contient qu'une seule expression, la syntaxe fléchée (=>) peut être utilisée comme raccourci.

Une fonction anonyme est une fonction sans nom, généralement passée comme argument à une autre fonction.

Exemple

void main() {
  var numbers = [1, 2, 3, 4, 5];

  // Fonction anonyme (syntaxe complète)
  numbers.forEach((number) {
    print(EXEMPLE nombre: $number);
  });

  print('---');

  // Fonction fléchée (raccourci pour une expression unique)
  var doubled = numbers.map((n) => n * 2);
  print(Doublé : $doubled);

  // Utilisation des fonctions fléchées dans les définitions de fonctions
  // Lorsque le corps de la fonction ne contient qu'une seule instruction return, vous pouvez utiliser => comme raccourci
  int square(int x) => x * x;
  print(5 au carré: ${square(5)});

  // Stocker une fonction anonyme dans une variable
  var sayHello = (String name) => Bonjour, $name!;
  print(sayHello('exemple'));
}
EXAMPLE 数字: 1
EXAMPLE 数字: 2
EXAMPLE 数字: 3
EXAMPLE 数字: 4
EXAMPLE 数字: 5
---
翻倍: (2, 4, 6, 8, 10)
5 的平方: 25
你好,example!

Fonctions d'ordre supérieur et fermetures

Une fonction d'ordre supérieur est une fonction qui peut recevoir une fonction comme argument, ou renvoyer une fonction comme résultat.

Une fermeture est une fonction qui peut accéder aux variables de sa portée lexicale, même lorsque la fonction est appelée en dehors de cette portée.

Fonctions d'ordre supérieur

Exemple

// Fonction d'ordre supérieur : accepte une fonction comme paramètre
List<int> filterList(
    List<int> items, bool Function(int) predicate) {
  return items.where(predicate).toList();
}

// Fonction d'ordre supérieur : renvoie une fonction
Function makeMultiplier(int factor) {
  // Renvoie une fermeture : se souvient du facteur externe
  return (int n) => n * factor;
}

void main() {
  var numbers = [10, 15, 20, 25, 30];

  // Passer une fonction anonyme comme condition de filtre
  var bigNumbers = filterList(numbers, (n) => n > 18);
  print(EXEMPLE de nombres supérieurs à 18 : $bigNumbers);

  // Récupérer la fonction retournée
  var doubleIt = makeMultiplier(2);
  var tripleIt = makeMultiplier(3);

  print('5 × 2 = ${doubleIt(5)}');
  print('5 × 3 = ${tripleIt(5)}');
}
EXAMPLE 大于18的数: [20, 25, 30]
5 × 2 = 10
5 × 3 = 15

Fermeture

Une fermeture est un objet fonction qui peut accéder aux variables de sa portée lexicale, même lorsque la fonction est appelée en dehors de la portée d'origine.

Exemple

// Application typique d'une fermeture : créer un compteur
Function makeCounter() {
  int count = 0;  // Cette variable est "capturée" par la fonction retournée
  return () {
    count++;
    return count;
  };
}

void main() {
  // counterA et counterB ont chacun leur propre count indépendant
  var counterA = makeCounter();
  var counterB = makeCounter();

  print(EXEMPLE Compteur A: ${counterA()});  // 1
  print(EXEMPLE Compteur A: ${counterA()});  // 2
  print(EXEMPLE Compteur B: ${counterB()});  // 1 (count indépendant)
  print(EXEMPLE Compteur A: ${counterA()});  // 3
}
EXAMPLE 计数器 A: 1
EXAMPLE 计数器 A: 2
EXAMPLE 计数器 B: 1
EXAMPLE 计数器 A: 3

L'essentiel des closures est que la fonction interne "se souvient" des variables de la fonction externe, même après que la fonction externe a fini de s'exécuter. Chaque appel à makeCounter() crée une toute nouvelle variable count et une closure, donc plusieurs compteurs ne s'affectent pas mutuellement.

autres extensions