devstory

Fonctions dans Dart

  1. Qu'est-ce qu'une fonction ?
  2. La fonction régulière
  3. Closure (clôture)
  4. Le paramètre optionnel
  5. Le paramètre optionnel nommé

1. Qu'est-ce qu'une fonction ?

Dans le langage de programmation Dart, une fonction (function) est un bloc de code nommé, qui peut prendre des paramètres et renvoyer une valeur ou rien du tout, et ne s'exécuter que lorsqu'elle est convoquée. Les fonctions divisent les grandes tâches en petites parties et effectuent des opérations spécifiques de ce programme. Ce processus augmente la possibilité de réutilisation du code et améliore l'approche modulaire du programme.
return_type function_name(arguments)  {
   // Statements
}
Remarque : À l'instar de JavaScript, Dart n'autorise pas deux fonctions ayant le même nom, même si elles disposent des paramètres différents.

2. La fonction régulière

La syntaxe pour déclarer une fonction régulière :
return_type function_name(data_type1 arg1, data_type2 arg2, data_typeN argN)  {
   // Statements
}
Utiliser le mot-clef void (ou vide) comme un type de renvoie si la fonction ne renvoie rien du tout.
void function_name(data_type1 arg1, data_type2 arg2, data_typeN argN)  {
   // Statements
}
// Same as:
function_name(data_type1 arg1, data_type2 arg2, data_typeN argN)  {
   // Statements
}
Par exemple : La fonction sum prend deux arguments de type int, et renvoie une valeur de type int.
function_ex1.dart
int sum(int a, int b)  {
  return a + b;
}
void main()  {
   var result  = sum(100, 200); // 300
   print('result = $result');  
}
Par exemple : La fonction greeting accepte un paramètre String et ne renvoie rien du tout.
function_ex2.dart
void greeting(String name)  {
   var s = 'Hello $name';
   print(s);
}
void main()  {
   // Call the function:
   greeting('Tom'); // Hello Tom
}

3. Closure (clôture)

Dans le langage de programmation Dart, Closure (clôture) est une fonction spéciale.
  • A l'instare d'une fonction, une clôture est un bloc d'instructions avec des paramètres et peut renvoyer une valeur ou rien du tout.
  • A l'inverse d'une fonction, une clôture n'a pas de nom. Cependant, vous pouvez l'identifier grâce à une variable.
Voir l'article détaillé sur Closure :

4. Le paramètre optionnel

Comme mentionné ci-dessus, Dart n'accepte pas les fonctions ayant le même nom, mais une fonction peut inclure des paramètres optionnels, qui doivent être les derniers de la liste des paramètres.
La syntaxe :
return_type function_name(typeM argM, typeN argN, [typeP? argP, typeQ? argQ]) {  
     // statement(s)  
}
Ou la syntaxe - le paramètre optionnel avec la valeur par défaut :
return_type function_name(typeM argM, typeN argN,
                          [typeP? argP = defaultValueP, typeQ? argQ]) {  
     // statement(s)  
}
Par exemple :
function_optional_args_ex1.dart
String concat(String s1, String s2, [String? s3]) {
  if (s3 != null) {
    return s1 + s2 + s3;
  }
  return s1 + s2;
}
double sum(double v1, double v2, [double? v3, double? v4]) {
  return v1 + v2 + (v3 ?? 0) + (v4 ?? 0);
}
void main() {
  String result1 =  concat('One', 'Two');
  print('result1: $result1');
  String result2 =  concat('One', 'Two', 'Three');
  print('result2: $result2');
 
  double value1 =  sum(1, 2, 3, 4);
  print('value1: $value1');
  double value2 = sum(1, 2, 3);
  print('value2: $value2');
  double value3 = sum(1, 2);
  print('value3: $value3');
}
Output:
result1: OneTwo
result2: OneTwoThree
value1: 10.0
value2: 6.0
value3: 3.0

5. Le paramètre optionnel nommé

Les paramètres optionnels nommés sont des paramètres entre accolades { } et placés à la fin de la liste des paramètres de la fonction. Tous ces paramètres ont des valeurs par défaut.
La syntaxe :
return_type function_name(typeM argM, typeN argN,
                                   {typeP argP = defaultValueP, typeQ argQ = defaultValueQ}){  
     // statement(s)  
}
Par exemple :
function_optional_named_args_ex1.dart
String concatAndTrim(String s1, String s2, {bool trimLeft = true, bool trimRight = true}) {
  var s = s1 + s2;
  if (trimLeft && trimRight) {
    return s.trim();
  } else if (trimLeft) {
    return s.trimLeft();
  } else if (trimRight) {
    return s.trimRight();
  }
  return s;
}
void main() {
  var s1 = '  One  ';
  var s2 = '  Two  ';

  var result1 = concatAndTrim(s1, s2); // trim left and right
  print('result1: -->$result1<-- (Trim left and right)');

  var result2 = concatAndTrim(s1, s2, trimLeft: false); // trim right only
  print('result2: -->$result2<-- (Trim right only)');

  var result3 = concatAndTrim(s1, s2, trimRight: false); // trim left only
  print('result3: -->$result3<-- (Trim left only)' );

  var result4 =
      concatAndTrim(s1, s2, trimLeft: false, trimRight: false); // no trim
  print('result4: -->$result4<!-- (No Trim)');
}
Output:
result1: -->One    Two<-- (Trim left and right)
result2: -->  One    Two<-- (Trim right only)
result3: -->One    Two  <-- (Trim left only)
result4: -->  One    Two  <!-- (No Trim)

Articles les plus récents

Show More