Énumérer l'utilisation du double point (.) dans les fléchettes ?

Question

Parfois, je vois ceci List list = [];

Dans ce cas list..add(color)

Quelle est la différence entre l'utilisation de 1 point( . ) et 2 points ( .. ) ?

Answer 1

.. est connu sous le nom de notation en cascade . Il permet de ne pas répéter la même cible si l'on veut appeler plusieurs méthodes sur le même objet.

List list = [];
list.add(color1);
list.add(color2);
list.add(color3);
list.add(color4);

// with cascade

List list = [];
list
  ..add(color1)
  ..add(color2)
  ..add(color3)
  ..add(color4);

Answer 2

C'est la cascade de l'opérateur de Dart

var l1 = new List<int>()..add(0)..addAll([1, 2, 3]);

résultats en l1 étant une liste [0, 1, 2, 3]

var l1 = new List<int>().add(0).addAll([1, 2, 3]);

résultats une erreur, car .add(0) retours void

.. (dans l'exemple précédent) désigne new List(), alors qu' . (au plus tard) se réfère à la valeur de retour de la partie précédente de l'expression.

.. a été instaurée pour éviter la nécessité de revenir this dans toutes sortes de méthodes comme l' add() à être en mesure d'utiliser une API dans un fluide manière.

.. offre ce de la boîte pour toutes les classes.

Answer 3

Les cascades (..) permettent d'effectuer une séquence d'opérations sur le même objet. Lire le document pour plus de détails

querySelector('#confirm') // Get an object.
  ..text = 'Confirm' // Use its members.
  ..classes.add('important')
  ..onClick.listen((e) => window.alert('Confirmed!'));

L'exemple précédent est équivalent à :

var button = querySelector('#confirm');
button.text = 'Confirm';
button.classes.add('important');
button.onClick.listen((e) => window.alert('Confirmed!'));

Answer 4

.. Est connu sous le nom de opérateur en cascade en fléchette.

Il vous permet d'utiliser plus d'une opération de sous-séquence :

Exemples :

banerad..load()..show().

List coursename;
coursename..add("java")..add("flutter" )..add("dart");

Voici un autre exemple

Answer 5

Cascade dans Dart Parce que les développeurs Dart utilisent beaucoup l'enchaînement de méthodes, la fonction de cascade est fournie pour les soutenir.

Voir le code suivant :

class Calculator {
  double _accumulator = 0;

  Calculator(double startValue) {
    this._accumulator = startValue;
  }

  void add(double val) {
    this._accumulator += val;
  }

  void subtract(double val) {
    this._accumulator -= val;
  }

  double result() {
    return this._accumulator;
  }
}

C'est presque la même chose que ChainCalculator à une seule différence près, à savoir que return this a été supprimée dans chaque méthode.

Utilisons la fonction de cascade.

Calculator calculator = Calculator(0.0)
    ..add(12.0)
    ..subtract(10.0)
    ..add(5.0)..subtract(8.0);

print("Result: " + calculator.result().toString());

Il fonctionne parfaitement et est similaire au code précédent, mais au lieu de . la notation, les utilisations en cascade .. (double point) pour accéder à l'instance de modification en cours.

Pourquoi une cascade dans Dart ?

D'une manière générale, la cascade est très utile pour :

construction d'objets complexes (configuration de nombreuses propriétés) améliorer les objets pour l'encapsulation. return this rend les objets trop ouverts. construire des objets plus rapidement avec la cascade imbriquée. moins de lignes de code.

il est extrait de : Enchaînement de méthodes à l'aide de Cascade dans Dart