Nulables vs No nulables

Parte de la sección Programación Orientada a Objetos del Journey de Dart de Coddy — lección 24 de 110.

Ahora que entiendes por qué la seguridad contra nulos (null safety) es importante, veamos cómo declarar variables que pueden contener null. En Dart, haces que un tipo sea nullable añadiendo un ? después del nombre del tipo.

String name = 'Alice';   // No admite nulos - siempre debe tener un valor
String? nickname;        // Admite nulos - puede ser null o un String

print(name);      // Alice
print(nickname);  // null

La diferencia clave es que los tipos que no admiten nulos (non-nullable) garantizan que existe un valor, mientras que los tipos que admiten nulos (nullable) permiten explícitamente la ausencia de un valor. Esta distinción se aplica a todos los tipos:

int count = 10;       // Debe tener un valor
int? optionalCount;   // Puede ser nulo

List<String> items = [];      // Debe ser una lista (puede estar vacía)
List<String>? maybeItems;     // Podría ser nulo (sin lista en absoluto)

Ten en cuenta que una lista vacía [] es diferente de null. Una lista vacía existe pero no contiene nada; null significa que no existe ninguna lista en absoluto.

El compilador aplica estas reglas estrictamente. No puedes asignar null a una variable no nulable, y no puedes usar una variable nulable donde se espera una no nulable sin comprobar primero si es nula:

String? maybeName = 'Bob';
// String definite = maybeName;  // ¡Error! No se puede asignar un tipo anulable a uno no anulable

En la próxima lección, aprenderás los operadores que Dart proporciona para trabajar de forma segura con valores nulos (nullable).

Desafío

Fácil

Vamos a construir un sistema de lista de películas que demuestre la diferencia entre la información obligatoria y la opcional utilizando tipos que admiten valores nulos (nullable) y tipos que no los admiten (non-nullable).

Crearás dos archivos para organizar tu código:

movie.dart: Define una clase Movie que represente una película en tu lista. Cada película debe tener un título y un año de estreno (estos siempre son obligatorios), pero algunos detalles adicionales podrían no estar disponibles para todas las películas. Tu clase debe tener:
- Un String title no nulo: cada película debe tener un título
- Un int year no nulo: cada película debe tener un año de estreno
- Un String? director nulo: el director podría ser desconocido
- Un double? rating nulo: no todas las películas han sido calificadas aún
- Un constructor que tome title y year como parámetros obligatorios
- Un método displayInfo() que imprima la información de la película, mostrando "Unknown" para el director faltante y "Not rated" para la calificación faltante
main.dart: Importa tu clase de película y crea una pequeña lista que demuestre tanto datos de películas completos como incompletos:
- Crea una película con el título 'Inception' y el año 2010, luego establece su director como 'Christopher Nolan' y su calificación como 8.8
- Crea una película con el título 'The Matrix' y el año 1999, luego establece solo su calificación como 8.7 (deja el director como nulo)
- Crea una película con el título 'Upcoming Film' y el año 2025 (deja tanto el director como la calificación como nulos)
- Llama a displayInfo() en cada película en el orden listado anteriormente

El método displayInfo() debe imprimir en este formato exacto:

[title] ([year])
Director: [director or "Unknown"]
Rating: [rating or "Not rated"]

Observa cómo los campos no nulos (title y year) siempre tienen garantizado un valor, mientras que los campos nulos (director? y rating?) pueden permanecer sin establecer. Esto refleja escenarios del mundo real donde algunos datos son esenciales y otros son opcionales.

Salida esperada:

Inception (2010)
Director: Christopher Nolan
Rating: 8.8
The Matrix (1999)
Director: Unknown
Rating: 8.7
Upcoming Film (2025)
Director: Unknown
Rating: Not rated

Hoja de referencia

Para hacer que un tipo admita valores nulos (nullable) en Dart, añade un ? después del nombre del tipo:

String name = 'Alice';   // Non-nullable - must always have a value
String? nickname;        // Nullable - can be null or a String

Esta distinción se aplica a todos los tipos:

int count = 10;       // Must have a value
int? optionalCount;   // Can be null

List<String> items = [];      // Must be a list (can be empty)
List<String>? maybeItems;     // Could be null (no list at all)

Una lista vacía [] es diferente de null. Una lista vacía existe pero no contiene nada; null significa que no existe ninguna lista en absoluto.

El compilador aplica las reglas de seguridad contra nulos (null safety) de forma estricta. No puedes asignar null a una variable no nula, y no puedes usar una variable que admite nulos donde se espera una que no los admite sin comprobar primero si es nula:

String? maybeName = 'Bob';
// String definite = maybeName;  // Error! Can't assign nullable to non-nullable

Pruébalo tú mismo

import 'movie.dart';

void main() {
  // TODO: Crear una película con el título 'Inception' y el año 2010
  // Luego establecer su director como 'Christopher Nolan' y su calificación en 8.8
  
  // TODO: Crear una película con el título 'The Matrix' y el año 1999
  // Luego establecer solo su calificación en 8.7 (dejar el director como null)
  
  // TODO: Crear una película con el título 'Upcoming Film' y el año 2025
  // Dejar tanto el director como la calificación como null
  
  // TODO: Llamar a displayInfo() en cada película en orden
}