Dot shorthands (abreviações com ponto)

A sintaxe abreviada com ponto .foo permite omitir o nome do tipo. Se o compilador conseguir inferir o tipo alvo a partir do contexto, você consegue escrever códigos Dart mais concisos. Ao acessar valores de enumeração, membros estáticos e construtores, não é necessário digitar por completo Tipo.foo.

Resumindo: a abreviação com ponto aceita expressões iniciadas nas formas abaixo, e depois é possível encadear outras operações:

• Identificador .myValue
• Construtor .new()
• Criação de constante const .myValue()

Exemplos

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() {
    // Abreviação para construtor nomeado
    Point origin = .origin(); // Equivale a Point.origin()
  
    // Abreviação para enumeração
	Status currentStatus = .running; // Equivale a Status.running

	// Abreviação para método estático
	int port = .parse('8080'); // Equivale a int.parse('8080')

}Code language: Dart (dart)

Tipo contextual (Context type)

A abreviação com ponto depende dotipo contextual para que o compilador deduza o membro de tipo correspondente.

Tipo contextual: o tipo que o Dart espera naquela posição, conforme o local onde a expressão está inserida.

Exemplo: Status currentStatus = .running

O compilador sabe que a variável precisa ser do tipo Status, logo interpreta .running como Status.running.

Estrutura léxica e sintaxe

A abreviação de membros estáticos é uma expressãoque começa com .. Quando o contexto define claramente o tipo, é possível acessar de forma simplificada membros estáticos, construtores e constantes de enumeração.

Cenários de utilização

1. Enumerações

Em atribuições e comparações com switch, o tipo da enumeração fica explícito, sendo ideal para usar a abreviação:

enum LogLevel { debug, info, warning, error }

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

void main() {
   // Chamada
   String warnColor = colorCode(.warning); //Identifica automaticamente LogLevel.warning
}Code language: Dart (dart)

2. Construtor nomeado / Construtor factory

Suporta o envio de parâmetros de tipo para construtores de classes 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]);

	// Classe genérica
	List<int> intList = .filled(5, 0); // List.filled(5,0)
}Code language: Dart (dart)

3. Construtor sem parâmetros .new

O .new serve para invocar de forma abreviada o construtor anônimo padrão da classe. Funciona muito bem para inicializar vários campos em classes de estado e infere automaticamente os parâmetros genéricos:

// Sem abreviação
late final AnimationController _animationController = AnimationController(vsync: this);
final ScrollController _scrollController = ScrollController();

// Com abreviação
late final AnimationController _animationController = .new(vsync: this);
final ScrollController _scrollController = .new();
final GlobalKey<ScaffoldMessengerState> scaffoldKey = .new();
Map<String, Map<String, bool>> properties = .new();Code language: Dart (dart)

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

int httpPort = .parse('80');        // int.parse('80')
BigInt bigIntZero = .zero;          // BigInt.zeroCode language: Dart (dart)

5 Expressões constantes

Dentro de um contexto constante, a abreviação pode ser usada desde que o membro alvo seja uma constante de compilação:

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)];Code language: Dart (dart)

Encadeamento de chamadas

É possível encadear métodos e propriedades de instância após a abreviação. O compilador primeiro resolve o destino da abreviação usando o contexto; o valor retornado pelas chamadas subsequentes precisa ter tipos compatíveis:

String lowerH = .fromCharCode(72).toLowerCase();
// String.fromCharCode(72).toLowerCase()
print(lowerH); // hCode language: JavaScript (javascript)

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

D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
h
Code language: CSS (css)

Dot shorthands (abreviações com ponto)