Benchmark: Partial use of function

Script Preparation code:

function ts(...args){
  let template = '';
  args.forEach(arg => {
  	if (typeof arg === 'string') { 
      template += ' '+arg;
      return; 
    }
  	if (arg.join) { 
      arg.forEach((e) => { 
        template += ' ' + e; 
      }) 
      return;
    }
    let entries = Object.entries(arg);
    if (entries.length) {
      entries.forEach(entry => {
       if(entry[1]) template += ' ' + entry[0]
      })
    }
  })
  return template;
}

var str = 'style';
var obj = {
 	 'style-2': true,
  	 'style-3': false,
 	 'style-4': true,
}
var arr = ['style-5', 'style-6']

Tests:

String, obj, arr
let result = ts(str, obj, arr, 'test classname')
str, obj
let result = ts(str, obj, 'test classname')
str, arr
let result = ts(str, arr, 'test classname')
str
let result = ts(str,'test classname')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
String, obj, arr
str, obj
str, arr
str

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition**

The benchmark measures how the usage of a function affects its performance in terms of operations per second (Ops/sec). The function `ts` is defined to take one or more arguments, which are either strings, objects, arrays, or a combination of these. The function's purpose is to concatenate and manipulate these inputs to generate a template string.

**Options Compared**

The benchmark compares four different approaches:

1. **Using all input arguments**: `let result = ts(str, obj, arr, 'test classname')`
2. **Using only two input arguments**: `let result = ts(str, obj)`
3. **Using only one input argument**: `let result = ts(str, arr)`
4. **Using no input arguments**: `let result = ts('test classname')`

**Pros and Cons of Each Approach**

1. **Using all input arguments**:
	* Pros: All inputs are used to generate the template string.
	* Cons: This approach might be slower due to the overhead of processing multiple inputs.
2. **Using only two input arguments**: `let result = ts(str, obj)`
	* Pros: Still uses all possible inputs, but with fewer function calls.
	* Cons: One input is skipped, which might affect performance.
3. **Using only one input argument**: `let result = ts(str, arr)`
	* Pros: Faster than using two arguments, as it processes less data.
	* Cons: Some potential benefits of using multiple inputs (e.g., object properties) are lost.
4. **Using no input arguments**:
	* Pros: Fastest approach, as it bypasses all processing and generates a fixed template string.
	* Cons: Does not utilize any input data and might not be representative of real-world usage.

**Library Used**

The `ts` function uses the `Array.prototype.forEach()` method to iterate over its input arguments. It also employs `Object.entries()` to access object properties. No specific library is required, as these methods are built-in or part of the ECMAScript standard.

**Special JavaScript Features**

No special JavaScript features or syntax are used in this benchmark. The code relies solely on standard language constructs and built-in methods.

**Other Alternatives**

If you want to explore alternative approaches or optimize the `ts` function, consider the following:

* Using a more efficient string concatenation method, like `template += `${arg}``.
* Leveraging `Function.prototype.apply()` to reduce function call overhead.
* Experimenting with different input data distributions (e.g., random, uniform) to find optimal usage patterns.

Keep in mind that these optimizations might come at the cost of increased complexity or performance degradation for non-optimized use cases.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/82.0.4073.0 Safari/537.36 Edg/82.0.446.0

Browser/OS: Chrome 82 on Mac OS X 10.15.3

View result in a separate tab

Test name	Executions per second
String, obj, arr	726676.1 Ops/sec
str, obj	848610.8 Ops/sec
str, arr	2461677.2 Ops/sec
str	4078991.0 Ops/sec

Related benchmarks:

Partial use of function (version: 0)

See how usage of function matters in Ops/sec

Comparing performance of: String, obj, arr vs str, obj vs str, arr vs str

Created: 4 years ago by: Registered User

Jump to the latest result

String, obj, arr

str, obj

str, arr

str

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):