Concepto de la Programación Orientada a Objetos (POO) y JavaScript

Definición de POO

La Programación Orientada a Objetos (POO) es un paradigma de programación que utiliza "objetos" para representar datos y comportamientos. A diferencia de la programación procedimental, que se basa en funciones y secuencias de instrucciones, la POO organiza el código en entidades que combinan estado (propiedades) y comportamiento (métodos).

Principios de la POO

Encapsulamiento: Consiste en ocultar el estado interno de un objeto y exponer solo lo necesario a través de métodos. Esto protege los datos y facilita el mantenimiento del código.
Abstracción: Permite representar conceptos complejos mediante modelos más simples, ocultando detalles innecesarios y mostrando solo las características relevantes.
Herencia: Es la capacidad de crear nuevas clases basadas en clases existentes, reutilizando código y estableciendo relaciones jerárquicas entre clases.
Polimorfismo: Permite que diferentes clases implementen métodos con el mismo nombre, pero con comportamientos distintos. Esto facilita la extensibilidad y flexibilidad del código.

POO en JavaScript

JavaScript es un lenguaje que admite la programación orientada a objetos a través de la creación de objetos y clases. Aunque JavaScript no tiene clases de forma tradicional como otros lenguajes (como Java o C++), se pueden implementar conceptos de POO utilizando funciones constructores, prototipos y la sintaxis de clases introducida en ECMAScript 2015 (ES6).

Ejemplo de POO en JavaScript

class Vehiculo {
    constructor(marca, modelo) {
        this.marca = marca;
        this.modelo = modelo;
    }

    mostrarInfo() {
        console.log(`Vehículo: ${this.marca} ${this.modelo}`);
    }
}

class Coche extends Vehiculo {
    constructor(marca, modelo, tipo) {
        super(marca, modelo); // Llama al constructor de la clase padre
        this.tipo = tipo;
    }

    mostrarInfo() {
        super.mostrarInfo(); // Llama al método de la clase padre
        console.log(`Tipo: ${this.tipo}`);
    }
}

const miCoche = new Coche("Toyota", "Corolla", "Sedán");
miCoche.mostrarInfo();
// Salida:
// Vehículo: Toyota Corolla
// Tipo: Sedán

Detalles del Ejemplo

Encapsulamiento: La clase Vehiculo encapsula las propiedades marca y modelo.
Herencia: La clase Coche hereda de la clase Vehiculo, reutilizando su constructor y métodos.
Polimorfismo: La clase Coche sobreescribe el método mostrarInfo de la clase padre, proporcionando su propia implementación.

Conclusión

La Programación Orientada a Objetos es un enfoque poderoso que permite estructurar y organizar el código de manera efectiva. JavaScript, aunque inicialmente no fue diseñado como un lenguaje orientado a objetos, ha evolucionado para soportar este paradigma, facilitando la creación de aplicaciones complejas y mantenibles. Entender la POO y cómo implementarla en JavaScript es esencial para cualquier desarrollador moderno.

VIDEO: Programación Orientada a Objetos

Tabla de Variables en TypeScript

Variable	Sintaxis TypeScript	Ejemplo TypeScript	Equivalente en JavaScript
let	let variable: tipo;	`let nombre: string = 'Juan';`	`let nombre = 'Juan';`
const	const variable: tipo = valor;	`const edad: number = 30;`	`const edad = 30;`
var	var variable: tipo;	`var esActivo: boolean = true;`	`var esActivo = true;`
Array	let variable: tipo[];	`let numeros: number[] = [1, 2, 3];`	`let numeros = [1, 2, 3];`
Tuple	let variable: [tipo1, tipo2];	`let persona: [string, number] = ['Juan', 30];`	`let persona = ['Juan', 30];`
Enum	enum NombreEnum { ... }	`enum Color { Rojo, Verde, Azul }`	`const Color = { Rojo: 0, Verde: 1, Azul: 2 };`
Any	let variable: any;	`let desconocido: any = 'Hola';`	`let desconocido = 'Hola';`
Unknown	let variable: unknown;	`let valorDesconocido: unknown = 4;`	`let valorDesconocido = 4;`
Void	function nombre(): void { ... }	`function saludar(): void { console.log('Hola'); }`	`function saludar() { console.log('Hola'); }`
Never	function nombre(): never { ... }	`function error(mensaje: string): never { throw new Error(mensaje); }`	`function error(mensaje) { throw new Error(mensaje); }`
Object	let variable: object;	`let persona: { nombre: string, edad: number } = { nombre: 'Juan', edad: 30 };`	`let persona = { nombre: 'Juan', edad: 30 };`
Interface	interface Nombre { ... }	`interface Persona { nombre: string; edad: number; }`	`const persona = { nombre: 'Juan', edad: 30 }; // No exacto, pero similar`
Type	type Nombre = { ... };	`type Persona = { nombre: string; edad: number; };`	`const persona = { nombre: 'Juan', edad: 30 }; // No exacto, pero similar`

INICIO

Definiciones y Ejemplos

let

Uso: Se utiliza para declarar variables que pueden ser reasignadas. Su ámbito es el bloque en el que se declara.

Sintaxis TypeScript: let variable: tipo;

Ejemplo TypeScript:

let nombre: string = 'Juan';

Equivalente en JavaScript:

let nombre = 'Juan';

const

Uso: Se utiliza para declarar constantes, cuyo valor no puede ser reasignado. Su ámbito es el bloque en el que se declara.

Sintaxis TypeScript: const variable: tipo = valor;

Ejemplo TypeScript:

const edad: number = 30;

Equivalente en JavaScript:

const edad = 30;

var

Uso: Se utiliza para declarar variables que pueden ser reasignadas. Su ámbito es la función en la que se declara o global si está fuera de una función.

Sintaxis TypeScript: var variable: tipo;

Ejemplo TypeScript:

var esActivo: boolean = true;

Equivalente en JavaScript:

var esActivo = true;

Array

Uso: Se utiliza para declarar matrices de elementos del mismo tipo.

Sintaxis TypeScript: let variable: tipo[];

Ejemplo TypeScript:

let numeros: number[] = [1, 2, 3];

Equivalente en JavaScript:

let numeros = [1, 2, 3];

Tuple

Uso: Se utiliza para declarar matrices de elementos de diferentes tipos con una longitud fija.

Sintaxis TypeScript: let variable: [tipo1, tipo2];

Ejemplo TypeScript:

let persona: [string, number] = ['Juan', 30];

Equivalente en JavaScript:

let persona = ['Juan', 30];

Enum

Uso: Se utiliza para definir un conjunto de valores con nombre.

Sintaxis TypeScript: enum NombreEnum { ... }

Ejemplo TypeScript:

enum Color { Rojo, Verde, Azul }

Equivalente en JavaScript:

const Color = { Rojo: 0, Verde: 1, Azul: 2 };

Any

Uso: Se utiliza para declarar una variable que puede contener cualquier tipo de valor.

Sintaxis TypeScript: let variable: any;

Ejemplo TypeScript:

let desconocido: any = 'Hola';

Equivalente en JavaScript:

let desconocido = 'Hola';

Unknown

Uso: Se utiliza para declarar una variable cuyo tipo es desconocido en el momento de la declaración, pero que puede ser determinado más adelante.

Sintaxis TypeScript: let variable: unknown;

Ejemplo TypeScript:

let valorDesconocido: unknown = 4;

Equivalente en JavaScript:

let valorDesconocido = 4;

Void

Uso: Se utiliza en funciones que no devuelven ningún valor.

Sintaxis TypeScript: function nombre(): void { ... }

Ejemplo TypeScript:

function saludar(): void { console.log('Hola'); }

Equivalente en JavaScript:

function saludar() { console.log('Hola'); }

Never

Uso: Se utiliza en funciones que nunca retornan un valor, generalmente se usa en funciones que lanzan excepciones o tienen bucles infinitos.

Sintaxis TypeScript: function nombre(): never { ... }

Ejemplo TypeScript:

function error(mensaje: string): never { throw new Error(mensaje); }

Equivalente en JavaScript:

function error(mensaje) { throw new Error(mensaje); }

Object

Uso: Se utiliza para declarar variables que contienen objetos.

Sintaxis TypeScript: let variable: object;

Ejemplo TypeScript:

let persona: { nombre: string, edad: number } = { nombre: 'Juan', edad: 30 };

Equivalente en JavaScript:

let persona = { nombre: 'Juan', edad: 30 };

Interface

Uso: Se utiliza para definir la forma de un objeto, es decir, las propiedades y tipos que debe tener.

Sintaxis TypeScript: interface Nombre { ... }

Ejemplo TypeScript:

interface Persona { nombre: string; edad: number; }

Equivalente en JavaScript:

const persona = { nombre: 'Juan', edad: 30 }; // No exacto, pero similar

Type

Uso: Se utiliza para definir tipos personalizados.

Sintaxis TypeScript: type Nombre = { ... };

Ejemplo TypeScript:

type Persona = { nombre: string; edad: number; };

Equivalente en JavaScript:

const persona = { nombre: 'Juan', edad: 30 }; // No exacto, pero similar

INICIO

Uso de Constantes en Funciones

Las constantes (const) en JavaScript y TypeScript se usan para declarar variables cuyo valor no puede ser reasignado. Esto significa que una vez que una constante es asignada, no se puede cambiar su valor a otro completamente nuevo. Sin embargo, es importante entender que const no hace que el valor sea completamente inmutable. Si la constante es un objeto o un array, las propiedades del objeto o los elementos del array pueden cambiar. Lo que no puede cambiar es la referencia de la variable.

Razones para Usar Constantes en Funciones

Garantizar Inmutabilidad de la Referencia: Utilizar const asegura que la referencia de la variable no cambiará, lo que ayuda a prevenir errores en el código al asegurar que la variable siempre apuntará al mismo objeto o valor inicial.
Mejor Lectura y Mantenimiento del Código: Usar const indica claramente a otros desarrolladores que la intención es que la variable no debe ser reasignada, lo que hace el código más fácil de leer y mantener.
Seguridad: Al usar const, se evita accidentalmente reasignar un valor a una variable que no debería cambiar, reduciendo así la posibilidad de errores en el código.

Ejemplo de Uso de Constantes en Funciones

function calcularAreaCirculo(radio) {
  // Uso de const para una variable que no debe cambiar
  const pi = 3.14159;
  
  // Esta operación es válida porque no cambia la referencia de pi
  return pi * radio * radio;
}

console.log(calcularAreaCirculo(5)); // Salida: 78.53975

En este caso, pi es una constante porque su valor de 3.14159 no debe cambiar dentro de la función. Usar const asegura que pi siempre tendrá el mismo valor, lo que previene errores y hace que la función sea más predecible.

INICIO