Lenguajes de Programación

Python

Una sola línea basta para imprimir un mensaje. El código se lee casi como inglés.

print("Hola, mundo!")

1 línea de código

C++

Necesitamos incluir librerías, definir una función main y manejar la salida explícitamente.

#include <iostream>

int main() {

    std::cout << "Hola, mundo!" << std::endl;

    return 0;

}

6 líneas de código

Assembly x86

Debemos manejar registros, syscalls y direcciones de memoria directamente.

section .data

    msg db "Hola, mundo!", 0xa

    len equ $ - msg

section .text

    global _start

_start:

    mov rax, 1

    mov rdi, 1

    mov rsi, msg

    mov rdx, len

    syscall

    mov rax, 60

    xor rdi, rdi

    syscall

14 líneas — el mismo resultado requiere más código a menor nivel de abstracción

Compilados, Transpilados e Interpretados

Tres formas distintas de pasar de código fuente a ejecución. TypeScript, por ejemplo, no es un lenguaje compilado: es un lenguaje transpilado a JavaScript.

TypeScript — Transpilado

tsc hola.ts    # transpila

node hola.js   # ejecuta

JavaScript — Interpretado

node hola.js   # ejecuta directamente

La realidad es más compleja

Estático vs Dinámico

let edad: number = 25;

edad = "veinticinco"; // ERROR al transpilar

let edad = 25;

edad = "veinticinco";  // Válido

let r = edad + 1; // ERROR en ejecución

Fuerte vs Débil

resultado = "5" + 3  # TypeError!

let resultado = "5" + 3;

// "53" (concatenó!)

let otro = "5" - 3;

// 2 (restó!)

Tabla resumen de tipado

Variables

Una variable es un contenedor con nombre que almacena un valor en memoria. Piensa en ella como una caja etiquetada.

// Declaración con tipo explícito

let nombre: string = "Ana";

let edad: number = 22;

let activo: boolean = true;

// const = no se puede reasignar

const PI: number = 3.1416;

Operadores

Símbolos que realizan operaciones sobre valores y variables.

5 + 3   // 8

10 - 4  // 6

3 * 7   // 21

20 / 4  // 5

10 % 3  // 1 (residuo)

===  // igual estricto

!==  // diferente

>    // mayor que

<    // menor que

>=   // mayor o igual

&&  // AND (y)

||  // OR (o)

!   // NOT (negación)

Arreglos (Arrays)

Una lista ordenada de elementos accesibles por su posición (índice, empezando en 0).

const frutas: string[] = ["manzana", "banana", "naranja"];

console.log(frutas[0]);    // "manzana"

console.log(frutas.length); // 3

// Métodos comunes

frutas.push("uva");        // agregar al final

frutas.pop();              // quitar del final

// Recorrer con for...of

for (const fruta of frutas) {

  console.log(fruta);

}

Condicionales

Permiten que el programa tome decisiones ejecutando código diferente según una condición.

const nota = 85;

if (nota >= 90) {

  console.log("Excelente");

} else if (nota >= 70) {

  console.log("Aprobado");

} else {

  console.log("Reprobado");

}

// condición ? sí : no

const mensaje = nota >= 70

  ? "Aprobado"

  : "Reprobado";

Bucles

Repiten un bloque de código múltiples veces, evitando escribir lo mismo una y otra vez.

for (let i = 0; i < 5; i++) {

  console.log(i);

}

let n = 1;

while (n <= 10) {

  console.log(n);

  n++;

}

const nums = [10, 20, 30];

for (const n of nums) {

  console.log(n);

}

Funciones

Bloques de código reutilizables que realizan una tarea específica. Reciben datos (parámetros) y pueden devolver un resultado.

function saludar(nombre: string): string {

  return `Hola, ${nombre}`;

}

console.log(saludar("Ana"));

// "Hola, Ana"

const sumar = (a: number, b: number)

  : number => {

  return a + b;

};

// Forma corta (una línea)

const doble = (n: number) => n * 2;

Clases

Una clase es un plano o molde para crear objetos. Define qué propiedades y métodos tendrá cada objeto creado a partir de ella.

class Persona {

  nombre: string;

  edad: number;

  constructor(nombre: string, edad: number) {

    this.nombre = nombre;

    this.edad = edad;

  }

  presentarse(): string {

    return `Soy ${this.nombre}, tengo ${this.edad} años`;

  }

}

const ana = new Persona("Ana", 22);

console.log(ana.presentarse());

Herencia

Clases — Parte 2

Una clase puede heredar propiedades y métodos de otra clase padre, evitando duplicar código.

class Animal {

  nombre: string;

  constructor(nombre: string) {

    this.nombre = nombre;

  }

  hablar(): string {

    return "...";

  }

}

// Perro hereda de Animal

class Perro extends Animal {

  hablar(): string {

    return `${this.nombre} dice: Guau!`;

  }

}

const rex = new Perro("Rex");

console.log(rex.hablar());

// "Rex dice: Guau!"

Polimorfismo

Clases — Parte 3

Distintas clases pueden responder al mismo mensaje de forma diferente. El mismo método, múltiples comportamientos.

class Gato extends Animal {

  hablar(): string {

    return `${this.nombre} dice: Miau!`;

  }

}

// Mismo tipo, diferente comportamiento

const animales: Animal[] = [

  new Perro("Rex"),

  new Gato("Michi"),

];

for (const a of animales) {

  console.log(a.hablar());

}

// "Rex dice: Guau!"

// "Michi dice: Miau!"

Tu primer programa

Crea un archivo hola.ts:

console.log("Hola, mundo!");

Transpila y ejecuta:

tsc hola.ts

node hola.js

Hola, mundo!

O usa npx ts-node hola.ts para transpilar y ejecutar en un solo paso.

Variables y tipos

const nombre: string = "Juan";

let edad: number = 25;

const altura: number = 1.75;

const esEstudiante: boolean = true;

console.log(`Nombre: ${nombre}`)

console.log(`Edad: ${edad}`)

Entrada del usuario

import * as readline from "readline";

const rl = readline.createInterface({

  input: process.stdin,

  output: process.stdout,

});

rl.question("¿Cómo te llamas? ", (nombre) => {

  rl.question("¿Cuántos años tienes? ", (input) => {

    const edad: number = parseInt(input);

    const nacimiento = 2026 - edad;

    console.log(`Hola ${nombre}! Naciste en ~${nacimiento}.`);

    rl.close();

  });

});

Condicionales

const nota: number = 85;

if (nota >= 90) {

  console.log("Excelente!");

} else if (nota >= 70) {

  console.log("Aprobado.");

} else {

  console.log("Necesitas estudiar más.");

}

La estructura if / else if / else es idéntica en TypeScript, JavaScript, Java, C++ y muchos más. Lo que cambia entre lenguajes es la sintaxis, no el concepto.

Bucles

for (let i = 1; i <= 5; i++) {

  console.log(`Iteración ${i}`)

}

let numero: number = 1;

while (numero <= 10) {

  console.log(numero);

  numero++;

}

Funciones

function sumar(a: number, b: number): number {

  return a + b;

}

function esPar(numero: number): boolean {

  return numero % 2 === 0;

}

console.log(`5 + 3 = ${sumar(5, 3)}`)

if (esPar(4)) console.log("4 es par")

Ejercicio 2.2: Quiz de tipado

¿Puedes predecir qué devuelve cada expresión? Escribe tu respuesta y revela el resultado.

"5" + 3

Ejercicio 2.3: Calculadora interactiva

Prueba la calculadora aquí y luego recréala en TypeScript por tu cuenta. A la derecha puedes ver cómo se estructura el código.

function calcular(

  a: number,

  b: number,

  op: string

): number {

  switch (op) {

    case "+": return a + b;

    case "-": return a - b;

    case "*": return a * b;

    case "/": return a / b;

  }

}

Ejercicio 2.4: Clasificador de lenguajes

Clasifica cada lenguaje usando los selectores. Cuando termines, verifica tus respuestas.

Estructura sugerida

// 1. Generar número aleatorio

const secreto = Math.floor(Math.random() * 100) + 1;

// 2. Crear interfaz readline

// ... (como en la práctica)

// 3. Función para pedir intento

function pedirIntento(): void {

  // Leer input del usuario

  // Comparar con secreto

  // Mostrar "mayor" o "menor"

  // Si acierta, mostrar intentos

  // Si no, llamar pedirIntento()

}

// 4. Iniciar el juego

pedirIntento();

Bonus y criterios