El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Tipos Básicos

Siguiente ►
►

En TypeScript, los tipos básicos son fundamentales para entender cómo funciona el sistema de tipos. A continuación, exploraremos los tipos más comunes y cómo se utilizan.

  1. Tipos Primitivos

1.1. Número (number)

En TypeScript, el tipo number se utiliza para representar tanto números enteros como de punto flotante.

let age: number = 25;
let pi: number = 3.14;

1.2. Cadena de Texto (string)

El tipo string se utiliza para representar texto.

let firstName: string = "John";
let greeting: string = `Hello, ${firstName}`;

1.3. Booleano (boolean)

El tipo boolean se utiliza para representar valores de verdad: true o false.

let isStudent: boolean = true;
let hasGraduated: boolean = false;

1.4. Nulo e Indefinido (null y undefined)

null y undefined son tipos que representan la ausencia de valor.

let emptyValue: null = null;
let notAssigned: undefined = undefined;

  1. Tipos Especiales

2.1. Arreglos (Array)

Los arreglos en TypeScript pueden contener elementos de un tipo específico.

let numbers: number[] = [1, 2, 3, 4, 5];
let names: string[] = ["Alice", "Bob", "Charlie"];

También se puede usar la sintaxis genérica:

let numbers: Array<number> = [1, 2, 3, 4, 5];

2.2. Tuplas (Tuple)

Las tuplas permiten definir un arreglo con un número fijo de elementos de tipos específicos.

let person: [string, number] = ["Alice", 30];

2.3. Enumeraciones (enum)

Las enumeraciones permiten definir un conjunto de valores con nombre.

enum Color {
    Red,
    Green,
    Blue
}

let favoriteColor: Color = Color.Green;

2.4. Any (any)

El tipo any permite que una variable contenga cualquier tipo de valor. Es útil cuando se migra código JavaScript a TypeScript.

let randomValue: any = 10;
randomValue = "Hello";
randomValue = true;

2.5. Void (void)

El tipo void se utiliza en funciones que no retornan un valor.

function logMessage(message: string): void {
    console.log(message);
}

2.6. Never (never)

El tipo never representa el tipo de valores que nunca ocurren. Es útil para funciones que siempre lanzan una excepción o que nunca retornan.

function throwError(errorMsg: string): never {
    throw new Error(errorMsg);
}

  1. Ejercicios Prácticos

Ejercicio 1: Declaración de Variables

Declara variables de diferentes tipos y asígnales valores.

let myNumber: number = 42;
let myString: string = "TypeScript";
let myBoolean: boolean = true;
let myArray: number[] = [1, 2, 3];
let myTuple: [string, number] = ["Alice", 30];
let myEnum: Color = Color.Blue;
let myAny: any = "Hello";
let myVoid: void = undefined;
let myNull: null = null;
let myUndefined: undefined = undefined;

Ejercicio 2: Función con Tipos

Escribe una función que tome un número y una cadena como parámetros y retorne una cadena.

function combineValues(num: number, str: string): string {
    return `${str} has the number ${num}`;
}

console.log(combineValues(5, "Alice")); // "Alice has the number 5"

Ejercicio 3: Uso de Enumeraciones

Crea una enumeración para los días de la semana y una función que retorne el nombre del día basado en un valor numérico.

enum Day {
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday
}

function getDayName(day: Day): string {
    return Day[day];
}

console.log(getDayName(Day.Monday)); // "Monday"

Conclusión

En esta sección, hemos cubierto los tipos básicos en TypeScript, incluyendo tipos primitivos, arreglos, tuplas, enumeraciones y tipos especiales como any, void y never. Estos conceptos son fundamentales para trabajar con TypeScript y proporcionan una base sólida para avanzar a temas más complejos.

En el siguiente módulo, exploraremos cómo trabajar con tipos más avanzados y cómo utilizar interfaces y clases para estructurar mejor nuestro código.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados