Resumen de expresiones Dart y azúcar sintáctico

prefacio

Hay muchas expresiones sintácticas de azúcar o lambda en el lenguaje Dart. La sintaxis y el tamaño del código son mucho más simples, pero me agregan muchos problemas a los que quieren comenzar. Cuando a menudo miro la API oficial o terceros, parte de la API de documentación, en el ejemplo, se utiliza una gran cantidad de azúcar gramatical similar, lo que reduce en gran medida la legibilidad del código. Se necesita mucha búsqueda de artículos para entender lo que significa este código. Este artículo es un resumen de algunos azúcares gramaticales hechos por mi mismo.

Expresiones sintácticas de azúcar o lambda

1. Métodos y sus flechas gordas (=>)

Debido a que dart realmente se da cuenta de que todo puede ser un objeto , el método (Función) en dart también es una clase (clase) .

Aunque dart es un lenguaje fuertemente tipado, las variables se pueden declarar con var. Con el tipo dinámico de dinámico, el tipo de la variable se puede inferir en tiempo de ejecución. El método no es una excepción. Puede omitir el tipo de retorno al declarar el método ( Oficialmente no recomendado)

como sigue:

add(int x,int y){
  return x+y;
}
main(){
  print(add(2, 3));
}

Después de ejecutar, la consola es la siguiente:

5

En este momento, si observamos el tipo de valor de retorno del método add(), encontraremos que es dinámico: tipo de datos dinámico

En el uso diario, se recomienda no omitir el tipo de retorno antes del método . Señalar claramente el tipo de retorno mejorará en gran medida la legibilidad del código .

En dart, si el método tiene solo una línea de declaración, puede usar la flecha ancha (=>) en lugar del cuerpo del método, como el método add() anterior

como sigue:

int add(int x,int y) => x + y ;

void main(){
  print(add(2, 3));
}

2. método call() 

Si una clase en dart tiene un método llamado "call" , se puede llamar directamente con ()

como sigue:

class Computer{
  Computer(){
    print('01');
  }
  Computer.game(){
    print('02');
  }
  void call({int a = 2}){
    print('call $a');
  }
}

void main(){
  Computer();
  Computer()();
  Computer()(a:6);
  final c = Computer();
  c();
  c(a:10);
  Computer.game()();
  Computer.game()(a:111);
}

 La consola se imprime como:

01
01
call 2
01
call 6
01
call 2
call 10
02
call 2
02
call 111

3. Declarar nulabilidad (?) y operador de aserción nulo (!)

Después de dart2.12, la seguridad nula está habilitada de forma predeterminada, lo que significa que las variables que normalmente declara no pueden estar vacías al determinar el tipo. Por ejemplo, la declaración a continuación es incorrecta y el compilador informará un error al compilar.

int a = null;

 Si desea declarar una variable vacía, puede agregar ? después del tipo de declaración para indicar que el tipo puede estar vacío y el valor predeterminado de todas las variables es nulo cuando no se asigna ningún valor

int? a;

Si se declara que la variable está vacía, se informará un error en tiempo de compilación cuando la llamada al método o la variable estén vacías:

 En este momento, puede usar el operador de aserción nulo para indicar que el objeto al que llama seguramente no estará vacío:

int? getNum() => 1;
void main(){
  var c = getNum();
  print(c!.abs());
}

O agregue (?) antes de (.) para indicar que admite valores NULL

int? getNum() => 1;
void main(){
  var c = getNum();
  print(c?.abs());
}

4. ?? y ??= Operadores de escape 

 Al declarar una variable anulable, puede usar el operador de evitación para asignar un valor para evitar que la variable esté vacía

int? a; // = null
a ??= 3;
print(a); // <-- Prints 3.

a ??= 5;
print(a); // <-- Still prints 3.

Al usar, puede usar ?? para evitar que la variable esté vacía

print(1 ?? 3); // <-- Prints 1.
print(null ?? 12); // <-- Prints 12.

5. Operador en cascada (..)

En dart, los operadores en cascada se pueden usar para realizar llamadas consecutivas al mismo objeto:

class Player{
  int ammo = 3;
  void walk() => print('walk');
  void run() => print('run');
  void fire(int a){
    if(ammo >= a){
      print('ta'*a);
      ammo -= a;
    }
  }
}
Player? getPlayer() => Player();
void main(){
  getPlayer()
      ?..walk()
      ..run()
      ..fire(3);
}

Esto se puede usar junto con el juicio nulo, usando (?..) para asegurar la ejecución cuando el objeto no es nulo.

Ejecutar de la siguiente manera:

walk
run
tatata

6, lambda

para cada()

String scream(int length) => 'A${'a' * length}h!';

main(){
  final values = [1,2,3,5,10,50];
  // for(var length in values){
  //   print(scream(length));
  // }
  // values.map(scream).forEach(print);
  //跳过1
  //拿3个结果
  values.skip(1).take(3).map(scream).forEach(print);
}