JavaScript typeof

typeof is an operator that tells you what type a value is, as a string. It is the quickest type check in JavaScript and works well for primitives, but it has a few famous blind spots. This lesson covers every result and when to use something else.

// Every Possible Result

typeof only ever returns one of eight strings:

// It Always Returns a String

typeof 42              // "number"
typeof typeof 42       // "string"  (the result of typeof is a string)

if (typeof x === "number") { }   // compare against a string, in quotes

// No Parentheses Needed

typeof is an operator like !, not a function. Parentheses are allowed but only group the expression:

typeof "a" + 1       // "string1"   typeof runs first, then + joins
typeof ("a" + 1)     // "string"    parentheses group the expression first

// Blind Spot 1: null

const v = null;
typeof v === "object"   // true: misleading
v === null              // true: the right check

This means "is it an object?" needs two checks:

const isObject = v => v !== null && typeof v === "object";

// Blind Spot 2: Arrays and Other Objects

Every kind of object except functions reports "object". Use a more specific check:

typeof [1, 2]            // "object"
Array.isArray([1, 2])     // true
new Date() instanceof Date // true

// Blind Spot 3: NaN Is a "number"

const result = "abc" * 2;
typeof result          // "number"  (but it is NaN)
Number.isFinite(result) // false     the check you actually want

// A Superpower: Undeclared Variables

Using a variable that was never declared normally throws an error. typeof is the one safe exception:

console.log(mystery);          // ReferenceError: mystery is not defined
console.log(typeof mystery);   // "undefined"  no error

That makes it useful for checking whether a feature exists before using it:

if (typeof structuredClone === "function") {
  // safe to use structuredClone in this browser
}

// instanceof: Which Constructor Made It?

typeof cannot tell objects apart. instanceof can: it asks "was this object made by that constructor?"

const time = new Date();
const fruits = ["apples", "bananas", "oranges"];
const prices = new Map([["apples", 500], ["bananas", 300]]);
const unique = new Set(["apples", "bananas"]);

console.log(time instanceof Date, fruits instanceof Array);
console.log(prices instanceof Map, unique instanceof Set);
console.log(fruits instanceof Object);    // every array is also an Object
console.log("hi" instanceof String);      // primitives are not instances of anything

// The constructor Property

Every value except null and undefined has a constructor property: the function that made it (for primitives, the wrapper that auto-boxing uses):

console.log([1, 2, 3].constructor === Array);
console.log(new Date().constructor === Date);
console.log(({ name: "John" }).constructor.name);
console.log((function () {}).constructor.name, "hi".constructor.name);

// The void Operator

void runs an expression, throws away the result, and always gives undefined:

let n = 0;
console.log(void 0);
console.log(void (n = 5), n);    // the assignment still happens
console.log(void 0 === undefined);

// A Complete Type Check

function typeName(v) {
  if (v === null) return "null";
  if (Array.isArray(v)) return "array";
  if (typeof v === "number" && Number.isNaN(v)) return "NaN";
  return typeof v;
}

[null, [], NaN, 5, "hi", {}].map(typeName);

// Quick Check

console.log(typeof typeof undefined);

// Try It

▶ Open Playground

1. Click Open Playground. Add a typeof line for every row of the table above and check the results
2. Predict, then test: typeof typeof null
3. Use typeof to safely check for a variable you never declared
4. Open the typeName example with its Try it Yourself button and extend it so it also reports "date" for Date objects