What is worker-loader?
The worker-loader npm package is a webpack loader that allows you to create web workers from your JavaScript files. It simplifies the process of offloading tasks to background threads, which can help improve the performance of your web applications by handling CPU-intensive operations without blocking the main thread.
What are worker-loader's main functionalities?
Basic Web Worker Setup
This feature allows you to set up a basic web worker using worker-loader. The code demonstrates how to import a worker script, create a new worker instance, send a message to the worker, and handle messages received from the worker.
const Worker = require('worker-loader!./worker.js');
const worker = new Worker();
worker.postMessage({ message: 'Hello, Worker!' });
worker.onmessage = function(event) {
console.log('Received from worker:', event.data);
};
Handling Multiple Workers
This feature demonstrates how to handle multiple web workers simultaneously. The code shows how to import and create instances of different worker scripts, send tasks to each worker, and handle their responses independently.
const Worker1 = require('worker-loader!./worker1.js');
const Worker2 = require('worker-loader!./worker2.js');
const worker1 = new Worker1();
const worker2 = new Worker2();
worker1.postMessage({ task: 'Task 1' });
worker2.postMessage({ task: 'Task 2' });
worker1.onmessage = function(event) {
console.log('Worker 1 completed:', event.data);
};
worker2.onmessage = function(event) {
console.log('Worker 2 completed:', event.data);
};
Using Web Workers with TypeScript
This feature illustrates how to use worker-loader with TypeScript. The code demonstrates importing a TypeScript worker script, creating a worker instance, sending a message to the worker, and handling the response.
import Worker from 'worker-loader!./worker.ts';
const worker = new Worker();
worker.postMessage({ message: 'Hello, TypeScript Worker!' });
worker.onmessage = function(event) {
console.log('Received from TypeScript worker:', event.data);
};
Other packages similar to worker-loader
comlink
Comlink is a library that simplifies the use of Web Workers by providing a proxy-based API. It allows you to call functions in the worker as if they were local functions, making the communication between the main thread and the worker more intuitive. Compared to worker-loader, Comlink offers a higher-level abstraction for worker communication.
threads
Threads is a library that provides a simple and modern API for using Web Workers. It supports both JavaScript and TypeScript and offers features like thread pools and message channels. Threads focuses on ease of use and performance, making it a good alternative to worker-loader for more complex worker management.
greenlet
Greenlet is a lightweight library that allows you to run functions in a Web Worker with minimal overhead. It provides a simple API for offloading functions to a worker and returning the results as promises. Greenlet is a good choice for projects that need a minimalistic solution for using Web Workers compared to the more feature-rich worker-loader.
Worker Loader
This loader registers the script as Web Worker.
Install
npm i -D worker-loader
or
yarn add worker-loader --dev
Import the worker file:
var MyWorker = require("worker-loader!./file.js");
var worker = new MyWorker();
worker.postMessage({a: 1});
worker.onmessage = function(event) {...};
worker.addEventListener("message", function(event) {...});
You can also inline the worker as a blob with the inline
parameter:
var MyWorker = require("worker-loader?inline!./myWorker.js");
Inline mode will also create chunks for browsers without supporting of inline workers,
to disable this behavior just set fallback
parameter as false
:
var MyWorker = require("worker-loader?inline&fallback=false!./myWorker.js");
To set a custom name for the output script, use the name
parameter. The name may contain the string [hash]
,
which will be replaced with a content-dependent hash for caching purposes. For example:
var MyWorker = require("worker-loader?name=outputWorkerName.[hash].js!./myWorker.js");
The worker file can import dependencies just like any other file:
var _ = require('lodash')
var o = {foo: 'foo'}
_.has(o, 'foo')
self.postMessage({foo: 'foo'})
self.addEventListener('message', function(event){ console.log(event); });
You can even use ES6 modules if you have the babel-loader configured:
import _ from 'lodash'
let o = {foo: 'foo'}
_.has(o, 'foo')
self.postMessage({foo: 'foo'})
self.addEventListener('message', (event) => { console.log(event); });
Integrating with TypeScript
To integrate with TypeScript, you will need to define a custom module for the exports of your worker. You will also need to cast the new worker as the Worker
type:
typings/custom.d.ts
declare module "worker-loader!*" {
const content: any;
export = content;
}
App.ts
import * as MyWorker from "worker-loader!../../worker";
const worker: Worker = new MyWorker();
Maintainers