7 Weird JavaScript Tricks That Look Like Bugs (#3 Will Shock You!)

JavaScript has some peculiar behaviors that look like bugs but are technically correct. These mysterious behavior make beginners confused. But if you dig down the aspects its always fascinating.

In this article I am going to explain such 7 weird JavaScript tricks that feel like bugs but are actually real. Wanna explore how JavaScript works under the hood?

Let’s explore these fabulous JavaScript tricks, understand why they occur. Wait! We will also explain when to use them in real code or not. So bear with us for 5 minutes BRO to see the amazing JS code examples!

1. true + false = 1 (Boolean Arithmetic)

console.log(true + false); // 1

Why This Happens

• JavaScript converts booleans to numbers in math operations
• true becomes 1
• false becomes 0
• So 1 + 0 = 1

Practical Example

Instead of:

let count = 0;
if (isAdmin) count++;
if (isModerator) count++;

You could write your code like below:

const count = isAdmin + isModerator;

2. [] + {} = "[object Object]" (Strange Concatenation)

console.log([] + {}); // "[object Object]"
console.log({} + []); // 0 (in some browsers)

What’s Happening?

Expression	Conversion	Result
[] + {}	[] → "", {} → "[object Object]"	"" + "[object Object]"
{} + []	{} as empty block, +[] → 0	0

3. 0.1 + 0.2 !== 0.3 (Floating-Point Puzzle)

console.log(0.1 + 0.2); // 0.30000000000000004

Why This Happens

Computers use binary floating-point which can’t perfectly represent decimals.

Solutions

Method	Example
toFixed()	(0.1 + 0.2).toFixed(1)
Integer math	(0.1*10 + 0.2*10)/10

4. "b" + "a" + +"a" + "a" = "baNaNa"

console.log("b" + "a" + +"a" + "a"); // "baNaNa"

Breakdown

1. "b" + "a" → "ba"
2. +"a" → NaN (failed number conversion)
3. "ba" + NaN + "a" → "baNaNa"

5. (!+[]+[]+![]).length === 9

console.log((!+[]+[]+![]).length); // 9

Step-by-Step Explanation

1. +[] → 0
2. !0 → true
3. true + [] → "true"
4. ![] → false
5. "true" + "false" → "truefalse" (length 9)

6. null > 0, null == 0, null >= 0 (Weird Comparisons)

console.log(null > 0);   // false
console.log(null == 0);  // false
console.log(null >= 0);  // true

Why?

• > and < convert null to 0
• == doesn’t convert null except with undefined
• >= uses > logic

7. "2" + "2" - "2" = 20 (String vs Number Math)

console.log("2" + "2" - "2"); // 20

Explanation

1. "2" + "2" → "22" (string concatenation)
2. "22" - "2" → 20 (subtraction forces number conversion)

JavaScript Funny Quiz

Test your knowledge:

Answers: 1-a, 2-a, 3-c, 4-a, 5-a

Should You Use These Tricks?

Lets judge what we should do?

 When They’re Helpful

• Debugging type coercion issues
• Understanding how JavaScript works

 When to Avoid

• Production code
• Team projects
• Anywhere readability matters

{
  "rules": {
    "no-implicit-coercion": "error",
    "eqeqeq": "error"
  }
}

Final Thoughts to Share

These interesting piece of code make JavaScript:

• Confusing at first
• Fascinating to master
• Teachable moments about type systems

Best Practices:

• Always use === over ==
• Explicitly convert types when needed
• Add comments when using non-obvious behavior

 Further Learning:

• JavaScript Equality Table
• IEEE 754 Floating Point