Dot shorthands (abréviations par point)

La syntaxe abrégée par point .foo permet d’omettre le nom du type. Si le compilateur peut déduire le type cible à partir du contexte, vous pouvez écrire du code Dart plus concis. Il n’est pas nécessaire d’écrire intégralement Type.foo pour accéder aux valeurs d’énumération, aux membres statiques ou aux constructeurs.

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')

}Langage du code : Dart (dart)

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
}Langage du code : Dart (dart)

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)
}Langage du code : Dart (dart)

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();Langage du code : Dart (dart)

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

int httpPort = .parse('80');        // int.parse('80')
BigInt bigIntZero = .zero;          // BigInt.zeroLangage du code : Dart (dart)

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)];Langage du code : Dart (dart)

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); // hLangage du code : JavaScript (javascript)

void main() {
    String lowerH = .fromCharCode(72).toLowerCase();
	// String.fromCharCode(72).toLowerCase()
	print(lowerH); // h
}Langage du code : Dart (dart)

D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
h
Langage du code : CSS (css)

Dot shorthands (abréviations par point)