Service workers essentially act as proxy servers that sit between web applications, the browser, and the network (when available). They are intended, among other things, to enable the creation of effective offline experiences, intercept network requests and take appropriate action based on whether the network is available, and update assets residing on the server. They will also allow access to push notifications and background sync APIs.
Service workers only run over HTTPS, for security reasons. Most significantly, HTTP connections are susceptible to malicious code injection by man in the middle attacks, and such attacks could be worse if allowed access to these powerful APIs. In Firefox, service worker APIs are also hidden and cannot be used when the user is in private browsing mode.
Note: On Firefox, for testing you can run service workers over HTTP (insecurely); simply check the Enable Service Workers over HTTP (when toolbox is open) option in the Firefox Devtools options/gear menu.
Note: Unlike previous attempts in this area such as AppCache, service workers don't make assumptions about what you are trying to do, but then break when those assumptions are not exactly right. Instead, service workers give you much more granular control.
Note: Service workers make heavy use of promises, as generally they will wait for responses to come through, after which they will respond with a success or failure action. The promises architecture is ideal for this.
A service worker is first registered using the
ServiceWorkerContainer.register() method. If successful, your service worker will be downloaded to the client and attempt installation/activation (see below) for URLs accessed by the user inside the whole origin, or inside a subset specified by you.
At this point, your service worker will observe the following lifecycle:
The service worker is immediately downloaded when a user first accesses a service worker–controlled site/page.
After that, it is updated when:
- A navigation to an in-scope page occurs.
- An event is fired on the service worker and it hasn't been downloaded in the last 24 hours.
Installation is attempted when the downloaded file is found to be new — either different to an existing service worker (byte-wise compared), or the first service worker encountered for this page/site.
If this is the first time a service worker has been made available, installation is attempted, then after a successful installation, it is activated.
If there is an existing service worker available, the new version is installed in the background, but not yet activated — at this point it is called the worker in waiting. It is only activated when there are no longer any pages loaded that are still using the old service worker. As soon as there are no more pages to be loaded, the new service worker activates (becoming the active worker). Activation can happen sooner using
ServiceWorkerGlobalScope.skipWaiting() and existing pages can be claimed by the active worker using
You can listen for the
install event; a standard action is to prepare your service worker for usage when this fires, for example by creating a cache using the built in storage API, and placing assets inside it that you'll want for running your app offline.
There is also an
activate event. The point where this event fires is generally a good time to clean up old caches and other things associated with the previous version of your service worker.
activate events could take a while to complete, the service worker spec provides a
waitUntil() method. Once it is called on
activate events with a promise, functional events such as
push will wait until the promise is successfully resolved.
For a complete tutorial to show how to build up your first basic example, read Using Service Workers.
Service workers are also intended to be used for such things as:
- Background data synchronization.
- Responding to resource requests from other origins.
- Receiving centralized updates to expensive-to-calculate data such as geolocation or gyroscope, so multiple pages can make use of one set of data.
- Client-side compiling and dependency management of CoffeeScript, less, CJS/AMD modules, etc. for development purposes.
- Hooks for background services.
- Custom templating based on certain URL patterns.
- Performance enhancements, for example pre-fetching resources that the user is likely to need in the near future, such as the next few pictures in a photo album.
- API mocking.
In the future, service workers will be able to do a number of other useful things for the web platform that will bring it closer towards native app viability. Interestingly, other specifications can and will start to make use of the service worker context, for example:
Represents the storage for
Cacheobjects. It provides a master directory of all the named caches that a
ServiceWorkercan access, and maintains a mapping of string names to corresponding
Represents the scope of a service worker client. A service worker client is either a document in a browser context or a
SharedWorker, which is controlled by an active worker.
Represents a container for a list of
Clientobjects; the main way to access the active service worker clients at the current origin.
Extends the lifetime of the
activateevents dispatched on the
ServiceWorkerGlobalScope, as part of the service worker lifecycle. This ensures that any functional events (like
FetchEvent) are not dispatched to the
ServiceWorker, until it upgrades database schemas, and deletes outdated cache entries, etc.
The parameter passed into the
FetchEventrepresents a fetch action that is dispatched on the
ServiceWorker. It contains information about the request and resulting response, and provides the
FetchEvent.respondWith()method, which allows us to provide an arbitrary response back to the controlled page.
The parameter passed into the
InstallEventinterface represents an install action that is dispatched on the
ServiceWorker. As a child of
ExtendableEvent, it ensures that functional events such as
FetchEventare not dispatched during installation.
Provides methods for managing the preloading of resources with a service worker.
Represents a service worker. Multiple browsing contexts (e.g. pages, workers, etc.) can be associated with the same
Provides an object representing the service worker as an overall unit in the network ecosystem, including facilities to register, unregister, and update service workers, and access the state of service workers and their registrations.
Represents the global execution context of a service worker.
Represents a service worker registration.
Represents the scope of a service worker client that is a document in a browser context, controlled by an active worker. This is a special type of
Clientobject, with some additional methods and properties available.
CacheStorageobject associated with the current context.
- Using Service Workers
- Service Worker Lifecycle
- Service workers basic code example
- Web APIs that are related to the Service Worker API: