Dot shorthands (abreviaturas con punto)

La sintaxis abreviada con punto .foo permite omitir el nombre del tipo. Si el compilador puede deducir el tipo objetivo a partir del contexto, podrás escribir código Dart más compacto. No hace falta escribir completamente Tipo.foo para acceder a valores de enumeración, miembros estáticos y constructores.

En pocas palabras: la abreviatura con punto admite expresiones que comienzan de estas formas, y se pueden encadenar otras operaciones después:

• Identificador .myValue
• Constructor .new()
• Creación de constante const .myValue()

Ejemplos

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() {
    // Abreviatura de constructor con nombre
    Point origin = .origin(); // Equivale a Point.origin()
  
    // Abreviatura para enumeración
	Status currentStatus = .running; // Equivale a Status.running

	// Abreviatura de método estático
	int port = .parse('8080'); // Equivale a int.parse('8080')

}Lenguaje del código: Dart (dart)

Tipo contextual (Context type)

La abreviatura con punto se apoya en eltipo contextual para que el compilador infiera el miembro de tipo correspondiente.

Tipo contextual: el tipo que Dart espera en esa posición según dónde se sitúa la expresión.

Ejemplo: Status currentStatus = .running

El compilador detecta que la variable debe ser de tipo Status, por lo tanto interpreta .running como Status.running.

Estructura léxica y sintaxis

La abreviatura de miembros estáticos es una expresiónque empieza por .. Cuando el contexto define el tipo, se puede acceder de forma abreviada a miembros estáticos, constructores y constantes de enumeración.

Casos de uso

1. Enumeraciones

En asignaciones y coincidencias con switch, el tipo de enumeración queda bien definido, por lo que es ideal usar esta abreviatura:

enum LogLevel { debug, info, warning, error }

String colorCode(LogLevel level) {
  return switch (level) {
    .debug => 'gray',
    .info => 'blue',
    .warning => 'orange',
    .error => 'red',
  };
}

void main() {
   // Llamada
   String warnColor = colorCode(.warning); //Se reconoce automáticamente LogLevel.warning
}Lenguaje del código: Dart (dart)

2. Constructor con nombre / Constructor factoría

Admite el envío de parámetros de tipo a constructores de clases genéricas:

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]);

	// Clase genérica
	List<int> intList = .filled(5, 0); // List.filled(5,0)
}Lenguaje del código: Dart (dart)

3. Constructor sin parámetros .new

.new sirve para invocar de forma abreviada el constructor anónimo predeterminado de la clase. Resulta práctico para inicializar muchos campos en clases de estado y deduce automáticamente los parámetros genéricos:

// Sin abreviatura
late final AnimationController _animationController = AnimationController(vsync: this);
final ScrollController _scrollController = ScrollController();

// Con abreviatura
late final AnimationController _animationController = .new(vsync: this);
final ScrollController _scrollController = .new();
final GlobalKey<ScaffoldMessengerState> scaffoldKey = .new();
Map<String, Map<String, bool>> properties = .new();Lenguaje del código: Dart (dart)

4 Miembros estáticos (métodos estáticos, campos estáticos)

int httpPort = .parse('80');        // int.parse('80')
BigInt bigIntZero = .zero;          // BigInt.zeroLenguaje del código: Dart (dart)

5 Expresiones constantes

Dentro de un contexto constante, la abreviatura funciona siempre que el miembro destino sea una constante de compilación:

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)];Lenguaje del código: Dart (dart)

Encadenamiento de llamadas

Tras la abreviatura se pueden encadenar métodos y propiedades de instancia. El compilador resuelve primero el destino de la abreviatura a partir del contexto; el valor devuelto por las llamadas encadenadas debe tener tipos compatibles:

String lowerH = .fromCharCode(72).toLowerCase();
// String.fromCharCode(72).toLowerCase()
print(lowerH); // hLenguaje del código: JavaScript (javascript)

void main() {
    String lowerH = .fromCharCode(72).toLowerCase();
	// String.fromCharCode(72).toLowerCase()
	print(lowerH); // h
}Lenguaje del código: Dart (dart)

D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
h
Lenguaje del código: CSS (css)

Dot shorthands (abreviaturas con punto)