Cheatsheet Dart

Instalación en Windows

Descarga el instalador desde dart.dev

Instalación en Linux

sudo apt update -y
sudo apt install dart

Instalación en macOS

brew tap dart-lang/dart
brew install dart

Verificar Instalación

Para comprobar que Dart está correctamente instalado

dart --version

Compilar y ejecutar un archivo Dart

Para compilar y ejecutar un archivo .dart:

dart run archivo.dart

Programa simple

El siguiente código muestra un programa básico en Dart con la función main como punto de entrada.

void main() {
  print('Hola, Mundo!');
}

Comentario de línea

// Este es un comentario de una línea

Comentario de bloque

/*
Este es un comentario
de múltiples líneas
*/

Tipos primitivos en Dart

Dart tiene varios tipos de datos primitivos: int, double, bool, String y var.

int entero = 42;
double decimal = 3.14;
bool esVerdad = true;
String texto = 'Hola';
var indefinido = 'puede ser cualquier tipo';

Constantes

En Dart, se pueden definir constantes con const o final.

• const: Valor de la constante en tiempo de compilación.
• final: Valor fijo en tiempo de ejecución, pero no se puede cambiar después de inicializarlo.

const double pi = 3.1416;
final DateTime ahora = DateTime.now();

Null Safety

Dart tiene null safety para evitar errores de referencia nula:

int? edad; // Puede ser null
edad = 20;
print(edad);

Dart incluye varios tipos de operadores para realizar operaciones con variables y constantes.

Operadores Aritméticos

• + Suma
• - Resta
• * Multiplicación
• / División (devuelve un double)
• ~/ División entera (devuelve un int)
• % Módulo (resto de la división)

int a = 10;
int b = 3;
print(a + b);   // 13
print(a ~/ b);  // 3
print(a % b);   // 1

Operadores de Asignación

• = Asignación
• +=, -=, *=, /=, ~/=, %=

int c = 5;
c += 2;  // c = 7

Operadores Relacionales

• == Igual a
• != No igual a
• > Mayor que
• < Menor que
• >= Mayor o igual que
• <= Menor o igual que

print(5 > 3);   // true

Operadores Lógicos

• && Y lógico (AND)
• || O lógico (OR)
• ! Negación lógica (NOT)

bool esMayor = (5 > 3) && (2 < 4);  // true

Operador de incremento/decremento

• ++ Incremento en 1
• -- Decremento en 1

int d = 5;
d++;  // d = 6

Operador de nulidad

• ?? Devuelve el valor de la izquierda si no es null, de lo contrario devuelve el de la derecha.

String? nombre;
print(nombre ?? 'Sin nombre');  // 'Sin nombre'

if (condicion) {
  // código si la condición es verdadera
} else if (otraCondicion) {
  // código si la otra condición es verdadera
} else {
  // código si ninguna condición es verdadera
}

Operador ternario

var resultado = (condicion) ? valor1 : valor2;

Switch-case

switch (variable) {
  case valor1:
    // código para valor1
    break;
  case valor2:
    // código para valor2
    break;
  default:
    // código si no hay coincidencias
}

Bucle for

for (int i = 0; i < 10; i++) {
  print(i);
}

Bucle while

int i = 0;
while (i < 10) {
  print(i);
  i++;
}

Bucle do-while

int i = 0;
do {
  print(i);
  i++;
} while (i < 10);

Definición básica de una función

void imprimirMensaje(String mensaje) {
  print(mensaje);
}

Función con valor de retorno

int sumar(int a, int b) {
  return a + b;
}

Funciones anónimas

var funcionAnonima = () {
  print('Esto es una función anónima');
};

Parámetros opcionales

En Dart, los parámetros pueden ser opcionales o tener valores predeterminados:

• Parámetros nombrados:

void saludo({String nombre = 'amigo'}) {
  print('Hola, $nombre');
}

• Parámetros posicionales:

void mostrarDatos(String nombre, [int edad = 0]) {
  print('Nombre: $nombre, Edad: $edad');
}

Funciones de flecha (Arrow functions)

Las funciones cortas pueden expresarse con flechas:

int multiplicar(int a, int b) => a * b;

Funciones como parámetros

void ejecutarFuncion(void Function() funcion) {
  funcion();
}

void main() {
  ejecutarFuncion(() => print('Función ejecutada'));
}

Closures

Function sumar(int a) {
  return (int b) => a + b;
}

void main() {
  var sumaCon5 = sumar(5);
  print(sumaCon5(3)); // 8
}

Declaración de listas

List<int> numeros = [1, 2, 3, 4, 5];

Acceso a elementos

print(lista[0]); // Imprime 1

Operaciones comunes con listas

numeros.add(6);
numeros.remove(3);
print(numeros.length);

Declaración de sets

Set<String> nombres = {'Ana', 'Luis', 'Carlos'};

Operaciones con sets

nombres.add('Pedro');
nombres.remove('Ana');

Declaración de mapas

Map<String, int> edades = {'Luis': 25, 'Ana': 30};

Acceso a valores

print(edades['Luis']); // 25

Definición de clase

class Persona {
  String nombre;
  int edad;

  Persona(this.nombre, this.edad);

  void mostrarDatos() {
    print('Nombre: $nombre, Edad: $edad');
  }
}

Crear una instancia de clase

void main() {
  var persona = Persona('Luis', 25);
  persona.mostrarDatos();
}

Uso de getters y setters

class Circulo {
  double radio;

  Circulo(this.radio);

  double get area => 3.1416 * radio * radio;
  set cambiarRadio(double nuevoRadio) => radio = nuevoRadio;
}

Constructores nombrados

class Persona {
  String nombre;
  int edad;

  Persona(this.nombre, this.edad);

  Persona.sinEdad(this.nombre) {
    edad = 0;
  }
}

Herencia

class Animal {
  void sonido() {
    print('El animal hace un sonido');
  }
}

class Perro extends Animal {
  @override
  void sonido() {
    print('El perro ladra');
  }
}

Métodos estáticos

class Matematica {
  static int sumar(int a, int b) {
    return a + b;
  }
}

void main() {
  print(Matematica.sumar(5, 3));
}

Funciones asincrónicas

Dart permite ejecutar código de forma asíncrona usando Future y async/await.

Future<String> obtenerDatos() async {
  return 'Datos obtenidos';
}

void main() async {
  String resultado = await obtenerDatos();
  print(resultado);
}

Simulación de retrasos

Future<void> simularRetraso() async {
  await Future.delayed(Duration(seconds: 2));
  print('Retraso completado');
}

Uso de Streams para manejar flujos de datos

Stream<int> contar() async* {
  for (int i = 1; i <= 5; i++) {
    yield i;
    await Future.delayed(Duration(seconds: 1));
  }
}

void main() async {
  await for (var valor in contar()) {
    print(valor);
  }
}

Try-catch-finally

void main() {
  try {
    int resultado = 100 ~/ 0; // División por cero
  } catch (e) {
    print('Error: $e');
  } finally {
    print('Operación completada');
  }
}

Lanzar excepciones

void validarEdad(int edad) {
  if (edad < 18) {
    throw Exception('Edad no válida');
  }
}

Importar una biblioteca

import 'dart:math';

Creación de un nuevo proyecto

dart create mi_proyecto

Gestión de dependencias con pubspec.yaml

En este archivo, se gestionan las dependencias de tu proyecto:

dependencies:
  http: ^0.13.3

Para instalar las dependencias:

dart pub get

Uso de un paquete

import 'package:http/http.dart' as http;

void main() async {
  var respuesta = await http.get(Uri.parse('https://ejemplo.com'));
  print(respuesta.body);
}