Dart: Bases del lenguaje

Dart es un lenguaje de programación moderno, orientado a objetos y fuertemente tipado desarrollado por Google. En este artículo vamos a ver brevemente las bases de dart, las variables, clases, funciones, listas, mapas, sets, entre otros.

Lista de los temas:

¿Qué es Dart?

Dart es un lenguaje de programación que podemos usarlo para crear aplicaciones multiplataforma para dispositivos móviles, escritorio y web. Después de escribir estas aplicaciones, debe compilarse en código de máquina nativo (o en JavaScript si se está desarrollando para la web), de modo que las aplicaciones se puede ejecutar en esas diferentes plataformas, como en un dispositivo Android o en un dispositivo iOS. Dart se conoce como un lenguaje fuertemente tipado, lo que significa que cada variable debe tener su propio tipo, por ejemplo, un string, un número entero, booleano o algún otro tipo.

Para probar este maravilloso lenguaje podemos usar DartPad, que es un editor de código en línea que nos permite escribir y ejecutar código Dart en el navegador. Para instalar localmente, podemos descargar el SDK de Dart desde el sitio web oficial y seguir las instrucciones de instalación y uso.

En Dart, la ejecución de un programa comienza en la función main(). Esta función es el punto de entrada de cualquier aplicación Dart. Aquí hay un ejemplo de una función main():

dart
void main() {
  print('Hola, mundo!'); // Hola, mundo!
 
  String name = 'Javier';
 
  print('Mi nombre es $name'); //Mi nombre es Javier
 
  print('Cantidad de caracteres ${name.length}'); // Cantidad de caracteres 6
 
  print(name.length); // 6
}

Variables y tipos de datos

En Dart, podemos declarar variables de varias maneras, dependiendo de las necesidades:

dart
void main() {
    // Definición de variables
    var name = 'Javier';  // Inferencia de tipo
    print(name);  // Javier
 
    // Definición de variables con tipo explícito
    String lastName = 'Acosta';
    print(lastName);  // Acosta
 
    // Definición de constantes
    const pi = 3.1416;
    print(pi);  // 3.1416
 
    // Definición de números enteros
    int age = 35;
    print(age);  // 35
 
    // Definición de números decimales
    double height = 1.80;
    print(height);  // 1.80
 
    // Definición de booleanos
    bool isDev = true;
    print(isDev);  // true
}
Cuándo usar cada tipo
  • var: Cuando queremos que Dart infiera el tipo de la variable. Es útil cuando el tipo de la variable es obvio a partir del valor inicial.
  • String, int, double, bool: Cuando queremos especificar el tipo de la variable. Esto puede hacer que el código sea más claro y predecible.
  • const: Cuando tenemos un valor que no cambiará. Las constantes ayudan a hacer la aplicación más eficiente y también pueden hacer que la intención sea más clara. Hay que tener en cuenta que las constantes son inmutables y se establecen en tiempo de compilación. Otra opción es usar final que es similar a const pero se establece en tiempo de ejecución.

Funciones

En Dart podemos definir funciones de la siguiente manera:

dart
// Funciones sin retorno
void sum(int a, int b) {
  print('$a + $b = ${a + b}');
}
 
// Funciones con retorno
String getFullName(String name, String lastName) {
  String fullName = 'Nombre completo: $name $lastName';
  return fullName;
}
 
// Enviar objeto como parámetro
String contactData(
    {required String name, bool isDeveloper = false, required int age}) {
  String data =
      'Nombre $name. Edad: $age. Desarrollador: ${isDeveloper ? 'Si' : 'No'}';
  return data;
}
 
void main() {
  sum(4, 6); // 4 + 6 = 10
  final String fullName = getFullName('Javier', 'Acosta');
  print(fullName); // Nombre completo: Javier Acosta
  final String contact =
      contactData(name: 'Javier', isDeveloper: true, age: 35);
  print(contact); // Nombre Javier. Edad: 35. Desarrollador: Si
}

Lists y Sets

Los lists y los sets son formas de almacenar múltiples valores.

List

Los list son una colección ordenada de elementos que pueden tener duplicados. Vamos a ver un ejemplo simple de como crear una lista e interactuar con ella:

dart
void main() {
  // Definir una lista dinámica (puede contener varios tipos de datos)
  List<dynamic> dynamicList = [100, 'Javier', true, 10.75];
 
  // Definir una lista de tipo enteros
  List<int> numbers = [1, 2, 3, 4, 5];
 
  numbers.remove(4); // removemos la coincidencia con el número 4 -> [1, 2, 3, 5]
  numbers.removeAt(0); // removemos la primera posición -> [2, 3, 5]
  numbers.removeLast(); // removemos el último elemento de la lista -> [2, 3]
  numbers.add(6); // agregamos un elemento a la lista -> [2, 3, 6]
 
 
  numbers.indexOf(3); // obtenemos el índice del número 3
  print(numbers.contains(4)); // la lista contiene el número 4? -> false
  print(numbers.contains(2)); // la lista contiene el número 2? -> true
  numbers.shuffle(); // mezcla la lista aleatoriamente
 
  // Seleccionar un item de la lista
  int firstNumber = numbers[0];.
}
Set

Los sets son una colección de elementos únicos, es decir, no pueden tener duplicados. Vamos a ver un ejemplo simple de como crear un set e interactuar con él:

dart
void main() {
  // Definir un Set de string
  Set <String> frutas = {"bananas", "manzanas", "peras"};
 
  // Al igual que las listas se pueden agregar o remover elementos
  frutas.add("uvas");
  frutas.remove("manzanas");
 
  print(frutas); // {bananas, peras, uvas}
 
  // Definir un Set dynamic
  Set<dynamic> setValues = {"Javier", 35, true, 1.80, [1,2,3]};
 
  print(setValues); // {Javier, 35, true, 1.8, [1, 2, 3]}
  print(setValues.length); // 5
 
  dynamic toList = setValues.toList(); // podemos transformar un Set en un List y luego acceder a un valor de la lista
 
  print(toList); // [Javier, 35, true, 1.8, [1, 2, 3]]
  print(toList[4][1]); // 2
}

Control de flujos

Dart tiene varias estructuras de control de flujo, como if, for, while, etc. Veamos un ejemplo:

Condicional if else y ternario
dart
void main() {
    int number = 10;
 
    if(number > 10) {
        print('Mayor a 10');
    } else if(number == 10) {
        print('Es 10');
    } else {
        print('Menor a 10');
    }
 
    // Ternario
    bool isActive = false;
    isActive ? print('Está activo') : print('Está inactivo');
}
Condicional switch
dart
void main() {
  String favoriteColor = 'rojo';
 
  switch (favoriteColor) {
    case 'azul':
      print('Color favorito: azul');
    case 'verde':
      print('Color favorito: verde');
    case 'rojo':
      print('Color favorito: rojo');
    default:
      print('El color no está en la lista');
  }
}
Ciclo for
dart
void main() {
  for (int i = 0; i < 5; i++) {
    print('Índice actual $i');
  }
}
Ciclo forin
dart
  // for in
  List <int> averages = [100, 55, 23, 68, 33];
 
  for(int average in averages) {
    print(average);
  }
 
  // condicionales
  print('Promedios > ó = a 50:');
  for(int average in averages) {
    if(average >= 50) {
      print(average);
    }
  }
 
  // otra manera de usar la condicional en el for in
  print('Promedios < a 50:');
  for(int average in averages.where( (item) => item < 50)) {
      print(average);
  }
}
Ciclo foreach
dart
void main() {
  List<int> collection = [1, 2, 3];
  collection.forEach(print); // 1 2 3
 
  collection.forEach((int item) {
    print(item * 2);
  }); // 2 4 6
 
  collection.where((int item) => item == 3).forEach(print); // 3
}
Ciclo while y do while
dart
void main() {
  // While
  while (!isDone()) {
    doSomething();
  }
 
  // Do while
  do {
    doSomething();
  } while (!isDone());
}

Maps

Los mapas en Dart son una colección de pares clave-valor. Cada clave y cada valor en un mapa son objetos. Las claves son únicas, pero los valores no. Vamos a ver un ejemplo simple de como crear un mapa e interactuar con él:

dart
void main() {
  //Definimos un mapa de frutas el cual la key es un entero y el value es un string
  Map<int, String> frutas = {0: 'bananas', 1: 'manzanas', 3: 'peras'};
 
  print(frutas[0]); // bananas
 
  // Definimos un mapa de un usuario el cual la key es string y el value es dynamic
  // (ya que contiene valores enteros, strings y booleanos)
  Map<String, dynamic> user = {
    "id": 1,
    "name": "Javier",
    "email": "javier@email.com",
    "active": true,
  };
 
  print(user); // imprimir el Map user
  print('Nombre: ${user["name"]}'); // imprimir el valor del key name
  print('Email: ${user["email"]}'); // imprimir el valor del key email
 
  print(user.values); // Acceder a los valores del mapa
  print(user.keys); // Acceder a las keys del mapa
 
  print(user.values
      .toList()[1]); // Convertir a una lista y acceder al segundo valor
}

Clases

Las clases en Dart son una forma de modelar objetos. Los objetos son una instancia de una clase. Vamos a ver un ejemplo simple de como crear una clase e interactuar con ella:

dart
// 👇 Podemos definir una clase de la siguiente manera
class Product {
  String title = 'Producto 1';
  String description = 'Descripción producto 1';
  bool isActive = true;
  int stock = 50;
  double price = 9.99;
}
 
void main() {
 
  var product1 = Product();
  var product2 = Product();
 
  print(product1.title); // Producto 1
  print(product2.title); // Producto 1
 
}

Pero, ¿que pasa si queremos definir los valores de los productos de manera dinámica? Podemos hacerlo de la siguiente manera creando el constructor de la clase:

dart
class Product {
  String title;
  String description;
  bool isActive;
  int stock;
  double price;
 
  // 👇 Definimos el constructor de la clase
  Product(
    this.title,
    this.description,
    this.isActive,
    this.stock,
    this.price,
  );
}
 
void main() {
  var product1 = Product('producto 1', 'descripción 1', true, 20, 9.99);
  var product2 = Product('producto 2', 'descripción 2', false, 5, 15.99);
 
  print(product1.title); // producto 1
  print(product1.isActive); // true
  print(product2.title); // producto 2
  print(product2.isActive); //false
}

Ahora, podemos definir el constructor de la clase para recibir parámetros opcionales:

dart
class Product {
  String title;
  String? description; // 👈 lo establecemos como opcional
  bool isActive;
  int? stock; // 👈 lo definimos como opcional
  double price;
 
  // Definición del constructor
  Product({
    required this.title,
    this.description, // 👈 opcional
    required this.isActive,
    this.stock = 0, // 👈 opcional - valor inicial '0'
    required this.price,
  });
}
 
void main() {
  // En vez de que Dart infiera el tipo
  // 👇 definimos que es de tipo 'Product'
  Product product1 = Product(
    title:'producto 1',
    description:'descripción 1',
    isActive: true,
    stock: 20,
    price: 9.99
  );
 
  // 👇 Definimos que es de tipo 'Product'
  Product product2 = Product(
    title: 'producto 2',
    isActive: false,
    price: 15.99
  );
 
  print(product1.title); // producto 1
  print(product1.isActive); // true
  print(product2.title); // producto 2
  print(product2.stock); // 0
}

Veamos otro ejemplo definiendo una clase con métodos:

dart
class Product {
  String title;
  String? description;
  bool isActive;
  int? stock;
  double price;
 
  Product({
    required this.title,
    this.description,
    required this.isActive,
    this.stock = 0,
    required this.price,
  });
 
  // 👇 Definimos un Método de la clase
  String formatProduct() {
    return '$title ==> $price';
  }
}
 
void main() {
  Product product1 = Product(
      title: 'producto 1',
      description: 'descripción 1',
      isActive: true,
      stock: 20,
      price: 9.99);
 
  // 👇 método de la clase definido arriba
  print(product1.formatProduct()); // producto 1 ==> 9.99
}

Veamos un ejemplo de herencia en las clases de Dart:

dart
// Definimos la clase Employee
class Employee {
  int id;
  String name;
 
  Employee({
    required this.id,
    required this.name,
  });
}
 
// Definimos la clase Developer la cual extienda de la clase Employee
class Developer extends Employee {
  String area;
  double salary;
 
  Developer({
    required super.id,
    required super.name,
    required this.area,
    required this.salary,
  });
 
  String employeeData() {
    return 'ID: $id, NOMBRE: $name, PUESTO: $area, SUELDO: $salary';
  }
}
 
void main() {
  var employee = Developer(
    id: 1,
    name: 'Juan',
    area: 'FullStack Developer',
    salary: 8000,
  );
  print(employee.employeeData()); // 👈 ID: 1, NOMBRE: Juan, PUESTO: FullStack Developer, SUELDO: 8000
}

Método Overriding

Dart soporta la sobrecarga de métodos, lo que significa que una clase hija puede cambiar la implementación de un método de su clase padre o de una clase abstracta. Siguiendo el último ejemplo de empleados, veamos el método Overriding:

dart
class Employee {
  int id;
  String name;
 
  Employee({
    required this.id,
    required this.name,
  });
 
  // 👇 Creamos un método para obtener los datos del Empleado
  String getEmployee() {
    return '$id => $name';
  }
}
 
class Developer extends Employee {
  String area;
  double salary;
 
  Developer({
    required super.id,
    required super.name,
    required this.area,
    required this.salary,
  });
}
 
void main() {
  var employee = Developer(
    id: 1,
    name: 'Javier',
    area: 'FullStack Developer',
    salary: 8000,
  );
 
  // 👇 usamos el nuevo método creado
  print(employee.getEmployee()); // 1 => Javier
}

Ahora, vamos a sobreescribir el método getEmployee en la clase Developer:

dart
class Employee {
  int id;
  String name;
 
  Employee({
    required this.id,
    required this.name,
  });
 
  String getEmployee() {
    return '$id => $name';
  }
}
 
class Developer extends Employee {
  String area;
  double salary;
 
  Developer({
    required super.id,
    required super.name,
    required this.area,
    required this.salary,
  });
 
 
  // 👇 Sobreescribimos el método getEmployee()
  @override
  String getEmployee() {
    return 'Nombre => $name \nPuesto: $area \nSueldo: $salary';
  }
}
 
void main() {
  var employee = Developer(
    id: 1,
    name: 'Javier',
    area: 'FullStack Developer',
    salary: 8000,
  );
 
  print(employee.getEmployee());
  /* 👇 El resultado sería del método sobreescrito
   * Nombre => Javier
   * Puesto: FullStack Developer
   * Sueldo: 8000
   */
}

Vamos con otro ejemplo. Si hacemos un print() de la instancia employee, obtendremos el mensaje de instancia de la clase, Instance of 'Developer'. Podemos, entonces, sobreescribir el método toString() (que es el usado para mostrar ese mensaje) de la clase Employee para obtener un mensaje más descriptivo:

dart
class Employee {
  int id;
  String name;
 
  Employee({
    required this.id,
    required this.name,
  });
 
  String getEmployee() {
    return '$id => $name';
  }
 
  // 👇 se sobreescribe el método toString()
  // por el método getEmployee()
  @override
  String toString() {
    return getEmployee();
  }
}
 
class Developer extends Employee {
  String area;
  double salary;
 
  Developer({
    required super.id,
    required super.name,
    required this.area,
    required this.salary,
  });
 
 
  @override
  String getEmployee() {
    return 'Nombre => $name \nPuesto: $area \nSueldo: $salary';
  }
}
 
void main() {
  var employee = Developer(
    id: 1,
    name: 'Javier',
    area: 'FullStack Developer',
    salary: 8000,
  );
 
  print(employee);
  /* ☝ Imprimimos la instancia
   * Si la instancia viene de la clase Developer
   * y este tiene sobreescrito el método getEmployee()
   * se usará la sobrescritura del método,
   * RESULTADO:
      Nombre => Javier
      Puesto: FullStack Developer
      Sueldo: 8000
   * caso contrario, se imprimirá el método de la clase padre
   * RESULTADO:
      1 => Javier
   */
}

Genéricos

Dart soporta programación genérica para ayudar a escribir código reutilizable y flexible. Veamos un ejemplo simple en el cual creamos una clase Collection que es de tipo genérico el cuál tiene dos métodos, uno para agregar items a una lista y otro para imprimir lista. Luego instanciamos la clase Collection pasandole el tipo a inferir y agregamos alumnos y promedios con el método add(), e imprimimos la lista de cada uno con el método printItems():

dart
class Collection<T> {
  List<T> items = [];
 
  void add(T item) {
    items.add(item);
  }
 
  void printItems() {
    for (var item in items) {
      print(item);
    }
  }
}
 
void main() {
  Collection alumnos = Collection<String>();
  alumnos.add('Javier');
  alumnos.add('Juan');
  alumnos.add('Pedro');
 
  Collection promedios = Collection<double>();
  promedios.add(8.75);
  promedios.add(9.05);
  promedios.add(7.9);
 
  print('Alumnos:');
  alumnos.printItems();
  print('----');
  print('Promedios:');
  promedios.printItems();
}

Si bien este ejemplo es simple, nos muestra cómo podemos usar genéricos para crear código reutilizable y flexible. No solo podemos pasarle tipos de datos, sino también pasarle clases como tipo de dato, etc.

Async, Await y Futures

Los Futures son como las promesas en Javascript (te será familiar si alguna vez usaste ese lenguaje), pueden tener estados incompletos o completos y son una forma de trabajar con operaciones asincrónicas en Dart. Vamos a ver un ejemplo simple de cómo usar Futures con async y await:

dart
// Definimos la clase Post
class Post {
  String title;
  String author;
 
  Post(this.title, this.author);
 
  @override
  String toString() {
    return 'Autor: $author \nTítulo: $title';
  }
}
 
// Creamos el método fetchPost
Future<Post> fetchPost() {
  // usamos Duration que es para retrasar la "petición"
  const delay = Duration(seconds: 3);
 
  // imitamos una petición asíncrona retornando el post
  return Future.delayed(delay, () {
    return Post('Bases de Dart', 'Javier');
  });
}
 
void main() async {
  // realizamos la "petición"
  final post = await fetchPost();
 
  // luego de 3 segundos se mostrará el resultado
  print(post);
}

Fetching data

Para hacer una petición a una API, podemos usar el paquete http, lo podemos instalar usando el comando dart pub add http si estás corriendo en local, si usas Dartpad, que es mi caso, vamos a importar de la siguiente manera:

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

También vamos a usar {JSON} Placeholder para traer datos. Vamos a ver un ejemplo simple de cómo hacer una petición a una API y obtener los datos:

dart
// https://jsonplaceholder.typicode.com/posts/1 👉 traer datos de un post
/* Esta es la respuesta que tendremos
    {
        "userId": 1,
        "id": 1,
        "title": "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
        "body": "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto"
    }
*/
 
// Importamos el paquete http y convert
import 'package:http/http.dart' as http;
import 'dart:convert' as convert;
 
// Definimos la clase Post
class Post {
  String title;
  int userId;
  String body;
 
  Post(this.title, this.userId, this.body);
 
  @override
  String toString() {
    return 'UserId: \n$userId \n\nTítulo: \n$title \n\nContenido: \n$body';
  }
}
 
// Creamos el método fetchPost
Future<Post> fetchPost() async {
  var uri = Uri.https('jsonplaceholder.typicode.com', '/posts/1');
 
  final response = await http.get(uri);
 
  Map<String, dynamic> data = convert.jsonDecode(response.body);
 
  return Post(data["title"], data["userId"], data['body']);
}
 
void main() async {
  // realizamos la petición
  final post = await fetchPost();
 
  // mostramos el resultado
  print(post);
}

Conclusión 👨‍🏫

En este post hemos visto las bases del lenguaje Dart. Hemos visto cómo definir variables, funciones, listas, sets, maps, clases, genéricos, control de flujos, métodos async, await y Futures. Dart es un lenguaje moderno, orientado a objetos y fuertemente tipado que nos permite crear aplicaciones multiplataforma para dispositivos móviles, escritorio y web. Espero que este artículo hay sido de utilidad.

Gracias por leer. Nos vemos! 👋