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
// 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
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
// 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
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énarios | Approche recommandée | Raison |
|---|---|---|
| De nombreux paramètres (plus de 3) | Paramètres nommés | Les 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 clair | Paramètres nommés | Des valeurs telles que true/false n'expliquent pas leur objectif ; ajouter un nom les rend plus explicites. |
| Peu de paramètres et un sens clair | Paramètres positionnels | Comme add(1, 2), concis et clair. |
| Construction de widgets Flutter | Paramètres nommés | Style 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
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
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
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
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
autres extensionsL'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.