個別のJavascriptファイルのないWebワーカーですか？
私が知る限り、Webワーカーは別のJavaScriptファイルで記述し、次のように呼び出す必要があります。
new Worker('longrunning.js')
私はすべてのJavaScriptソースコードを結合および縮小するためにクロージャーコンパイラを使用しており、配布のためにワーカーを別々のファイルに置く必要はありません。これを行う方法はありますか？
new Worker(function() {
//Long-running work here
});
ファーストクラスの関数がJavaScriptにとって非常に重要であることを考えると、バックグラウンド作業を行う標準的な方法では、サーバーから「別のJavaScriptファイル全体をロードする必要があるのはなぜですか？」
http://www.html5rocks.com/en/tutorials/workers/basics/#toc-inlineworkers
ワーカースクリプトをその場で作成する場合、または個別のワーカーファイルを作成せずに自己完結型のページを作成する場合はどうでしょうか。 Blob（）を使用すると、ワーカーコードへのURLハンドルを文字列として作成することにより、メインロジックと同じHTMLファイルでワーカーを「インライン化」できます。
BLOBインラインワーカーの完全な例：
<!DOCTYPE html>
<script id="worker1" type="javascript/worker">
// This script won't be parsed by JS engines because its type is javascript/worker.
self.onmessage = function(e) {
self.postMessage('msg from worker');
};
// Rest of your worker code goes here.
</script>
<script>
var blob = new Blob([
document.querySelector('#worker1').textContent
], { type: "text/javascript" })
// Note: window.webkitURL.createObjectURL() in Chrome 10+.
var worker = new Worker(window.URL.createObjectURL(blob));
worker.onmessage = function(e) {
console.log("Received: " + e.data);
}
worker.postMessage("hello"); // Start the worker.
</script>Web Worker CodeをHTMLに埋め込むhtml5rocksソリューションはかなり恐ろしいものです。
そして、エスケープされたJavaScript-as-a-a-stringのblobは、特にワークフローを複雑にするため（Closureコンパイラは文字列を操作できません）、ましです。
個人的に私はtoStringメソッドが本当に好きですが、 @ dan-man その正規表現！
私の優先アプローチ：
// Build a worker from an anonymous function body
var blobURL = URL.createObjectURL( new Blob([ '(',
function(){
//Long-running work here
}.toString(),
')()' ], { type: 'application/javascript' } ) ),
worker = new Worker( blobURL );
// Won't be needing this anymore
URL.revokeObjectURL( blobURL );
サポートは、これら3つのテーブルの共通部分です。
- http://caniuse.com/#feat=webworkers
- http://caniuse.com/#feat=blobbuilder
- http://caniuse.com/#feat=bloburls
これは、SharedWorkerでは機能しません。これは、オプションの「name」パラメーターが一致しても、URLは完全に一致する必要があるためです。 SharedWorkerの場合、個別のJavaScriptファイルが必要です。
2015更新-ServiceWorkerの特異点が到着
この問題を解決するさらに強力な方法があります。繰り返しますが、ワーカーコードを（静的文字列ではなく）関数として保存し、.toString（）を使用して変換してから、選択した静的URLの下のCacheStorageにコードを挿入します。
// Post code from window to ServiceWorker...
navigator.serviceWorker.controller.postMessage(
[ '/my_workers/worker1.js', '(' + workerFunction1.toString() + ')()' ]
);
// Insert via ServiceWorker.onmessage. Or directly once window.caches is exposed
caches.open( 'myCache' ).then( function( cache )
{
cache.put( '/my_workers/worker1.js',
new Response( workerScript, { headers: {'content-type':'application/javascript'}})
);
});
2つのフォールバックが考えられます。上記のObjectURL、またはよりシームレスに、/ my_workers/worker1.jsにrealJavaScriptファイルを配置します
このアプローチの利点は次のとおりです。
- SharedWorkersもサポートできます。
- タブは、固定アドレスでキャッシュされた単一のコピーを共有できます。 blobアプローチでは、タブごとにランダムなobjectURLが増殖します。
実行コンテキストを認識し、親スクリプトとワーカーの両方として機能できる単一のJavaScriptファイルを作成できます。このようなファイルの基本構造から始めましょう。
(function(global) {
var is_worker = !this.document;
var script_path = is_worker ? null : (function() {
// append random number and time to ID
var id = (Math.random()+''+(+new Date)).substring(2);
document.write('<script id="wts' + id + '"></script>');
return document.getElementById('wts' + id).
previousSibling.src;
})();
function msg_parent(e) {
// event handler for parent -> worker messages
}
function msg_worker(e) {
// event handler for worker -> parent messages
}
function new_worker() {
var w = new Worker(script_path);
w.addEventListener('message', msg_worker, false);
return w;
}
if (is_worker)
global.addEventListener('message', msg_parent, false);
// put the rest of your library here
// to spawn a worker, use new_worker()
})(this);
ご覧のように、スクリプトには親とワーカーの両方の視点のすべてのコードが含まれており、独自のインスタンスが!documentを持つワーカーであるかどうかを確認します。多少扱いにくいscript_path計算は、new Workerに提供されるパスがスクリプトではなく親ページに関連するため、親ページに関連するスクリプトのパスを正確に計算するために使用されます。
Blobメソッドを使用して、ワーカーファクトリでこれを行う方法は次のとおりです。
var BuildWorker = function(foo){
var str = foo.toString()
.match(/^\s*function\s*\(\s*\)\s*\{(([\s\S](?!\}$))*[\s\S])/)[1];
return new Worker(window.URL.createObjectURL(
new Blob([str],{type:'text/javascript'})));
}
このように使用できます...
var myWorker = BuildWorker(function(){
//first line of worker
self.onmessage(){....};
//last line of worker
});
編集：
クロススレッド通信をより簡単にするために、このアイデアをさらに拡張しました： bridged-worker.js 。
編集2：
上記のリンクは、私が作成した要旨です。他の誰かが後でそれを 実際のレポ に変えました。
Webワーカーは、個別のプログラムとして完全に独立したコンテキストで動作します。
これは、コードがオブジェクト形式であるコンテキストから別のコンテキストに移動できないことを意味します。コードは、他のコンテキストに属するクロージャを介してオブジェクトを参照できるためです。
ECMAScriptはシングルスレッド言語として設計されているため、これは特に重要です。Webワーカーは個別のスレッドで動作するため、スレッドセーフでない操作が実行されるリスクがあります。
これもまた、Webワーカーをソース形式のコードで初期化する必要があることを意味します。
WHATWG の仕様には、
結果の絶対URLのオリジンがエントリスクリプトのオリジンと異なる場合、SECURITY_ERR例外をスローします。
したがって、スクリプトは元のページと同じスキームの外部ファイルである必要があります：data：URLまたはjavascript：URLからスクリプトをロードすることはできず、https：ページはhttp：URLのスクリプトを使用してワーカーを開始できませんでした。
しかし、残念ながら、ソースコードを含む文字列をコンストラクタに渡すことを許可できなかった理由は実際には説明されていません。
インラインワーカーには読みやすい方法です。
var worker_fn = function(e)
{
self.postMessage('msg from worker');
};
var blob = new Blob(["onmessage ="+worker_fn.toString()], { type: "text/javascript" });
var worker = new Worker(window.URL.createObjectURL(blob));
worker.onmessage = function(e)
{
alert(e.data);
};
worker.postMessage("start");
最近の回答（2018）
Greenlet を使用できます。
非同期関数を独自のスレッドに移動します。 Workerize の単純化された単一機能バージョン。
例：
import greenlet from 'greenlet'
const getName = greenlet(async username => {
const url = `https://api.github.com/users/${username}`
const res = await fetch(url)
const profile = await res.json()
return profile.name
})
console.log(await getName('developit'))
Adriaの応答を取得し、現在のChromeおよびFFで動作するがIE10では動作しないコピー貼り付け可能な関数に配置します（blobのワーカーは セキュリティエラー を引き起こします）。
var newWorker = function (funcObj) {
// Build a worker from an anonymous function body
var blobURL = URL.createObjectURL(new Blob(
['(', funcObj.toString(), ')()'],
{type: 'application/javascript'}
));
var worker = new Worker(blobURL);
// Won't be needing this anymore
URL.revokeObjectURL(blobURL);
return worker;
}
そして、ここに実例があります http://jsfiddle.net/ubershmekel/YYzvr/
VkThreadプラグインをご覧ください。 htisプラグインを使用すると、メインコードで任意の関数を取得し、スレッド（Webワーカー）で実行できます。したがって、特別な「ウェブワーカーファイル」を作成する必要はありません。
http://www.eslinstructor.net/vkthread/
-ヴァディム
ユースケースに応じて、次のようなものを使用できます
task.jsCPUを集中的に使用するコードをすべてのコア（node.js、およびweb）で実行するための簡素化されたインターフェース
例は
function blocking (exampleArgument) {
// block thread
}
// turn blocking pure function into a worker task
const blockingAsync = task.wrap(blocking);
// run task on a autoscaling worker pool
blockingAsync('exampleArgumentValue').then(result => {
// do something with result
});
インラインWebworkerを使用して、同じjavascriptファイルでWeb Workerを使用できます。
以下の記事では、Webワーカーとその制限およびWebワーカーのデバッグを簡単に理解できるように説明します。
これを行うためのより良い方法は、Blobオブジェクトを使用することだと思います。以下に簡単な例を示します。
// create a Blob object with a worker code
var blob = new Blob(["onmessage = function(e) { postMessage('msg from worker'); }"]);
// Obtain a blob URL reference to our worker 'file'.
var blobURL = window.URL.createObjectURL(blob);
// create a Worker
var worker = new Worker(blobURL);
worker.onmessage = function(e) {
console.log(e.data);
};
worker.postMessage("Send some Data");
ThisArgと引数（callと同様）を取り、promiseを返す、単純な約束バージョンFunction#callAsWorker：
Function.prototype.callAsWorker = function (...args) {
return new Promise( (resolve, reject) => {
const code = `self.onmessage = e => self.postMessage((${this.toString()}).call(...e.data));`,
blob = new Blob([code], { type: "text/javascript" }),
worker = new Worker(window.URL.createObjectURL(blob));
worker.onmessage = e => (resolve(e.data), worker.terminate());
worker.onerror = e => (reject(e.message), worker.terminate());
worker.postMessage(args);
});
}
// Demo
function add(...nums) {
return nums.reduce( (a,b) => a+b );
}
// Let the worker execute the above function, with the specified arguments
add.callAsWorker(null, 1, 2, 3).then(function (result) {
console.log('result: ', result);
});JThreadを使用してみてください。 https://github.com/cheprasov/jThread
// You can use simple calling like this
jThread(
function(arr){
//... some code for Worker
return arr;
}
,function(arr){
//... done code
}
)( [1,2,3,4,5,6,7] ); // some params
これは上記の単なる追加です。jsFiddleでWebワーカーをテストするための素敵なテンプレートがあります。 Blobではなく、jsFiddles ?js apiを使用します。
function workerFN() {
self.onmessage = function(e) {
switch(e.data.name) {
case "" :
break;
default:
console.error("Unknown message:", e.data.name);
}
}
}
// This is a trick to generate real worker script that is loaded from server
var url = "/echo/js/?js="+encodeURIComponent("("+workerFN.toString()+")()");
var worker = new Worker(url);
worker.addEventListener("message", function(e) {
switch(e.data.name) {
case "" :
break;
default:
console.error("Unknown message:", e.data.name);
}
})
通常の web worker および shared worker テンプレートが利用可能です。
https://developer.mozilla.org/es/docs/Web/Guide/Performance/Using_web_workers
// Syntax: asyncEval(code[, listener])
var asyncEval = (function () {
var aListeners = [], oParser = new Worker("data:text/javascript;charset=US-ASCII,onmessage%20%3D%20function%20%28oEvent%29%20%7B%0A%09postMessage%28%7B%0A%09%09%22id%22%3A%20oEvent.data.id%2C%0A%09%09%22evaluated%22%3A%20eval%28oEvent.data.code%29%0A%09%7D%29%3B%0A%7D");
oParser.onmessage = function (oEvent) {
if (aListeners[oEvent.data.id]) { aListeners[oEvent.data.id](oEvent.data.evaluated); }
delete aListeners[oEvent.data.id];
};
return function (sCode, fListener) {
aListeners.Push(fListener || null);
oParser.postMessage({
"id": aListeners.length - 1,
"code": sCode
});
};
})();
ES6のテンプレートリテラルのおかげで、これにはもう1つのクールなオプションがあると思います。これにより、余分なワーカー関数（およびその奇妙なスコープ）を省き、ワーカーを対象としたコードを複数行テキストとして記述することができます。これは、テキストやDOMを実際に必要とせずに、それを行うには。例：
const workerScript = `
self.addEventListener('message', function(e) {
var data = e.data;
console.log('worker recieved: ',data);
self.postMessage('worker added! :'+ addOne(data.value));
self.close();//kills the worker
}, false);
`;
そのアプローチの残りの要点 です。
配列に収集し、それぞれに対して.toStringを実行して文字列に減らすだけで、必要な追加の関数依存関係をワーカーに取り込むことができます（関数宣言である限り機能します）。それをスクリプト文字列の先頭に追加します。そうすれば、私たちが書いているコードの範囲に既にバンドルしているかもしれないスクリプトをインポートする必要がありません。
この特定のバージョンの唯一の本当の欠点は、リンターが（単なる文字列であるため）サービスワーカーコードをリントできないことです。これは、「個別のワーカー関数アプローチ」の利点です。
ここコンソール：
var worker=new Worker(window.URL.createObjectURL(new Blob([function(){
//Long-running work here
postMessage('done');
}.toString().split('\n').slice(1,-1).join('\n')],{type:'text/javascript'})));
worker.addEventListener('message',function(event){
console.log(event.data);
});
私の小さなプラグインを使用してください https://github.com/zevero/worker-create
var worker_url = Worker.createURL(function(e){
self.postMessage('Example post from Worker'); //your code here
});
var worker = new Worker(worker_url);
CodePenは現在、<script>ではない（またはtype属性を持たない）インラインtype="text/javascript"タグを構文強調表示しないことを発見しました。
そこで、 ラベル付きブロック とbreakを使用して、似ているがわずかに異なるソリューションを考案しました。これは、ラッパー関数を作成せずに<script>タグから救済できる唯一の方法です（これは不要です）。
<!DOCTYPE html>
<script id="worker1">
worker: { // Labeled block wrapper
if (typeof window === 'object') break worker; // Bail if we're not a Worker
self.onmessage = function(e) {
self.postMessage('msg from worker');
};
// Rest of your worker code goes here.
}
</script>
<script>
var blob = new Blob([
document.querySelector('#worker1').textContent
], { type: "text/javascript" })
// Note: window.webkitURL.createObjectURL() in Chrome 10+.
var worker = new Worker(window.URL.createObjectURL(blob));
worker.onmessage = function(e) {
console.log("Received: " + e.data);
}
worker.postMessage("hello"); // Start the worker.
</script>このようなコードを使用すると、onmessageをプレーンテキスト以外の関数として定義できるため、エディターでコードを強調表示してjshintを機能させることができます。
const worker = createWorker();
createWorker() {
const scriptContent = getWorkerScript();
const blob = new Blob([
scriptContent,
], {
type: "text/javascipt"
});
const worker = new Worker(window.URL.createObjectURL(blob));
return worker;
}
getWorkerScript() {
const script = {
onmessage: function (e) {
console.log(e);
let result = "Hello " + e.data
postMessage(result);
}
};
let content = "";
for (let prop in script){
content += `${prop}=${script[prop].toString()}`;
}
return content;
}はい、可能です。Blobファイルを使用してコールバックを渡しました
私が書いたクラスが何をするか、そしてそれがバックグラウンドでコールバックの実行をどのように管理するかを示します。
まず、Web Workerで実行するコールバックに渡したいデータを使用してGenericWebWorkerをインスタンス化します。このデータには、使用する関数、この場合は数値、日付、blockerという関数が含まれます。
var worker = new GenericWebWorker(100, new Date(), blocker)
このブロッカー関数は、nミリ秒の間無限に実行されます
function blocker (ms) {
var now = new Date().getTime();
while(true) {
if (new Date().getTime() > now +ms)
return;
}
}
そして、あなたはこのようにそれを使用します
worker.exec((num, date, fnBlocker) => {
/*Everithing here does not block the main thread
and this callback has access to the number, date and the blocker */
fnBlocker(10000) //All of this run in backgrownd
return num*10
}).then(d => console.log(d)) //Print 1000
さて、次の例で魔法を見る時間です
/*https://github.com/fercarvo/GenericWebWorker*/
class GenericWebWorker {
constructor(...ags) {
this.args = ags.map(a => (typeof a == 'function') ? {type:'fn', fn:a.toString()} : a)
}
async exec(cb) {
var wk_string = this.worker.toString();
wk_string = wk_string.substring(wk_string.indexOf('{') + 1, wk_string.lastIndexOf('}'));
var wk_link = window.URL.createObjectURL( new Blob([ wk_string ]) );
var wk = new Worker(wk_link);
wk.postMessage({ callback: cb.toString(), args: this.args });
var resultado = await new Promise((next, error) => {
wk.onmessage = e => (e.data && e.data.error) ? error(e.data.error) : next(e.data);
wk.onerror = e => error(e.message);
})
wk.terminate(); window.URL.revokeObjectURL(wk_link);
return resultado
}
async parallel(arr, cb) {
var res = [...arr].map(it => new GenericWebWorker(it, ...this.args).exec(cb))
var all = await Promise.all(res)
return all
}
worker() {
onmessage = async function (e) {
try {
var cb = new Function(`return ${e.data.callback}`)();
var args = e.data.args.map(p => (p.type == 'fn') ? new Function(`return ${p.fn}`)() : p);
try {
var result = await cb.apply(this, args); //If it is a promise or async function
return postMessage(result)
} catch (e) { throw new Error(`CallbackError: ${e}`) }
} catch (e) { postMessage({error: e.message}) }
}
}
}
function blocker (ms) {
var now = new Date().getTime();
while(true) {
if (new Date().getTime() > now +ms)
return;
}
}
setInterval(()=> console.log("Not blocked " + Math.random()), 1000)
console.log("\n\nstarting blocking code in Worker\n\n")
var worker = new GenericWebWorker(100, new Date(), blocker)
worker.exec((num, date, fnBlocker) => {
fnBlocker(7000) //All of this run in backgrownd
return num*10
})
.then(d => console.log(`\n\nEnd of blocking code: result ${d}\n\n`)) //Print 1000Worker.jsファイルの内容をバックティック（複数行の文字列定数を許可）内に配置し、次のようにblobからワーカーを作成できます。
var workerScript = `
self.onmessage = function(e) {
self.postMessage('message from worker');
};
// rest of worker code goes here
`;
var worker =
new Worker(createObjectURL(new Blob([workerScript], { type: "text/javascript" })));
これは、何らかの理由でワーカーに個別のスクリプトタグを持たせたくない場合に便利です。
別の解決策は、Workerを関数でラップしてから、次のように関数を呼び出すblobを作成することです。
function workerCode() {
self.onmessage = function (e) {
console.log("Got message from parent", e.data);
};
setTimeout(() => {
self.postMessage("Message From Worker");
}, 2000);
}
let blob = new Blob([
"(" + workerCode.toString() + ")()"
], {type: "text/javascript"});
// Note: window.webkitURL.createObjectURL() in Chrome 10+.
let worker = new Worker(window.URL.createObjectURL(blob));
worker.onmessage = function (e) {
console.log("Received: " + e.data);
};
worker.postMessage("hello"); // Start the worker.