Launching a website offline without the Internet using Service Worker (English version)
Tags: webdev, javascript, tutorial, serviceworker
Published: 2024-04-17 16:28:49

Nowadays, when Internet access has become an integral part of everyday life, the ability to work offline without an Internet connection is becoming increasingly important. Service Worker is a technology that allows a site to save resources and work even when there is no Internet connection.

**What is a Service Worker?**
Service Worker is a script that runs in the background in the browser and manages network requests and caching. It acts as a proxy server between the application and the network, providing control over how requests are processed and resources are cached.

**Use cases**

1. Offline mode: Service Worker can cache resources such as HTML, CSS, JavaScript and images, allowing the site to function offline.
2. Improved Cache: When connected to the Internet, Service Worker can cache resources to improve download speeds and reduce server load.
3. Notifications: Service Worker can be used to send notifications to the user even when the site is not active in the browser.

**Getting started**
**Registering a Service Worker:** Create a JavaScript file for your Service Worker and register it in the main script of your site.

```
// Checking if the browser supports Service Worker
if ('serviceWorker' in navigator) {
    // Registering the Service Worker file '/service-worker.js'
    navigator.serviceWorker.register('/service-worker.js')
    .then((registration) => {
        // If the registration was successful, we display a message about successful registration
        console.log('Service Worker is registered:', registration);
    })
    .catch((error) => {
        // If an error occurred during registration, we display an error message
        console.error('Error registering Service Worker:', error);
    });
}
```
**Service Worker Implementation:** In your Service Worker file, define which resources need to be cached and how to process requests.

```
// Installing Service Worker
self.addEventListener('install', (event) => {
    // Waiting for the installation process to complete
    event.waitUntil(
        // Opening a new cache named 'my-cache'
        caches.open('my-cache')
        .then((cache) => {
            // Adding resources to the cache that need to be cached
            return cache.addAll([
                '/index.html',    // Main page
                '/styles.css',    // CSS styles file
                '/script.js',     // JavaScript file
                '/offline.html'   // Page for offline mode
            ]);
        })
    );
});

// Handling requests
self.addEventListener('fetch', (event) => {
    event.respondWith(
        // Looking for the corresponding resource in the cache
        caches.match(event.request)
        .then((response) => {
            // If the resource is found in the cache, return it
            // If not, make a network request to get the resource
            return response || fetch(event.request);
        })
        .catch(() => {
            // If an error occurs while searching in the cache or making a network request,
            // return a special page for offline mode
            return caches.match('/offline.html');
        })
    );
});
```

**Cache Management:** You can use Service Worker methods to manage the cache, add, delete, or update resources.

**Example 1:**
**Offline page:** Create an HTML page offline.html which will be displayed when there is no Internet connection, and add it to the cache.

```
<!-- offline.html -->
<html>
<head>
    <title>Offline</title>
</head>
<body>
    <h1>You are offline</h1>
</body>
</html>
```
**Example 2:**
**Notifications:** Use Service Worker to send notifications to the user.

```
// In the Service Worker file
self.addEventListener('push', (event) => {
    // Setting the notification title
    const title = 'Notification';

    // Forming notification parameters
    const options = {
        body: event.data.text(), // Notification text obtained from the event
        icon: '/icon.png',       // Notification icon
        badge: '/badge.png'      // Notification badge (usually a small icon)
    };

    // Displaying the notification
    // Waiting until the notification is shown
    event.waitUntil(
        // Calling the showNotification() method to register the notification
        self.registration.showNotification(title, options)
    );
});
```
**Conclusion**
This article is a basic overview of the Service Worker technology, designed to provide an understanding of its capabilities. Using Service Broker, you can create a website that, in principle, can fully function offline, providing users with access to content even in the absence of the Internet.

Running a website offline using Service Worker is just the beginning of the path to creating a sustainable and responsive web application. Using this technology, you can implement various functions such as content caching, query processing, cache management, and sending notifications. By exploring and experimenting more deeply with Service Worker, you will be able to create more complex and powerful web applications, providing users with a better experience using your site.