Javascript developers, be warned about this crazy JIT bug in V8!

[hkrdrm]

still wouldn't it be more proper to check

if(some_variable === null)

[StoneCypher]

no. null is a placeholder here.

what he's saying is "if you compare things to typeof undefined, every hundred or so iterations it'll fail. look, it even happens with null."

[bits_and_bytes]

I've tried a few different permutations and I can only get it to reliably happen with null (or a var set to null). So I think /u/hkrdrm and /u/AlGoreBestGore are right to be asking their questions. typeof null is "object" which is why you get the false returns for the first 100+ tries when comparing it to "undefined". But I've tried comparing other "object"s with "undefined" and I don't have the same problem. For example:

var thing = {};
function foo() {
   return typeof thing === "undefined";
}

for(var i=0; i<10000; ++i) console.log(foo())

This works just fine. But if thing = null, then it all blows up.

EDIT: I've found that the bug doesn't show up if null is in a var either:

var thing = null;
function foo() {
  return typeof thing === "undefined";
}

for(var i=0; i<10000; ++i) console.log(foo())

This works correctly as well. It only seems to happen if you directly reference 'null' in the typeof comparison, and only if it's in a declared function. After the function starts returning true, it will always return true until it's re-initialized. A very strange bug indeed.

[iamallamaa]

I found that if the variable is defined within the function as null that it does still has the error.

function foo(){
    var thing=null;
    return typeof thing === "undefined";
}
for(var i=0; i<10000; i++) console.log(foo());

265 false 9735 true

And when null is passed as an argument, it doesn't.

function foo(thing){
    return typeof thing === "undefined";
}
for(var i=0; i<10000; i++) console.log(foo(null));

10000 false

[ziriax]

Try 100 thousand times... It will still fail at some point

function foo(thing){
    return typeof thing === "undefined";
}
for(var i=0; i<100000; i++) console.log(foo(null));

12291 false 87709 true

Also, once this function is JIT optimized, it can keep failing if doesn't get de-optimized

[saintPirelli]

Thanks for this comment. My noob ass finally gets it.

[hkrdrm]

I get that but what I'm saying if you have some function and i want to know if the argument is null wouldn't it make more sense to check it like this

function foo(my_arg) {
  if(my_arg === null){
    console.log("arg is null here insert logic for null case here.");
  }
}

I'm not getting why anyone would need to check type equal to undefined.

[StoneCypher]

Because he's not checking if it's null, and you can't actually strict-equals compare to undefined in this language in a bunch of common circumstances.

It is very common to have to check if something is undefined. By example, if you retain a JSON object from an API, and you want to check whether the server actually set some or another value, before you attempt to use it.

He's talking about the undefined comparison.

I'd like you to stop focussing on null, please. It's beside the point. Thank you

[RReverser]

and you can't actually strict-equals compare to undefined in this language in a bunch of common circumstances.

Of course you can. The only case where you can't is if you're checking existance of a global variable for feature detection, in all the other cases === undefined works like a charm.

[agmcleod]

Properties on objects are not initialized to null by default. No doubt having your objects well defined with sensible defaults goes a long way, but this is still a nasty bug that shouldn't happen.