Service workers in Svelte - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a service worker in web development?

A service worker is a script that runs in the background of a web browser, separate from the web page. It helps manage caching, offline support, and background tasks like push notifications.

beginner

How do service workers improve user experience in Svelte apps?

Service workers cache app files and data, so the app loads faster and works offline. This means users can keep using the app even without an internet connection.

intermediate

Which lifecycle event is used to cache files when a service worker is installed?

The 'install' event is used to cache files. During this event, the service worker can open a cache and store important files for offline use.

intermediate

What is the role of the 'fetch' event in a service worker?

The 'fetch' event intercepts network requests. The service worker can respond with cached files or fetch fresh data from the network, enabling offline support and faster loading.

beginner

How can you register a service worker in a Svelte app?

You register a service worker by calling 'navigator.serviceWorker.register("/service-worker.js")' in your app's main script, usually inside a lifecycle hook or on page load.

What does a service worker run separately from?

A The web page

B The server

C The database

D The operating system

Service workers run separately from the web page in the browser background.

Which event is used to cache files when a service worker starts?

A load

B activate

C fetch

D install

The 'install' event is where caching usually happens.

How does a service worker help when the user is offline?

A It disables the app

B It fetches data from the server

C It serves cached files

D It restarts the browser

Service workers serve cached files to keep the app working offline.

Where do you usually register a service worker in a Svelte app?

A In the main JavaScript file

B In the HTML head

C In the CSS file

D In the server code

You register service workers in the main JavaScript or Svelte script.

What does the 'fetch' event in a service worker do?

A Starts the service worker

B Intercepts network requests

C Caches files

D Deletes old caches

The 'fetch' event lets the service worker intercept network requests.

Explain how service workers enable offline support in a Svelte app.

Think about how the app can still work without internet.

Describe the steps to register and use a service worker in a Svelte project.

Focus on registration and lifecycle events.

Practice

1. What is the main purpose of a service worker in a Svelte app?

easy

A. To enable offline support and faster loading by caching files

B. To handle user authentication and sessions

C. To manage component state and props

D. To style components dynamically

Solution

1. Step 1: Understand service worker role

   Service workers run in the background and cache files to allow offline use and faster loading.

2. Step 2: Differentiate from other app features

   User authentication, state management, and styling are handled by other parts of the app, not service workers.

3. Final Answer:

   To enable offline support and faster loading by caching files -> Option A

4. Quick Check:

   Service workers = offline support and caching [OK]

Hint: Service workers cache files for offline use [OK]

Common Mistakes:

• Confusing service workers with authentication
• Thinking service workers manage UI state
• Assuming service workers handle styling

2. Which is the correct way to register a service worker in a Svelte app?

easy

A. navigator.serviceWorker.register('/service-worker.js')

B. serviceWorker.register('/service-worker.js')

C. navigator.registerServiceWorker('/service-worker.js')

D. register.serviceWorker('/service-worker.js')

Solution

1. Step 1: Recall the correct API

   The standard API to register a service worker is navigator.serviceWorker.register().

2. Step 2: Check method and object names

   Only navigator.serviceWorker.register('/service-worker.js') uses the correct object (navigator.serviceWorker) and method (register).

3. Final Answer:

   navigator.serviceWorker.register('/service-worker.js') -> Option A

4. Quick Check:

   Use navigator.serviceWorker.register() [OK]

Hint: Use navigator.serviceWorker.register() to register [OK]

Common Mistakes:

• Using wrong method names like registerServiceWorker
• Calling register on wrong objects
• Missing navigator or serviceWorker in the call

3. What will happen if you try to register a service worker in a browser that does not support it, using this code?

if ('serviceWorker' in navigator) {
  navigator.serviceWorker.register('/sw.js')
    .then(() => console.log('Registered'))
    .catch(err => console.error('Failed', err));
} else {
  console.log('No support');
}

medium

A. Registers the service worker anyway

B. Throws an error because serviceWorker is undefined

C. Logs 'No support' and does not attempt registration

D. Logs 'Registered' even if unsupported

Solution

1. Step 1: Check the feature detection condition

   The code checks if 'serviceWorker' exists in navigator before registering.

2. Step 2: Understand behavior if unsupported

   If unsupported, the else block runs, logging 'No support' and skipping registration.

3. Final Answer:

   Logs 'No support' and does not attempt registration -> Option C

4. Quick Check:

   Feature check prevents errors = logs 'No support' [OK]

Hint: Check 'serviceWorker' in navigator before registering [OK]

Common Mistakes:

• Assuming registration runs without support
• Expecting errors instead of safe fallback
• Confusing logs from then/catch with else block

4. Identify the error in this service worker registration code snippet:

if (navigator.serviceWorker) {
  navigator.serviceWorker.register('/sw.js')
    .then(() => console.log('Registered'))
    .catch(err => console.error('Failed', err));
}

medium

A. The catch block is incorrectly placed

B. register() method is missing parentheses

C. The path '/sw.js' must be absolute URL

D. Should check 'serviceWorker' in navigator, not just navigator.serviceWorker

Solution

1. Step 1: Analyze the feature detection condition

   The code checks if navigator.serviceWorker exists directly, which can cause errors if undefined.

2. Step 2: Correct way to check support

   The proper check is 'serviceWorker' in navigator to safely detect support.

3. Final Answer:

   Should check 'serviceWorker' in navigator, not just navigator.serviceWorker -> Option D

4. Quick Check:

   Use 'serviceWorker' in navigator for support check [OK]

Hint: Use 'serviceWorker' in navigator, not navigator.serviceWorker alone [OK]

Common Mistakes:

• Checking navigator.serviceWorker directly without 'in'
• Misplacing catch block
• Thinking path must be full URL

5. You want your Svelte app to update the cached files when a new service worker version is available. Which approach correctly handles this scenario?

hard

A. Reload the page immediately after registering the service worker

B. Listen for 'updatefound' event on registration and call skipWaiting() in the new worker

C. Unregister the old service worker manually before registering a new one

D. Do nothing; service workers update automatically without extra code

Solution

1. Step 1: Understand service worker update process

   When a new service worker is found, the 'updatefound' event fires on the registration.

2. Step 2: Use skipWaiting() to activate new worker immediately

   Calling skipWaiting() on the new worker lets it take control without waiting for old pages to close.

3. Step 3: Evaluate other options

   Reloading immediately or unregistering manually is not recommended; automatic updates require event handling.

4. Final Answer:

   Listen for 'updatefound' event on registration and call skipWaiting() in the new worker -> Option B

5. Quick Check:

   Use 'updatefound' + skipWaiting() to update cache [OK]

Hint: Use 'updatefound' event and skipWaiting() to update cache [OK]

Common Mistakes:

• Ignoring updatefound event
• Reloading page too early
• Unregistering service workers unnecessarily
• Assuming automatic update without code