Variables y Tipos

## Objetivos de Aprendizaje - Declarar variables con let, const y var - Comprender los tipos basicos de TypeScript - Dominar la inferencia de tipos - Aprender anotaciones de tipo - Trabajar con arrays y tuplas ## Declaraciones de Variables ### let Variable de ambito de bloque, mutable: ```typescript let age: number = 25; age = 26; // OK ``` ### const Enlace de ambito de bloque, inmutable: ```typescript const PI: number = 3.14159; // PI = 3.14; // Error: No se puede asignar a 'PI' ``` ### var (Evitar) Ambito de funcion, hoisted (evitar en TypeScript): ```typescript var name: string = "Juan"; // Preferir let y const ``` ## Tipos Basicos ### number Todos los numeros, enteros y decimales: ```typescript let integer: number = 42; let decimal: number = 3.14; let hex: number = 0xFF; let binary: number = 0b1010; let octal: number = 0o744; ``` ### string Valores de texto: ```typescript let firstName: string = "Juan"; let lastName: string = 'Perez'; let fullName: string = `${firstName} ${lastName}`; // Literales de plantilla let greeting: string = `Hola, ${firstName}!`; ``` ### boolean True o false: ```typescript let isActive: boolean = true; let isComplete: boolean = false; ``` ### null y undefined ```typescript let nullValue: null = null; let undefinedValue: undefined = undefined; ``` ## Inferencia de Tipos TypeScript puede inferir tipos desde valores iniciales: ```typescript // El tipo se infiere como 'string' let message = "Hola"; message = 123; // Error: El tipo 'number' no es asignable al tipo 'string' // El tipo se infiere como 'number' let count = 10; count = "diez"; // Error ``` ### Cuando Funciona la Inferencia ```typescript let x = 10; // number let y = "hola"; // string let z = true; // boolean ``` ## Anotaciones de Tipo Declaraciones de tipo explicitas: ```typescript let age: number; let name: string; let active: boolean; // Con inicializacion let score: number = 100; let title: string = "Desarrollador"; ``` ## Arrays ### Anotacion de Tipo ```typescript let numbers: number[] = [1, 2, 3, 4, 5]; let names: string[] = ["Alice", "Bob", "Charlie"]; let flags: boolean[] = [true, false, true]; ``` ### Sintaxis Generica de Array ```typescript let numbers: Array = [1, 2, 3]; let names: Array = ["Alice", "Bob"]; ``` ### Acceder a Elementos ```typescript let first: number = numbers[0]; let last: string = names[names.length - 1]; ``` ## Tuplas Arrays de longitud fija con tipos conocidos: ```typescript let person: [string, number]; person = ["Alice", 30]; // person = [30, "Alice"]; // Error: El tipo 'number' no es asignable al tipo 'string' let name: string = person[0]; let age: number = person[1]; ``` ### Elementos Opcionales ```typescript let config: [string, number?]; config = ["desarrollo"]; config = ["desarrollo", 8080]; ``` ## Tipo Any Evitar comprobacion de tipos (evitar cuando sea posible): ```typescript let dynamic: any = 123; dynamic = "hola"; dynamic = true; dynamic = [1, 2, 3]; // Sin comprobacion de tipos en any dynamic.toUpperCase(); // Funciona en tiempo de compilacion ``` ## Tipo Unknown Alternativa segura a any: ```typescript let unknownValue: unknown = 123; // Debe reducir o verificar antes de usar if (typeof unknownValue === "string") { console.log(unknownValue.toUpperCase()); } // O usar asercion de tipo let str: string = unknownValue as string; ``` ## Tipo Void Sin valor de retorno: ```typescript function logMessage(message: string): void { console.log(message); // Sin return } let result: void = undefined; ``` ## Tipo Never Funcion que nunca retorna: ```typescript function throwError(message: string): never { throw new Error(message); } function infiniteLoop(): never { while (true) { // Nunca retorna } } ``` ## Aserciones de Tipo Decirle a TypeScript el tipo: ```typescript let value: unknown = "hola"; // Sintaxis de corchetes angulares let len1: number = (value).length; // Sintaxis as let len2: number = (value as string).length; ``` ## Tipos de Objetos ```typescript let point: { x: number; y: number } = { x: 10, y: 20 }; function distance(p1: { x: number; y: number }): number { return Math.sqrt(p1.x ** 2 + p1.y ** 2); } ``` ## Tipos Union Multiples tipos posibles: ```typescript let id: string | number; id = 123; id = "ABC123"; function printId(id: string | number): void { console.log(`ID: ${id}`); } ``` ## Alias de Tipo Nombre para un tipo: ```typescript type StringOrNumber = string | number; type Point = { x: number; y: number }; let value: StringOrNumber = "hola"; let coord: Point = { x: 0, y: 0 }; ``` ## Propiedades readonly No pueden ser modificadas despues de la creacion: ```typescript interface Config { readonly host: string; readonly port: number; } let config: Config = { host: "localhost", port: 8080 }; // config.port = 3000; // Error: No se puede asignar a 'port' ``` ## Resumen - Usar `const` por defecto, `let` cuando sea necesario, evitar `var` - Tipos basicos: `number`, `string`, `boolean`, `null`, `undefined` - TypeScript infiere tipos desde valores iniciales - Arrays: `number[]` o `Array` - Tuplas: `[string, number]` para arrays de longitud fija - Evitar `any`, preferir `unknown` - Usar alias de tipo para tipos complejos - `readonly` para propiedades inmutables