No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Adquiere por un a帽o todos los cursos, escuelas y certificados por un precio especial.

Antes: $249

Currency
$219/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Comprar ahora

Termina en:

0D
18H
16M
54S

Valores: Truthy y Falsy

11/29
Recursos

Los valores truthy y falsy son valores verdaderos y falsos cuando se realiza una coerci贸n de cualquier tipo a booleano, respectivamente. Esto es importante para manejar condicionales, ya que una estructura condicional eval煤a si un valor es verdadero o falso en un contexto booleano.

Qu茅 son los valores falsy

Un valor falsy es aquel que es falso en un contexto booleano, estos son: 0, "" (string vac铆o), false, NaN, undefined o null.

// Coersi贸n expl铆cita
Boolean(0) // false
Boolean("") // false
Boolean(null) // false
Boolean(undefined) // false
Boolean(NaN) // false
Boolean(false) // false

Tambi茅n puedes realizar una coerci贸n impl铆cita con el operador de negaci贸n (!), pero solo es para que la conozcas, no es recomendable.

// Coersi贸n impl铆cita (no la uses)
!!0 // false
!!"" // false
!!null // false
!!undefined // false
!!NaN // false
!!false // false

Qu茅 son los valores truthy

Un valor truthy es aquel que es verdadero en un contexto booleano, son todos los valores que no sean falsy, que especificamos en la anterior secci贸n.

// Coersi贸n expl铆cita
Boolean(12) // true
Boolean("hola") // true
Boolean(true) // true
Boolean([1, 2, 3]) // true
Boolean(function hola() {}) // true
Boolean({ a: 1, b: 2 }) // true

Cabe recalcar que en JavaScript todo valor que no sea falsy es truthy incluyendo las estructuras vac铆as de array y objetos.

Boolean([]) // true
Boolean({}) // true

Contribuci贸n creada por Andr茅s Guano (Platzi Contributor).

Aportes 297

Preguntas 15

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

//Ejemplos en los que Boolean devuelve Falso:
Boolean(0); //false
Boolean(null); //false
Boolean(NaN); //false
Boolean(undefined); //false
Boolean(false); //false
Boolean(""); //false

//Ejemplos en los que Boolean devuelve verdadero:
Boolean(1); //true para 1 o cualquier n煤mero diferente de cero (0)
Boolean("a"); //true para cualquier caracter o espacio en blanco en el string
Boolean([]); //true aunque el array est茅 vac铆o
Boolean({}); //true aunque el objeto est茅 vac铆o
Boolean(function(){}); //Cualquier funci贸n es verdadera tambi茅n

驴Que tipos por default son verdaderos y falsos?

Usamos la funci贸n de JS que es Boolean() dentro del par茅ntesis ponemos el valor y nos dice si el mismo el False o True.

鈥> Falsy

  • Boolean() 鈥> sin ningun valor es false
  • Boolean(0) 鈥> false
  • Boolean(null) 鈥> false
  • Boolean(NaN) 鈥> false // NaN es Not and Number
  • Boolean(Undefined) 鈥> false
  • Boolean(false) 鈥> false
  • Boolean("") 鈥> false

鈥> Truthy

  • Boolean(1) 鈥> true //cualquier numero que no sea igual a cero es true
  • Boolean(鈥渁鈥) 鈥> true
  • Boolean(" ") 鈥> true // siendo un espacio el valor es true
  • Boolean([]) 鈥> true // un array nos da un true
  • Boolean({}) 鈥> true // un objeto nos da el valor de true
  • Boolean(function() {}) 鈥> true //una funcion tambien es true
  • Boolean(true) 鈥> true

Todo esto lo vamos a usar en condiciones esto valida si es verdadero o falso para ejecutar cierta acci贸n.

Enlaces a documentaci贸n en mozilla de Truthy y Falsy:
https://developer.mozilla.org/es/docs/Glossary/Falsy
https://developer.mozilla.org/es/docs/Glossary/Truthy

Si escribes

Boolean("false")

Este devuelve true

En este punto me gustar铆a dejar la definici贸n de varios tipos de datos raros que tiene JS por si a煤n no se han entendido bien:

  1. NaN: En JS significa Not a Number y quiere decir que esa operaci贸n necesita de dos n煤meros o m谩s para poder operarse.
  2. Undefined: Undefined es un valor especial de JavaScript que existe cuando no se le asigna un valor a una variable. Es decir, la variable si existe o ha sido creada pero no se le ha asignado ning煤n valor. (Su valor es indefinido).
  3. Null: null es cuando algo no existe. (De plano no existe para nada y ya esta). 馃槃

Espero les haya servido para quienes a煤n ten铆an dudas con estos valores. 馃槈

creo que esta es una de las clases que evita muchos errores

Que tipo de valor es verdadero y faso?

Que tipos por default son verdaderos y falsos

La siguiente lista daremos ejemplos

usamos la funcion de JS que es Boolean() dentro del p脿rentesis ponemos el valor

Boolean() 鈥> sin ningun valor es false
Boolean(0) 鈥> false
Boolean(null) 鈥> false
Boolean(NaN) 鈥> false // NaN es Not and Number
Boolean(Undefined) 鈥> false
Boolean(false) 鈥> false
Boolean(鈥") 鈥> false

Boolean(1) 鈥> true //cualquier numero que no sea igual a cero es true
Boolean(鈥渁") 鈥> true
Boolean(鈥 ") 鈥> true // siendo un espacio el valor es true
Boolean([]) 鈥> true // un array nos da un true
Boolean({}) 鈥> true // un objeto nos da el valor de true
Boolean(function() {}) 鈥> true //una funcion tambien es true
Boolean(true) 鈥> true

Todo esto lo vamos a ucupar en condiciones esto valida si es verdadero o falso para ejecutar cierta acci贸n

https://developer.mozilla.org/es/docs/Glossary/Falsy
https://developer.mozilla.org/es/docs/Glossary/Truthy

Truthy and Falsy
Hay varios tipos de valores que son falsos
  => Boolean(0) -> False
  => Boolean(null) -> False
  => Boolean(undefined) -> False
  => Boolean(NaN) -> False
  => Boolean(false) -> False
  => Boolean("") -> False

Lista de verdaderos
 => Boolean(1) -> True
 => Boolean("a") -> True
 => Boolean([]) -> True
 => Boolean({}) -> True
 => Boolean(function(){}) -> True
 => Boolean(true) -> True

Lo utilizamos bastabte en el curso de React js

驴Por que 0 es false y cualquier otro numero es true?
Cuando se trabaja en una computadora, los datos son convertidos en n煤meros d铆gitos que, a su vez, son representados como pulsaciones o pulsos electr贸nicos.

En la actualidad para comunicarnos, expresarnos y guardar nuestra informaci贸n, usamos el sistema de numeraci贸n decimal y el alfabeto, seg煤n se trate de valores num茅ricos o de texto. Una computadora como funciona con electricidad, reconoce dos clases de mensajes: cuando hay corriente el茅ctrica el mensaje es s铆 y cuando no hay corriente, el mensaje es no. Para representar un valor dentro de una computadora se usa el sistema de numeraci贸n binario, que utiliza s贸lo dos d铆gitos: el cero (0) y el uno (1).

En el MDN se pueden encontrar los valores, dejo los enlaces:

Para los que no son tan avanzados (como yo) destaco que los n煤meros negativos tambi茅n son verdaderos.

Dato curioso, si escribimos Boolean(鈥渇alse鈥) devuelve true, quiere decir que cualquier string que no est茅 vac铆o es true

Otra forma de convertir un valor a tipo booleano es utilizando dos veces el operador l贸gico de negaci贸n ( ! ) .
El operador de negaci贸n transforma el valor a tipo booleano y retorna el valor booleano contrario. Ejemplo

var n1 = !true;  	// devuelve false
var n2 = !false; 	// devuelve true
var n3 = !'Cat'; 	// devuelve false
var n3 = !'';		// devuelve true
var n5 = !1;		// devuelve false
var n6 = !0;		// devuelve true

Pero si utilizamos dos veces el operador de negaci贸n (!!) nos retornara el valor booleano inicial.

var n1 = !!true;  	// devuelve true
var n2 = !!false; 	// devuelve false
var n3 = !!'Cat'; 	// devuelve true
var n4 = !!'';		// devuelve false
var n5 = !!1;		// devuelve true
var n6 = !!0;		// devuelve false
En JS todos los valores son verdaderos por defecto, a menos que los definamos como falsos con alguno de los siguientes valores:
  • false.
  • 鈥溾 Un string vacio
  • null
  • NaN
  • undefined

Si quieres saber si un valor es verdadero o falso utiliza la funci贸n Boolean(El valor que vas a evaluar);

Valores FALSY

- 0 es      FALSY/FALSO     Boolean(0)
- null es   FALSY/FALSO     Boolean(null)
- NaN es    FALSY/FALSO     Boolean(NaN)
- undefined FALSY/FALSO     Boolean(undefined)
- false     FALSY/FALSO     Boolean(false)
- ""        FALSY/FALSO     Boolean("")

Valores THRUTHY

- Cualquier cadena no vacia                 THRUTHY     Boolean("hola")
- " " (El espacio tambien cuenta como true) THRUTHY     Boolean(" ")
- N煤meros mayores a 0                       THRUTHY     Boolean(22)
- Un Arreglo                                THRUTHY     Boolean([])
- Un Objeto                                 THRUTHY     Boolean({})
- Cualquier funcion                         THRUTHY     Boolean(function(){})
- True                                      THRUTHY     Boolean(true)
//falsy
console.log(Boolean(0))
console.log(Boolean(null))
console.log(Boolean(NaN)) //not a number
console.log(Boolean(undefined)) //not value yet
console.log(Boolean(false))
console.log(Boolean("")) //empty string

//truthly
console.log(Boolean(" ")) //string con algo
console.log(Boolean("a"))
console.log(Boolean(1)) //any number 
console.log(Boolean({})) //arrays, even if they are empty
console.log(Boolean(function(){})) //functions, even if they are empty

Hay un total de 6 valores / expresiones falsas en javascript.

  • boolean 鈥榝alse鈥

  • Cadena vac铆a es decir 鈥樷"

  • undefined Cualquier variable undefined ser谩 igual a false.

  • null Cualquier variable null ser谩 igual a false.

  • NaN Cualquier expresi贸n num茅rica con resultado en NaN(no un n煤mero) ser谩 igual a false.

  • N煤mero cero 0: Cualquier expresi贸n num茅rica con resultado en cero ser谩 igual a false.

Recuerden siempre colocar Boolean con B mayuscula ya que sino genera error.

Lo comento porque me acabo de percatar y nadie lo mencion贸.

Saludos

隆Hola a todos! Les comparto mis notas de esta clase, espero les sean de utilidad 馃槂

Ac谩 est谩 todo el glosario de los valores Truthy y Falsy. Para repasar 馃槈

Me encanta que tanto en Javascript como en Python, el tipo de dato de NaN es un n煤mero. Si haces typeof(NaN) te devuelve "Number". I guess not a number is still a number. Me hace mucha gracia.

En el caso de hacer una consulta en MySQL con node y no trae nada mysql retorna NULL, esto se interpreta como FALSE

Valores que dan False
0
null
undefined
NaN
false
String vacio
Valores que dan True
Funciones
Strings
1 o mas
Arrays
Objetos
true

NO olvidar NaN = not a number

Les comparto mis apuntes

馃摝 Cualquier valor tiene un valor booleano inherente, conocido como truthy o falsy.

//Valores que regresan false
Boolean(null);
Boolean(undefined);
Boolean(0);
Boolean(NaN);
Boolean("");

//Valores que regresan true
Boolean("a");//Si tiene ya una letra, entonces es true
Boolean(1);//Cualquier tipo de num茅ro excepto 0, es true
Boolean([]);//Si es array vacio o no, es true
Boolean({});//Si existe un objeto vacio o no, es true
Boolean(function(){});//Cualquier tipo de funci贸n, es true
Boolean(-1);//N煤meros negativos son true

Excelente clase, siempre es bueno ver cursos b谩sicos. Esta clase me fue muy util!

Excelente aprender desde un inicio como trabaja Javascript con los True y False.
Excelente explicaci贸n Teacher Diego 馃槃

En JavaScript, un valor verdadero es un valor que se considera true/verdadero cuando es evaluado en un contexto Booleano. Todos los valores son verdaderos a menos que se definan como falso (es decir, excepto false, 0, 鈥溾, null, undefined, y NaN).

n煤meros negativos tambi茅n son true

    // Es Falso
    Boolean();

    // Es Falso
    Boolean(0);

    // Es Falso
    Boolean(null);

    // Es Falso
    Boolean(NaN);

    // Es Falso
    Boolean(undefined);

    // Es Falso
    Boolean(false);

    // Es Falso
    Boolean("");

    // Es Verdadero
    Boolean(1);

    // Es Verdadero
    Boolean(" ");

    // Es Verdadero
    Boolean("a");

    // Es Verdadero
    Boolean(1);

    // Es Verdadero
    Boolean([]);

    // Es Verdadero
    Boolean({});

    // Es Verdadero
    Boolean(function(){});

    // Es Verdadero
    Boolean(true);

Estas son mis notas de clase

<// Estos son los valores que son falsos por default
Boolean();
Boolean(0);
Boolean(undefined);
Boolean(!5);
Boolean(NaN);
Boolean(null);

// A continuaci'on pondremos ejemplos de tipos de datos que en particular son verdaderos.Vale saber que cualquier afirmaci'on o tipo de dato que sea diferente a los falsos son verdaderos.
Boolean(1);
Boolean([]); // todos los arrays son verdaderos aunque est'en vacios
Boolean({}); // todos los objetos son verdaderos aunque esten vacios
Boolean("a"); // Todo valor de string que este ocupando un espacio entre las comillas del string es verdadero 
Boolean(function(){}); // Las funciones son siempre verdaderas> 

Vamos a tener dos tipos de valores, true y false.
Los valores falsos ser谩n aquellos que tengan un valor igual a cero o que por defecto sean valores que sean asumidos como no existentes (Null, False, NaN, Undefined, 鈥溾)
Los valores verdaderos son aquellos que sean igual o mayor a uno, o que tambi茅n tengan contenido dentro de si (鈥渁鈥, {}, [], Function(){}, true)

Mi resumen de la clase

馃コ

馃摡

  • Es falso cuando es falso, o no definido
  • Es verdadero cuando es verdadero, o esta definido

Existe una serie de valores que por defecto son verdaderos y otros falsos, y para utilizarlos en diferentes algoritmos se debe saber cu谩les son por defecto.

// valores falsos por defecto:
Boolean(0); // false
Boolean(null); // false
Boolean(NaN); // false "Not a Number"
Boolean(undefined); // false
Boolean(false); // false
Boolean(""); // false "string vacio" 

// valores verdaderos por defecto:
Boolean("a"); // true  -> un caracter puede ser un espacio en blanco
Boolean(1); // true -> cualquier numero de 1 en adelante
Boolean([]); // true -> un array asi est茅 vacio
Boolean({}); // true -> un objeto asi est茅 vacio
Boolean(function(){}); // true -> cualquier funci贸n es verdadera
Boolean(true); // true

Una cosa extra que no se mecion贸: los n煤meros negativos tambi茅n son valores verdaderos

Ejemplos: Truthy y Falsy.

(鈱愨枲_鈻)

TRUTHY: Un valor que se considera " true/Verdadero " es verdadero cuando es evaluado desde el contexto booleano, todos los valores son verdaderos a menos que se definan como falsos, hay unas excepciones

FALSY: son las excepciones, los 煤nicos valores que por defecto son falsos son:

  • False
  • cero 0
  • " "
  • Null
  • Undefinded
  • NaN

Para el caso de los numeros Boolean(0) es falso. Es true cualquier numero incluyendo los negativos Boolean(-5).

En este sitio hay una explicaci贸n muy buena: (https://arielfuggini.com/javascript-valores-truthy-falsy/)

la clase fue genial, tambi茅n acabo de descubrir que Boolean(鈥0n鈥) resulta false. Pru茅balo!!

Existen tipos de valores que son verdaderos: Truthy. Y valos que son falsos: Falsy.
Esto son servir谩 cuando empecemos a generar condiciones o funciones en Javascript, esto nos ayudar谩 a validar si estas condiciones son verdaderas o falsas en ciertas acciones.

//argumento explicito
var a = Boolean(false);
var b = Boolean(true);
console.log(a); //false
console.log(b); //true

//argumento vacio
var a = Boolean();
var b = Boolean("");
console.log(a); //false
console.log(b); //false

//argumento no vacio
var a = Boolean(" ");
var b = Boolean([]);
var c = Boolean({});
var d = Boolean(function(){});
console.log(a); //true
console.log(b); //true
console.log(c); //true
console.log(d); //true

//argumento numerico
var a = Boolean(0);
var b = Boolean(1);
var c = Boolean(2);
var d = Boolean(-1);
console.log(a); //false
console.log(b); //true
console.log(c); //true
console.log(d); //true

//argumento null || undefined || NaN
var a = Boolean(null);
var b = Boolean(undefined);
var c = Boolean(NaN);
console.log(a); //false
console.log(b); //false
console.log(c); //false

Otros casos en que tambi茅n se debe tener cuidado:

Boolean(true - true); // false
Boolean(false + 1); // true

Aqui hay tablas de la verdad que tiene que ver con los booleanos, te ayuda a saber como usarlos y que te va a regresar 馃槃

considerar que los numeros negativos tambi茅n son true.

Thursty y Falsy

Valores que por defecto son verdaderos y cuales son falsos.
Por ejemplo:

Para Valores Falsy por defecto

    Boolean(0); //False
    Boolean(null);/False
	Boolean(NaN);//False not a number
	Boolean(undefined); //False
	Boolean(false); //Fase
	Boolean(""); //False
    

Para Valores Thursty

    Boolean("a"); //True - string con 1 caracter
    Boolean(1);/True Cualquie # dif a cero
	Boolean([]);//True arreglo
	Boolean({}); //True objeto
	Boolean(function()); //True cualquier funci贸n
	Boolean(true); //True    

Apuntes completos en Notion

0, false, null, undefine, NaN o vacio = Falso
1, true, valor cualquiera, array, funci贸n u objeto = True

Esto es muy importante para condicionales, y luego con esos true o false las tablas de valores son lo siguiente a aprender para dominar los condicionales-

Boolean (); = false
Boolean (0); = false
Boolean (null); = false
Boolean (NaN); = false
Boolean (undefined); = false
Boolean (false); = false
Boolean (""); = false
Boolean (1); = true
Boolean (鈥渁鈥); = true
Boolean ({}); = true
Boolean (function {} ); = true
Boolean (true); = true

boolean ( '") ; // falselo unico que sumaria a los aportes de mis compa帽eros es que hay que tener cuidado con el espacio en las comillas por que suman valor y cambia el boolean a 鈥渢rue鈥

De acuerdo MDN Web Docs, Boolean Object es un contenedor de objetos para valores boleanos.

Donde Boolean() retornara un valor false para los valores de 0, - 0, false, null, undefined, 鈥溾, NaN.

Algunos caracteres como [], o incluso una cadena de texto 鈥渇alse鈥 obtendre un retorno de un true al usar Boolean().

Tomando el aporte de Edison Arteaga y ampliandolo:

//algunos resultados false

Boolean(false + false)
false

Boolean(0 + 0)
false

Boolean(true - true)
false

Boolean(false - false)
false


Boolean(false * false)
false

Boolean(true * false)
false

Boolean(false / true)
false

Boolean(false / false)
false


//algunos resultados true

Boolean(0 + 1)
true

Boolean(false + 1)
true

Boolean(true - false)
true

Boolean(false - 1)
true

Boolean(true * true)
true

Boolean(true / true)
true

Aporto mi apuntes con algunos mas que intent茅

Boolean(null); //false
Boolean(NaN); //false - nan es un valor que no es un n煤mero
Boolean(undefined); //false
Boolean(""); //false
Boolean(0); //false
Boolean(0.0); //false
Boolean(0+0); //false
Boolean(false); //false

Boolean(" "); //true
Boolean("hola"); //true
Boolean(1); //true
Boolean(-1); //true - todo valor que no sea 0 es verdadero
Boolean(0.1); //true
Boolean([]); //true
Boolean({}); //true
Boolean(function(){}); //true
Boolean(true); //true

Estos Booleanos son TODOS FALSOS!
0
Null
NaN
Undefined
false
"" (y comillas, pero OJO!, sin espacio entre ellas unicamente seria falso.)

Boolean(-0) da false 馃槀

Los valores bol茅anos pueden parecer poco 煤tiles cuando comenzamos, pero apenas lleguemos a funciones o ciclos van a ser como nuestros mejores amigos, 隆no lo olvides!

Boolean( expr ); // true or false

Cualquier expresi贸n que le pases a la funci贸n Boolean , javascript te dir谩 si esa expresi贸n es Verdadera o Falsa.

NaN // Not a Number

De a poco aprendiendo!!

// Valores Truthy
"a"
1
Infinity
-Infinity
[]
{}
function() {}
true


// Valores Falsy
""
0
null
undefined
NaN
false

The following values are always falsy:

false
0 (zero)
鈥欌 or 鈥溾 (empty string)
null
undefined
NaN

Everything else is truthy. That includes:

鈥0鈥 (a string containing a single zero)
鈥榝alse鈥 (a string containing the text 鈥渇alse鈥)
[] (an empty array)
{} (an empty object)
function(){} (an 鈥渆mpty鈥 function)

//Valores Falsy
Boolean();
0
null
NaN
undefined
false
""

//Valores Truthy
1
"c"
true
{}
[]
function(){}


Sobre los tipos de valores:

var numV = 1; // true, valores mayor a 0 son verdaderos
var numF = 0; // false, el valor 0 es falso
var stringV = 'Hola no estoy vacio'; // true, strings no vac铆os son verdaderos
var stringF = ''; // false, strings vac铆os son falso;

var miFuncion = function() { return false; }
console.log( Boolean( miFuncion ) ); // true, es verdadero porque le pasamos referencia de la funci贸n
console.log( Boolean( miFuncion() ) ); // false, debido a que accionamos la funci贸n y esta regresa falso;

Boolean( {} ); // true, objetos vac铆os son verdadero (depende la circunstanc铆a o m茅todo)
Boolean( [] ); // true, los arreglos vac铆os son verdadero (depende la circunstanc铆a o m茅todo)

Boolean( undefined ); // false
Boolean( null ); // false

Acerca de las funciones鈥 verdadero debido a que le est谩s pasando la referencia de la funci贸n (sin su ejecuci贸n) lo cual regresa verdadero porque el valor de tipo es function lo cual no es igual a falso, sin embargo si t煤 usas 鈥渦ndefined鈥 o 鈥渘ull鈥 regresar谩 falso. Ahora cabe destacar que la referencia de la funci贸n no es igual a la ejecuci贸n de la funci贸n, la acci贸n que est谩s haciendo es declararla y pasar como referencia y por lo tanto es verdadero, pero si tu ejecutas la funci贸n regresara falso del return:

var nombre = () => {
  return false;
};

console.log( nombre ); // function nombre() { return false; } --- osea su referencia
console.log( nombre() ); // false --- osea su ejecuci贸n

console.log( Boolean( nombre ) ); // Verdadero porque le estamos pasando la referencia
console.log( Boolean( nombre() ) ); // Falso porque ejecutamos el c贸digo dentro de la funci贸n

Espero que as铆 puedas entender mejor el porqu茅 es verdadero, igual puedes probar el c贸digo en tu consola.

Es s煤per f谩cil, pero se entiende m谩s cuando se hacen condicionales!

Clase sencilla y facil de comprender

los numeros negativos son true.

estupendo

Truthy and falsy

Se usan cuando tenemos que validar cuando algo es verdadero o falso

Boolean - true or false

Ejemplos valores que por default nos regresan negativo

boolean(0);

boolean(NaN);

Ejemplos valores que por default nos regresan positivo

boolean(1);

boolean(鈥渁鈥);

En conclusi贸n Truthy y Falsy, son los valores inherentes booleanos que tienen impl铆citos todos los valores, esto con el objetivo de que JavaScript pueda identificar cuando en un condicional se use un valor diferente al booleano y pueda saber si es true o false ,para ejecutar alg煤n tipo de instrucci贸n.

NaN = Not a Number

Si tenemos una variable, tambi茅n es verdadera o falso?

yo nunca pense que existia algo asi en JavaScript para cuestiones booleanas.

// Coersi贸n expl铆cita

Boolean(0) // false
Boolean("") // false
Boolean(null) // false
Boolean(undefined) // false
Boolean(NaN) // false
Boolean(false) // false

// Coersi贸n expl铆cita

Boolean(12) // true
Boolean("hola") // true
Boolean(true) // true
Boolean([1, 2, 3]) // true
Boolean(function hola() {}) // true
Boolean({ a: 1, b: 2 }) // true
typeof true
boolean
.
typeof false
boolean

Ya entiendo!, es por eso que muchas veces al preguntar en un if(variable) {} me determina si pasa o no pasa, comprueba si es verdad o no

El valor Trhuty or falsy , sirve para verificar los booleanos en la console list

no cualquier cadena de texto dentro de la funci贸n Boolean() se evaluar谩 como verdadera (true). La funci贸n Boolean() en JavaScript convierte un valor a su equivalente booleano. Los siguientes valores ser谩n evaluados como false:

false (booleano falso)
0 (n煤mero cero)
"" o 鈥樷 (cadena de texto vac铆a)
null (valor nulo)
undefined (valor no definido)
NaN (Not-a-Number)
Cualquier otro valor, incluyendo cualquier cadena de texto no vac铆a, ser谩 evaluado como true.

Ejemplos

var valor1 = "hello";
if (valor1) {
  console.log("Es truthy");
} else {
  console.log("Es falsy");
}

var valor2 = 0;
if (valor2) {
  console.log("Es truthy");
} else {
  console.log("Es falsy");
}

var valor3 = {};
if (valor3) {
  console.log("Es truthy");
} else {
  console.log("Es falsy");
}

var valor4 = null;
if (valor4) {
  console.log("Es truthy");
} else {
  console.log("Es falsy");
}

Boolean(0);//No hay valor por lo tanto es falso (0)
Boolean(1);//Su valor es verdadero
Boolean(NaN);//False
Boolean(undefined);//False
Boolean(鈥渁鈥);//True
Boolean({});//True
Boolean(function({}));//True
Boolean(true);//True

y ya entendido la parte de que es un valor verdadero y uno falso ya se podr铆an trabajar con los aperadores de l贸gica

var True = False;
bolean(True)

Estoy repasando el curso y siempre se aprende algo nuevo鈥

para saber si un n煤mero es par:

function isPairNumber(number){
    return !Boolean(number%2)
}

console.log(isPairNumber(25)) //false
console.log(isPairNumber(12)) //true

Incluso el -0.01 es true 馃槷

Comparto un screenshot a tener en cuenta para validar correctamente los arrays y objetos vac铆os.

11/30 Valores: Truthy y Falsy

Los valores truthy y falsy son valores verdadero y falsos en un contexto booleano.

Un valor falsy es aquel que es falso en un contexto booleano, incluyendo:

  • 0
  • 鈥 鈥 String vac铆o
  • false
  • NaN
  • undefined
  • null

Un valor truthy es cualquier valor que no sea falsy, incluyendo:

  • valores num茅ricos
  • Strings no vacios
  • true
  • arrays
  • objetos vacios.

Cabe destacar que en JavaScript todo valor que no sea falsy es truthy, incluso en las estructuras vac铆as de array y objetos.

Es importante conocer los valores falsy y truthy para manejar correctamente las condicionales.

Joder que buen profesor

testing bookmarks

Boolean();
false
Boolean(0);
false
Boolean(1);
true
Boolean({});
true
Boolean([]);
true
Boolean(null);
false
Boolean(NaN);
false
Boolean(undefined);
false
Boolean(function(){});
true
Boolean("");
false
Boolean(" ");
true