What Is Truthy and Falsy? How Is It Different from True and False

What is Truthy and Falsy? How is it different from True and False?

As the comments described, it just refers to values which are evaluated to True or False.

For instance, to see if a list is not empty, instead of checking like this:

if len(my_list) != 0:
   print("Not empty!")

You can simply do this:

if my_list:
   print("Not empty!")

This is because some values, such as empty lists, are considered False when evaluated for a boolean value. Non-empty lists are True.

Similarly for the integer 0, the empty string "", and so on, for False, and non-zero integers, non-empty strings, and so on, for True.

The idea of terms like "truthy" and "falsy" simply refer to those values which are considered True in cases like those described above, and those which are considered False.

For example, an empty list ([]) is considered "falsy", and a non-empty list (for example, [1]) is considered "truthy".

See also this section of the documentation.

What is the difference between truthy and falsy with true and false in JavaScript?

JavaScript likes to convert values to other types implicitly whenever possible. Because of that, when comparing booleans to other types of variables, JavaScript uses the same logic as older programming languages. A value that represents empty, null, or zero (such as 0, or "") evaluates to false, and any other value (such as 1, 5, -19, "ghsfsah", or other meaningful content) evaluates to true.

Why does it do this? Well for one it allows developers a small shortcut when checking to see if a variable has content. For example, if a user doesn't give input in a text field, we can easily check to see if a field is empty and prompt the user.

if ( !textfield.value ) {
    alert( "Please enter something in the text box" );
}

If you need to see if something is actually true or false, you can use ===.

Understanding JavaScript Truthy and Falsy

From my understanding, I believe that var a = 1; is the only truthy and the rest are falsy’s - is this correct?

No.

1. var a = 0;

   Number zero is falsy. However, note that the string zero "0" is truthy.

2. var a = 10 == 5;

   This is same as var a = (10 == 5);, so this is falsy.

3. var a = 1;

   var a = -1;

   Any non-zero number including negative numbers is truthy.

Quoting from MDN

In JavaScript, a truthy value is a value that translates to true when evaluated in a Boolean context. All values are truthy unless they are defined as falsy (i.e., except for false, 0, "", null, undefined, and NaN).

List of falsy values in JavaScript:^{From MDN}

1. false
2. null
3. undefined
4. 0
5. NaN
6. '', "", ``(Empty template string)
7. document.all
8. 0n: BigInt
9. -0

Equality of truthy and falsy values (JavaScript)

document.getElementById('header') returns a DOM object or null. So, in your second comparison (assuming it is resolving to an object), you're comparing:

if (obj == true)

A DOM object is not == to true.

To see why, you have to go to the ECMAScript rules for automatic type conversion which you can see in the ECMAScript 5 specification here: http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3.

The operative rules when comparing an object == boolean are all the way down to rules 9 and 10.

9. If Type(x) is Object and Type(y) is either String or Number, return the result of the comparison ToPrimitive(x) == y.

10. Return false.

Rule 9 is the first rule where Type(x) is Object and the two types are not the same, so it's the first one to check.

Since Type(y) is Boolean, it does not pass rule 9.

Thus, when it hasn't passed any rules 1-9, it evaluates to false.

When you do this comparison:

(false == 0) // evaluates to true

you're looking at rule #6 in the type conversion rules which will do:

ToNumber(false) == 0

which will resolve to:

0 == 0

which will be true.

For this one:

(false === 0)

Whenever you use ===, if the two types are different, then the result is immediately false so this evaluates to false. === requires type AND value to be the same so if the type is not the same, then it doesn't even attempt to compare the value. No type conversion is ever done with === which is one of the useful reasons to use it.

You should understand that the truthy and falsey rules apply to only a single check like this with no == or === in the comparison:

if (obj)

They do not apply when you are comparing x == y. For that, you have to refer to the type conversion rules in section 11.9.3 of the specification (linked above).

Whats the difference in checking for falsy / truthy values in different ways?

There are differences depending on what you want to achieve ...

for example:

0 == false // true
0 === false // false
undefined == null // true
undefined === null // false
...

Here is a game that will help you understand what are the Boolean relationships in JS:
Pedagogical-Game

trouble with truthy/falsey

Edit:

The question was a bit confusing because of the snippet, I understood that you were trying to look for falsy values.

The reason why:

value => value == true

would print out false it's because none of the elements of the array is equal to true.

You are correct about what a falsy value is, but that doesn't mean that a truthy value would be == to true.

Here you can read more about it:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness

One way of checking for truthy values would be:

(values.some(value => value != false)) 

or

(values.some(value => !!value === true)) 

Old answer:

Because the method you use tests that at least one element in the array matches the condition.

You can read more here

If you want to check that all elements of the array matches the condition, then you can use .every()

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every

let values = [11, NaN, [], ""]

function checkForFalsey() {
  if (values.every(value => value == false)) {
    console.log("All values are falsey");
  } else {
    console.log("NOT all values are falsey");
  }
}
checkForFalsey()

if None:
    # some code here

if False:
    # some code here

if None == False:
    # code in here would not execute because None is not equal to False

false
null
undefined
0
NaN
''

var value = valueToTest;

if (value) {
  console.log('Truthy!');
} else {
  console.log('Falsy!');
}