Skip to main content
100%

Gist 164876

✓ Published0🌍 Public
XXXX
Last edited Aug 9, 2009
Created on Aug 9, 2009

This example demonstrates a minimal two-way communication setup between a main HTML page and a background worker thread, using the `Worker` API to offload a request. The worker script `my_worker.js` uses `XMLHttpRequest` to fetch `http://www.google.com/` and posts the response text back to the main page via `postMessage`, which is displayed through an `alert`. The code shows the basic pattern of instantiating a `Worker`, assigning an `onmessage` handler, and triggering an asynchronous request, but it does not include any data visualization or rendering.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 164985

This example demonstrates a failed attempt to use an XMLHttpRequest inside a Web Worker, triggered by a postMessage from the main page. The main script creates a Worker from `my_worker.js`, which defines a `makeRequest` function that tries to open a GET request to `http://www.google.com/`. The worker’s `onmessage` handler calls this function, but the request fails with an exception (`0x805e000a`), revealing that cross-origin or file-protocol requests are blocked in this context. The code uses the Web Worker API and the native `XMLHttpRequest` object, but does not show any data visualization or rendering.

XXXX
85% match
Loading thumbnail…

Minimal WebWorker example

This example demonstrates a minimal use of the Web Worker API to exchange messages between a main thread and a background worker. It shows a round-trip communication where `main.js` creates a `Worker` from `worker.js`, posts the string "ping", and logs the worker's reply "pong" to the console, while the worker logs its received message. The code relies on the native `Worker`, `postMessage`, and `onmessage` APIs, with no external libraries, and uses a simple JavaScript file pair as the data source.

TThomasG77
77% match
Loading thumbnail…

Gist eeac85f83bbc682a4f2d

This example demonstrates how to run a simple inline Web Worker that greets a user by name, with a fallback to executing the worker script on the main thread when the browser lacks necessary APIs. It uses a `<script type="javascript/worker">` block for the worker code and the `runWorkerJs` helper, which checks for `Blob`, `BlobBuilder`, `URL.createObjectURL`, and `Worker` support. If those are available, it creates a worker from the script’s text and posts a parameter object; otherwise, it evals the script in a proxy scope. The result updates the page body text.

PPhilippe Rivière
76% match
Loading thumbnail…

Gist 164984

This example demonstrates an error that occurs when a Web Worker attempts to make a cross-origin XMLHttpRequest to `http://www.google.com/` from a local file. The page spawns a worker via `new Worker('my_worker.js')`, which sends a GET request and tries to post the response status back to the main thread. However, the worker’s `XMLHttpRequest.open` call throws a security exception (`0x805e000a`), highlighting the restriction that workers cannot access external URLs without proper CORS headers, even when the worker itself is loaded locally.

XXXX
76% match
Loading thumbnail…

Hello World!

This example demonstrates a minimal Electron application that displays runtime versions for Node.js, Chromium, and Electron while also enabling worker-thread communication. It shows a button that triggers a streaming data exchange via the MessageChannel API, where a worker thread sends ten messages back to the renderer process. The main process uses `ipcMain.on` to handle requests and spawns a Node.js Worker, while the renderer relies on `ipcRenderer.postMessage` and `MessageChannel` ports for bidirectional messaging. The code uses Electron 28, Node.js worker threads, and plain HTML/CSS for the interface.

ZZaitsev
65% match
Loading thumbnail…

Gist 7233762

This example shows a JavaScript application skeleton converted to use AJAX, with the updated files provided as a gist. The code demonstrates an asynchronous data-loading pattern, fetching external resources via `XMLHttpRequest` or a similar AJAX mechanism. It relies on standard browser APIs for handling responses and updating the page content dynamically. The visualization aspect is minimal, focusing instead on the structural change from a static app to one that retrieves data on demand. The author lists the modified files and includes instructions for downloading the original skeleton, making the gist a practical exercise in refactoring for asynchronous behavior.

EElaineYu
61% match
Loading thumbnail…

Gist 2d272134b57b02eb8cdd0c5904249591

This example tests the archival fidelity of a web page by loading a series of images and scripts that mimic dynamic behavior, including DOM manipulation, AJAX requests, and delayed updates. It uses JavaScript’s `XMLHttpRequest` to fetch remote images and replaces them via base64 data URLs, while `setTimeout` and scroll events trigger asynchronous content changes. The page is rendered within an iframe by the pywb web archiving tool, with a banner and rewrite layer applied. The visualization demonstrates how archived sites handle live interactions and resource loading over time.

NN0taN3rd
60% match
Loading thumbnail…

Gist 7232670

This example demonstrates how a single-page application skeleton is transformed from a static document into an interactive, AJAX-driven experience. The visualization shows a list of user-submitted code entries, with each entry dynamically loaded and rendered without a full page refresh. The implementation uses jQuery’s `$.ajax` method to fetch the `lucky_ajax.md` file and other resources, then updates the DOM with the retrieved content. The code also relies on JavaScript’s `Promise` API for handling asynchronous responses, and highlights the use of `XMLHttpRequest` for network communication. The data source is the downloaded application skeleton, whose structure is revealed through the fetched files. The example focuses on the interaction between client-side scripting and server responses.

EElaineYu
59% match