"Type of undefined" vs "=== undefined" (v12)

Revision 12 of this benchmark created on

Setup

var a = 1,
        b = true,
        c = "c",
        d = [],
        e = {},
        u;
    
    function isUndefinedA(thing) {
    
      return typeof thing === 'undefined';
    }
    
    function isUndefinedB(thing) {
    
      return thing === undefined;
    }
    
    var _undefined;
    
    function isUndefinedC(thing) {
    
      return thing === _undefined;
    }
    
    function isUndefinedD(thing) {
    
      return thing === void 0;
    }
    
    function isUndefinedE(thing) {
    
      return thing === void null;
    }
    
    var cachedUndefined = void 0;
    function isUndefinedF(thing) {
    
      return thing === cachedUndefined;
    }
    
    // tests
    var funcs = [isUndefinedA, isUndefinedB, isUndefinedC, isUndefinedD, isUndefinedE];
    var vars = [a, b, c, d, e, u];
    
    for (var f = 0; f < funcs.length; f++) {
    
      var func = funcs[f];
      for (var v = 0; v < vars.length; v++) {
    
        var val = vars[v];
        var isUndefined = func(val);
        var expect;
        if (v === 5) {
    
          expect = true;
        } else {
    
          expect = false;
        }
    
        if (isUndefined !== expect) {
    
          throw new Error('assert failure');
        }
      }
    }

Test runner

Ready to run.

Testing in
TestOps/sec
typeof undefined
isUndefinedA(a);
isUndefinedA(b);
isUndefinedA(c);
isUndefinedA(d);
isUndefinedA(e);
isUndefinedA(u);
ready
=== undefined
isUndefinedB(a);
isUndefinedB(b);
isUndefinedB(c);
isUndefinedB(d);
isUndefinedB(e);
isUndefinedB(u);
ready
=== undefined(local)
isUndefinedC(a);
isUndefinedC(b);
isUndefinedC(c);
isUndefinedC(d);
isUndefinedC(e);
isUndefinedC(u);
ready
void 0
isUndefinedD(a);
isUndefinedD(b);
isUndefinedD(c);
isUndefinedD(d);
isUndefinedD(e);
isUndefinedD(u);
ready
void null
isUndefinedE(a);
isUndefinedE(b);
isUndefinedE(c);
isUndefinedE(d);
isUndefinedE(e);
isUndefinedE(u);
ready
cached void 0
isUndefinedF(a);
isUndefinedF(b);
isUndefinedF(c);
isUndefinedF(d);
isUndefinedF(e);
isUndefinedF(u);
ready

Revisions

You can edit these tests or add more tests to this page by appending /edit to the URL.