1. javascript
  2. /basics
  3. /errors

JavaScript Errors

What are errors in JavaScript?

Errors in JavaScript are messages that indicate that something has gone wrong in the execution of a script. They can happen for a variety of reasons and in different situations, and it's important to understand how to handle them effectively to write better code and improve your debugging skills.

Causes of JavaScript Errors

JavaScript errors can happen for a variety of reasons, some of which include:

  • Writing code with incorrect syntax

  • Using undefined variables

  • Calling functions on non-function objects

  • Providing incorrect arguments to a function

  • Using a value outside of its expected range

  • Accessing an object's property that does not exist

  • Attempting to execute code that has been blocked by the browser's security features

  • Interacting with third-party libraries or APIs that have bugs or unexpected behavior

These situations can occur due to mistakes in the code, bugs in third-party libraries, unexpected user input, and other factors. It's advisable to anticipate potential errors and have a plan on how to handle them accordingly. By understanding the common causes, developers can take steps to prevent them from happening and write more robust and reliable code.

Syntax Errors

Syntax errors occur when the code you've written does not conform to the rules of the JavaScript language. This can include missing semicolons, incorrect use of quotes, or mismatched parentheses. These errors are usually easy to spot and fix, as the JavaScript interpreter will point out the specific line of code that contains the error.

let x = "hello"

In the above example, if we forget the semicolon at the end of the first line, it will cause a syntax error.

Reference Errors

Reference errors occur when the code references a variable or object that hasn't been defined. Usually, this can happen if you've misspelled a variable name, or if you've forgotten to declare a variable with the var, let, or const keywords.

let y = 5

The variable y is not defined before it's used, which will cause a reference error.

Type Errors

Type errors occur when the code is expecting a certain type of value but receives a different one. This can happen if you try to call a method on a non-object value, or if you try to access a property of an undefined object.

let x = "hello"

In the above example, the variable x is a string, but we're trying to call the toUpperCase() method on it, which is only available on String objects, so it will cause a type error.

Range Errors

Range errors occur when a value is outside of the expected range. This can happen if you try to create an array with a negative length, or if you try to access an element of an array at an index that is out of bounds.

let x = new Array(-5)

In the above example, we're trying to create an array with a negative length, which will cause a range error.

URI (Uniform Resource Identifier) Error

URI errors occur when a malformed URI is passed to the encodeURI() or decodeURI() functions.

encodeURI("http://example.com/my file.txt")
  • The "#" symbol is not a valid character for a URI and will cause a URI error.
encodeURI("http://example.com/my file.txt")
  • The space in the file name is not a valid character for a URI and will cause a URI error.

Handling Errors

There are multiple ways to handle errors in JavaScript, including:

  • Using try-catch blocks to handle specific errors

  • Using finally blocks to run code after a try-catch block

  • Using the onerror event to handle global errors

  • Using the window.onerror event to handle global errors in the browser

  • Using the Promise.catch() method to handle errors in Promises

try {
    // code that might throw an error
} catch (error) {
    // code to handle the error

Here, we're using a try-catch block to handle any errors that occur within the try block. If an error is thrown, it will be caught by the catch block, where it can be logged or handled in some other way.

Bear in mind that you should always try to handle errors as close to where they occur as possible and avoid using a global error handler as it can make it harder to diagnose and fix the error.


  • Understanding and handling errors in JavaScript is an essential part of writing better code and improving your debugging skills.

  • Always check the error message and the line number to get an idea of what went wrong

  • Use the developer tools in your browser to debug and track down errors.

  • Practice makes perfect, and the more you work with errors, the better you'll get at handling them.

  • Don't get discouraged if you encounter an error you can't fix immediately, take a break and come back to it later with a fresh perspective.

  • Remember that everyone makes mistakes and encountering errors is a normal part of the development process.

  • Always try to handle errors as close to where they occur as possible