A web worker is a JavaScript running in the background, without affecting the performance of the page.

JavaScript was designed to run in a single-threaded environment, meaning multiple scripts cannot run at the same time. Consider a situation where you need to handle UI events, query and process large amounts of API data, and manipulate the DOM.

What is a Web Worker?

When executing scripts in an HTML page, the page becomes unresponsive until the script is finished.

A web worker is a JavaScript that runs in the background, independently of other scripts, without affecting the performance of the page. You can continue to do whatever you want: clicking, selecting things, etc., while the web worker runs in the background.

The situation explained above can be handled using Web Workers who will do all the computationally expensive tasks without interrupting the user interface and typically run on separate threads.

Web Workers allow for long-running scripts that are not interrupted by scripts that respond to clicks or other user interactions and allow long tasks to be executed without yielding to keep the page responsive.

Web Workers are background scripts and they are relatively heavy-weight and are not intended to be used in large numbers. For example, it would be inappropriate to launch one worker for each pixel of a four-megapixel image.

When a script is executing inside a Web Worker it cannot access the web page’s window object (window. document), which means that Web Workers don’t have direct access to the web page and the DOM API. Although Web Workers cannot block the browser UI, they can still consume CPU cycles and make the system less responsive.

How Web Workers Work?

Web Workers are initialized with the URL of a JavaScript file, which contains the code the worker will execute. This code sets event listeners and communicates with the script that spawned it from the main page. Following is the simple syntax −

var worker = new Worker('bigLoop.js');

If the specified javascript file exists, the browser will spawn a new worker thread, which is downloaded asynchronously. If the path to your worker returns a 404 error, the worker will fail silently.

If your application has multiple supporting JavaScript files, you can import them importScripts()method which takes file name(s) as argument separated by comma as follows −

importScripts("helper.js", "anotherHelper.js");

Once the Web Worker is spawned, communication between the web worker and its parent page is done using the postMessage() method. Depending on your browser/version, postMessage() can accept either a string or JSON object as its single argument.

The message passed by Web Worker is accessed using the message event on the main page. Now let us write our big loop example using Web Worker. Below is the main page (hello.htm) which will spawn a web worker to execute the loop and to return the final value of the variable.

Browser Support

The numbers in the table specify the first browser version that fully supports Web Workers.

Check Web Worker Support

Before creating a web worker, check whether the user’s browser supports it:

if (typeof(Worker) !== "undefined") {
  // Yes! Web worker support!
  // Some code.....
} else {
  // Sorry! No Web Worker support..

Create a Web Worker File

Now, let’s create our web worker in external JavaScript.

Here, we create a script that counts. The script is stored in the “demo_workers.js” file:

var i = 0;

function timedCount() {
  i = i + 1;


The important part of the code above is the postMessage() method – which is used to post a message back to the HTML page.

Note: Normally web workers are not used for such simple scripts, but for more CPU-intensive tasks.

Create a Web Worker Object

Now that we have the web worker file, we need to call it from an HTML page.

The following lines check if the worker already exists, if not – it creates a new web worker object and runs the code in “demo_workers.js”:

if (typeof(w) == "undefined") {
  w = new Worker("demo_workers.js");

Then we can send and receive messages from the web worker. Add an “onmessage” event listener to the web worker.

w.onmessage = function(event){
  document.getElementById("result").innerHTML = event.data;

When the web worker posts a message, the code within the event listener is executed. The data from the web worker is stored in event.data.

Terminate a Web Worker

When a web worker object is created, it will continue to listen for messages (even after the external script is finished) until it is terminated. To terminate a web worker, and free browser/computer resources, use the terminate() method:


Reuse the Web Worker

If you set the worker variable to undefined after it has been terminated, you can reuse the code:

w = undefined;

Full Web Worker Example Code

We have already seen the Worker code in the .js file. Below is the code for the HTML page:

<!DOCTYPE html>

<p>Count numbers: <output id="result"></output></p>
<button onclick="startWorker()">Start Worker</button> 
<button onclick="stopWorker()">Stop Worker</button>

var w;

function startWorker() {
  if (typeof(Worker) !== "undefined") {
    if (typeof(w) == "undefined") {
      w = new Worker("demo_workers.js");
    w.onmessage = function(event) {
      document.getElementById("result").innerHTML = event.data;
  } else {
    document.getElementById("result").innerHTML = "Sorry! No Web Worker support.";

function stopWorker() { 
  w = undefined;


Web Workers and the DOM

Since web workers are in external files, they do not have access to the following JavaScript objects:

  1. The window object
  2. The document object
  3. The parent object