Funny JavaScript, It'll make you Laugh and Cry
Tags: javascript, beginners, webdev, learning
Published: 2024-06-09 04:46:56

Even though Javascript is the most sought after language for developers all around the world, it is a funny language, with nuances that can turn our everyday jobs hell. Some of the nuances will even have you laughing out loud.

### 1. JavaScript will have you go *BaNaNa*
Lets start with something that most of you would mostly know, the infamous joke in JS.

```
'"B" + "a" + +"a" + "a"; // -> BaNaNa
```

#### Explanation

The first part `"B"+"a"` will be a string concatenation. the magically part would be `+ + 'a'`, here first JS will try and type cast `+ 'a'` to a string, will would result in NaN getting concatenated to the string. The remaining would also be a simple concatenation, `+ 'a'`. 

This would make the result go *BaNaNa*

### 2. Two `[]` are not equal
Array is not equal to an array 🤯
```
[] == ![]; //-> true
```

#### Explanation
The abstract equality operator will convert both sides to zero but for different reasons. Arrays are always truthy, the opposite of that would be `false`, which would then be coerced to a `0`. On the left it would be coerced to a `0`, because empty array is coerced to a number without becoming a boolean first, and empty arrays are coerced to 0, despite being truthy.


### 3. `true` is not equal to `[]` but also not to `![]`

```
true == []; // -> false
true == ![]; // -> false
```

#### Explanation

For the first statement, because we are using abstract equalities, the `[]` would be coerced to 0 and true will be coerced to 1.  Hence `1 != 0`!

While in the second statement, `![]` would change to false, because `[]` is a truthy value.


### 4. `Object.is()` and `===` don't work respond the same

`Object.is()` determines if two values have the same value or not. It works similar(not the same) to the `===` operator. 

```
Object.is(-0, 0); // -> false
-0 === 0; // -> true
```

#### Explanation
In JS, `-0` and `0` are strict equals but they are not the same value. 

### 5. Minimal value is greater than zero

`Number.MIN_VALUE` is the smallest number, which is greater than zero:

```
Number.MIN_VALUE > 0; // -> true
```
 
#### Explanation
`Number.MIN_VALUE` is `5e-324`, the smallest positive number that can be represented with floating point precision(closest you can get to zero). 

### 6. Precision of `0.1` + `0.2`

This will tickle your funny bone, the addition of 0.1 and 0.2 with accuracy you couldn't imagine. 

```
0.1 + 0.2; // -> 0.30000000000000004
0.1 + 0.2 === 0.3; // -> false
```

#### Explanation

The response is not a bug but the *indented* behaviour, because our systems are 2 based systems, you can clearly express fractions whose denominator only has a prime factor of 2. In binary, 1/2, 1/4, 1/8 would all be expressed cleanly as decimals, while 1/5 or 1/10 would be repeating decimals. 

### 7. Comparing 3 numbers
```
1 < 2 < 3; // -> true
3 > 2 > 1; // -> false
```

#### Explanation
This all happens because of type conversions, lets try and understand what is happening with code itself

```
1 < 2 < 3; // 1 < 2 -> true
true < 3; // true -> 1
1 < 3; // -> true

3 > 2 > 1; // 3 > 2 -> true
true > 1; // true -> 1
1 > 1; // -> false
```
---
### TL;DR

*JavaScript is a very funny language, and understanding it can be a pain, share this with your friends to give them a headache as well*