Otro uso que le podemos dar a OR ( | | )
const edad = null;
const edadUsuario = edad || 18;
console.log(edadUsuario);
Resultado:
18
Si el usuario no proporciona la edad, se usa 18 como valor por defecto.
Los operadores lógicos en JavaScript te permiten combinar, negar o evaluar varias condiciones a la vez, y son la base para controlar el flujo de cualquier aplicación que construyas. Si estás aprendiendo a programar, dominarlos te abre la puerta a validaciones, permisos y árboles de decisión.
Aquí trabajamos con tres operadores: && (AND), || (OR) y ! (NOT). Cada uno tiene una lógica distinta, y entender cuándo usar cada uno marca la diferencia entre una app que se comporta como esperas y una llena de bugs raros.
¿Qué hace el operador AND en JavaScript?
El operador AND, representado con &&, devuelve true solo si ambas expresiones son verdaderas. Si una sola falla, el resultado completo es false.
Mira cómo se comporta en un archivo 07-logic.js:
javascript console.log(true && true); // true console.log(true && false); // false console.log(false && true); // false
Este operador brilla cuando necesitas que todas las condiciones se cumplan al mismo tiempo. Por ejemplo, imagina que validas si alguien puede ver la lista de usuarios en tu sistema:
javascript const esAdministrador = true; const esUsuarioActivo = true; console.log(esAdministrador && esUsuarioActivo); // true
Solo si la persona es administradora y además está activa, la dejas pasar al siguiente flujo. Si una de las dos falla, se queda fuera.
¿Cuándo usar AND en JavaScript? Úsalo cuando necesites que dos o más condiciones sean verdaderas al mismo tiempo, como validar permisos de administrador junto con un estado activo.
¿Cómo funciona el operador OR y cuándo conviene usarlo?
El operador OR se escribe con doble pipe || y devuelve true si al menos una de las expresiones es verdadera. Solo retorna false cuando todas son falsas.
javascript console.log(true || true); // true console.log(true || false); // true console.log(false || false); // false
Aquí hay que ir con cuidado, porque OR puede jugarte en contra si esperas un flujo más estricto. Como estos operadores controlan por dónde se mueve tu aplicación, una comparación mal hecha te lleva a comportamientos que no deseas.
Un caso típico: dejar pasar a un usuario si tiene al menos uno de varios permisos. No necesita todos, basta con uno. Ese es el escenario natural del OR.
¿Qué diferencia hay entre AND y OR en la práctica?
La distinción es directa:
&&) exige que todas las condiciones sean verdaderas.||) se conforma con que una sola sea verdadera.Cuando diseñes validaciones de permisos, piensa primero qué tan estricto quieres ser. Si el usuario debe ser administrador y activo, usa AND. Si basta con que sea administrador o moderador, usa OR.
¿Para qué sirve el operador NOT en JavaScript?
El operador NOT se escribe con el signo de admiración de cierre ! y su función es invertir el valor booleano. Lo que era true se vuelve false, y viceversa.
javascript console.log(!true); // false console.log(!false); // true
¿Dónde entra en juego? Cuando quieres negar una condición dentro de tu lógica. Por ejemplo: si no es administrador, haz esto; si es administrador, haz aquello. NOT te ayuda a expresar esa negación de forma limpia, sin tener que reescribir toda la condición.
¿Qué hace el operador ! en JavaScript? Invierte el valor booleano de una expresión.
!truese convierte enfalsey!falseentrue, útil para validar negaciones.
¿Cómo aplicar operadores lógicos en el flujo de una aplicación?
Piensa en tu aplicación como un árbol de decisiones. Cada operador lógico es una bifurcación que lleva al usuario por un camino u otro: ver un panel, recibir un permiso, acceder a una sección.
Una recomendación práctica cuando estés diseñando esta lógica:
console.log para confirmar que el resultado coincide con lo que esperas.Este hábito te evita horas de depuración después, porque visualizas las decisiones antes de programarlas. Y te prepara para proyectos más grandes, como un sistema de notas en Markdown donde la lógica de validación marca toda la experiencia.
¿Ya probaste combinar AND, OR y NOT en una misma expresión? Cuéntame en los comentarios qué reto resolviste con ellos.
Los operadores lógicos en JavaScript te permiten combinar, negar o evaluar varias condiciones a la vez, y son la base para controlar el flujo de cualquier aplicación que construyas. Si estás aprendiendo a programar, dominarlos te abre la puerta a validaciones, permisos y árboles de decisión.
Aquí trabajamos con tres operadores: && (AND), || (OR) y ! (NOT). Cada uno tiene una lógica distinta, y entender cuándo usar cada uno marca la diferencia entre una app que se comporta como esperas y una llena de bugs raros.
El operador AND, representado con &&, devuelve true solo si ambas expresiones son verdaderas. Si una sola falla, el resultado completo es false.
Mira cómo se comporta en un archivo 07-logic.js:
javascript console.log(true && true); // true console.log(true && false); // false console.log(false && true); // false
Este operador brilla cuando necesitas que todas las condiciones se cumplan al mismo tiempo. Por ejemplo, imagina que validas si alguien puede ver la lista de usuarios en tu sistema:
javascript const esAdministrador = true; const esUsuarioActivo = true; console.log(esAdministrador && esUsuarioActivo); // true
Solo si la persona es administradora y además está activa, la dejas pasar al siguiente flujo. Si una de las dos falla, se queda fuera.
¿Cuándo usar AND en JavaScript? Úsalo cuando necesites que dos o más condiciones sean verdaderas al mismo tiempo, como validar permisos de administrador junto con un estado activo.
El operador OR se escribe con doble pipe || y devuelve true si al menos una de las expresiones es verdadera. Solo retorna false cuando todas son falsas.
javascript console.log(true || true); // true console.log(true || false); // true console.log(false || false); // false
Aquí hay que ir con cuidado, porque OR puede jugarte en contra si esperas un flujo más estricto. Como estos operadores controlan por dónde se mueve tu aplicación, una comparación mal hecha te lleva a comportamientos que no deseas.
Un caso típico: dejar pasar a un usuario si tiene al menos uno de varios permisos. No necesita todos, basta con uno. Ese es el escenario natural del OR.
La distinción es directa:
&&) exige que todas las condiciones sean verdaderas.||) se conforma con que una sola sea verdadera.Cuando diseñes validaciones de permisos, piensa primero qué tan estricto quieres ser. Si el usuario debe ser administrador y activo, usa AND. Si basta con que sea administrador o moderador, usa OR.
El operador NOT se escribe con el signo de admiración de cierre ! y su función es invertir el valor booleano. Lo que era true se vuelve false, y viceversa.
javascript console.log(!true); // false console.log(!false); // true
¿Dónde entra en juego? Cuando quieres negar una condición dentro de tu lógica. Por ejemplo: si no es administrador, haz esto; si es administrador, haz aquello. NOT te ayuda a expresar esa negación de forma limpia, sin tener que reescribir toda la condición.
¿Qué hace el operador ! en JavaScript? Invierte el valor booleano de una expresión.
!truese convierte enfalsey!falseentrue, útil para validar negaciones.
Piensa en tu aplicación como un árbol de decisiones. Cada operador lógico es una bifurcación que lleva al usuario por un camino u otro: ver un panel, recibir un permiso, acceder a una sección.
Una recomendación práctica cuando estés diseñando esta lógica:
console.log para confirmar que el resultado coincide con lo que esperas.Este hábito te evita horas de depuración después, porque visualizas las decisiones antes de programarlas. Y te prepara para proyectos más grandes, como un sistema de notas en Markdown donde la lógica de validación marca toda la experiencia.
¿Ya probaste combinar AND, OR y NOT en una misma expresión? Cuéntame en los comentarios qué reto resolviste con ellos.
Otro uso que le podemos dar a OR ( | | )
const edad = null;
const edadUsuario = edad || 18;
console.log(edadUsuario);
Resultado:
18
Si el usuario no proporciona la edad, se usa 18 como valor por defecto.
reto 8 superado, vamos por maaas!
****
// ============================================
// Reto: Operadores lógicos AND, OR y NOT en JavaScript
// ============================================
// Practica AND (&&), OR (||) y NOT (!) para combinar, evaluar y negar condiciones.
// Útil para validaciones, permisos (admin, usuario activo) y flujos de decisión.
// Ejecuta los tests con: npx vitest src/08-logic
// ============================================
// --- Reto 1: AND (&&) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a && b (true solo si ambas son true).
function resultadoAnd(a, b) {
return a && b;
}
// --- Reto 2: OR (||) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a || b (true si al menos una es true).
function resultadoOr(a, b) {
return a || b;
}
// --- Reto 3: NOT (!) ---
// Recibe un booleano "val".
// Retorna el resultado de !val (invierte: true → false, false → true).
function resultadoNot(val) {
return !val;
}
// --- Reto 4: Validación con AND (ambas condiciones) ---
// Recibe "esAdmin" y "estaActivo" (booleanos).
// Retorna true solo si es administrador Y está activo (puede ver la lista de usuarios).
function puedeVerListaUsuarios(esAdmin, estaActivo) {
return esAdmin && estaActivo;
}
// --- Reto 5: Validación con OR (al menos una condición) ---
// Recibe "esUsuarioValido" y "tienePermisoEspecial" (booleanos).
// Retorna true si cumple cualquiera de las dos condiciones (puede acceder).
function puedeAcceder(esUsuarioValido, tienePermisoEspecial) {
return esUsuarioValido || tienePermisoEspecial;
}
// --- Reto 6: Validación con NOT (negar condición) ---
// Recibe "esAdmin" (booleano).
// Retorna true si NO es administrador (mostrar opción limitada para no admins).
function mostrarOpcionLimitada(esAdmin) {
return !esAdmin;
}
export {
resultadoAnd,
resultadoOr,
resultadoNot,
puedeVerListaUsuarios,
puedeAcceder,
mostrarOpcionLimitada,
};
// Reto completado:
// --- Reto 1: AND (&&) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a && b (true solo si ambas son true).
function resultadoAnd(a, b) {
return a && b
}
// --- Reto 2: OR (||) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a || b (true si al menos una es true).
function resultadoOr(a, b) {
return a || b
}
// --- Reto 3: NOT (!) ---
// Recibe un booleano "val".
// Retorna el resultado de !val (invierte: true → false, false → true).
function resultadoNot(val) {
return (!val)
}
// --- Reto 4: Validación con AND (ambas condiciones) ---
// Recibe "esAdmin" y "estaActivo" (booleanos).
// Retorna true solo si es administrador Y está activo (puede ver la lista de usuarios).
function puedeVerListaUsuarios(esAdmin, estaActivo) {
return esAdmin && estaActivo;
}
// --- Reto 5: Validación con OR (al menos una condición) ---
// Recibe "esUsuarioValido" y "tienePermisoEspecial" (booleanos).
// Retorna true si cumple cualquiera de las dos condiciones (puede acceder).
function puedeAcceder(esUsuarioValido, tienePermisoEspecial) {
return esUsuarioValido || tienePermisoEspecial;
}
// --- Reto 6: Validación con NOT (negar condición) ---
// Recibe "esAdmin" (booleano).
// Retorna true si NO es administrador (mostrar opción limitada para no admins).
function mostrarOpcionLimitada(esAdmin) {
return !esAdmin;
}
module.exports = {
resultadoAnd,
resultadoOr,
resultadoNot,
puedeVerListaUsuarios,
puedeAcceder,
mostrarOpcionLimitada,
};

Done!
function resultadoAnd(a, b) {
return a && b;
}
// --- Reto 2: OR (||) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a || b (true si al menos una es true).
function resultadoOr(a, b) {
return a || b;
}
// --- Reto 3: NOT (!) ---
// Recibe un booleano "val".
// Retorna el resultado de !val (invierte: true → false, false → true).
function resultadoNot(val) {
return !val;
}
// --- Reto 4: Validación con AND (ambas condiciones) ---
// Recibe "esAdmin" y "estaActivo" (booleanos).
// Retorna true solo si es administrador Y está activo (puede ver la lista de usuarios).
function puedeVerListaUsuarios(esAdmin, estaActivo) {
return esAdmin && estaActivo;
}
// --- Reto 5: Validación con OR (al menos una condición) ---
// Recibe "esUsuarioValido" y "tienePermisoEspecial" (booleanos).
// Retorna true si cumple cualquiera de las dos condiciones (puede acceder).
function puedeAcceder(esUsuarioValido, tienePermisoEspecial) {
return esUsuarioValido || tienePermisoEspecial;
}
// --- Reto 6: Validación con NOT (negar condición) ---
// Recibe "esAdmin" (booleano).
// Retorna true si NO es administrador (mostrar opción limitada para no admins).
function mostrarOpcionLimitada(esAdmin) {
return !esAdmin;
}

Mi solución al reto:
// ============================================
// Reto: Operadores lógicos AND, OR y NOT en JavaScript
// ============================================
// Practica AND (&&), OR (||) y NOT (!) para combinar, evaluar y negar condiciones.
// Útil para validaciones, permisos (admin, usuario activo) y flujos de decisión.
// Ejecuta los tests con: npx vitest src/08-logic
// ============================================
// --- Reto 1: AND (&&) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a && b (true solo si ambas son true).
function resultadoAnd(a, b) {
// Tu código aquí
return a && b;
}
console.log(resultadoAnd(true,false));
// --- Reto 2: OR (||) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a || b (true si al menos una es true).
function resultadoOr(a, b) {
// Tu código aquí
return a || b;
}
console.log(resultadoOr(false,false));
// --- Reto 3: NOT (!) ---
// Recibe un booleano "val".
// Retorna el resultado de !val (invierte: true → false, false → true).
function resultadoNot(val) {
// Tu código aquí
return !val;
}
console.log(resultadoNot(false));
// --- Reto 4: Validación con AND (ambas condiciones) ---
// Recibe "esAdmin" y "estaActivo" (booleanos).
// Retorna true solo si es administrador Y está activo (puede ver la lista de usuarios).
function puedeVerListaUsuarios(esAdmin, estaActivo) {
// Tu código aquí
if (esAdmin && estaActivo === true) {
return "Puede ver la lista de usuarios"
}
else {
return "No puede ver la lista de usuarios"
}
}
console.log(puedeVerListaUsuarios(true,false));
// --- Reto 5: Validación con OR (al menos una condición) ---
// Recibe "esUsuarioValido" y "tienePermisoEspecial" (booleanos).
// Retorna true si cumple cualquiera de las dos condiciones (puede acceder).
function puedeAcceder(esUsuarioValido, tienePermisoEspecial) {
// Tu código aquí
if (esUsuarioValido || tienePermisoEspecial == true) {
return "Puede acceder"
}
else {
return "No puede acceder"
}
}
console.log(puedeAcceder(false,false));
// --- Reto 6: Validación con NOT (negar condición) ---
// Recibe "esAdmin" (booleano).
// Retorna true si NO es administrador (mostrar opción limitada para no admins).
function mostrarOpcionLimitada(esAdmin) {
// Tu código aquí
if (!esAdmin == true) {
return "Opción limitada para administradores"
}
else {
return "Ingreso administradores"
}
}
console.log(mostrarOpcionLimitada(false));
module.exports = {
resultadoAnd,
resultadoOr,
resultadoNot,
puedeVerListaUsuarios,
puedeAcceder,
mostrarOpcionLimitada,
};
// ============================================
// Reto: Operadores lógicos AND, OR y NOT en JavaScript
// ============================================
// Practica AND (&&), OR (||) y NOT (!) para combinar, evaluar y negar condiciones.
// Útil para validaciones, permisos (admin, usuario activo) y flujos de decisión.
// Ejecuta los tests con: npx vitest src/08-logic
// ============================================
// --- Reto 1: AND (&&) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a && b (true solo si ambas son true).
function resultadoAnd(a, b) {
// Tu código aquí
return (a && b)
}
console.log(resultadoAnd(true, true));
// --- Reto 2: OR (||) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a || b (true si al menos una es true).
function resultadoOr(a, b) {
// Tu código aquí
return (a || b)
}
console.log(resultadoOr(true,false))
// --- Reto 3: NOT (!) ---
// Recibe un booleano "val".
// Retorna el resultado de !val (invierte: true → false, false → true).
function resultadoNot(val) {
// Tu código aquí
return !val
}
console.log(resultadoNot(false));
// --- Reto 4: Validación con AND (ambas condiciones) ---
// Recibe "esAdmin" y "estaActivo" (booleanos).
// Retorna true solo si es administrador Y está activo (puede ver la lista de usuarios).
function puedeVerListaUsuarios(esAdmin, estaActivo) {
// Tu código aquí
return (esAdmin && estaActivo)
}
console.log(puedeVerListaUsuarios(true, true));
// --- Reto 5: Validación con OR (al menos una condición) ---
// Recibe "esUsuarioValido" y "tienePermisoEspecial" (booleanos).
// Retorna true si cumple cualquiera de las dos condiciones (puede acceder).
function puedeAcceder(esUsuarioValido, tienePermisoEspecial) {
// Tu código aquí
return esUsuarioValido || tienePermisoEspecial
}
console.log(puedeAcceder(true, false));
// --- Reto 6: Validación con NOT (negar condición) ---
// Recibe "esAdmin" (booleano).
// Retorna true si NO es administrador (mostrar opción limitada para no admins).
function mostrarOpcionLimitada(esAdmin) {
// Tu código aquí
return !esAdmin
}
console.log(mostrarOpcionLimitada(false));
module.exports = {
resultadoAnd,
resultadoOr,
resultadoNot,
puedeVerListaUsuarios,
puedeAcceder,
mostrarOpcionLimitada,
};
Mi resultado, por cierto me encanta el tema que usa el profesor en VS code:
// ============================================
// Reto: Operadores lógicos AND, OR y NOT en JavaScript
// ============================================
// Practica AND (&&), OR (||) y NOT (!) para combinar, evaluar y negar condiciones.
// Útil para validaciones, permisos (admin, usuario activo) y flujos de decisión.
// Ejecuta los tests con: npx vitest src/08-logic
// ============================================
// --- Reto 1: AND (&&) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a && b (true solo si ambas son true).
function resultadoAnd(a, b) {
return a && b;
}
// --- Reto 2: OR (||) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a || b (true si al menos una es true).
function resultadoOr(a, b) {
return a || b;
}
// --- Reto 3: NOT (!) ---
// Recibe un booleano "val".
// Retorna el resultado de !val (invierte: true → false, false → true).
function resultadoNot(val) {
return !val;
}
// --- Reto 4: Validación con AND (ambas condiciones) ---
// Recibe "esAdmin" y "estaActivo" (booleanos).
// Retorna true solo si es administrador Y está activo (puede ver la lista de usuarios).
function puedeVerListaUsuarios(esAdmin, estaActivo) {
return esAdmin && estaActivo;
}
// --- Reto 5: Validación con OR (al menos una condición) ---
// Recibe "esUsuarioValido" y "tienePermisoEspecial" (booleanos).
// Retorna true si cumple cualquiera de las dos condiciones (puede acceder).
function puedeAcceder(esUsuarioValido, tienePermisoEspecial) {
return esUsuarioValido || tienePermisoEspecial;
}
// --- Reto 6: Validación con NOT (negar condición) ---
// Recibe "esAdmin" (booleano).
// Retorna true si NO es administrador (mostrar opción limitada para no admins).
function mostrarOpcionLimitada(esAdmin) {
return !esAdmin;
}
export {
resultadoAnd,
resultadoOr,
resultadoNot,
puedeVerListaUsuarios,
puedeAcceder,
mostrarOpcionLimitada,
};
Mi solución:
// ============================================
// Reto: Operadores lógicos AND, OR y NOT en JavaScript
// ============================================
// Practica AND (&&), OR (||) y NOT (!) para combinar, evaluar y negar condiciones.
// Útil para validaciones, permisos (admin, usuario activo) y flujos de decisión.
// Ejecuta los tests con: npx vitest src/08-logic
// ============================================
// --- Reto 1: AND (&&) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a && b (true solo si ambas son true).
function resultadoAnd(a, b) {
// Tu código aquí
return a && b;
}
// --- Reto 2: OR (||) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a || b (true si al menos una es true).
function resultadoOr(a, b) {
// Tu código aquí
return a || b;
}
// --- Reto 3: NOT (!) ---
// Recibe un booleano "val".
// Retorna el resultado de !val (invierte: true → false, false → true).
function resultadoNot(val) {
// Tu código aquí
return !val;
}
// --- Reto 4: Validación con AND (ambas condiciones) ---
// Recibe "esAdmin" y "estaActivo" (booleanos).
// Retorna true solo si es administrador Y está activo (puede ver la lista de usuarios).
function puedeVerListaUsuarios(esAdmin, estaActivo) {
// Tu código aquí
return esAdmin && estaActivo;
}
// --- Reto 5: Validación con OR (al menos una condición) ---
// Recibe "esUsuarioValido" y "tienePermisoEspecial" (booleanos).
// Retorna true si cumple cualquiera de las dos condiciones (puede acceder).
function puedeAcceder(esUsuarioValido, tienePermisoEspecial) {
// Tu código aquí
return esUsuarioValido || tienePermisoEspecial;
}
// --- Reto 6: Validación con NOT (negar condición) ---
// Recibe "esAdmin" (booleano).
// Retorna true si NO es administrador (mostrar opción limitada para no admins).
function mostrarOpcionLimitada(esAdmin) {
// Tu código aquí
return !esAdmin;
}
module.exports = {
resultadoAnd,
resultadoOr,
resultadoNot,
puedeVerListaUsuarios,
puedeAcceder,
mostrarOpcionLimitada,
};
Todos los tests pasaron en verde 💚

Comparto el código que hice para este ejercicio
// ============================================
// Reto: Operadores lógicos AND, OR y NOT en JavaScript
// ============================================
// Practica AND (&&), OR (||) y NOT (!) para combinar, evaluar y negar condiciones.
// Útil para validaciones, permisos (admin, usuario activo) y flujos de decisión.
// Ejecuta los tests con: npx vitest src/08-logic
// ============================================
// --- Reto 1: AND (&&) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a && b (true solo si ambas son true).
function resultadoAnd(a, b) {
// Tu código aquí
return a&&b;
}
console.log(resultadoAnd(true,true));
// --- Reto 2: OR (||) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a || b (true si al menos una es true).
function resultadoOr(a, b) {
// Tu código aquí
return a||b;
}
console.log(resultadoOr(false,false));
// --- Reto 3: NOT (!) ---
// Recibe un booleano "val".
// Retorna el resultado de !val (invierte: true → false, false → true).
function resultadoNot(val) {
// Tu código aquí
return !val;
}
console.log(resultadoNot(true));
// --- Reto 4: Validación con AND (ambas condiciones) ---
// Recibe "esAdmin" y "estaActivo" (booleanos).
// Retorna true solo si es administrador Y está activo (puede ver la lista de usuarios).
function puedeVerListaUsuarios(esAdmin, estaActivo) {
// Tu código aquí
return (esAdmin && estaActivo);
}
console.log(puedeVerListaUsuarios(true,true));
// --- Reto 5: Validación con OR (al menos una condición) ---
// Recibe "esUsuarioValido" y "tienePermisoEspecial" (booleanos).
// Retorna true si cumple cualquiera de las dos condiciones (puede acceder).
function puedeAcceder(esUsuarioValido, tienePermisoEspecial) {
// Tu código aquí
return esUsuarioValido||tienePermisoEspecial;
}
console.log(puedeAcceder(true,false));
// --- Reto 6: Validación con NOT (negar condición) ---
// Recibe "esAdmin" (booleano).
// Retorna true si NO es administrador (mostrar opción limitada para no admins).
function mostrarOpcionLimitada(esAdmin) {
// Tu código aquí
return !esAdmin;
}
console.log(mostrarOpcionLimitada(false));
module.exports = {
resultadoAnd,
resultadoOr,
resultadoNot,
puedeVerListaUsuarios,
puedeAcceder,
mostrarOpcionLimitada,
};
// ============================================
// Reto: Operadores lógicos AND, OR y NOT en JavaScript
// ============================================
// Practica AND (&&), OR (||) y NOT (!) para combinar, evaluar y negar condiciones.
// Útil para validaciones, permisos (admin, usuario activo) y flujos de decisión.
// Ejecuta los tests con: npx vitest src/08-logic
// ============================================
// --- Reto 1: AND (&&) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a && b (true solo si ambas son true).
function resultadoAnd(a, b) {
// Tu código aquí
return a&&b;
}
console.log(resultadoAnd(true,true));
// --- Reto 2: OR (||) ---
// Recibe dos booleanos "a" y "b".
// Retorna el resultado de a || b (true si al menos una es true).
function resultadoOr(a, b) {
// Tu código aquí
return a||b;
}
console.log(resultadoOr(false,false));
// --- Reto 3: NOT (!) ---
// Recibe un booleano "val".
// Retorna el resultado de !val (invierte: true → false, false → true).
function resultadoNot(val) {
// Tu código aquí
return !val;
}
console.log(resultadoNot(true));
// --- Reto 4: Validación con AND (ambas condiciones) ---
// Recibe "esAdmin" y "estaActivo" (booleanos).
// Retorna true solo si es administrador Y está activo (puede ver la lista de usuarios).
function puedeVerListaUsuarios(esAdmin, estaActivo) {
// Tu código aquí
return (esAdmin && estaActivo);
}
console.log(puedeVerListaUsuarios(true,true));
// --- Reto 5: Validación con OR (al menos una condición) ---
// Recibe "esUsuarioValido" y "tienePermisoEspecial" (booleanos).
// Retorna true si cumple cualquiera de las dos condiciones (puede acceder).
function puedeAcceder(esUsuarioValido, tienePermisoEspecial) {
// Tu código aquí
return esUsuarioValido||tienePermisoEspecial;
}
console.log(puedeAcceder(true,false));
// --- Reto 6: Validación con NOT (negar condición) ---
// Recibe "esAdmin" (booleano).
// Retorna true si NO es administrador (mostrar opción limitada para no admins).
function mostrarOpcionLimitada(esAdmin) {
// Tu código aquí
return !esAdmin;
}
console.log(mostrarOpcionLimitada(false));
module.exports = {
resultadoAnd,
resultadoOr,
resultadoNot,
puedeVerListaUsuarios,
puedeAcceder,
mostrarOpcionLimitada,
};