Benchmark: Time to create simple promises

Tests:

One promise
console.log(test()); async function test(){ let param = 'test'; const result = await doSomething(param); return result; } async function doSomething(p) { const result1 = p; const result2 = p + 'a'; const result3 = p + 'b'; const result4 = p + 'c'; const result5 = p + 'd'; return new Promise(function(resolve, reject) { resolve([result1, result2, result3, result4, result5]); }); }
two promise
console.log(test()); async function test(){ let param = 'test'; const result = await doSomething(param); return result; } async function doSomething(p) { const result1 = await doSomethingElse(p); const result2 = await doSomethingElse(p, 'a'); const result3 = await doSomethingElse(p, 'b'); const result4 = await doSomethingElse(p, 'c'); const result5 = await doSomethingElse(p, 'd'); return new Promise(function (resolve, reject) { resolve([result1, result2, result3, result4, result5]); }); async function doSomethingElse(p, p2 = '') { const result = p + p2; return new Promise(function (resolve, reject) { resolve(result); }); } }
zero promise
console.log(test()); function test(){ let param = 'test'; const result = doSomething(param); return result; } function doSomething(p) { const result1 = p; const result2 = p + 'a'; const result3 = p + 'b'; const result4 = p + 'c'; const result5 = p + 'd'; return [result1, result2, result3, result4, result5]; }
shorter
console.log(test()); function test(){ return doSomething('test'); } function doSomething(p) { return [p, p + 'a', p + 'b', p + 'c', p + 'd']; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
One promise
two promise
zero promise
shorter

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):

LLMs can make mistakes. Check important info.

To explain what is tested on the provided JSON, I'll break down each test case.

**Test Case 1: "One promise"**

This test case measures the time it takes to create and return a single Promise in JavaScript. The `test()` function creates a new Promise by calling `doSomething('test')` and returns its result. The `doSomething(p)` function also creates a new Promise that resolves with an array of strings, where each string is constructed by concatenating the input parameter `p` with additional characters.

**Options compared:**

* Using `Promise` constructor to create a new Promise.
* Returning the resolved value directly from the Promise constructor.

**Pros and Cons:**

* Creating a Promise using the constructor can be more explicit and safer, as it allows for better error handling and cancellation.
* However, in this specific test case, the difference might not be noticeable, as the execution time is relatively short.

**Test Case 2: "Two promise"**

This test case measures the time it takes to create and return two Promises in JavaScript. The `test()` function creates a new Promise by calling `doSomething('test', 'a')` and returns its result. The `doSomething(p, p2)` function also creates two Promises that resolve with arrays of strings, where each string is constructed by concatenating the input parameters.

**Options compared:**

* Using multiple `Promise` constructors to create separate Promises.
* Returning an array of resolved values from a single Promise constructor.

**Pros and Cons:**

* Creating multiple Promises using separate constructors can be more efficient, as it avoids creating unnecessary intermediate objects.
* However, in this specific test case, the difference might not be noticeable, as the execution time is relatively short.

**Test Case 3: "Zero promise"**

This test case measures the time it takes to create and return a Promise that resolves with an array of strings, without using the `Promise` constructor. The `test()` function calls `doSomething('test')` directly and returns its result.

**Options compared:**

* Using the `Promise` constructor to create a new Promise.
* Returning an array of values directly from the `doSomething(p)` function.

**Pros and Cons:**

* Not using the `Promise` constructor can be more lightweight, as it avoids creating unnecessary objects.
* However, in this specific test case, the difference might not be noticeable, as the execution time is relatively short.

**Test Case 4: "Shorter"**

This test case measures the time it takes to create and return a Promise that resolves with an array of strings, using a shorter version of the `doSomething(p)` function. The only change is that the concatenation operations are performed directly on the input parameter.

**Options compared:**

* Using a longer version of the `doSomething(p)` function.
* Using a shorter version of the same function.

**Pros and Cons:**

* Using a shorter version of the same function can be more efficient, as it reduces overhead due to extra concatenation operations.
* However, in this specific test case, the difference might not be noticeable, as the execution time is relatively short.

**Libraries used:**

None.

**Special JS features or syntax:**

The test cases use JavaScript's async/await syntax, which allows for more readable code and easier handling of Promises. The `doSomething(p)` function uses template literals to construct strings by concatenating the input parameter with additional characters.

Other alternatives:

* To create a Promise, you can use the `new Promise()` constructor or the `.then()` method.
* To return multiple values from a function, you can use an array of values or a data structure like `Map` or `Reduce`.
* To optimize performance, you can consider using techniques like memoization, caching, or parallel processing.

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:106.0) Gecko/20100101 Firefox/106.0

Browser/OS: Firefox 106 on Linux

View result in a separate tab

Test name	Executions per second
One promise	122316.9 Ops/sec
two promise	91413.9 Ops/sec
zero promise	180159.0 Ops/sec
shorter	183905.6 Ops/sec

Related benchmarks:

Time to create simple promises (version: 0)

Comparing performance of: One promise vs two promise vs zero promise vs shorter

Created: 4 years ago by: Guest

Jump to the latest result

One promise

two promise

zero promise

shorter

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):