¿Qué hace
esta palabra?

let declara un nombre que se puede reasignar. El nombre es elegido por ti.

let vidas = 3;
vidas = 2;

No vuelvas a declarar el mismo nombre con let en el mismo bloque.

vidas = 3
vidas = 2

const impide reasignar el nombre. No congela el contenido de arrays u objetos.

const lista = [1];
lista.push(2);

lista = [] fallaría; lista.push(2) puede modificar el array.

LIMITE = 10

var declara variables con alcance de función, o del entorno global si están fuera de una función.

function ejemplo() {
  var total = 2;
  return total;
}

Su declaración se eleva con valor inicial undefined. let y const tienen otras reglas; no los sustituyas mecánicamente.

total = 2

= evalúa la expresión de la derecha y asigna el resultado a la izquierda.

let total = 2 + 3;

Para comparar igualdad estricta se usa ===.

total = 2 + 3

console.log muestra valores en la salida del entorno. No es una palabra reservada.

console.log(2 + 3);

Mostrar no equivale a devolver un resultado desde una función.

print(2 + 3)

Un string representa caracteres delimitados por comillas o acentos graves.

const mensaje = "Hola";

El texto "12" y el número 12 tienen tipos diferentes.

mensaje = "Hola"

typeof permite observar el tipo. Enteros y decimales habituales usan number.

console.log(typeof 3.5);

typeof null devuelve object por una particularidad histórica.

print(type(3.5).__name__)

JavaScript no usa int para declarar variables. Los enteros habituales son valores number.

const cantidad = 3;

JavaScript también tiene BigInt para otros casos, fuera de este curso.

cantidad = int("3")

Los números habituales con parte decimal también tienen tipo number.

const precio = 3.5;

No existe una declaración float precio en JavaScript.

precio = float("3.5")

Number y String son herramientas incorporadas para convertir valores.

const total = Number("8") + 2;

Number puede producir NaN para un texto no numérico.

total = int("8") + 2

true y false son valores booleanos. Se escriben en minúscula.

const listo = true;

"false" es texto, no el booleano false.

listo = True

null suele representar ausencia intencional; undefined suele indicar un valor no proporcionado.

let elegido = null;

No son equivalentes al número 0 ni al texto vacío.

elegido = None

Los operadores calculan con valores. + también concatena si interviene texto.

const total = 3 * 4 + 2;

* y / tienen prioridad sobre + y -. Usa paréntesis para agrupar.

total = 3 * 4 + 2

Una comparación responde con un booleano. === compara sin convertir tipos.

console.log(5 === 5);

= asigna. == existe, pero convierte tipos; aquí preferimos ===.

print(5 == 5)

if evalúa una condición y ejecuta su bloque si es verdadera.

if (edad >= 18) {
  console.log("Adelante");
}

Los paréntesis contienen la condición y las llaves delimitan el bloque.

if edad >= 18:
    print("Adelante")

else ejecuta el otro camino cuando el if anterior no se cumple. else if añade otra condición.

if (n > 0) { console.log("Positivo"); } else { console.log("Otro"); }

En una cadena se ejecuta el primer bloque que corresponde.

if n > 0:
    print("Positivo")
else:
    print("Otro")

&& combina con y; || con o; ! niega. Aquí trabajamos con condiciones booleanas explícitas.

const puede = tieneEntrada && edad >= 12;

& y | no son sustitutos de && y ||.

puede = tiene_entrada and edad >= 12

Las llaves delimitan bloques en if, bucles y funciones. También aparecen en objetos con otro papel.

if (true) {
  console.log("Dentro");
}

La sangría ayuda a leer, pero las llaves delimitan el bloque.

if True:
    print("Dentro")

Un array guarda elementos en orden. length consulta su tamaño.

const datos = [2, 4];
console.log(datos.length);

Un array vacío tiene longitud 0.

datos = [2, 4]
print(len(datos))

Los corchetes crean arrays o consultan una posición, según el contexto.

const datos = ["a", "b"];
console.log(datos[0]);

El primer índice es 0. Consultar fuera del array devuelve undefined.

datos = ["a", "b"]
print(datos[0])

Un objeto literal reúne propiedades con nombres.

const ficha = { nombre: "Sol", puntos: 7 };

const no congela las propiedades del objeto.

ficha = {"nombre": "Sol", "puntos": 7}

push añade un elemento al final de un array y devuelve el tamaño nuevo.

const lista = [1];
lista.push(2);

Mutar el array no equivale a reasignar su nombre.

lista = [1]
lista.append(2)

for...of recorre valores de una colección iterable.

for (const n of [1, 2]) {
  console.log(n);
}

for...in recorre claves: no tiene el mismo comportamiento.

for n in [1, 2]:
    print(n)

while comprueba la condición antes de cada vuelta.

let n = 1;
while (n < 3) { n += 1; }

Algo debe cambiar para que la condición deje de cumplirse.

n = 1
while n < 3:
    n += 1

function declara una función con nombre, parámetros y cuerpo.

function doble(n) { return n * 2; }

Definir no ejecuta el cuerpo. La llamada doble(3) sí lo ejecuta.

def doble(n):
    return n * 2

return entrega un valor y termina la llamada actual de la función.

function doble(n) { return n * 2; }

Sin retorno explícito una función devuelve undefined. console.log no sustituye a return.

def doble(n):
    return n * 2

// inicia una nota hasta el final de la línea, fuera de un texto.

// La comisión se cobra una vez
const total = 10 + 2;

El comentario no se ejecuta.

# La comisión se cobra una vez
total = 10 + 2

Una plantilla usa acentos graves y ${expresión} para insertar un dato.

const nombre = "Sol";
console.log(`Hola, ${nombre}`);

Las comillas dobles no activan ${...}.

nombre = "Sol"
print(f"Hola, {nombre}")

El alcance determina dónde puedes consultar un nombre. let y const pertenecen al bloque en que se declaran.

function doble(n) {
  const resultado = n * 2;
  return resultado;
}

resultado es local a la función; no se consulta directamente desde fuera.

def doble(n):
    resultado = n * 2
    return resultado

Un parámetro nombra una entrada en la definición. El argumento es el valor concreto que se entrega al llamar.

function doble(n) { return n * 2; }
console.log(doble(3));

Aquí n es el parámetro y 3 es el argumento.

def doble(n):
    return n * 2
print(doble(3))

Una llamada usa paréntesis después de una función. Su cuerpo se ejecuta y produce un valor devuelto.

function doble(n) { return n * 2; }
const resultado = doble(4);

Escribir doble sin paréntesis se refiere a la función, pero no la ejecuta.

def doble(n):
    return n * 2
resultado = doble(4)

Un error de sintaxis impide interpretar el código; un error al ejecutar interrumpe un programa válido. Un error de lógica puede producir una salida equivocada sin lanzar una excepción.

const precio = 4;
const cantidad = 3;
console.log(precio * cantidad);

Comprueba el requisito con datos pequeños, la salida esperada y casos de frontera.

precio = 4
cantidad = 3
print(precio * cantidad)

Un acumulador guarda el resultado que se construye entre vueltas. Para sumar, se inicializa en cero antes del bucle.

let total = 0;
for (const n of [2, 3]) { total += n; }
console.log(total);

Reiniciarlo dentro del bucle descarta el subtotal anterior.

total = 0
for n in [2, 3]:
    total += n
print(total)