What are the different types of errors in JavaScript?

The short answer

JavaScript has several built-in error types: SyntaxError (invalid code), ReferenceError (undefined variable), TypeError (wrong type), RangeError (value out of range), URIError (bad URI), and EvalError. You can also create custom errors by extending the Error class.

The common error types

SyntaxError — the code is not valid JavaScript. The engine cannot parse it:

Copy
// Missing closing bracket
const obj = { name: 'John'; // SyntaxError
// Invalid syntax
let 123abc = 'hello'; // SyntaxError

These are caught before the code runs — during parsing.

ReferenceError — you are using a variable that does not exist:

Copy
console.log(myVariable); // ReferenceError: myVariable is not defined
// Also happens with TDZ
console.log(x); // ReferenceError
let x = 10;

TypeError — you are using a value in a way that is not allowed for its type:

Copy
null.toString(); // TypeError: Cannot read properties of null
undefined.map(); // TypeError: undefined is not a function
const num = 42;
num(); // TypeError: num is not a function

This is the most common error type you will see in JavaScript.

RangeError — a value is outside the allowed range:

Copy
new Array(-1); // RangeError: Invalid array length
(1).toFixed(200); // RangeError: toFixed() digits argument must be between 0 and 100

Custom errors

You can create your own error types for better error handling:

Copy
class ValidationError extends Error {
  constructor(field, message) {
    super(message);
    this.name = 'ValidationError';
    this.field = field;
  }
}
function validateAge(age) {
  if (age < 0 || age > 150) {
    throw new ValidationError(
      'age',
      'Age must be between 0 and 150'
    );
  }
}
try {
  validateAge(-5);
} catch (error) {
  if (error instanceof ValidationError) {
    console.log(`${error.field}: ${error.message}`);
  }
}

Why interviewers ask this

This tests basic JavaScript knowledge. Interviewers want to see if you can identify what kind of error you are dealing with, which helps in debugging. Knowing the difference between a TypeError and a ReferenceError means you can find the root cause faster.