Ejercicios Resueltos en TypeScript

Ej-1: Uso de Variables y Condicionales

Escribir un programa que determine si un número es par o impar.

// TypeScript
function esParOImpar(numero: number): string {
  if (numero % 2 === 0) {
    return `${numero} es par.`;
  } else {
    return `${numero} es impar.`;
  }
}

let numero: number = 4;
console.log(esParOImpar(numero)); // 4 es par.

4 es par.

INICIO

Ej-2: Uso de Arrays y Bucles

Escribir un programa que imprima los elementos de un array de números.

// TypeScript
let numeros: number[] = [1, 2, 3, 4, 5];

for (let i = 0; i < numeros.length; i++) {
  console.log(numeros[i]);
}

1
2
3
4
5

INICIO

Ej-3: Uso de Enumeraciones

Escribir un programa que defina una enumeración para los días de la semana y devuelva el nombre del día dado su número.

// TypeScript
enum Dia {
  Lunes,
  Martes,
  Miercoles,
  Jueves,
  Viernes,
  Sabado,
  Domingo
}

function obtenerNombreDia(dia: Dia): string {
  return Dia[dia];
}

let dia: Dia = Dia.Miercoles;
console.log(obtenerNombreDia(dia)); // Miercoles

Miercoles

INICIO

Ej-4: Uso de Funciones

Escribir un programa que calcule el factorial de un número utilizando una función.

// TypeScript
function factorial(n: number): number {
  if (n === 0 || n === 1) {
    return 1;
  } else {
    return n * factorial(n - 1);
  }
}

let numero: number = 5;
console.log(`El factorial de ${numero} es ${factorial(numero)}`); // El factorial de 5 es 120

El factorial de 5 es 120

INICIO

Ej-5: Uso de Clases e Interfaces

Escribir un programa que defina una clase que implemente una interfaz para representar una persona y saludar.

// TypeScript
interface IPersona {
  nombre: string;
  edad: number;
  saludar(): string;
}

class Persona implements IPersona {
  constructor(public nombre: string, public edad: number) {}

  saludar(): string {
    return `Hola, mi nombre es ${this.nombre} y tengo ${this.edad} años.`;
  }
}

let persona: Persona = new Persona('Ana', 25);
console.log(persona.saludar()); // Hola, mi nombre es Ana y tengo 25 años.

Hola, mi nombre es Ana y tengo 25 años.

INICIO

Ej-6: Suma de los Elementos de un Array

Escribir un programa que sume todos los elementos de un array de números.

// TypeScript
function sumaArray(numeros: number[]): number {
  let suma: number = 0;
  for (let numero of numeros) {
    suma += numero;
  }
  return suma;
}

let numeros: number[] = [1, 2, 3, 4, 5];
console.log(`La suma es: ${sumaArray(numeros)}`); // La suma es: 15

La suma es: 15

INICIO

Ej-7: Uso de Tuplas

Escribir un programa que defina una tupla para almacenar un nombre y una edad, y luego imprima estos valores.

// TypeScript
let persona: [string, number] = ['Juan', 30];
console.log(`Nombre: ${persona[0]}, Edad: ${persona[1]}`); // Nombre: Juan, Edad: 30

Nombre: Juan, Edad: 30

INICIO

Ej-8: Uso de Genéricos

Escribir una función genérica que invierta un array.

// TypeScript
function invertirArray(array: T[]): T[] {
  return array.reverse();
}

let numeros: number[] = [1, 2, 3, 4, 5];
console.log(invertirArray(numeros)); // [5, 4, 3, 2, 1]

[5, 4, 3, 2, 1]

INICIO

Ej-9: Uso de Mapas

Escribir un programa que utilice un mapa para almacenar nombres y edades, y luego imprima estos valores.

// TypeScript
let mapa: Map = new Map([
  ['Juan', 30],
  ['Ana', 25],
  ['Luis', 40]
]);

mapa.forEach((valor, clave) => {
  console.log(`Nombre: ${clave}, Edad: ${valor}`);
});

Nombre: Juan, Edad: 30
Nombre: Ana, Edad: 25
Nombre: Luis, Edad: 40

INICIO

Ej-10: Uso de Promesas

Escribir un programa que utilice una promesa para simular una operación asincrónica y luego imprima el resultado.

// TypeScript
function operacionAsincronica(): Promise {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve('Operación completada');
    }, 2000);
  });
}

operacionAsincronica().then(resultado => {
  console.log(resultado); // Operación completada
});

Operación completada

INICIO

Ej-11: Uso de Clases y Métodos Estáticos

Escribir una clase que contenga un método estático para sumar dos números.

// TypeScript
class Calculadora {
  static sumar(a: number, b: number): number {
    return a + b;
  }
}

console.log(Calculadora.sumar(10, 5)); // 15

INICIO

Ej-12: Uso de Módulos

Escribir un programa que utilice un módulo para organizar el código.

// mathUtils.ts
export function sumar(a: number, b: number): number {
  return a + b;
}

// main.ts
import { sumar } from './mathUtils';

console.log(sumar(10, 5)); // 15

INICIO

Ej-13: Uso de Clases con Herencia

Escribir una clase base Animal y una clase derivada Perro que herede de Animal.

// TypeScript
class Animal {
  constructor(public nombre: string) {}

  hacerSonido(): void {
    console.log('Sonido genérico');
  }
}

class Perro extends Animal {
  hacerSonido(): void {
    console.log('Guau!');
  }
}

let miPerro: Perro = new Perro('Firulais');
miPerro.hacerSonido(); // Guau!

Guau!

INICIO

Ej-14: Uso de Interfaces y Herencia

Escribir una interfaz base IAnimal y una interfaz derivada IPerro que herede de IAnimal.

// TypeScript
interface IAnimal {
  nombre: string;
  hacerSonido(): void;
}

interface IPerro extends IAnimal {
  raza: string;
}

class Perro implements IPerro {
  constructor(public nombre: string, public raza: string) {}

  hacerSonido(): void {
    console.log('Guau!');
  }
}

let miPerro: Perro = new Perro('Firulais', 'Labrador');
miPerro.hacerSonido(); // Guau!
console.log(`Nombre: ${miPerro.nombre}, Raza: ${miPerro.raza}`); // Nombre: Firulais, Raza: Labrador

Guau!
Nombre: Firulais, Raza: Labrador

INICIO

Ej-15: Uso de Uniones de Tipos

Escribir un programa que utilice una unión de tipos para definir una variable que pueda ser un número o una cadena.

// TypeScript
let valor: number | string;

valor = 42;
console.log(`Valor: ${valor}`); // Valor: 42

valor = 'Hola';
console.log(`Valor: ${valor}`); // Valor: Hola

Valor: 42
Valor: Hola

INICIO