Types are important. They keep you away from inconsistent mess, guard from certain errors, allow to model and document things, and write performant code. The better type system of your language is, the better your code should be.

JavaScript type system... JS type system... well it's formally there 😐. But informally it feels like you're at a playground and nobody's watching, so you can easily find yourself swinging on a merry-go-round and spinning on a swing (I honestly don't mind that kind of fun 🤓).

There are lots of crazy cool examples related to JS built in data-types and its type coercion. If somehow you've missed a hilarious WTFJS - enjoy. Here are some of my favourites:

> true + true

2

> Math.pow(10, false)

1

> "hello " + + "world"

'hello NaN'

> 9_999_999_999_999_999

10000000000000000

And can a poor monkey dodge a snake and have enough mangoes and maybe a pie in a cruel JS world?

let mangoes = [Math.PI]
mangoes[3] = "🥭";
console.log(`${mangoes.length}`);
mangoes[-1] = "🐍";
mangoes[Infinity] = "🥭";
mangoes.forEach((mango, index) => {
    console.log(`🐒 eating ${mango} at ${index}`);
});

🤔

There have been quite a few data-types added to the language over time, like BigInt and Symbol for example. To me, addition of Typed arrays was like entering The Twilight Zone - science fiction, suspense, horror and super cool at once 😐.
Promise and Generator (JS functions are good parts for sure) additions were warmly welcomed as well. How about mango-infinity for that monkey?

function* mangoInfinityGenerator() {
    for(let i = 0; i < Infinity; i++) {
        yield "🥭";
    }
}
let mangoInfinity = mangoInfinityGenerator();
let nextMango;
while(nextMango = mangoInfinity.next().value) {
    console.log(`🐒 eating ${nextMango}`)
}

And I can't but agree that If it walks like a duck and it quacks like a duck, then it must be a duck is a no fuss behavior oriented way to code. And since why not, how about some Duckenstein:

let ifItWalksLikeADuck = it => typeof it.waddle === "function"
let itQuacksLikeADuck = it => typeof it.quack === "function"
let itMustBeADuck = it => ifItWalksLikeADuck(it) && itQuacksLikeADuck(it);

let duckenstein = it => {
    it.__proto__.quack = () => console.log("quack");
    it.__proto__.waddle = () => console.log("waddle");
    return it;
}

[Infinity, false, "not a duck", /.*/, {}, Symbol("@"), null, undefined].forEach(it => {
    try {
        it = duckenstein(it);
        if (itMustBeADuck(it)) {
            console.log(`${it.constructor.name}, ${it.toString()} - It's Aduck!`)
        }
    } catch (err) {
        console.log(`${it} - I am alone and miserable. Only someone as ugly as I am could love me.`)
    }
})