Valores: Truthy y Falsy

//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(“a”) —> 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(“a") —> 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:

• Falsy
• Truthy

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

Dato curioso, si escribimos Boolean(“false”) 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 ‘false’

• 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 😉

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

muy útil tambien el concepto de nullish
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator

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 (“a”, {}, [], 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 (“a”); = 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 “true”

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 “false” 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)
‘false’ (a string containing the text “false”)
[] (an empty array)
{} (an empty object)
function(){} (an “empty” 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 “undefined” o “null” 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(“a”);

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(“a”);//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