Truthy and Falsy Values in JavaScript: A Complete Guide with Examples
If you’ve been writing JavaScript for a while, you’ve probably seen code like this:
if (user) {
console.log("User exists");
}
But what exactly is JavaScript checking here?
Is user equal to true? Not necessarily.
Instead, JavaScript determines whether the value is truthy or falsy.
Understanding truthy and falsy values in JavaScript is one of the most important fundamentals for every developer. These concepts appear everywhere—from if statements and loops to React conditional rendering, Node.js applications, and JavaScript interviews.
In this guide, you’ll learn what truthy and falsy values are, see the complete list of falsy values, understand why empty arrays are truthy, and explore the !! (double bang) operator, and learn how modern JavaScript operators like ||=, &&=, and ??= rely on truthy and falsy evaluations.
Table of Contents
What Are Truthy and Falsy Values?
In JavaScript, every value has an inherent boolean representation.
When JavaScript evaluates a condition, it doesn’t require the value to literally be true or false. Instead, it converts the value into a boolean behind the scenes.
For example:
const username = "John";
if (username) {
console.log("Welcome!");
}
Output:
Welcome!
Although "John" isn’t the boolean value true, JavaScript treats it as truthy, so the condition executes.
This automatic conversion is called Boolean coercion.
The Complete List of Falsy Values
One of the easiest JavaScript interview questions is:
How many falsy values are there in JavaScript?
There are 8 falsy values in modern JavaScript.
| Value | Description |
|---|---|
false | Boolean false |
0 | Number zero |
-0 | Negative zero |
0n | BigInt zero |
"" | Empty string |
null | Intentional absence of value |
undefined | Variable without a value |
NaN | Not a Number |
These are the only falsy values.
Everything else is truthy.
Example:
console.log(Boolean(0));
console.log(Boolean(""));
console.log(Boolean(null));
console.log(Boolean(undefined));
Output:
false
false
false
false
Common Truthy Values
Many developers assume certain values are falsy when they’re actually truthy.
Here are some examples.
| Value | Truthy or Falsy |
|---|---|
"false" | Truthy |
"0" | Truthy |
" " (space) | Truthy |
[] | Truthy |
{} | Truthy |
function(){} | Truthy |
Infinity | Truthy |
-1 | Truthy |
Example:
if ("false") {
console.log("Runs");
}
Output:
Runs
Even though the string contains the word "false", it’s still a non-empty string, making it truthy.
Truthy vs Falsy Examples
Understanding real examples makes these concepts much easier.
Example 1
if (0) {
console.log("Hello");
}
Nothing is printed because 0 is falsy.
Example 2
if ("Hello") {
console.log("Hello");
}
Output:
Hello
A non-empty string is truthy.
Example 3
if ([]) {
console.log("Array exists");
}
Output:
Array exists
An empty array is truthy.
Example 4
if ({}) {
console.log("Object exists");
}
Output:
Object exists
An empty object is also truthy.
Why Are Empty Arrays and Objects Truthy?
This is one of the most frequently asked JavaScript interview questions.
Many beginners expect:
[]
to behave like:
false
However:
Boolean([]);
returns:
true
The same applies to objects:
Boolean({});
returns:
true
Why?
Because arrays and objects are reference types.
Even when they’re empty, they still reference a valid object in memory.
JavaScript only considers the finite list of falsy values as false. Since arrays and objects aren’t on that list, they’re truthy.
Boolean Conversion and the Double Bang (!!) Operator
Sometimes you want to convert any value into a true boolean.
The simplest way is with the double bang (!!) operator.
Example:
const username = "Alice";
console.log(!!username);
Output:
true
Another example:
console.log(!!0);
Output:
false
The first ! converts the value to its opposite boolean.
The second ! reverses it again, leaving you with the actual boolean representation.
This technique is widely used in React, Vue, Angular, and Node.js applications.
Logical Assignment Operators (||=, &&=, ??=)
Modern JavaScript introduced logical assignment operators that rely heavily on truthy and falsy evaluations.
OR Assignment (||=)
let username = "";
username ||= "Guest";
console.log(username);
Output:
Guest
Because the empty string is falsy.
AND Assignment (&&=)
let isAdmin = true;
isAdmin &&= false;
console.log(isAdmin);
Output:
false
The assignment only occurs because the original value is truthy.
Nullish Assignment (??=)
let language = null;
language ??= "English";
console.log(language);
Output:
English
Unlike ||=, the ??= operator only checks for null and undefined.
This makes it much safer when 0, false, or an empty string are valid values.
Practical Use Cases
Truthy and falsy values appear throughout modern JavaScript development.
Conditional Rendering
if (user) {
showDashboard();
}
Default Values
const name = username || "Guest";
Modern Default Values
const name = username ?? "Guest";
This preserves values like:
0false""
while only replacing null and undefined.
Form Validation
if (!email) {
alert("Email is required");
}
React Conditional Rendering
{user && <Dashboard />}
React developers use truthy and falsy evaluations constantly.
Truthy vs Falsy: Quick Comparison
| Truthy | Falsy |
|---|---|
"Hello" | "" |
"0" | 0 |
[] | null |
{} | undefined |
1 | NaN |
true | false |
-10 | 0n |
Best Practices
When working with truthy and falsy values:
- Know the complete list of falsy values.
- Don’t assume empty arrays or objects are falsy.
- Use
!!when you explicitly need a boolean. - Prefer
??over||when handlingnullorundefined. - Use logical assignment operators (
||=,&&=,??=) appropriately. - Write conditions that clearly express your intent instead of relying on implicit conversions where readability suffers.
Frequently Asked Questions
What are truthy and falsy values in JavaScript?
Truthy values evaluate to true in a boolean context, while falsy values evaluate to false.
How many falsy values are there in JavaScript?
There are 8 falsy values in modern JavaScript:
false0-00n""nullundefinedNaN
Is an empty array truthy or falsy?
An empty array ([]) is truthy because it is still a valid object reference.
Is an empty object truthy or falsy?
An empty object ({}) is truthy for the same reason—it is a valid object in memory.
What does the !! operator do?
The double bang operator converts any value into its boolean equivalent.
Example:
!!"Hello"
returns:
true
Additional Learning Resources
To learn more about JavaScript boolean conversions and conditional logic, explore these trusted resources:
- MDN Web Docs – Truthy
https://developer.mozilla.org/en-US/docs/Glossary/Truthy - MDN Web Docs – Falsy
https://developer.mozilla.org/en-US/docs/Glossary/Falsy - JavaScript.info – Type Conversions
https://javascript.info/type-conversions - ECMAScript Language Specification
https://tc39.es/ecma262/
Related Articles
Continue strengthening your JavaScript fundamentals with these topics:
- Null vs Undefined in JavaScript
- Difference Between
==and=== - JavaScript Data Types Explained
- Optional Chaining (
?.) Explained - Nullish Coalescing (
??) Explained - JavaScript Logical Operators
- Difference Between
var,let, andconst
Final Thoughts
Understanding truthy and falsy values in JavaScript is fundamental to writing clean, reliable, and bug-free code.
Remember these key takeaways:
- JavaScript automatically converts values to
trueorfalsein conditional statements. - There are only 8 falsy values in modern JavaScript.
- Empty arrays (
[]) and empty objects ({}) are truthy, even though they’re empty. - The
!!operator is a simple way to convert any value into a boolean. - Modern operators like
||=,&&=, and??=depend on truthy and falsy evaluations, making this concept more relevant than ever.
Whether you’re preparing for a JavaScript interview or building production applications, mastering truthy and falsy values will help you write more predictable code and avoid subtle bugs that are often difficult to debug.
