Objetos TypeScript simplificados para principiantes

Los objetos son una parte fundamental de JavaScript y TypeScript. Permiten agrupar datos y funciones relacionados, lo que proporciona una forma de modelar entidades del mundo real en el código. TypeScript mejora los objetos de JavaScript con seguridad de tipos, lo que hace que el código sea más predecible y más fácil de mantener. Esta guía simplificará el concepto de objetos de TypeScript para principiantes.

¿Qué es un objeto en TypeScript?

Un object es una colección de pares clave-valor, donde las claves son cadenas (o símbolos) y los valores pueden ser de cualquier tipo. En TypeScript, puedes definir la forma de un objeto mediante tipos o interfaces, lo que garantiza que el objeto siga una estructura específica.

Definición de objetos simples en TypeScript

Comencemos definiendo un objeto simple en TypeScript. Esto es similar a cómo se definen los objetos en JavaScript, pero con el beneficio adicional de la seguridad de tipos.

Ejemplo de objeto básico

A continuación se explica cómo definir un objeto simple en TypeScript:

const person: { name: string; age: number } = {
  name: "Alice",
  age: 25
};

console.log(person.name); // Output: Alice
console.log(person.age);  // Output: 25

En este ejemplo, el objeto person tiene dos propiedades: name (de tipo string) y age (de tipo number). TypeScript se asegurará de que el objeto respete esta estructura.

Uso de interfaces para definir la estructura de un objeto

Una interfaz es una característica poderosa de TypeScript que define la forma de un objeto. Las interfaces brindan una manera de definir contratos dentro de su código, lo que garantiza que los objetos se adhieran a una estructura específica.

Definición de una interfaz

A continuación se explica cómo utilizar una interfaz para definir la estructura de un objeto:

interface Person {
  name: string;
  age: number;
}

const person: Person = {
  name: "Bob",
  age: 30
};

console.log(person.name); // Output: Bob
console.log(person.age);  // Output: 30

En este ejemplo, la interfaz Person define la estructura de un objeto de persona. La variable person debe respetar esta estructura o TypeScript generará un error.

Propiedades opcionales en objetos

TypeScript permite definir propiedades opcionales en objetos mediante el símbolo ?. Las propiedades opcionales se pueden omitir al crear objetos, lo que brinda flexibilidad en la forma de definir las estructuras de los objetos.

Ejemplo con propiedades opcionales

A continuación se muestra un ejemplo donde la propiedad phoneNumber es opcional:

interface Employee {
  name: string;
  age: number;
  phoneNumber?: string; // Optional property
}

const employee1: Employee = {
  name: "John",
  age: 28
};

const employee2: Employee = {
  name: "Doe",
  age: 32,
  phoneNumber: "123-456-7890"
};

console.log(employee1.phoneNumber); // Output: undefined
console.log(employee2.phoneNumber); // Output: 123-456-7890

En este ejemplo, employee1 no tiene una propiedad phoneNumber, mientras que employee2 sí la tiene. Ambas son válidas según la interfaz Employee.

Propiedades de solo lectura en objetos

TypeScript permite que las propiedades sean readonly, lo que evita que se modifiquen después de crear el objeto. Esto resulta útil para crear objetos inmutables.

Ejemplo con propiedades de solo lectura

A continuación se explica cómo definir propiedades de solo lectura:

interface Car {
  readonly brand: string;
  model: string;
}

const car: Car = {
  brand: "Toyota",
  model: "Camry"
};

// car.brand = "Honda"; // Error: Cannot assign to 'brand' because it is a read-only property

car.model = "Corolla"; // Valid
console.log(car.model); // Output: Corolla

En este ejemplo, la propiedad brand está marcada como readonly. Cualquier intento de modificarla generará un error en tiempo de compilación.

Objetos anidados en TypeScript

Los objetos TypeScript se pueden anidar, lo que significa que un objeto puede contener otro objeto como propiedad. Esto es común en estructuras de datos complejas.

Ejemplo de objetos anidados

He aquí un ejemplo de un objeto anidado:

interface Address {
  street: string;
  city: string;
  zipCode: string;
}

interface User {
  name: string;
  age: number;
  address: Address; // Nested object
}

const user: User = {
  name: "Emily",
  age: 27,
  address: {
    street: "123 Main St",
    city: "New York",
    zipCode: "10001"
  }
};

console.log(user.address.city); // Output: New York

En este ejemplo, la interfaz User tiene un objeto Address anidado. El objeto user sigue esta estructura, lo que permite el acceso a propiedades anidadas.

Conclusión

Los objetos en TypeScript son más potentes y flexibles que los objetos JavaScript simples debido a las definiciones de tipos, las propiedades opcionales, las propiedades de solo lectura y las estructuras anidadas. Al definir objetos mediante interfaces, puede crear código más sólido y sin errores. Comience a usar objetos TypeScript en sus proyectos para aprovechar todo el poder de la seguridad de tipos y los datos estructurados.