Hoja de Trucos de Dart
Última actualización
Hola Mundo y estructura del programa
Cada programa Dart empieza en la función main de nivel superior.
| Operación | Sintaxis |
|---|---|
| Punto de entrada | void main() { ... } |
| Imprimir una línea | print("Hello, World!"); |
| Interpolación de cadenas | print("Hi $name"); |
| Expresión en la interpolación | print("Sum: ${a + b}"); |
| Comentario | // this is a comment |
| Comentario de varias líneas | /* ... */ |
| Importar una biblioteca | import 'dart:math'; |
| Ejecutar un archivo | dart run main.dart |
Variables y tipos
Dart es de tipado estático pero puede inferir tipos con var.
| Operación | Sintaxis |
|---|---|
| Variable inferida | var age = 30; |
| Tipo explícito | int age = 30; |
| Constante en tiempo de compilación | const pi = 3.14; |
| Constante en tiempo de ejecución | final name = getName(); |
| Tipos básicos | int, double, String, bool |
| Tipo dinámico | dynamic x = 5; |
| Conversión de tipo | int.parse("42"), n.toString() |
| Comprobar el tipo | x is String, x as String |
Null safety
Los tipos no admiten null por defecto; añade ? para permitir null.
| Operación | Sintaxis |
|---|---|
| No anulable (por defecto) | int count = 0; |
| Tipo anulable | String? name; |
| Acceso seguro ante null | user?.name |
| Fusión de nulos | name ?? "default" |
| Asignación con fusión de nulos | name ??= "default"; |
| Afirmar no nulo | name! |
| Inicialización tardía | late String value; |
| Spread seguro ante null | [...?maybeList] |
Cadenas
Las cadenas admiten comillas simples, dobles y triples.
| Operación | Sintaxis |
|---|---|
| Longitud | s.length |
| Mayúsculas / minúsculas | s.toUpperCase(), s.toLowerCase() |
| Interpolación | "Total: $price" |
| Concatenar | "foo" + "bar" |
| Contiene | s.contains("ell") |
| Empieza / termina con | s.startsWith("he") |
| Dividir | "a,b,c".split(",") |
| Reemplazar | s.replaceAll("a", "b") |
| Subcadena | s.substring(0, 3) |
| Recortar | s.trim() |
Colecciones (List, Map, Set)
Tres tipos de colección principales con sintaxis literal.
| Operación | Sintaxis |
|---|---|
| Literal de lista | var nums = [1, 2, 3]; |
| Añadir a la lista | nums.add(4); |
| Acceder / longitud | nums[0], nums.length |
| Map / where | nums.map((n) => n * 2), nums.where((n) => n > 1) |
| Literal de mapa | var ages = {"Ada": 30}; |
| Acceso al mapa | ages["Ada"] |
| Literal de conjunto | var ids = {1, 2, 3}; |
| Operador spread | var all = [...a, ...b]; |
| If / for en colecciones | [if (show) 1, for (n in xs) n] |
Control de flujo
Las condiciones van entre paréntesis; switch admite patrones.
| Operación | Sintaxis |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| Ternario | var r = x > 0 ? "pos" : "neg"; |
| Switch | switch (n) { case 1: ...; default: ... } |
| Bucle for | for (var i = 0; i < 10; i++) { ... } |
| Bucle for-in | for (var item in items) { ... } |
| forEach | items.forEach((x) => print(x)); |
| Bucle while | while (x < 100) { ... } |
| Do-while | do { ... } while (x < 100); |
| Break / continue | break;, continue; |
Funciones
Las funciones son de primera clase; la sintaxis de flecha acorta las expresiones únicas.
| Operación | Sintaxis |
|---|---|
| Definir una función | int add(int a, int b) { return a + b; } |
| Función flecha | int square(int x) => x * x; |
| Posicional opcional | void log(String m, [int? code]) { ... } |
| Parámetros con nombre | void box({int w = 0, int h = 0}) { ... } |
| Con nombre obligatorio | void box({required int w}) { ... } |
| Función anónima | var f = (x) => x * 2; |
| Pasar como argumento | nums.map((n) => n * 2) |
| Typedef | typedef IntOp = int Function(int); |
Clases y constructores
Las clases contienen estado y comportamiento; los constructores vienen en varias formas.
| Operación | Sintaxis |
|---|---|
| Definir una clase | class Point { int x; int y; } |
| Constructor | Point(this.x, this.y); |
| Constructor con nombre | Point.origin() : x = 0, y = 0; |
| Crear una instancia | var p = Point(1, 2); |
| Método | double dist() { ... } |
| Getter | int get area => w * h; |
| Herencia | class Circle extends Shape { ... } |
| Llamar a super | super(args) |
| Clase abstracta | abstract class Shape { ... } |
| Implementar una interfaz | class Dog implements Animal { ... } |
Async (Future / async-await)
Los futures representan valores disponibles más tarde; await pausa hasta que se resuelven.
| Operación | Sintaxis |
|---|---|
| Función async | Future<int> load() async { ... } |
| Esperar un future | var data = await load(); |
| Devolver un valor | return 42; dentro de una función async |
| Retraso | await Future.delayed(Duration(seconds: 1)); |
| Manejar errores | try { await load(); } catch (e) { ... } |
| Encadenar con then | load().then((v) => print(v)); |
| Ejecutar en paralelo | await Future.wait([a(), b()]); |
| Stream async | await for (var x in stream) { ... } |
La sintaxis de Dart que más usas, en una sola página. Esta hoja de trucos de Dart es una referencia rápida para el núcleo del lenguaje: variables y tipos, null safety, cadenas, colecciones, control de flujo, funciones, clases y los futures y async/await que usas para escribir las apps detrás de Flutter.
Todo lo que hay aquí es Dart estándar y se ejecuta en el SDK oficial. Copia lo que necesites o prueba cada fragmento en vivo en el playground de Dart, sin necesidad de instalar nada.
Preguntas frecuentes sobre la hoja de trucos de Dart
¿Esta hoja de trucos de Dart es gratis?
Sí. Esta hoja de trucos de Dart es completamente gratuita, sin necesidad de registrarse. Guárdala en favoritos y vuelve cuando necesites consultar un operador de null safety, un método de colección o un patrón async.
¿Cómo funciona la null safety en Dart?
En Dart, cada tipo no admite null por defecto:
int count nunca puede contener null. Para permitir null añades un ? (String? name), y entonces el compilador te obliga a manejar el caso nulo. Algunos ayudantes lo hacen conciso: ?. para el acceso seguro ante null, ?? para un valor de reserva y ! para afirmar que un valor no es nulo cuando estás seguro. Esto detecta los errores de null en tiempo de compilación en lugar de en tiempo de ejecución.¿Qué es un Future y cómo funcionan async y await?
Un
Future representa un valor que estará disponible más tarde, como el resultado de una llamada de red. Marcar una función como async te permite usar await, que pausa la ejecución hasta que el future se completa y luego te da el valor, de modo que escribes código asíncrono que se lee de arriba abajo como código síncrono. Envuelve los await en try/catch para manejar los errores.¿Puedo practicar Dart en línea?
Sí. Abre el playground de Dart para ejecutar cualquier fragmento de esta hoja de trucos en tu navegador, sin instalar ningún SDK. Cuando quieras estructura, el curso interactivo y gratuito de Dart de Coddy te lleva paso a paso desde la null safety y las colecciones hasta las clases y async/await.
¿Esta hoja de trucos es buena para principiantes?
Sí. Está organizada desde los temas más comunes (variables, null safety, control de flujo) hasta los avanzados (clases, futures, async/await), de modo que puedes usar las secciones de arriba desde el primer día e ir avanzando hacia el resto.
Recursos relacionados
Más hojas de referencia
