Recursivos

Bucle ‘for’ - Curso de JS

2025-12-03T00:00:00+00:00

La instrucción for es una estructura de control que permite crear bucles de forma controlada, por lo que es una herramienta muy utilizada en JavaScript. Su uso facilita la repetición de código tantas veces como sea necesario, hasta que la condición especificada se evalúe como falsa.

A diferencia del bucle ‘while’, que suele utilizarse cuando no se conoce el número de repeticiones necesarias, el bucle for es la opción habitual cuando el número de iteraciones es fijo y conocido o fácilmente controlable. Por ejemplo, puede usarse para recorrer un rango definido de números, recorrer los índices de un array, crear estructuras repetitivas o acumular cálculos que requieren varios pasos.

Existen otras variantes más específicas de bucles controlados: for…of se utiliza para crear bucles sobre arrays, mientras que for…in permite trabajar con bucles relacionados con las propiedades de objetos.

Estructura

La estructura de los bucles for integra tres expresiones en su encabezado (inicialización, condición y actualización), lo que lo hacen compacto y flexible, aunque puede resultar algo complejo para quien empieza a programar. Tras el encabezado se encuentra el cuerpo, que contiene el código a repetir.

Veamos detalladamente el propósito de estas expresiones:

Inicialización: es la expresión que se ejecuta una sola vez, antes de que comience el bucle. Se utiliza para declarar o asignar una variable de control, como sería un contador. Con esta variable indicamos el valor inicial del bucle.

Condición: es una expresión booleana que se evalúa al inicio de cada iteración. Comprueba si la condición es verdadera. Si es verdadera, se ejecuta el código indicado en el bucle. En caso contrario, el bucle termina. La condición indicada será evaluada al inicio de cada nueva iteración.

Si se omite la condición, se considera siempre verdadera. Esto podría producir un bucle infinito si no se controla de otra manera.

Actualización: es la expresión que se ejecuta al finalizar cada iteración, justo después de ejecutar el código del cuerpo del bucle. Se utiliza para modificar (incrementar o disminuir) el valor de la variable de control.

Cualquiera de estas tres expresiones del encabezado del for son opcionales, por lo que pueden omitirse. Lo único que no puede omitirse son los punto y coma (;) que permiten delimitar su posición. Así podemos construir bucles muy flexibles, como los bucles infinitos controlados de forma manual.

for (;;) { // Bucle infinito } 

Algoritmo

El algoritmo del bucle for sigue un orden de ejecución muy concreto. En primer lugar se ejecuta la expresión de «inicialización», que se evalúa una sola vez antes de que comience el bucle y permite declarar la variable de control.

A continuación se evalúa la «condición»: si el resultado es verdadero, se inicia la primera iteración; pero si es falso, el bucle finaliza de forma inmediata sin ejecutar el código del cuerpo. La condición se verifica en cada iteración.

Diagrama de flujo de un bucle 'for'.

Cuando se ejecuta el cuerpo del bucle, JS evalúa la expresión de «actualización», cuya función habitual es modificar la variable de control (incrementándola o disminuyéndola), para avanzar hacia la finalización del bucle.

Tras la actualización, el flujo de control del programa regresa al punto de evaluación de la «condición». Este ciclo se repite tantas veces como sea necesario, hasta que la condición inicial resulte falsa. Entonces, el bucle habrá terminado.

Sintaxis

La sintaxis del bucle for es compacta y bien definida. Comienza con la palabra reservada for y, entre paréntesis (), se indican las tres expresiones que controlan el bucle, separadas con un punto y coma (;).

for (inicialización; condición; actualización) { // Código que se ejecuta // si la condición es true } 

Tras el encabezado se coloca el cuerpo del bucle, delimitado por llaves {}. El cuerpo contiene las sentencias que se ejecutarán en cada iteración. Si el cuerpo consta de una sola instrucción, las llaves pueden omitirse, aunque si se incluyen se mejora significativamente la legibilidad del código.

Ejemplo: contador numérico

Un ejemplo sencillo para comprender cómo funciona el bucle for es crear un contador. Para ello, se inicializa la variable de control con un valor inicial: en este caso, 1; se define una condición que debe cumplirse: i < 5 (i es menor que 5); y se indica una actualización que incrementa el contador en cada iteración: el operador aritmético i++, equivalente a i = i + 1.

for (let i = 1; i < 5; i++) { console.log('Iteración:', i); } 

Como la expresión de inicialización establece i en 1, el primer mensaje mostrado corresponde a ese valor. El bucle sigue ejecutándose mientras la condición sea verdadera, por lo que se realizan cuatro iteraciones.

Este es el resultado:

Iteración: 1
Iteración: 2
Iteración: 3
Iteración: 4

Saltar una iteración

La instrucción continue permite saltar una iteración del bucle para ir de forma directa hacia la iteración siguiente. Esta funcionalidad puede ser muy útil cuando se necesita crear excepciones dentro de un bucle.

Por ejemplo, vamos a esquivar la tercera iteración:

for (let i = 1; i < 5; i++) { if (i === 3) { continue; } console.log('Iteración:', i); } 

Cuando la variable i vale 3, se ejecuta la instrucción continue, con lo cual, el flujo del programa salta hasta la siguiente iteración.

Resultado:

Iteración: 1
Iteración: 2
Iteración: 4

Interrumpir el bucle

La instrucción break permite interrumpir el bucle en la iteración actual, siempre que se cumpla una condición determinada. Su utilidad radica en la necesidad de terminar el bucle de forma excepcional.

Vamos a terminar el bucle en la tercera iteración:

for (let i = 1; i < 5; i++) { if (i === 3) { break; } console.log('Iteración:', i); } 

Cuando la variable i vale 3, se ejecuta la instrucción break. En este momento, el bucle termina antes de imprimir la tercera iteración.

Resultado:

Iteración: 1
Iteración: 2

Bucle ‘while’ y ‘do…while’ - Curso de JS

2025-11-02T00:00:00+00:00

La instrucción while del lenguaje JavaScript es una estructura de control que permite crear bucles. Está diseñada para repetir un bloque de código mientras se cumpla una condición evaluada como verdadera (truthy). Se trata de una herramienta flexible, pero debe usarse con cuidado para evitar los bucles infinitos.

Su propósito principal es permitir la iteración indefinida, es decir, repetir una tarea un número desconocido de veces hasta que la condición deje de ser verdadera. Por tanto, a diferencia del bucle ‘for’, que suelen usarse cuando se conoce el número de iteraciones necesarias, el bucle while resulta ideal para cuando se desconoce cuántas repeticiones harán falta para llegar al final.

En JavaScript existen dos variantes de bucles basados en esta idea. El bucle while, por defecto, evalúa la condición antes de cada iteración. Si la condición es verdadera, ejecuta el bloque de código; si es falsa, el bucle termina.

En cambio, la instrucción do…while funciona diferente: ejecuta el bloque al menos una vez antes de evaluar la condición. Si dicha condición es verdadera, vuelve a ejecutar el código, y así sucesivamente hasta que se vuelva falsa.

La instrucción ‘while’

La instrucción while permite crear bucles controlados por entrada, es decir, que primero comprueba si la condición establecida es válida. Luego, entra en el cuerpo del bucle para ejecutar el bloque de código.

Diagrama de flujo de un bucle 'while'.

Como podemos ver en este diagrama de flujo, el bucle se ejecutará repetidamente y de forma indefinida siempre que la condición sea true (verdadera). El bucle no terminará hasta que la condición sea false (falsa).

La sintaxis de while es la siguiente:

while (condición) { // Código que se ejecuta // si la condición es true } 

Entre paréntesis () se indica la condición a evaluar. Puede ser una expresión lógica, aritmética, comparativa o booleana. Las llaves {} que delimitan el bloque contienen el código a ejecutar mientras la condición devuelva true.

Por ejemplo:

let contador = 1; while (contador <= 5) { console.log("Iteración:", contador); contador++; } 

En este ejemplo, primero declaramos la variable contador y la inicializamos en 1. En la condición del bucle se especifica que su valor debe ser menor o igual que 5. Luego, dentro del bloque del while incrementamos la variable en una unidad para preparar la siguiente iteración; así evitamos un bucle infinito.

Resultado:

Iteración: 1
Iteración: 2
Iteración: 3
Iteración: 4
Iteración: 5

En la última iteración, el valor de la variable contador pasó a ser 6. Al evaluarse nuevamente la condición, esta dejó de ser verdadera, por lo que el bucle finalizó y ya no se imprimió ningún valor adicional.

La instrucción ‘do…while’

La instrucción do...while permite crear bucles controlados por salida. En este caso, primero se ejecuta el bloque de código del bucle, antes de verificar la condición. Tras completar la primera iteración, se verifica la condición.

Diagrama de flujo de un bucle 'do...while'.

Este tipo de bucle también seguirá ejecutándose mientras la condición sea verdadera. Pero a diferencia del while, se garantiza que el código se ejecuta al menos una vez. El bucle termina cuando la condición deja de cumplirse.

Esta es la sintaxis de do...while:

do { // Código que se ejecuta // como mínimo una vez } while (condición); 

La palabra reservada do inicia el bucle, y dentro de las llaves {} se coloca el código que se ejecutará al menos una vez. Tras cerrar el bloque de código se especifica la palabra reservada while. Después del while, entre paréntesis (), se indica la condición a evaluar al final de cada iteración.

Por ejemplo:

let contador = 1; do { console.log("Iteración:", contador); contador++; } while (contador <= 5); 

En este ejemplo, tras declarar la variable contador se ejecuta una primera iteración sin evaluar la condición. Se incrementa el valor de la variable en una unidad. Después se verifica que la variable sea menor o igual que 5.

Resultado:

Iteración: 1
Iteración: 2
Iteración: 3
Iteración: 4
Iteración: 5

Obtenemos el mismo resultado que en el ejemplo con while, pero con una diferencia: el código se ejecutará siempre la primera vez. Por ejemplo, si el contador empezara en 7, el resultado sería «Iteración: 7».

Esquivar iteraciones

Mediante el uso de la instrucción continue es posible omitir la ejecución de una iteración concreta, saltando directamente a la siguiente iteración. En un bucle while, el programa comprobará de nuevo la condición del bucle.

Vamos a esquivar la tercera iteración:

let contador = 0; while (contador <= 5) { contador++; if (contador === 3) { continue; } console.log("Iteración:", contador); } 

Cuando la variable contador vale 3, se ejecuta la instrucción continue, por lo que el resto del bucle se omite y se pasa a la iteración siguiente.

Resultado:

Iteración: 1
Iteración: 2
Iteración: 4
Iteración: 5

Interrupción de bucles

Si por el contrario, queremos que el bucle while finalice de forma inmediata en la iteración actual, se puede usar la instrucción break. También se utiliza si se quiere abandonar el bucle al cumplirse una condición excepcional y concreta.

Vamos a interrumpirlo en la tercera iteración:

let contador = 0; while (contador <= 5) { contador++; if (contador === 3) { break; } console.log("Iteración:", contador); } 

En este caso, cuando contador vale 3 se ejecuta la instrucción break, deteniendo el bucle sin completar más iteraciones.

Ahora ya solo imprime:

Iteración: 1
Iteración: 2

Operador condicional (ternario) - Curso de JS

2025-11-01T00:00:00+00:00

El operador condicional (ternario) constituye una forma compacta, concisa y elegante de escribir una sentencia condicional del tipo if…else, pero en una sola línea. De hecho, es conocido como operador «ternario» porque es el único operador del lenguaje JavaScript que usa tres operandos para funcionar. Se expresa con dos símbolos: el de interrogación (?) y los dos puntos (:).

Mientras que la instrucción if…else se utiliza para ejecutar bloques de código con múltiples sentencias y manejar lógica más compleja, el operador ternario (? :) se usa principalmente cuando se necesita evaluar una condición y devolver un valor de forma directa, ideal para expresiones simples y de una sola línea.

Sintaxis

Como su propio nombre sugiere, la sintaxis del operador ternario está compuesta por tres partes, ya que usa tres operandos. La primera parte es una condición, seguida de un signo de interrogación (?). Le sigue una expresión para ejecutar cuando la condición sea verdadera, seguida de los dos puntos (:). Finalmente, se indica la expresión a ejecutar si la condición es falsa.

condición ? exprSiTrue : exprSiFalse 

La condición es una expresión booleana, es decir, algo que puede evaluarse como true (verdadero) o false (falso). Por ejemplo, una comparación (edad >= 30) o una verificación de igualdad (usuario === 'admin').

La expresión verdadera es la parte del operador ternario que se ejecuta solo si la condición inicial se cumple (verdadera). Puede ser cualquier expresión válida del lenguaje JavaScript, como sería un valor literal, una llamada a función, una operación matemática o incluso otra expresión condicional.

Por su parte, la expresión falsa define el resultado alternativo, es decir, lo que se devuelve cuando la condición no se cumple (falsa). Aunque no es obligatorio, es una buena práctica que ambas expresiones devuelvan valores del mismo tipo o con un propósito equivalente, para mantener la coherencia del código.

Ejemplo básico

Vamos a crear un ejemplo en el que se asigna un valor monetario a la variable precioEnvio para decidir el precio de envío de un paquete. Si el usuario es miembro, el precio de envío vale 0,00 €, pero si no es miembro, vale 4,95 €.

const esMiembro = true; let precioEnvio = esMiembro ? 0 : 4.95; console.log('El precio de envío es:', precioEnvio); 

La constante esMiembro es verdadera, por tanto, se le asigna el precio de 0,00 €. Si fuese falsa, se le aplicaría el precio de 4,95 €. Como se puede ver, el valor se asigna en la misma declaración de la variable precioEnvio.

Este código tan simple y compacto es equivalente al siguiente, que usa la instrucción condicional ‘if…else’ en lugar del operador condicional ternario:

const esMiembro = true; let precioEnvio; if (esMiembro) { precioEnvio = 0; } else { precioEnvio = 4.95; } 

En este caso, el código es más extenso y algo repetitivo, ya que requiere realizar dos asignaciones por separado. Sin embargo, al tener dos bloques de código independientes, resultaría útil si se tuviera que añadir más sentencias o realizar operaciones adicionales en cada rama del condicional.

Anidación

Los operadores ternarios pueden anidarse de manera encadenada, de forma similar a la que se consigue mediante un ‘if…else if…else’. No obstante, no se recomienda abusar de esta técnica porque reduce la legibilidad del código.

La sintaxis es la siguiente:

condición1 ? valor1 : condición2 ? valor2 : condición3 ? valor3 : valor4; 

Para mejorar la legibilidad, el código se puede dividir en varias líneas sin que esto afecte a su funcionamiento. Si se deja todo en una misma línea, el resultado será una instrucción larga y difícil de leer.

El operador ternario se evalúa de izquierda a derecha. Si la primera condición es falsa, pasa a la expresión de la derecha, después de los dos puntos (:). Entonces, el operando de la derecha del todo se convierte en otro operador ternario, y así sucesivamente tantas veces como sea necesario.

Ejemplo de anidación

Para “ilustrar” esta estructura de código, vamos a crear un pequeño programa que analice una nota de examen y muestre la calificación textual: «suspendido» (< 5), «aprobado» (< 7), «notable» (< 9) o «sobresaliente».

let nota = 7; let calificacion = nota < 5 ? 'Suspendido' : nota < 7 ? 'Aprobado' : nota < 9 ? 'Notable' : 'Excelente'; console.log(calificacion); 

En este ejemplo, primero se evalúa la expresión nota < 5. Como la variable nota vale 7, la condición es falsa, por lo que el flujo pasa al siguiente ternario. Luego se evalúa la expresión nota < 7, que también es falsa. En este punto, la expresión a evaluar es nota < 9; ahora la condición es verdadera, por lo tanto, se asigna el valor «Notable» a la variable calificacion.

Aunque este ejemplo funciona correctamente, no se recomienda anidar operadores ternarios más allá de dos o tres condiciones, ya que dificulta la legibilidad y el mantenimiento del código, sobre todo para otros programadores. Para más de tres condiciones, es preferible utilizar la estructura switch.

Consejos

Usa el operador condicional ternario cuando la condición sea simple o cuando ambas ramas devuelvan valores claros y breves. También es útil usarlo es cuando se quiere mantener un código más compacto y conciso.

Por el contrario, evita emplearlo cuando las operaciones sean demasiado largas o complejas, ya que esto solo añadiría complejidad a su su legibilidad. Tampoco conviene abusar de las anidaciones de ternarios.

Condicional ‘switch’ - Curso de JS

2025-10-18T00:00:00+00:00

El condicional switch es una instrucción que permite evaluar una expresión y ejecutar diferentes bloques de código según el valor obtenido. Resulta útil cuando se puede tener varios valores posibles, ya que organiza el código de forma más clara, legible y fácil de mantener que otras estructuras condicionales.

Como alternativa, existe el condicional if…else combinando varias cláusulas else if o incluso if anidados. Sin embargo, la instrucción switch ofrece una sintaxis más limpia y estructurada: en vez de escribir múltiples condiciones, las agrupa en un solo bloque, facilitando la lectura de cada caso.

Algoritmo

Su funcionamiento es sencillo: primero se evalúa la expresión indicada; si su valor coincide con alguna de las etiquetas de caso (case), se ejecuta su bloque de código asociado. Si ninguna etiqueta coincide con el valor de la expresión, se ejecuta el bloque de código del caso por defecto (default).

Diagrama de flujo de un condicional 'switch'.

Cada vez que se ejecuta el programa, la expresión se evalúa una sola vez. Si su valor coincide con el primer caso, se ejecuta su bloque asociado y se termina el switch. Si no coincide con el primero continúa comprobando hasta llegar al último caso. Puede haber tantos casos como se necesiten, y si no se cumple ninguno, se ejecutará el código del bloque predeterminado (default).

Sintaxis

La palabra reservada switch marca el inicio de esta estructura condicional. Después, entre paréntesis (()) se indica la expresión que se quiere evaluar, y se comparará con los diferentes casos establecidos. Entre llaves ({}) se incluyen todos los casos, y de forma opcional, el caso por defecto.

Su sintaxis es la siguiente:

switch (expresión) { case 1: // Código que se ejecuta // si el valor es 1 break; case 2: // Código que se ejecuta // si el valor es 2 break; case 3: // Código que se ejecuta // si el valor es 3 break; default: // Código que se ejecuta // si no es ninguno de // los anteriores } 

La expresión entre paréntesis puede ser una variable, una expresión matemática, el resultado de una función, una expresión lógica o incluso un tipo de dato. En resumen, se trata de cualquier expresión evaluable que devuelve un valor.

Cada caso se declara mediante la palabra reservada case, seguida del valor que se quiere comparar con la expresión. Dicho valor puede ser un número, una cadena de texto o un valor booleano. No obstante, no tendría sentido crear un switch para decisiones tan simples que solo requieran dos posibles caminos.

Por último, la palabra default es opcional y permite definir el bloque de código por defecto o predeterminado. Este código se ejecutará cuando ninguno de los casos anteriores coincida con el valor de la expresión. Haciendo una comparativa, actúa de forma similar a un else en una estructura if...else.

Ejemplo: los días de la semana

Una de las formas más comunes de utilizar el condicional switch es cuando se desea ejecutar diferentes acciones según el valor de una variable concreta. En este ejemplo, si tenemos una variable que representa un número que va del 1 al 7, podemos asociar cada número con un día de la semana.

let dia = 3; switch (dia) { case 1: console.log("Lunes"); break; case 2: console.log("Martes"); break; case 3: console.log("Miércoles"); break; case 4: console.log("Jueves"); break; case 5: console.log("Viernes"); break; case 6: console.log("Sábado"); break; case 7: console.log("Domingo"); break; default: console.log("Número de día no válido"); } 

Lo primero que hace el switch es evaluar el valor de la variable dia. El programa recorre los distintos casos (del 1 a 7) hasta encontrar una coincidencia exacta con el valor almacenado en la variable, y mostrará el mensaje correspondiente. Por tanto, si la variable dia vale 3, el programa mostrará «Miércoles».

Cada bloque finaliza con la instrucción break, lo que indica que el programa debe salir del switch una vez ejecutado el caso correcto. Si se omitiera el break, el flujo continuaría ejecutando los siguientes casos, dando resultados indeseados. A este comportamiento se le conoce como «fall through».

Finalmente, si el valor de la variable no coincide con ninguno de los casos definidos, se ejecuta el bloque del default, actuando como una especie de plan alternativo. Así se puede tomar decisiones cuando hay valores fuera del rango de 1 a 7.

Ejemplo: las notas de examen

Para profundizar más en el funcionamiento del condicional switch, veamos un ejemplo más complejo: analizar una nota de examen y mostrar su calificación textual (suspendido, aprobado, notable o sobresaliente). Para simplificarlo un poco, almacenamos la nota del estudiante en la variable nota.

let nota = 7; switch (true) { case (nota < 5): console.log('Suspendido'); break; case (nota < 7): console.log('Aprobado'); break; case (nota < 9): console.log('Notable'); break; default: console.log('Excelente'); } 

En este ejemplo, la instrucción switch evalúa la expresión true. Aunque pueda parecer extraño, esta técnica es muy común cuando se quiere evaluar condiciones lógicas en lugar de valores exactos. De esta manera, cada case contiene una comparación comprobada de forma secuencial hasta que una de ellas devuelve true. En este punto se ejecuta el bloque correspondiente.

Como en el ejemplo anterior, si no se incluyera el break, el flujo de ejecución continuaría con los siguientes bloques, ejecutando todos los casos indicados. Esta “caída” o «fall through» puede ser útil en situaciones concretas, aunque en la mayoría de los casos se evita para mantener un control más preciso.

Condicional ‘if…else’ - Curso de JS

2025-10-15T00:00:00+00:00

En programación, muchas veces es necesario que el código tome decisiones. Por ejemplo, mostrar un mensaje si el usuario ha iniciado sesión, aplicar un descuento si el pedido supera cierta cantidad o permitir el acceso si se tiene permisos. En estos casos, el programa debe evaluar una condición y ejecutar una operación u otra en función de si el resultado es verdadero o falso (un resultado booleano).

En JavaScript existe la instrucción if…else para tomar decisiones dinámicas según las circunstancias. Si la condición es verdadera, se ejecuta el bloque de código del if. Si es falsa, se ejecuta un bloque alternativo usando else.

JavaScript incluye varias formas de usar esta estructura condicional:

Instrucción condicional

Vamos a ver más de cerca cómo funcionan los condicionales. Una instrucción condicional permite controlar el flujo de ejecución de un programa. Primero evalúa una expresión, como una comparación o el valor de una variable, y decide qué bloque de código ejecutar según si el resultado es verdadero o falso.

Diagrama de flujo de un condicional.

En este diagrama de flujo se puede ver una bifurcación condicional. Si la condición evaluada devuelve true (verdadero), se ejecutarán las sentencias agrupadas en el primer bloque del condicional. En caso contrario —si la condición devuelve false (falso)—, se ejecutarán las del segundo bloque.

La instrucción ‘if’

La instrucción if puede usarse de una forma muy básica, ya que por si sola (sin el else) permite decidir si se ejecuta o no el código del bloque.

Diagrama de flujo de un condicional 'if'.

Explicación: si la condición devuelve true, se ejecutan las sentencias. En caso contrario, se salta la sentencias y el programa prosigue.

La sintaxis es la siguiente:

if (condición) { // Código que se ejecuta // si la condición es true } 

Entre los paréntesis () se indica la condición a evaluar. Puede ser una expresión lógica, aritmética, comparativa o booleana. Entre las llaves {} se incluyen las sentencias que se ejecutarán solo si la condición devuelve true.

Por ejemplo:

let edad = 21; if (edad >= 35) { console.log('Eres mayor de 35'); } 

El mensaje solo se muestra si la variable edad es mayor o igual que 35. Como «edad» vale 21, la condición es falsa y el mensaje no se muestra.

La combinación ‘if else’

La instrucción else permite ejecutar sentencias cuando la condición indicada en el if devuelve false. En esencia, lo que hace es ampliar el control de flujo que ofrece if, ya que permite definir dos caminos posibles: uno cuando la condición es verdadera y otro cuando es falsa, creando así una bifurcación.

Diagrama de flujo de un condicional 'if...else'.

Explicación: primero se evalúa la condición. Si el resultado es true, se ejecuta la sentencia 1 y se omite la sentencia 2. En caso contrario, resultado es false, por lo tanto se salta la sentencia 1 pero se ejecuta la sentencia 2.

Su sintaxis es la siguiente:

if (condición) { // Código que se ejecuta // si la condición es true } else { // Código que se ejecuta // si la condición es false } 

Entre las segundas llaves {} —las que siguen al else— se incluyen las sentencias que se ejecutan cuando la condición devuelve false.

Ampliando el ejemplo anterior:

let edad = 21; if (edad >= 35) { console.log('Eres mayor de 35'); } else { console.log('Eres menor de 35') } 

En este caso, si la edad es mayor o igual que 35, se ejecuta el bloque del if. De lo contrario, se ejecuta el bloque del else.

Varias condiciones: ‘if else if’

La instrucción else if permite evaluar múltiples condiciones dentro de una misma estructura. Esta instrucción se coloca después de la llave de cierre del if inicial. Esta instrucción permite crear una ramificación múltiple sin tener que anidar varios if; en realidad son bifurcaciones sucesivas.

Diagrama de flujo de un condicional 'if...else if...'.

Explicación: primero se evalúa la condición 1; si es true se ejecuta la sentencia 1, pero si no, se omite. Entonces se evalúa la condición 2; si es true se ejecuta la sentencia 2, pero si no, se salta salta hasta el else. En este punto, ninguna de las dos anteriores es true, por lo que se ejecuta la sentencia 3.

Veamos su sintaxis:

if (condición 1) { // Código que se ejecuta // si la condición 1 es true } else if (condición 2) { // Código que se ejecuta // si la condición 2 es true } else { // Código que se ejecuta si // ninguna de las anteriores es true } 

JavaScript evalúa las opciones de arriba a abajo. Cada else if forma parte del else de la declaración anterior. Esto significa que el bloque que se ejecuta es aquel cuya condición devuelve true. En caso de que ninguna de las condiciones anteriores sea true, se ejecuta el bloque final del else.

Ampliando el ejemplo anterior:

let edad = 21; if (edad >= 35) { console.log('Eres mayor de 35'); } else if (edad >= 30) { console.log('Tienes entre 30 y 34'); } else if (edad >= 25) { console.log('Tienes entre 25 y 29'); } else { console.log('Eres menor de 25'); } 

En este caso, si la edad es mayor o igual que 35, se muestra el mensaje del bloque del if. Si no lo es, se comprueba si es mayor o igual que 30 y, después, si es mayor o igual que 25. Si ninguna de las condiciones es verdadera, se ejecuta el bloque del else.

Condiciones compuestas con operadores lógicos

Hasta ahora hemos visto cómo evaluar una sola condición dentro de una estructura condicional. Sin embargo, en JavaScript es posible evaluar varias condiciones al mismo tiempo dentro de una misma instrucción. Esto se consigue combinándolas mediante los operadores lógicos AND (&&) y OR (||).

El operador AND

El operador AND (&&) se usa cuando todas las condiciones deben ser verdaderas. Si ambas condiciones son truthy, la condición completa devuelve true y se ejecuta el bloque del if. En caso contrario, el código se omite.

Sintaxis básica:

if (condición && condición) { // El código se ejecuta si // ambas condiciones son verdaderas } 

Por ejemplo:

let edad = 25; let tieneCarnet = true; if (edad >= 18 && tieneCarnet) { console.log("Puedes conducir") } 

En este ejemplo, el mensaje se muestra solo si la persona tiene 18 años o más y además posee la licencia de conducir vehículos. Si una de las dos condiciones no se cumple, el mensaje no se muestra.

El operador OR

El operador OR (||) se usa cuando basta con que una de las condiciones sea verdadera. Si una de ellas es truthy, devolverá true y se ejecutará el bloque del if. Si ambas falsy, el motor omitirá el bloque y saltará a la siguiente línea.

Sintaxis básica:

if (condición || condición) { // El código se ejecuta si // una condición es verdadera } 

Por ejemplo:

let esAdmin = false; let esEditor = true; if (esAdmin || esEditor) { console.log("Tienes acceso") } 

En este ejemplo, el mensaje se muestra si el usuario es administrador o editor. Si ambas son falsas (valores falsy), el mensaje no se muestra.

El operador NOT

El operador NOT (!) permite negar el valor de una condición con el fin de devolver el valor opuesto. En otras palabras, si la condición es truthy, el resultado será false (falso); si es falsy, el resultado será true (verdadero).

Sintaxis básica:

if (!condición) { // El código se ejecuta // si la condición es falsa }

Por ejemplo:

let edad = 25; let tieneCarnet = false; if (edad >= 18 && !tieneCarnet) { console.log("Eres mayor de edad, pero no tienes carnet") } 

En este ejemplo, primero se evalúa si la persona es mayor de edad y luego si no tiene carnet. Solo si ambas condiciones se cumplen, se ejecuta el bloque.

Agrupación con paréntesis

Los paréntesis son un gran aliado a para agrupar y organizar varias condiciones dentro de una misma instrucción if. JavaScript evalúa primero los paréntesis internos y luego los externos, siguiendo la jerarquía que definamos.

Por ejemplo:

if ((edad >= 18 && edad < 65) || esAdmin) { console.log("Acceso permitido"); } 

En este ejemplo, primero se evalúa si la edad está comprendida entre los 18 y 65 años. Si esta condición es verdadera o bien la persona es administrador, se ejecuta el bloque, mostrando el mensaje.

Coerción de tipos de datos - Curso de JS

2025-10-14T00:00:00+00:00

La coerción de tipos (o conversión implícita) ocurre cuando JavaScript convierte de forma automática un valor de un tipo de dato a otro tipo. Este proceso se produce al realizar una operación, como un cálculo aritmético o una comparación, cuando el motor necesita un tipo de dato diferente para evaluarla.

¿Por qué se produce la coerción? Porque JavaScript es un lenguaje de tipado dinámico (débilmente tipado), lo que significa que los valores de las variables, constantes o funciones no tienen un tipo de dato fijo. De hecho, los tipos de datos pueden cambiar varias veces durante la ejecución del programa.

Estas conversiones automáticas son esenciales para que el lenguaje pueda realizar operaciones de forma flexible. Sin embargo, comprender cómo y cuándo ocurren es fundamental, ya que la coerción puede generar resultados inesperados o errores de lógica. En contraste, la conversión explícita se realiza de forma intencional, usando funciones y métodos integrados en el propio lenguaje.

Un ejemplo de coerción. Si usamos el operador de adición (+) cuyos operandos son un número (tipo number) y una cadena de texto (tipo string), el motor convertirá el número a cadena y realizará una concatenación.

20 + 'hola'; // '20hola' 

El resultado es una cadena de texto con el valor «20hola».

En cambio, si el operador es el de sustracción (-) y la cadena de texto contiene un número válido (sin caracteres no numéricos), la cadena se convertirá a tipo number para efectuar la operación aritmética de forma correcta.

20 - '5'; // 15 

Ahora sí ha realizado una operación aritmética.

Vamos a verlos con más detalle.

Coerción a cadena de texto

La coerción a cadena de texto ocurre cuando JavaScript necesita un valor de tipo string. Esto sucede, por ejemplo, al usar el operador de adición (+) cuando uno de los dos operandos es una cadena de texto y el otro no.

Las reglas de la coerción a cadena de texto son muy simples: todos los tipos de datos pueden ser convertidos a una representación textual usando su valor. Por ejemplo, true se convierte en 'true' y null en 'null'.

Por ejemplo:

'10' + 5000; // '105000' '10' + false; // '10false' '10' + null; // '10null' 

En estos ejemplos, JavaScript convierte a cadena de texto (tipo string) los operandos «5000», «false» y «null» para realizar la concatenación.

Coerción a número

La coerción a número se produce de forma automática cuando un valor de un tipo no numérico debe convertirse a number, porque así lo requiere la operación que se está realizando. Esto sucede con la mayoría de los operadores aritméticos (-, *, /, %) y de comparación relacional (<, >, <=, >=).

Existe una excepción importante: el operador de adición (+) no realiza la conversión implícita número cuando uno de los operandos es una cadena de texto. En tal caso, JS realiza una concatenación.

Estas son las reglas de la coerción a número:

Valor	Conversión
Cadenas de texto con números (‘123’)	Números
Cadenas de texto sin números (‘abc’)	NaN
Cadenas vacías o con espacios (‘’)	0
El valor booleano `true`	1
El valor booleano `false`	0
La ausencia de valor (`null`)	0
Valor no asignado (`undefined`)	NaN

Veamos algunos ejemplos para entenderlo mejor:

'10' / 5; // 2 (10 / 5) '10' - '5'; // 5 (10 - 5) '10' - true; // 9 (10 - 1) '10' * false; // 0 (10 * 0) 'tp' / 50; // NaN (NaN / 50) 

En este ejemplo, las cadenas de texto ‘10’ y ‘5’ se convierten a números. Los valores booleanos true y false se convierten en 1 y 0, respectivamente. La cadena de texto ‘tp’ no contiene números, por tanto no puede realizar una operación y como resultado devuelve NaN (Not a Number).

Conversión de ‘null’ a número

El tipo de dato null (ausencia de valor) se convierte de forma automática a 0 cuando se usa como operando en un contexto que requiere un número.

Por ejemplo:

10 * null; // 0 (10 * 0) 10 - null; // 10 (10 - 0) 10 + null; // 10 (10 + 0) 

Conversión de ‘undefined’ a número

El tipo de dato undefined (valor no asignado) siempre se convierte a NaN (Not a Number) cuando se usa con operadores aritméticos. De hecho, cualquier operación aritmética que incluya NaN será NaN.

10 * undefined; // NaN (10 * NaN) 10 - undefined; // NaN (10 - NaN) 10 + undefined; // NaN (10 + NaN) 

Coerción a booleano

La coerción a booleano se produce cuando un valor es evaluado en un contexto lógico, lo que requiere que el valor se interprete como verdadero o falso. Esto ocurre al aplicar el operador lógico NOT (!) de negación o al evaluar una estructura condicional, como puede ser un if o un while.

Los valores se convierten de forma automática a true o false dependiendo de su valor de verdad, conocido como la regla truthy o falsy.

Por tanto, la regla principal para la conversión automática de valores booleanos es la siguiente: los valores falsy como false, 0, '' (cadena vacía), null, undefined y NaN se convierten a false (falso). Por el contrario, el resto son truthy, en consecuencia se convierten a true (verdaderos).

Por ejemplo:

!true; // false !false; // true !0; // true (0 es falsy) !1; // false (1 es truthy) !''; // true (cadena vacía es falsy) !'ABC'; // false (string es truthy) !null; // true (null es falsy) !NaN; // true (NaN es falsy) !{}; // false (un objeto vacío es truthy) ![]; // false (un array vacío es truthy) 

Como se puede ver, la negación de los valores falsy devuelve true, mientras que la negación de los valores truthy devuelve false.

Conversión de tipos de datos - Curso de JS

2025-10-12T00:00:00+00:00

En programación, la conversión de tipos de datos es el proceso mediante el cual se transforma el tipo de dato de un valor a otro. Por ejemplo, un número puede convertirse en una cadena de texto, o una cadena en un valor booleano. Este tipo de conversiones permiten que los programas sean más flexibles al manejar información de distinta naturaleza, evitando errores o resultados inesperados.

En JavaScript, la conversión de tipos cobra importancia porque es un lenguaje débilmente tipado: las variables, constantes y funciones no tienen un tipo de dato fijo, por lo que pueden cambiar durante la ejecución. Pueden transformarse de forma automática (coerción o conversión implícita) o de forma intencional (conversión explícita), es decir, que el programador las realiza manualmente.

En este artículo nos centraremos en esta última: la conversión explícita de tipos. A diferencia de la coerción, que ocurre de manera automática y a veces impredecible, la conversión explícita se realiza de manera consciente y controlada. JavaScript proporciona funciones y métodos, como Number(), String() o Boolean(), para transformar valores entre distintos tipos de forma más precisa.

Comprender y aplicar correctamente la conversión explícita es una práctica esencial para evitar errores lógicos y garantizar resultados coherentes, especialmente al trabajar con operaciones aritméticas o validaciones de datos.

Conversión explícita a cadena de texto

Para convertir cualquier tipo de dato a una cadena de texto, existen dos formas principales: usar el constructor String() o el método toString(). Según el contexto, nos interesará más una forma o la otra.

El constructor String() es la opción más segura cuando el tipo de dato es incierto (null o undefined), ya que no produce error en estos casos. Basta con indicar como parámetro el dato que queremos convertir a cadena de texto.

String(10); // '10' String(null); // 'null' String(true); // 'true' 

El método toString(), en cambio, se invoca de forma directa sobre el valor o la variable. Por ejemplo: miNumero.toString(). Sin embargo, no puede usarse con null y undefined, porque no tienen métodos asociados.

(10).toString(); // '10' (null).toString(); // Error 

Una ventaja de usar el método toString() es que permite especificar como parámetro la base numérica en la que se representará el número. Por ejemplo, se puede convertir un número de base decimal (o base 10) en una cadena de texto que muestre su valor en base binaria (o base 2); de esta manera:

(10).toString(2); // '1010' 

Conversión explícita a número

Para convertir valores a tipo numérico (number) de forma intencional se pueden usar varias opciones: el constructor Number(), las funciones parseInt() y parseFloat(), o bien el operador «unario más» (+N).

El constructor Number() se usa indicando como parámetro el valor que se desea convertir a tipo number. Puede recibir cadenas de texto que contengan números, valores booleanos o el valor null. En cambio, si el valor es una cadena sin números o el valor undefined, devolverá NaN (Not a Number).

Number('10'); // 10 Number(true); // 1 Number(false); // 0 Number(null); // 0 Number('ABC'); // NaN 

En lugar Number(), también puede usarse el operador «unario más» (+N) como prefijo. Funciona de forma equivalente, pero es más breve:

+'10'; // 10 +true; // 1 +false; // 0 +null; // 0 

La función parseInt() convierte cadenas de texto a números enteros. Si el texto del parámetro indicado contiene un número con decimales, solo se conserva la parte entera. Además, acepta un segundo parámetro opcional para indicar la base numérica del primer parámetro (por defecto, base 10).

parseInt('10.95'); // 10 parseInt(10.9543); // 10 parseInt('ABCD'); // NaN parseInt(false); // NaN parseInt(1010, 2); // 10 

Por otro lado, parseFloat() permite convertir cadenas de texto a números de coma flotante (con decimales). Admite un solo parámetro, que si no es una cadena de texto, primero se convierte a texto antes de ser analizado.

parseFloat(3.14); // 3.14 parseFloat("3.14"); // 3.14 parseFloat(" 3.14 "); // 3.14 parseFloat("FF2"); // NaN 

Conversión explícita a booleano

Para convertir cualquier tipo de dato a un valor booleano (verdadero o falso) de forma voluntaria se utiliza el constructor Boolean(). Este proceso convierte los valores en función de si son considerados falsy o truthy. De forma alternativa también puede usarse la doble negación (!!).

Los valores falsy —que se convierten en false— son los siete siguientes: 0, '' (cadena vacía), null, undefined, NaN y false. Todos los demás valores se consideran truthy y, por lo tanto, se convierten en true.

Boolean(100); // true Boolean(0); // false (0 es falsy) Boolean(""); // false (cadena vacía es falsy) Boolean(null); // false (null es falsy) Boolean("Hi"); // true 

En lugar Boolean(), también puede usarse el doble operador de negación (!!). El primer ! niega el valor de forma implícita, pero el segundo fuerza una nueva inversión, devolviendo el valor original ya convertido.

!!'ABC'; // true (string es truthy) !!0; // false !!null; // false !!{}; // true 

Operadores bit a bit - Curso de JS

2025-10-09T00:00:00+00:00

Los operadores bit a bit (bitwise) son símbolos que permiten trabajar de forma directa con la representación binaria de los números enteros. En lugar de operar sobre valores numéricos, evalúan y manipulan cada bit de sus operandos, de forma individual. Esto es esencial en operaciones de bajo nivel.

Estos operadores trabajan con operandos de 32 bits. Puesto que JavaScript guarda el tipo de dato number como números de punto flotante de 64 bits, los convierte de forma automática. Antes de una operación bit a bit, el valor se convierte a un entero con signo de 32 bits. Después de la operación, el resultado se convierte de nuevo al formato de punto flotante de 64 bits.

En JavaScript hay siete operadores de este tipo:

Operador	Nombre	Descripción
`&`	AND bit a bit	Compara cada bit de los operandos y devuelve 1 si ambos son 1.
`\|`	OR bit a bit	Compara cada bit de los operandos y devuelve 1 si uno de los dos es 1.
`^`	XOR bit a bit	Devuelve 1 si los bits son distintos, y 0 si son iguales.
`~`	NOT bit a bit	Operador unario: invierte cada bit del operando (complemento a uno).
`<<`	Desplazamiento a la izquierda	Desplaza los bits del operando izquierdo a la izquierda tantas posiciones como indique el operando derecho. Los espacios vacíos se rellenan con ceros. Equivale a multiplicar por potencias de 2.
`>>`	Desplazamiento a la derecha con signo	Desplaza los bits del operando izquierdo a la derecha. Los bits de la izquierda se rellenan con el bit de signo (se conserva el signo del número).
`>>>`	Desplazamiento a la derecha con ceros	Similar a `>>`, pero siempre rellena con ceros por la izquierda, sin conservar el signo.

El operador AND bit a bit

El operador AND bit a bit se representa con un solo símbolo «ampersand» (&). Este operador binario realiza la operación lógica AND comparando, de forma individual, cada bit de sus dos operandos enteros.

Su funcionamiento es simple: si los dos bits comparados son 1, el bit resultante será 1. En cualquier otro caso, el bit resultante será 0.

Por ejemplo, comparemos 9 & 5;. En sistema binario, el 9 es 1001 y el 5 es 0101, sin olvidar que JavaScript trabaja con 32 bits en vez de 4. Por cada par de bits obtenemos un bit resultante:

Bit 1	Bit 2	Resultado (con `&`)
1	0	0
0	1	0
0	0	0
1	1	1

En este ejemplo, el único bit que resulta en 1 es el de la posición más a la derecha, porque ambos operandos tenían 1. El valor resultante es 0001, que en el sistema decimal equivale a 1. Por lo tanto: 9 & 5; es 1.

El operador OR bit a bit

El operador OR bit a bit se representa con una sola barra vertical (|). Se trata de un operador binario que realiza la operación lógica OR comparando los bits de forma individual de sus dos operandos enteros.

Su funcionamiento interno es el siguiente: si uno de los dos bits es 1, el bit resultante será 1. Si ninguno de los bits es 1, el bit resultante será 0.

Ahora comparemos 9 | 5;. En sistema binario, tomando solo los últimos 4 bits en lugar de los 32 que utiliza JavaScript, el 9 es 1001 y el 5 es 0101. Tras comparar cada par de bits obtenemos un bit resultante:

Bit 1	Bit 2	Resultado (con `\|`)
1	0	1
0	1	1
0	0	0
1	1	1

En este ejemplo, el único bit que resulta en 0 es el tercero. Esto sucede porque ambos operandos tenían 0. El valor resultante es 1101, que traducido al sistema decimal es 13. Por tanto: 9 | 5; es 13.

El operador XOR bit a bit

El operador XOR bit a bit (o «OR exclusivo») se identifica con el símbolo del acento circunflejo (^). Es un operador binario que ejecuta la operación lógica XOR al confrontar de manera individual cada bit de sus dos operandos enteros.

La lógica interna de esta operación se basa en la diferencia: el bit resultante será 1 solo si los dos bits comparados son distintos. Por tanto, si ambos bits son iguales (1 y 1, o 0 y 0), el bit resultante será 0.

Retomemos la comparación de los números 9 y 5: 9 ^ 5;. En la tabla siguiente se muestra la confrontación de cada par de bits y el valor obtenido:

Bit 1	Bit 2	Resultado (con `^`)
1	0	1
0	1	1
0	0	0
1	1	0

En este ejemplo, el valor binario resultante es 1100, que traducido al sistema decimal es el 12. Este resultado se debe a que los dos primeros pares de operandos eran diferentes, resultando en 1, mientras que los dos últimos pares son iguales, resultando en 0. Por lo tanto: 9 ^ 5; equivale a 12.

El operador NOT bit a bit

El operador NOT bit a bit (o «complemento a uno») se representa con la virguilla (~). A diferencia de los operadores anteriores, este es un operador es unario, ya que se aplica a un único operando entero. Su función es invertir el valor de cada bit del número: donde hay un 1, coloca un 0, y donde hay un 0, coloca un 1.

En otras palabras, el operador ~ niega todos los bits del número con el que trabaja. Además, es importante recordar que JavaScript utiliza una representación de 32 bits con signo para los números enteros en las operaciones bit a bit. De forma resumida: ~x equivale a la fórmula -(x + 1).

Vamos a ver un ejemplo con el número 5 (…00000101 en 32 bits). En la tabla siguiente solo mostramos la inversión en los últimos 4 bits:

Bit original	Inversión (con `~`)
0	1
1	0
0	1
1	0

¡Ojo! Esto no significa que el resultado sea 10. El resultado de esta inversión (~5;) es la representación binaria de -6 en 32 bits. Para simplificar el proceso, solo necesitamos recordar la fórmula que JavaScript aplica internamente. Por tanto, el resultado de ~7; será -8, y el de ~8; será -9.

El operador << bit a bit

El operador de desplazamiento a la izquierda bit a bit se representa con dos símbolos «menor que» (<<). Este operador toma los bits de un número y los mueve hacia la izquierda tantas posiciones como se indique en el segundo operando. Por tanto, requiere dos operandos para funcionar.

Cada desplazamiento de una posición hacia la izquierda equivale a multiplicarlo por 2, cada desplazamiento de dos posiciones equivale a multiplicarlo por 4, y así sucesivamente. Por tanto, por cada desplazamiento se duplica el valor del número. Los espacios vacíos de la derecha se rellenan con ceros.

Veamos un ejemplo de desplazamiento del número 5 en varias posiciones hacia la izquierda. Para simplificar la visualización, la tabla solo muestra los bits relevantes, aunque JavaScript trabaja con 32 bits, rellenando el resto con ceros.

Expresión (con `<<`)	Núm. binario	Núm. decimal
`5 << 0;`	0101	5
`5 << 1;`	1010	10
`5 << 2;`	10100	20
`5 << 3;`	101000	40

Como podemos ver en esta tabla, cuantas más posiciones se desplazan los bits del número 5 en sistema binario, más grande es el valor del número decimal resultante, duplicándose cada vez respecto la anterior.

El operador >> bit a bit

El operador de desplazamiento a la derecha bit a bit se representa mediante dos símbolos «mayor que» (>>). Este operador desplaza los bits de un número hacia la derecha, tantas posiciones como se especifique en el segundo operando. Al igual que el operado anterior, requiere dos operandos.

Cada movimiento de una posición hacia la derecha equivale a dividir el número entre 2 y descartar cualquier resto decimal (redondeo a la baja). Así, por cada movimiento, el valor numérico entero se reduce casi a la mitad.

Dado que este desplazamiento es con signo, el bit que está más a la izquierda —el bit de signo, que es 0 para positivos y 1 para negativos— se preserva y se utiliza para rellenar los huecos que se abren a la izquierda. Esto garantiza que el signo del número no cambie durante la operación.

Vamos a crear un desplazamiento del número 5 en varias posiciones hacia la derecha. Nuevamente, para simplificar la visualización, la siguiente tabla solo muestra los bits relevantes, ya que JS trabaja con 32 bits.

Expresión (con `>>`)	Núm. binario	Núm. decimal
`5 >> 0;`	0101	5
`5 >> 1;`	0010	2
`5 >> 2;`	0001	1
`5 >> 3;`	0000	0

Tal y como se puede ver en la tabla, a medida que los bits del número 5 se desplazan hacia la derecha, el valor decimal se reduce casi a la mitad en cada iteración: de 5 se pasa a 2, luego a 1 y, finalmente, a 0. Los bits desplazados fuera del rango por la derecha simplemente se descartan.

El operador >>> bit a bit

El operador de desplazamiento a la derecha sin signo se representa con tres símbolos de «mayor que» (>>>). Este operador también desplaza los bits de un número hacia la derecha según el número de posiciones indicado en el segundo operando. Pero a diferencia de >>, ignora el bit de signo del número, rellenando los espacios vacíos que se abren a la izquierda con ceros.

Por tanto, este operador es idéntico a >> para los números positivos. Sin embargo, es muy distinto para los números negativos: el relleno con ceros en la izquierda convierte el número de negativo a positivo.

Vamos a ver un ejemplo con un número negativo: -5. En el formato de 32 bits, el -5 comienza con 1, el bit que indica el signo negativo, mientras que el 5 desplazado comienza con 0, es decir, de signo positivo.

Expresión (con `>>>`)	Núm. binario	Núm. decimal
`-5 >>> 0;`	111…1011	4294967291
`-5 >>> 1;`	011…1101	2147483645
`-5 >>> 2;`	001…1110	1073741822
`-5 >>> 3;`	000…1111	536870911

Como se observa en la tabla, el operador >>> tiene un efecto drástico sobre los números negativos. Incluso cuando el desplazamiento es cero (-5 >>> 0;), el valor original negativo se convierte en un número positivo extremadamente grande (4294967291). A partir de ahí, cada desplazamiento posterior reduce ese gran valor aproximadamente a la mitad.

Operadores lógicos - Curso de JS

2025-10-08T00:00:00+00:00

Los operadores lógicos se utilizan para combinar o invertir expresiones booleanas, que siempre se evalúan como true o false. En JavaScript hay tres operadores lógicos principales: && (AND), || (OR) y ! (NOT). Son esenciales para construir condiciones complejas y controlar el flujo del programa.

Operador	Nombre	Descripción
`&&`	AND	Devuelve verdadero si ambos operandos son truthy.
`\|\|`	OR	Devuelve verdadero si uno de los dos operandos es truthy.
`!`	NOT	Niega el valor (devuelve el valor opuesto).

Los operadores lógicos no se limitan a trabajar con valores booleanos (true o false). Si los operandos son de otro tipo (como number o string), el lenguaje evalúa su “valor lógico”, es decir, si son «falsy» o «truthy».

Un valor falsy es aquel que se considera falso al convertirlo a booleano. Se trata de los siguientes valores: false, 0, '' (cadena vacía), null, undefined y NaN. En consecuencia, todos los demás se consideran truthy, es decir, los que se consideran verdaderos después de convertidos a booleanos. Esto sería: cualquier número distinto de cero, cualquier cadena no vacía, etc.

El operador AND

El operador AND se representa con el doble signo «ampersand» (&&) y evalúa las expresiones secuencialmente, siguiendo el orden de izquierda a derecha. Desde una perspectiva lógica (booleana), el resultado de la operación es verdadero solo si todos los operandos son considerados verdaderos.

Pero el mecanismo interno de JavaScript es más complejo y utiliza la evaluación en «cortocircuito» (short-circuiting). En realidad, el operador && busca el primer valor falsy. Si el primer operando que se evalúa es considerado falsy, la evaluación se detiene y el operador devuelve inmediatamente ese valor falsy.

En cambio, si el operando actual es truthy, la evaluación continúa con el siguiente operando, y así sucesivamente hasta el final. Si todos los operandos resultan ser truthy, el operador devuelve el valor del último operando.

Tomemos como ejemplo la expresión x && y. Si la variable x tiene un valor falsy, devolverá el valor de x. Si es truthy, evaluará el valor del siguiente operando (y). Al tratarse del último operando, el operador devolverá el valor de y. Esta regla se aplica a todos los tipos de datos (number, string, etc).

Como regla general, hay que tener claro que el operador && siempre devuelve el valor del último operando evaluado.

Veamos algunos ejemplos de operandos de tipo booleano:

true && true; // true (ambos son truthy) true && false; // false (el segundo es falsy) false && true; // false (el primero es falsy) false && false; // false (ambos son falsy) 

Algunos ejemplos con operandos numéricos:

0 && 10; // 0 (el primero es falsy) 10 && 4; // 4 (ambos son truthy) 25 && 0; // 0 (el segundo es falsy) 

Ejemplos con cadenas de texto:

'' && 'A'; // vacío (el primero es falsy) 'A' && 'B'; // B (ambos son truthy) 'C' && ''; // vacío (el segundo es falsy) 

Ejemplos variados:

0 && "Hola"; // 0 (el primero es falsy) "Hola" && 123; // 123 (ambos son truthy) null && true; // null (el primero es falsy) 

El operador OR

El operador OR se representa con el doble símbolo de barra vertical (||). Al igual que AND, también evalúa las expresiones de izquierda a derecha. Pero hay una diferencia clara: en este caso, el resultado de la operación es verdadero si al menos uno de los operandos es considerado verdadero.

Su funcionamiento interno es el siguiente: el operador || busca el primer valor truthy. Si el primer operando que se evalúa es considerado verdadero (truthy), la evaluación se detiene y el operador devuelve ese valor truthy.

En cambio, si el operando actual es falsy, la evaluación continúa hasta el siguiente operando, y así sucesivamente hasta el final. Si todos los operandos resultan ser falsy, el operador devolverá el valor del último operando.

Imaginemos el siguiente ejemplo: x || y. Si la variable x tiene un valor truthy, el operador devolverá su valor. Si es falsy, evaluará el valor del siguiente operando (y). En este caso, se trata del último operando y devolverá el valor de y.

Resumiendo lo importante, no hay que olvidar que el operador || siempre devuelve el primer valor truthy que encuentra; y si todos los operandos son falsy, entonces devuelve el último operando evaluado.

Ejemplos usando operandos booleanos:

true || true; // true (el primero es truthy) true || false; // true (el primero es truthy) false || true; // true (el segundo es truthy) false || false; // false (ambos son falsy) 

Ejemplos usando operandos numéricos:

0 || 10; // 10 (el segundo es truthy) 10 || 4; // 10 (el primero es truthy) 25 || 0; // 25 (el primero es truthy) 0 || 0; // 0 (ambos son falsy) 

Ejemplos con cadenas de texto:

'' || 'A'; // 'A' (el segundo es truthy) 'A' || 'B'; // 'A' (el primero es truthy) 'C' || ''; // 'C' (el primero es truthy) '' || ''; // '' (ambos son falsy) 

Ejemplos variados:

0 || "Hola"; // "Hola" (el segundo es truthy) "Hola" || 123; // "Hola" (el primero es truthy) null || true; // true (el segundo es truthy) undefined || 0; // 0 (ambos son falsy) 

El operador NOT

El operador NOT está representado con el signo de exclamación (!) y se aplica a un único operando. Por tanto, es un operador unario. Su función es invertir el valor lógico (booleano) del operando. Si el operando es truthy, el resultado será false (falso), y si es falsy, el resultado será true (verdadero).

Desde una perspectiva lógica, podemos decir que este operador convierte cualquier valor a su equivalente booleano opuesto. Para ello, primero realiza una conversión implícita (coerción) al tipo de dato boolean (booleano). Por esta razón, el operador NOT siempre devuelve un valor estrictamente booleano.

Como regla general, hay que tener en cuenta que el operador ! niega el valor lógico del operando después de convertirlo a booleano.

Veamos algunos ejemplos con valores booleanos:

!true; // false !false; // true 

Ejemplos usando operandos numéricos:

!0; // true (0 es falsy) !123; // false (123 es truthy) 

Ejemplos con cadenas de texto:

!''; // true (cadena vacía es falsy) !'Hola'; // false (cadena de texto es truthy) 

Ejemplos variados:

!null; // true (null es falsy) !undefined; // true (undefined es falsy) !NaN; // true (NaN es falsy) !{}; // false (objeto es truthy) ![]; // false (array vacío es truthy) 

Operadores de comparación - Curso de JS

2025-10-07T00:00:00+00:00

Los operadores de comparación son símbolos que permiten comparar dos valores y obtener un resultado booleano: verdadero o falso. Las comparaciones posibles son bastante habituales, pues permiten determinar si dos valores son iguales, diferentes, menores o mayores. Por tanto, permiten evaluar expresiones.

Es evidente, por lógica, que los operadores de comparación son de tipo binario, ya que requieren dos operandos para poder realizar una comparación. Dichos operandos pueden ser datos de cualquier tipo, como podría ser dos números, dos cadenas de texto, valores lógicos, objetos o arrays.

En JavaScript hay ocho operadores de este tipo:

Operador	Nombre	Descripción
`==`	Igualdad	Comprueba si dos valores son iguales, realizando conversión de tipo si es necesario.
`===`	Igualdad estricta	Comprueba si dos valores son iguales y del mismo tipo.
`!=`	Desigualdad	Comprueba si dos valores son diferentes, realizando conversión de tipo si es necesario.
`!==`	Desigualdad estricta	Comprueba si dos valores son diferentes o de distinto tipo.
`>`	Mayor que	Comprueba si el operando izquierdo es mayor que el derecho.
`<`	Menor que	Comprueba si el operando izquierdo es menor que el derecho.
`>=`	Mayor o igual que	Comprueba si el operando izquierdo es mayor o igual que el derecho.
`<=`	Menor o igual que	Comprueba si el operando izquierdo es menor o igual que el derecho.

En la mayoría de los operadores de comparación, JavaScript realiza coerción de tipo cuando los operandos son de tipos de datos diferentes. La excepción a esta regla son los operadores de igualdad estricta (===) y desigualdad estricta (!==), que comparan los valores sin ninguna conversión de tipo.

Durante el proceso de coerción, si una cadena de texto contiene un valor numérico, se convierte al tipo number. Si contiene caracteres no numéricos, se convierte a NaN (Not a Number). Si la cadena está vacía, se convierte en 0.

Igualdad

El operador de igualdad está representado por dos caracteres del símbolo igual (==) y comprueba si el valor de dos operandos es idéntico o no. Devuelve true (verdadero) si sin iguales; en caso contrario, devuelve false (falso). Si son de diferente tipo se realiza la conversión de tipo.

2 == 4; // false 4 == 4; // true 4 == '4'; // true 

En este ejemplo, la última comparación devuelve true (verdadero) porque JavaScript convierte la cadena de texto '4' al tipo numérico 4. Después de la coerción, evalúa la igualdad.

Igualdad estricta

El operador de igualdad estricta, compuesto por tres caracteres del símbolo igual (===), comprueba si el valor de dos operandos es idéntico, pero además comprueba que sean del mismo tipo. JavaScript no realizará la conversión de tipo. Por tanto, si son de diferente tipo, devuelve false (falso).

2 === 4; // false 4 === 4; // true 4 === '4'; // false 

Desigualdad

La desigualdad viene representada por el signo de exclamación y el igual (!=). Este operador comprueba si los valores de dos operandos no son iguales. Si no son iguales, devuelve true (verdadero); en caso contrario, devuelve false (falso). En caso de ser necesario, realiza la coerción del tipo de dato.

2 != 4; // true 4 != 4; // false 4 != '4'; // false 

Desigualdad estricta

El operador de desigualdad estricta está compuesto por el signo de exclamación y dos caracteres del símbolo igual (!==). Este operador devuelve true (verdadero) si dos operandos no son idénticos o si no son del mismo tipo. En cambio, si son iguales y del mismo tipo devuelve false (falso).

2 !== 4; // true 4 !== 4; // false 4 !== '4'; // true 

Mayor que

El operador mayor que (>) comprueba si el valor del operando de la izquierda es mayor que el valor del operando de la derecha. Si es afirmativa, dicha comparación devuelve true (verdadero); en caso contrario, devuelve false (falso).

8 > 5; // true 5 > 8; // false 

Menor que

El operador menor que (>) comprueba si el valor del operando de la izquierda es menor que el valor del operando de la derecha. En caso de ser cierto, el resultado será true (verdadero); en caso contrario, será false (falso).

5 < 8; // true 8 < 5; // false 

Mayor o igual que

El operador mayor o igual que está formado por dos caracteres: >=. Comprueba si el valor del operando de la izquierda es mayor o igual que el operando de la derecha. Por tanto, si es mayor o contiene el mismo valor, devolverá true (verdadero); en caso contrario, devolverá false (falso).

8 >= 5; // true 8 >= 8; // true 5 >= 8; // false 

Menor o igual que

El operador menor o igual que usa estos dos símbolos: <=. Lo que hace es revisar que el valor del operando izquierdo sea menor o igual que el operando de la derecha. Si es menor o contiene el mismo valor, devolverá true (verdadero); pero en caso contrario, devolverá false (falso).

5 <= 8; // true 8 <= 8; // true 8 <= 5; // false 