5 Things You don't know about JavaScript
JavaScript is a beautiful language. It has its secrets, which many people do not know, and which can surprise. Here is a list of several such secrets.
1. NaN is a number
Did you know that NaN
is that a number? NaN
so not a number, when you expand the abbreviation, it’s actually a number.
console.log(typeof NaN); //number
What’s more, NaN
it is not even equal to itself and is not equal to any other object. If you have to check if anything occurs as NaN
then you must use isNaN()
.
NaN === NaN // false
isNaN(NaN) //true
2. Void Operator
In JavaScript, there is an operator void
. You are probably wondering what such an operator can do in JS. So it takes whatever expression comes after it, runs it, and always returns undefined
. Sound useless? I think it does, or at least I thought it did.
void {}; // undefined
void "any text at all"; // undefined
void (() => {}); // undefined
let a = 0;
void a; // undefined
Do we even need something like this? Surprisingly, as much as possible. It is used to define undefined
. In fact, I didn’t even know that undefined
you can define.
(() => {
const undefined = "foo";
console.log(undefined, typeof undefined); // "foo", "string"
console.log(void 0, typeof void 0); // undefined, "undefined"
})();
Because undefined
if it is not a keyword, then you can use it as a variable name to override the global value in the range.
3. IIFE, i.e. Immediately Invoked Function Expression
I don’t think it’s that secret. IIFE is actually a function that can be called immediately after its definition. IIFE is usually wrapped in parentheses followed by parentheses to call a defined function.
() => {
// …
})();
When a function has a returned type, or when it is assigned to a variable, we don’t need to do that.
void function () {
// …
}();
const result = function () {
// …
}();
4. Operator in
One of the less commonly used operators in JS is the operator in
. Its purpose is to check whether the object contains the appropriate property.
let obj = { x: 1, y: 2, z: 3 };
"x" in obj; // true
"a" in obj; // false
But why do we need an operator in
when we can check it with help object[property]
? Because it gives us the convenience of checking whether any property is present, even if it has any values false
. In such cases, we usually use:
typeof obj[prop] === "undefined"
Instead of the above, we can also use:
"prop" in obj
5. Null is an object
We all assumed that null
it informs us that there is no object. However, let’s try to see what null
ma type:
console.log(typeof null); //object
Come on. null
it is also not an instance of an object, because it indicates that there is no value. So:
console.log(null instanceof Object); // false
Summary
The above are just a few js concepts that I had no idea about. I hope you can use them. Let us know in the comments whether you knew about them. Or maybe you know others?
You can read the original English text here.