Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
var start = new Date();
for(var i = 0; i <= max; i++) {
sumAsync(3, 4);
}
var asyncTime = new Date - start;
console.log('async() took %d ms (x%d)', asyncTime, ~~ (asyncTime / nativeTime));
var start = new Date();
for(var i = 0; i <= max; i++) {
sumAsync.sync(null, 3, 4);
}
var asyncSyncTime = new Date - start;
console.log('async().sync() took %d ms (x%d)', asyncSyncTime, ~~ (asyncSyncTime / nativeTime));
var Future = require('fibers/future');
var sumFuture = Future.wrap(sum);
var start = new Date();
for(var i = 0; i <= max; i++) {
Future.wait(sumFuture(3, 4));
}
var fibersFutureTime = new Date - start;
console.log('Fibers.future took %d ms (x%d)', fibersFutureTime, ~~ (fibersFutureTime / nativeTime));
// Test Fibers
Fiber(function(){
var f = Fiber.current;
var start = new Date();
for(var i = 0; i <= max; i++) {
sum(3, 4, function() {
f.run();
});
Fiber.yield();
// fiber/future port originally written by Marcel Laverdet
// https://gist.github.com/1131093
// I updated it to bring to feature parity with cb version.
// The bugs are probably mine, not Marcel's.
// -- isaacs
var path = require('path')
, fs = require('fs')
, Future = require('fibers/future')
// Create future-returning fs functions
var fs2 = {}
for (var ii in fs) {
fs2[ii] = Future.wrap(fs[ii])
}
// Return a future which just pauses for a certain amount of time
function timer (ms) {
var future = new Future
setTimeout(function () {
future.return()
}, ms)
return future
}
function realish (p) {
return path.resolve(path.dirname(fs2.readlink(p)))
}
// fiber/future port originally written by Marcel Laverdet
// https://gist.github.com/1131093
// I updated it to bring to feature parity with cb version.
// The bugs are probably mine, not Marcel's.
// -- isaacs
var path = require('path')
, fs = require('fs')
, Future = require('fibers/future')
// Create future-returning fs functions
var fs2 = {}
for (var ii in fs) {
fs2[ii] = Future.wrap(fs[ii])
}
// Return a future which just pauses for a certain amount of time
function timer (ms) {
var future = new Future
setTimeout(function () {
future.return()
}, ms)
return future
}
function realish (p) {
return path.resolve(path.dirname(fs2.readlink(p)))
}
require('sync');
console.time('sync');
for (i = 0; i < n; i++) {
results.push(asyncFn.sync(null, i));
}
console.timeEnd('sync');
require('fibrous');
console.time('fibrous');
for (i = 0; i < n; i++) {
results.push(asyncFn.sync(i));
}
console.timeEnd('fibrous');
var Fiber = require('fibers'), Future = require('fibers/future'), futureAsync = Future.wrap(asyncFn);
console.time('fibers');
var fiber = Fiber.current;
for (i = 0; i < n; i++) {
setTimeout(function() {
fiber.run('foo'+i);
}, t);
results.push(Fiber.yield());
}
console.timeEnd('fibers');
console.time('future');
for (i = 0; i < n; i++) {
results.push(futureAsync(i).wait());
}
console.timeEnd('future');
for (var i = 0; i < n; i++) {
batch[i].wait();
}
console.timeEnd('syncho-future');
console.time('async.parallel');
for (var i = 0, batch = []; i < n; i++) {
batch.push(runAsync(i));
}
async.parallel(batch, function (err, res) {
for (var i = 0; i < n; i++)
res[i];
console.timeEnd('async.parallel');
});
var Future = require('fibers/future'), wait = Future.wait, future = Future.wrap(asyncFn);
console.time('future');
for (var i = 0, batch = []; i < n; i++) {
batch.push(future(i));
}
wait(batch);
console.timeEnd('future');
});
})();
}
console.timeEnd('fibrous');
var Fiber = require('fibers');
results = [];
console.time('fibers');
var fiber = Fiber.current;
for (var i = 0; i < n; i++) {
fs.stat('./package.json', function (err, res) {
fiber.run(res);
});
results.push(Fiber.yield());
}
console.timeEnd('fibers');
var Future = require('fibers/future'), futureAsync = Future.wrap(fs.stat.bind(fs), 1);
results = [];
console.time('future');
for (var i = 0; i < n; i++) {
results.push(futureAsync('./package.json').wait());
}
console.timeEnd('future');
results = [];
console.time('async.series');
async.series(asyncSeries, function (err, res) {
results = res;
console.timeEnd('async.series');
trueAsync();
});
if (Fiber === undefined ||
Fiber.current === undefined ||
Fiber.current.__reactAsyncStatePacket === undefined) {
return {};
}
invariant(
typeof this.getInitialStateAsync === 'function',
this.displayName + ' component must implement a `getInitialStateAsync` method. ' +
'Otherwise you should not use ReactAsync.Mixin'
);
var Future = require('fibers/future');
var getInitialStateAsync = Future.wrap(function(cb) {
var promise = this.getInitialStateAsync(cb);
if (promise && typeof promise.then === 'function') {
promise.then(cb.bind(cb, null), cb);
} else if (promise === false) {
cb(null);
}
}.bind(this));
var asyncState = getInitialStateAsync().wait();
var fingerprint = getComponentFingerprint(this);
var storedAsyncState = asyncState;
if (typeof this.stateToJSON === 'function') {
storedAsyncState = this.stateToJSON(storedAsyncState);
}
module.exports = function(fn){
var fnF = Future.wrap(fn);
return function(){
return fnF.apply(this, arguments).wait();
};
};
module.exports = function(fn){
var fnF = Future.wrap(fn);
return function(){
return fnF.apply(this, arguments).wait();
};
};
utils.wrapPromise = function(fn, target, multi, isPrototype){
return Future.wrap(function(){
var args = Array.prototype.slice.call(arguments);
var cb = args.pop();
/**
* If you don't want to bind on target, such as prototype binding then
* set it to true to bind to this. This will be the instance of the target
* because is on it's prototype.
*/
fn.apply(isPrototype ? this : target, args).then(function onSuccess(){
var args = Array.prototype.slice.call(arguments);
args.unshift(void 0);
cb.apply({}, args);
}, function onError(err){
cb(err);
})
}, !!multi);
}