Dardo – Palabras clave

Dart Keywords son las palabras reservadas en el lenguaje de programación Dart que tiene un significado especial para el compilador. Estas palabras clave distinguen entre mayúsculas y minúsculas y no se pueden usar para nombrar variables, clases y funciones.

Hay un total de 61 palabras clave en el lenguaje de programación Dart:

La mayoría de estas palabras clave ya se han discutido en las diversas subsecciones de las Secciones de programación de Dart:

1. abstracto: el modificador abstracto se usa para definir una clase abstracta, una clase que no se puede instanciar. Las clases abstractas son útiles o definen interfaces, a menudo con alguna implementación.

// Understanding Abstract class in Dart
 
// Creating Abstract Class
abstract class Gfg {
    // Creating Abstract Methods
    void say();
    void write();
}
 
class Geeksforgeeks extends Gfg{
    @override
    void say()
    {
        print("Yo Geek!!");
    }
 
    @override
    void write()
    {
        print("Geeks For Geeks");
    }
}
 
main()
{
    Geeksforgeeks geek = new Geeksforgeeks();
    geek.say();
    geek.write();
}

2. as:- as se usa para convertir un objeto a un tipo particular si y solo si estamos seguros de que el objeto es de ese tipo.

Ejemplo:

void main() {
  (employee as Person).firstName = 'Bob';
}

3. afirmación: la declaración de afirmación se usa para depurar el código y usa la condición booleana para la prueba. Si la expresión booleana en la declaración de afirmación es verdadera, el código continúa ejecutándose, pero si devuelve falso, el código termina con un error de afirmación.

Syntax"  assert(condition, optionalMessage);

void main()
{
String geek = "Geeks For Geeks";
assert(geek != "Geeks For Geeks");
print("You Can See This Line Geek as a Output");
}

4. asíncrono: cuando se llama a una función asíncrona, se devuelve inmediatamente un futuro y el cuerpo de la función se ejecuta más tarde. A medida que se ejecuta el cuerpo de la función asíncrona, el Future devuelto por la llamada a la función se completará junto con su resultado. En el ejemplo anterior, llamar a demo() da como resultado el futuro. 

void hello() async {
print('something exciting is going to happen here...');
}

5. await: las expresiones Await te hacen escribir el código asincrónico casi como si fuera sincrónico. En general, una expresión de espera tiene la forma que se indica a continuación:

void main() async {
 await hello();
 print('all done');
}

6. break: break se usa para detener el ciclo y cambiar de caso siempre que se cumpla la condición. Por ejemplo: Interrumpir el bucle while

void main()
{
while (true) {
 
 if (shutDownRequested()) break;
 processIncomingRequests();
}
 
Break in Switch Case:-
 
var command = 'OPEN';
 
switch (command) {
 case 'CLOSED':
   executeClosed();
   break;
case 'DENIED':
   executeDenied();
   break;
 case 'OPEN':
   executeOpen();
   break;
 default:
   executeUnknown();
}
}

7. caso: el caso es el mismo que en otros lenguajes de programación, se usa con la declaración de cambio.

void main() {
  ar command = 'OPEN';
switch (command) {
  case 'CLOSED':
    executeClosed();
    break;
  case 'PENDING':
    executePending();
    break;
  case 'APPROVED':
    executeApproved();
    break;
  case 'DENIED':
    executeDenied();
    break;
  case 'OPEN':
    executeOpen();
    break;
  default:
    executeUnknown();
}
}

8. catch: catch se usa con el bloque try en dart para capturar excepciones en el programa.

syntax:-
try {  
  // program that might throw an exception  
}  
on Exception1 {  
  // code for handling exception 1
}  
catch Exception2 {  
  // code for handling exception 2
}

Ejemplo:

void main() {
int geek = 10;
try{
    var geek2 = geek ~/ 0;
    print(geek2);
}
catch(e){
    print(e);
}
finally {
    print("Code is at end, Geek");
}
}

9. clase: clase en dart igual que una clase en otros lenguajes de programación orientados a objetos. Una clase es un grupo de objetos que tienen propiedades comunes. Es una plantilla o modelo a partir del cual se crean objetos. Es una entidad lógica.

Syntax:
class  class_name
{
 //statements
}

class geeks
{
  String var= "Geeks for Geeks";
  void print()
  {
    print(var);
  }
}

10. continuar: la instrucción continuar se usa para interrumpir una iteración en el bucle siempre que la condición coincida y comenzar la siguiente iteración.

Ejemplo:

void main() {
  for(int i=0;i<6;i++)
  {
    if(i==4)
     continue;
    print(i);
  }
}

11. const: const se usa para hacer que una variable sea constante a lo largo del programa. La palabra clave const no es solo para declarar variables constantes. También podemos usarlo para crear valores constantes y declarar constructores que crean valores constantes. Cualquier variable puede tener un valor constante.

Ejemplo:

void main() {
  var foo = const [];
final bar = const [];
 
// Equivalent to `const []`
const baz = [];
}

Puede omitir const de la expresión de inicialización de una declaración const, como para baz arriba.

12. covariant: palabra clave covariant para decirle al analizador que está anulando el tipo de un parámetro con un subtipo, que no es válido. Esto elimina el error estático y, en su lugar, busca un tipo de argumento no válido en tiempo de ejecución.

Ejemplo:

void chase(Animal x) { ... }
}
 
class Mouse extends Animal { ... }
 
class Cat extends Animal {
 
 @override
 void chase(covariant Mouse x) { ... }
 
}

13. predeterminado: la declaración predeterminada se usa en caso de cambio cuando ninguna condición coincide, entonces se ejecuta la declaración predeterminada.

Ejemplo:

void main() {
  var command = 'GEEKS FOR GEEKS';
switch (command) {
  case 'CLOSED':
    print('Closed');
    break;
  case 'PENDING':
    print('PENDING');
    break;
  case 'APPROVED':
    print('APPROVED');
    break;
  case 'DENIED':
    print('DENIED');
    break;
  case 'OPEN':
    print('OPEN');
    break;
  default:
    print('DEFAULT STATEMENT EXECUTED');
}
}

14. diferido: – La carga diferida (también llamada carga diferida) permite que una aplicación web cargue una biblioteca a pedido cuando se necesita la biblioteca. 

Estos son algunos casos en los que se utiliza la carga diferida:

1. Para reducir el tiempo de inicio inicial de una aplicación web.
2. Para realizar pruebas A/B, por ejemplo, probar implementaciones alternativas de un algoritmo.
3. Para cargar funciones poco utilizadas, como pantallas y cuadros de diálogo opcionales.

15. do:  do se usa con while para el ciclo do-while.

Ejemplo:

void main() {
  int i=1; 
    do{ 
       print(i); 
          i++; 
    }while(i<=5); 
}

16. dinámico: – dinámico se usa para declarar una variable dinámica que puede almacenar cualquier valor, ya sea una string o un int, es lo mismo que var en javascript.

Ejemplo:

void main()
{
dynamic x=1;
 
print(x);
 
x="xx";
print(x);
}

17. else:  else se usa con la declaración if, se usa para probar la condición, si se ejecuta el bloque, si la condición es verdadera, de lo contrario, se ejecuta el bloque else.

if(condition)
{
 statements;
}
else
{
statements;
}

Ejemplo:

void main() {
  var i=10;
  if(i==9)
      print('Hello, Geeks!');
  else
    print('Geeks for Geeks');
}

18. enum: las enumeraciones son un tipo especial de clase que se utiliza para representar un número fijo de valores constantes.

// dart program to print all the
// elements from the enum data class
 
// Creating enum with name Gfg
enum Gfg {
     
// Inserting data
Welcome, to, GeeksForGeeks
}
 
void main() {
     
// Printing the value
// present in the Gfg
for (Gfg geek in Gfg.values) {
    print(geek);
}
}

19. exportar: la exportación se usa para crear una nueva biblioteca y usar otras bibliotecas que desea que estén disponibles automáticamente al usar su paquete, 

Ejemplo:

library mylib;
 
export 'otherlib.dart';

20. extends: se extiende para crear una subclase y super para referirse a la superclase:

Ejemplo:

class gfg
{
  void disp();
}
class geeks extends gfg
{
  void show()
  {
    //statement;
  }
}

21. extensiones: las extensiones son una forma a través de la cual podemos agregar funcionalidad a las bibliotecas existentes.

Aquí hay un ejemplo del uso de un método de extensión en String llamado parseInt() que está definido en string_apis.dart:

Ejemplo:

import 'string_apis.dart';
void main() {
  print('Hello, Geeks!');
   
  // Use a String method.
  print('42'.padLeft(5));
  print('42'.parseInt());
}

22. external:- Una función externa es una función cuyo cuerpo se proporciona por separado de su declaración. Una función externa puede ser una función de nivel superior o un método.

eg: external String toString();

23. fábrica: la fábrica se usa cuando se implementa un constructor que no siempre crea una nueva instancia de su clase.

En el siguiente ejemplo, el constructor de la fábrica Logger devuelve objetos de una memoria caché y el constructor de la fábrica Logger.fromJson inicializa una variable final de un objeto JSON.

Ejemplo:

class Logger {
 
 final String name;
 
 bool mute = false;
 
 // _cache is library-private, thanks to
 // the _ in front of its name.
 
 static final Map<String, Logger> _cache =
     <String, Logger>{};
 factory Logger(String name) {
   return _cache.putIfAbsent(
       name, () => Logger._internal(name));
 }
 
 factory Logger.fromJson(Map<String, Object> json) {
   return Logger(json['name'].toString());
 }
 
 Logger._internal(this.name);
 
 void log(String msg) {
   if (!mute) print(msg);
 }
}

24. false:- false es uno de los tipos booleanos de dart aparte de true.

void main()
{
  var gfg=false;
  print(gfg);
}

25. final:- final se usa cuando no pretendemos cambiar una variable en el resto del programa.

void main()
{
  final gfg=false;
  gfg=true;
  print(gfg);
}

26. finalmente: finalmente es un bloque, que se utiliza para colocar códigos que deben ejecutarse incluso si hay una excepción en el programa. El bloque finalmente se coloca después del bloque de prueba y cada vez que ocurre algún error, el control va al bloque finalmente y se ejecuta.

Ejemplo:

void main()
{
  try {
      int x=9,y=0;
      int res = x ~/ y;
   } 
   on IntegerDivisionByZeroException catch(e) {
      print(e);
   }
  finally
  {
    print('finally block executing');
  }
}

27. for:- for se usa en ‘for loop’, es lo mismo que for loops en otros lenguajes de programación. 

Ejemplo:

void main() {
  for(int i=0;i<5;i++)
      print(i);
}

28. Función: – Dart es un verdadero lenguaje orientado a objetos, por lo que incluso las funciones son objetos y tienen un tipo, «Función» . Significa que las funciones se pueden asignar a variables o pasar como argumentos a otras funciones. 

Ejemplo:

int gfg()
{
  int obj;
  return obj=1;
}
void main() {
  print(gfg());
}

29. get:- Getters y setters son métodos especiales que proporcionan acceso de lectura y escritura a las propiedades de un objeto.

Ejemplo:

   }
     
   void set s_name(String name) {
      this.name = name;
   }
    
   void set s_age(int age) {  
         this.age = age;
       
   }
    
   int get s_age {
      return age;    
   }
} 
void main() {
   Student obj = new Student();
   obj.stud_name = 'DART';
   obj.stud_age = 10;
   print(s1.stud_name);
   print(s1.stud_age);
}

30. hide:- hide se usa cuando solo es parte de una biblioteca, puede importar selectivamente la biblioteca. Por ejemplo:

// Import only foo.
import 'package:lib1/lib1.dart' show foo;
// Import all names EXCEPT foo.
import 'package:lib2/lib2.dart' hide foo;

31. if:- if es una declaración condicional, que se usa para verificar la condición y si las condiciones resultan ser verdaderas, entonces el bloque adjunto se ejecuta hasta que la condición se vuelve falsa.

Ejemplo:

void main()
{
  int x=5;
  if(x!=0)
  {
    print(x);
  }
  else
    print('else block executing');
}

32. import: la palabra clave import se usa para bibliotecas y otros archivos en el programa dart en particular.

Ejemplo:

import 'dart:html';

33. implements:- implements se utiliza para implementar la interfaz en el programa.

Ejemplo:

class Person {
   
  // In the interface, but visible
  // only in this library.
  final _name;
 
  // Not in the interface, since
  // this is a constructor.
  Person(this._name);
 
  // In the interface.
  String greet(String who) => 'Hello, $who. I am $_name.';
}
 
// An implementation of the Person interface.
class Impostor implements Person {
  get _name => '';
 
  String greet(String who) => 'Hi $who. Do you know who I am?';
}
 
String greetBob(Person person) => person.greet('Bob');
 
void main() {
  print(greetBob(Person('Kathy')));
  print(greetBob(Impostor()));
}

34. in:- in se usa en el bucle for-in. El bucle for-in se usa cuando estamos iterando sobre un iterable (como una lista o un conjunto).

Ejemplo:

void main() {
  var lists = [1, 2, 3];
  for (var obj in lists) print(obj);
}

35. interfaz:- La interfaz en el dardo proporciona al usuario el modelo de la clase, que cualquier clase debe seguir si interactúa con esa clase, es decir, si una clase hereda otra, debe redefinir cada función presente dentro de una clase interconectada a su manera. 

Ejemplo:

void main(){
     
// Creating Object
// of the class Gfg
Gfg geek1= new Gfg();
     
// Calling method
// (After Implementation )
geek1.printdata();
}
 
// Class Geek (Interface)
class Geek {
void printdata() {
    print("Hello Geek !!");
}
}
 
// Class Gfg implementing Geek
class Gfg implements Geek {
void printdata() {
    print("Welcome to GeeksForGeeks");
}
}

36. is:- is es un operador de prueba de tipo que es útil para verificar tipos en tiempo de ejecución. devuelve verdadero si el objeto es del tipo especificado.

Ejemplo:

if (employee is Person) {
 // Type check
 employee.firstName = 'Bob';
}

37. bibliotecas: las directivas de importación y biblioteca pueden ayudarlo a crear una base de código modular y compartible. Las bibliotecas no solo proporcionan API, sino que son una unidad de privacidad: los identificadores que comienzan con un guión bajo (_) solo son visibles dentro de la biblioteca. Cada aplicación de Dart es una biblioteca, incluso si no usa una directiva de biblioteca.

Por ejemplo, las aplicaciones web de Dart generalmente usan la biblioteca dart:html, que pueden importar de esta manera:

import 'dart:html';

38. mixin: – Los mixins son una forma de reutilizar el código de una clase en varias jerarquías de clases.

Ejemplo:

class Musician extends Performer with Musical {
 
 // ···
 
}
 
class Maestro extends Person
   with Musical, Aggressive, Demented {
 
 Maestro(String maestroName) {
   name = maestroName;
   canConduct = true;
 }
}

39. part:- part es una palabra clave a través de la cual una biblioteca se divide en varios archivos dart y esos archivos se importan en el programa dart. 

Ejemplo:

export 'src/cascade.dart';
export 'src/handler.dart';
export 'src/handlers/logger.dart';
export 'src/hijack_exception.dart';
export 'src/middleware.dart';
export 'src/pipeline.dart';
export 'src/request.dart';
export 'src/response.dart';
export 'src/server.dart';
export 'src/server_handler.dart';

40. new:- new es una palabra clave que se utiliza para crear una instancia de una clase.

syntax: class class_name = new class_name( [arguments]);

Ejemplo:

class gfg {
  var name = 'geeksforgeeks';
  void display() {
    print(name);
  }
}
 
void main() {
  gfg obj = new gfg();
  obj.display();
}

41. nulo: las variables no inicializadas que tienen un tipo anulable tienen un valor inicial de nulo. (Si no ha optado por la seguridad nula, entonces cada variable tiene un tipo anulable). Incluso las variables con tipos numéricos son inicialmente nulas, porque los números, como todo lo demás en Dart, son objetos.

Ejemplo:

void main() {
  var x;
  print(x);
}

42. on:- on es un bloque, que se usa con el bloque try cada vez que tenemos un tipo específico de excepción para atrapar.

Ejemplo:

void main()
{
  try
  {
    int x=10,y;
    y=x~/0;
  }
  on IntegerDivisionByZeroException
  {
    print("divide by zero exception");
  }
}

43. operador: – Los operadores son métodos de instancia con nombres especiales. Dart le permite definir operadores con los siguientes nombres:

Ejemplo:

class Vector {
  final int x, y;
 
  Vector(this.x, this.y);
 
  Vector operator +(Vector v) => Vector(x + v.x, y + v.y);
  Vector operator -(Vector v) => Vector(x - v.x, y - v.y);
 
  // Operator == and hashCode not shown.
  // ···
}
 
void main() {
  final v = Vector(2, 3);
  final w = Vector(2, 2);
 
  assert(v + w == Vector(4, 5));
  assert(v - w == Vector(0, 1));
}

44. parte: – La parte se usa para dividir una biblioteca en varios archivos y luego usarla. Pero se recomienda evitar el uso de partes y crear mini bibliotecas en su lugar.

Por ejemplo: dividir la carpeta src en varios archivos y usarla en el programa dart.

creando múltiples partes del directorio raíz del estante

export 'src/cascade.dart';
export 'src/handler.dart';
export 'src/handlers/logger.dart';
export 'src/hijack_exception.dart';
export 'src/middleware.dart';
export 'src/pipeline.dart';
export 'src/request.dart';
export 'src/response.dart';
export 'src/server.dart';
export 'src/server_handler.dart';

45.rethrow:-rethrow se usa para manejar parcialmente las excepciones mientras permite que se propague más. Rethrow se puede usar para asegurarse de que la excepción se maneje correctamente internamente antes de que se propague a otras personas que llaman.

Ejemplo:

void misbehave() {
  try {
    dynamic foo = true;
    print(foo++); // Runtime error
  } catch (e) {
    print('misbehave() partially handled ${e.runtimeType}.');
    rethrow; // Allow callers to see the exception.
  }
}
 
void main() {
  try {
    misbehave();
  } catch (e) {
    print('main() finished handling ${e.runtimeType}.');
  }
}

46. ​​return:- return se usa para devolver el valor de una función/método.

Ejemplo:

int fact(int n) {
  if (n <= 1)
    return 1;
  else
    return n * fact(n - 1);
}
 
void main() {
  int n = 5;
  print(fact(5));
}

47. set: – set se usa para inicializar variables en el programa, es útil cuando tenemos que establecer muchas variables en un programa.

Ejemplo:

class Rectangle {
 
 double left, top, width, height;
 
 Rectangle(this.left, this.top, this.width, this.height);
 
 // Define two calculated properties: right and bottom.
 double get right => left + width;
 set right(double value) => left = value - width;
 
 double get bottom => top + height;
 set bottom(double value) => top = value - height;
 
}
void main() {
 
 var rect = Rectangle(3, 4, 20, 15);
 assert(rect.left == 3);
 rect.right = 12;
 assert(rect.left == -8);
}

48. show: – show se usa para importar un archivo selectivo de una biblioteca.

Ejemplo:

// Import only foo.
import 'package:lib1/lib1.dart' show foo;

49. estática: – La palabra clave estática se utiliza para implementar variables y métodos de toda la clase.

Ejemplo:

//Variables
class Queue {
 
 static const initialCapacity = 16;
 // ···
}
 
void main() {
 
 assert(Queue.initialCapacity == 16);
}
 
//Methods
import 'dart:math';
 
class Point {
 
 double x, y;
 Point(this.x, this.y);
 
 static double distanceBetween(Point a, Point b) {
 
   var dx = a.x - b.x;
   var dy = a.y - b.y;
   return sqrt(dx * dx + dy * dy);
 }
}
 
void main() {
 
 var a = Point(2, 2);
 var b = Point(4, 4);
 var distance = Point.distanceBetween(a, b);
 assert(2.8 < distance && distance < 2.9);
 print(distance);
 
}

50.super:- super se usa para llamar a métodos y variables de la clase principal.

Ejemplo:

// Creating Parent class
class SuperGeek {
    String geek = "Geeks for Geeks";
}
 
// Creating child class
class SubGeek extends SuperGeek {
 
    // Accessing parent class variable
    void printInfo()
    {
        print(super.geek);
    }
}
 
void main()
{
    // Creating child class object
    SubGeek geek = new SubGeek();
 
    // Calling child class method
    geek.printInfo();
}

51.switch:- la palabra clave switch se usa en la declaración de caso de cambio, el caso de cambio es la versión simplificada de la declaración if-else anidada.

Ejemplo:

void main()
{
    int gfg = 1;
    switch (gfg) {
    case 1: {
        print("GeeksforGeeks number 1");
    } break;
    case 2: {
        print("GeeksforGeeks number 2");
    } break;
    case 3: {
        print("GeeksforGeeks number 3");
    } break;
    default: {
        print("This is default case");
    } break;
    }
}

52. sincronización: – Para implementar una función de generador síncrono, el cuerpo de la función se marca como sincronización*.

Ejemplo:

Iterable<int> naturalsTo(int n) sync* {
 
 int k = 0;
 while (k < n) yield k++;
}

53. esto:- esta palabra clave representa un objeto implícito que apunta al objeto de clase actual. Se refiere a la instancia actual de la clase en un método o constructor. La palabra clave this se utiliza principalmente para eliminar la ambigüedad entre los atributos de clase y los parámetros con el mismo nombre.

Ejemplo:

// Dart program to illustrate
// this keyword
void main()
{
Student s1 = new Student('S001');
}
 
class Student
{
// defining local st_id variable
var st_id;
Student(var st_id)
{
    // using this keyword
    this.st_id = st_id;
    print("GFG - Dart THIS Example");
    print("The Student ID is : ${st_id}");
}
}

54. throw: la palabra clave throw se usa para lanzar explícitamente una excepción. Debe manejarse correctamente, de lo contrario, hará que el programa se detenga abruptamente.

Ejemplo:

void gfg(int flag) {
  if (flag < 0) {
    throw new FormatException();
  }
}
 
void main() {
  try {
    gfg(-2);
  } catch (e) {
    print('Exception caught!');
  }
}

55. verdadero:- verdadero es un valor booleano que es una constante de tiempo de compilación.

Ejemplo:

void main()
{
  bool gfg=true;
  print(gfg);
}

56. try:- try es un bloque en dart en el que se guardan los códigos que pueden generar un error en el programa. Un bloque de prueba va seguido de al menos un bloque de activación/captura o un bloque de finalización.

void main() {
  int x = 10, y;
  try {
    y = x ~/ 0;
  } on Exception catch (e) {
    print(e);
  }
}

57. typedef: – Un typedef, o alias de tipo de función, le da a un tipo de función un nombre que puede usar al declarar campos y devolver tipos. Un typedef conserva la información de tipo cuando se asigna un tipo de función a una variable.

Ejemplo:

typedef Compare = int Function(Object a, Object b);
 
class SortedCollection {
 
 Compare compare;
 SortedCollection(this.compare);
 
}
 
// Initial, broken implementation.
int sort(Object a, Object b) => 0;
 
void main() {
 
 SortedCollection coll = SortedCollection(sort);
 assert(coll.compare is Function);
 assert(coll.compare is Compare);
}

58. var:-  var se usa para declarar una variable en el programa dart.

Ejemplo: 

var str="gfg";

59. void:- void es un tipo incorporado que indica que el valor nunca se usa. Generalmente se usa con la función para especificar que no tiene ningún tipo de retorno.

Ejemplo:

// void types shows that
// it will return nothing
void main() 
{
  print('Hello, Geeks!');
}

60.while:- while se usa en el bucle while. El bucle while evalúa la condición antes de entrar en el bucle, por eso se conoce como bucle de control de entrada.

Ejemplo:

void main() {
  int x = 5;
  while (x != 0) {
    print(x);
    x--;
  }
}

61. with:- with se usa para usar mixins en el programa dart.

Sintaxis:-

class B {  //B is not allowed to extend any other class other than object
 method(){
    ....
 }
}
class A with B {
 ....
    ......
}
void main() {
 A a = A();
 a.method();  //we got the method without inheriting B
}

Ejemplo:

mixin Geeks {
  bool java = false;
  bool c = false;
  bool python = false;
 
  void WhichLanguageYouKnow() {
    if (java) {
      print('I know Java');
    } else if (c) {
      print('I know C');
    } else {
      print('I know Dart');
    }
  }
}
class Gfg with Geeks
{
  int x;
}
void main()
{
  Gfg ob=new Gfg();
  ob.WhichLanguageYouKnow();
}

62. yield: la palabra clave yield se usa con la función sync* para entregar la salida de la función síncrona.

Ejemplo:

void main() {
  print('Hello, Geeks!');
}