Transición de C++ a JavaScript

1. Tipos de Datos Primitivos y Variables

En C++ declaras el tipo de dato de forma estática (int, double, bool, char). En JavaScript, la variable se adapta dinámicamente al valor asignado.

#include <iostream>
#include <string>

int main() {
    int edad = 20;
    double nota = 95.5;
    bool aprobado = true;
    std::string nombre = "Ana";

    std::cout << nombre << " tiene " << edad << " años.\n";
    return 0;
}

// Sin incluye ni función main
let edad = 20;
const nota = 95.5;
let aprobado = true;
const nombre = "Ana";

// Interpolación con template literals (` `)
console.log(`${nombre} tiene ${edad} años.`);

2. Estructuras Condicionales y Selectivas

JavaScript mantiene la misma estructura lógica que C++ para tomar decisiones, incorporando condicionales compuestas, selectivas y ternarias.

A. Estructura Condicional `if - else if - else`

int nota = 85;

if (nota >= 90) {
    std::cout << "Excelente\n";
} else if (nota >= 51) {
    std::cout << "Aprobado\n";
} else {
    std::cout << "Reprobado\n";
}

let nota = 85;

if (nota >= 90) {
    console.log("Excelente");
} else if (nota >= 51) {
    console.log("Aprobado");
} else {
    console.log("Reprobado");
}

B. Operador Ternario (`? :`)

int edad = 18;
std::string estado = (edad >= 18) ? "Mayor" : "Menor";
std::cout << estado << std::endl;

let edad = 18;
const estado = (edad >= 18) ? "Mayor" : "Menor";
console.log(estado);

C. Estructura Selectiva `switch`

int opcion = 2;

switch(opcion) {
    case 1:
        std::cout << "Iniciando...\n";
        break;
    case 2:
        std::cout << "Cargando...\n";
        break;
    default:
        std::cout << "Opción no válida\n";
}

let opcion = 2;

// Nota: En JS el switch evalúa con igualdad estricta (===)
switch(opcion) {
    case 1:
        console.log("Iniciando...");
        break;
    case 2:
        console.log("Cargando...");
        break;
    default:
        console.log("Opción no válida");
}

3. Estructuras Iterativas (Bucles) y Sentencias de Control

JavaScript implementa las tres estructuras iterativas clásicas aprendidas en C++ (for, while, do-while) manteniendo el soporte para break y continue.

A. Bucle `for`

for (int i = 0; i < 5; i++) {
    std::cout << "Iteración: " << i << "\n";
}

// Solo reemplazas 'int' por 'let'
for (let i = 0; i < 5; i++) {
    console.log(`Iteración: ${i}`);
}

B. Bucle `while` y sentencia `break`

int i = 0;
while (i < 10) {
    if (i == 5) {
        break; // Interrumpe el ciclo
    }
    std::cout << i << " ";
    i++;
}

let i = 0;
while (i < 10) {
    if (i === 5) {
        break; // Interrumpe el ciclo
    }
    console.log(i);
    i++;
}

C. Bucle `do-while` y sentencia `continue`

int contador = 0;
do {
    contador++;
    if (contador == 3) {
        continue; // Salta a la siguiente iteración
    }
    std::cout << contador << " ";
} while (contador < 5);

let contador = 0;
do {
    contador++;
    if (contador === 3) {
        continue; // Salta a la siguiente iteración
    }
    console.log(contador);
} while (contador < 5);

4. Cadenas (Strings) y Arreglos (Arrays)

A diferencia de los arreglos estáticos de C++, los arreglos en JavaScript son estructuras dinámicas equivalentes a un std::vector flexible que puede cambiar de tamaño en tiempo de ejecución.

#include <vector>
#include <iostream>

std::vector<int> numeros = {10, 20, 30};
numeros.push_back(40); // Insertar

int longitud = numeros.size();
std::cout << numeros[0]; // Acceso

// Arreglo dinámico por defecto
let numeros = [10, 20, 30];
numeros.push(40); // Insertar

let longitud = numeros.length;
console.log(numeros[0]); // Acceso

5. Funciones, Paso de Parámetros y Recursividad

En JS las funciones se definen con la palabra clave function. Los tipos de datos primitivos en JS siempre se pasan **por valor**, imitando el paso por valor por defecto de C++.

A. Paso de Parámetros por Valor

Al pasar un tipo primitivo (números, booleanos, strings), se pasa una **copia** del valor. Las modificaciones internas no afectan la variable externa.

#include <iostream>

void duplicar(int x) {
    x = x * 2; // Modifica solo la copia local
}

int main() {
    int num = 10;
    duplicar(num);
    std::cout << num; // Imprime 10
    return 0;
}

function duplicar(x) {
    x = x * 2; // Modifica solo la copia local
}

let num = 10;
duplicar(num);
console.log(num); // Imprime 10

B. Parámetros por Defecto

#include <iostream>

void saludar(std::string nombre, std::string saludo = "Hola") {
    std::cout << saludo << ", " << nombre << "!\n";
}

int main() {
    saludar("Carlos");            // Usa valor por defecto
    saludar("Ana", "Bienvenida"); // Reemplaza valor
    return 0;
}

function saludar(nombre, saludo = "Hola") {
    console.log(`${saludo}, ${nombre}!`);
}

saludar("Carlos");            // Imprime: "Hola, Carlos!"
saludar("Ana", "Bienvenida"); // Imprime: "Bienvenida, Ana!"

C. Recursividad

La lógica de llamadas recursivas y caso base es exactamente idéntica a la estudiada en C++.

int factorial(int n) {
    // Caso base
    if (n <= 1) return 1;
    // Caso recursivo
    return n * factorial(n - 1);
}

function factorial(n) {
    // Caso base
    if (n <= 1) return 1;
    // Caso recursivo
    return n * factorial(n - 1);
}