在JavaScript中与null和undefined进行比较的速度

Question

I have just run a very simple JavaScript performance test (don't ask why). The test declares a variable, but doesn't assign anything to it:

var x;

It then compares the speed of comparing the value variable to null , and to undefined , in other words:

var y = (x == null); and var y = (x == undefined); .

I was expecting the comparison with undefined to be the fasted. In fact it was nowhere near. The comparison with null was far and away the fastest, around 80% faster.

The results I've described above come from running the tests in Chrome (version 13). Running them in Firefox produces results far closer to what I would have expected (the comparison with undefined is faster than with null , albeit very marginally).

So, my question is what could the cause of this be? Why does Chrome seem to favour the comparison with null so greatly?

For quick reference, here's a screenshot of the results:

Answer 1

null is a reserved keyword which cannot be overriden, so when you are doing a comparison against null, all you have to do is a single comparison.

However, when you are checking against undefined , the engine must do a type lookup and then a comparison, meaning that it is actually slightly more demanding.

---

If you need to actually check to see if something is undefined, you should use

if(typeof notSet == "undefined"){ }

---

Proof

Try it... and set something to null in your JavaScript console.

null = "will error";
// Errors with --> ReferenceError: invalid assignment left-hand side

However, if you try and do it with undefined, it won't error. That is not to say that you can override undefined , because you can't, but that undefined is its own primitive type.

The only real similarity between null and undefined, is that they can both be coerced into a boolean false.

Answer 2

I recently discovered that this:

 if (typeof this._minLat === 'undefined') {
   this._minLat = Math.min(...this.points.map(point => point.lat));
 }
 return this._minLat;

seems to be many times faster than this:

 return  this._minLat || Math.min(...this.points.map(point => point.lat));    

Answer 3

if i think well, they are not the same. so you can't use null instead of undefined.

typeof !== "undefined" vs. != null

Answer 4

You're comparing against the lookup of a variable called undefined (which returns an undefined value), so it's not doing what you were intending.

There are ways to check whether a variable is undefined. As the other posters have mentioned, typeof x === 'undefined' is one. (There's probably another possibility that is something like hasOwnProperty('x') executed on the global object, but that doesn't check the scope chain.)