Skip to main content
100%

Gist 164985

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

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.

AI-generated description

Similar vizzes

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
87% match
Loading thumbnail…

Gist 164876

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.

XXXX
85% 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
70% 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
66% 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 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
57% match
Loading thumbnail…

Force-Directed Web Worker

This example shows a force-directed graph of 1,000 nodes computed in a web worker, with a progress bar indicating the simulation’s tick rate. The main thread receives progress updates and renders the final layout on a Canvas using `getContext("2d")`. The layout is calculated with `d3.forceSimulation`, using `forceManyBody`, `forceLink`, and `forceX`/`forceY` forces in worker.js, which imports d3-force modules via `importScripts`.

Mmbostock
56% match
Loading thumbnail…

Js xhr test

This example tests the behavior of the JavaScript `XMLHttpRequest` object inside a React environment, rendering a single "Hello Js" message in large text. The code attempts two approaches: one creates an `XMLHttpRequest` and accesses a nested `.xhr` property, while the other directly instantiates it. Each instance has a `load` event listener added, though the page displays no data loading or visualization output. The example uses plain HTML, CSS for styling, and vanilla JavaScript with no external libraries like D3 or React components.

LLaurens
56% match