yukaii / synchronized-promise Goto Github PK

View Code? Open in Web Editor NEW

43.0 4.0 5.0 594 KB

Turn ES6 Promise into synchronize function call, a simple wrapper of deasync package

Home Page: https://www.npmjs.com/package/synchronized-promise

License: MIT License

JavaScript 100.00%

deasync promise synchronize

synchronized-promise's Introduction

synchronized-promise

Turn ES6 Promise into synchronize function call, a simple wrapper of deasync package

Installation

npm install synchronized-promise --save

Usage

First, you need to require the synchronized-promise package, for JavaScript:

const sp = require('synchronized-promise')

For TypeScript or ES6 later JavaScript:

import sp from 'synchronized-promise'

Then call it as the following example:

// An promise base async function
let asyncFunction = (value) => {
  return new Promise((resolve, reject) => {
    setTimeout(function () {
      resolve(value)
    }, 2000)
  })
}

// regular usage
asyncFunction(5).then(value => value === 5)

// make it synchronized
let syncFunc = sp(asyncFunction)
const value = syncFunc(5) // value === 5

See test.js for usage in details.

Contributors ✨

Thanks goes to these wonderful people (emoji key):

_侠小然
💻

_{Clar Charron}
💻

_{Pedro Augusto de Paula Barbosa}
📖

This project follows the all-contributors specification. Contributions of any kind welcome!

synchronized-promise's People

Contributors

Stargazers

Watchers

Forkers

masquevil wph888666 supercipher papb rasata

synchronized-promise's Issues

其實已經有 deasync-promise 了

https://github.com/jakwuh/deasync-promise

呃，寫完才發現重造輪子，算了不管了 😂

Indicate that package only works in node environment

update README

Add test cases

https://gist.github.com/Yukaii/2f2ba5a3343740af26d65ae5ea2ca412

var data = syncPromise(asyncFunction, true, 10000)()
console.log(data)

// throw timeout error
try {
  syncPromise(asyncFunction, false, 1000)()
} catch (e) {
  console.log(e)
}

// Promise rejection
try {
  syncPromise(asyncFunction, false, 3000)()
} catch (e) {
  console.log(e)
}

console.log('aweeeeesome')

似乎不支持 this？

如果一个异步方法里面调用了 this，似乎是不支持的，有办法支持吗？

例子：

class A {
  constructor() { this.x = 1; }
  async getX() { return this.x; }
}
const a = new A();
sp(a.getX)();
// 会报错  Cannot read property 'x' of undefined

It's very slow for me.

This package is cool it makes something possible (in workaround situations) that should not be.. but from my initial tests it's very slow.

Following test case: (node v18.14.0)

const sp = require('synchronized-promise');
const a = async function( x ) { return x + 1; }
const b = function b( x ) { return x + 1; }
const n = 50;

console.time( 'simple sync');
let v = 0;
for( let i = 0; i < n; i++ )
{
	v = b( v );
}
console.timeEnd( 'simple sync');

console.time( 'synchornized promise');
const as = sp( a );
v = 0;
for( let i = 0; i < n; i++ )
{
	v = as( v );
}
console.timeEnd( 'synchornized promise');


console.time( 'classic async');
( async function test( )
{
	v = 0;
	for( let i = 0; i < n; i++ )
	{
		v = await a( v );
	}
	console.timeEnd( 'classic async');
}) ( );

classic async has to be last test, since the main loop would continue straight away.

Result:

$ node src/a.js 
simple sync: 0.044ms
synchornized promise: 5.022s
classic async: 0.136ms

As expected promises are a tad slower than direct calls.. but syncronized promises, is way out there in being extremly slow (the code generator I wanted to use it in, where I have an await edge case turns from being almost instant to .. wait a minute or two).

I'm okay with again some overhead to await/async, but this is a bit too much.