Benchmark: Bind: Native vs Underscore vs Lodash

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>
<script src='https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js'></script>

Script Preparation code:

var objA = {
  x: 66,
  offsetX: function(offset) {
    return this.x + offset;
  }
}

var objB = {
  x: 67
};

// Underscore was loaded last, so this saves an instance of underscore and resets _ to it's previous value (lodash).
var _underscore = _.noConflict();
// This saves an instance of lodash and resets _ to it's previous value (undefined).
var _lodash = _.noConflict();

Tests:

Native
objA.offsetX.bind(objB, 0);
Underscore
_underscore.bind(objA.offsetX, objB, 0);
Lodash
_lodash.bind(objA.offsetX, objB, 0);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native
Underscore
Lodash

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**What is being tested?**

MeasureThat.net is testing the performance of three different approaches to bind a function to an object in JavaScript:

1. Native binding (using `bind()` method directly)
2. Underscore.js binding (using `_` namespace and `bind()` method)
3. Lodash.js binding (using `_` namespace and `bind()` method)

The tests are comparing the execution speed of these three approaches.

**Options being compared:**

* Native binding (using `objA.offsetX.bind(objB, 0)`): This is a direct implementation using the built-in `bind()` method.
* Underscore.js binding (using `_underscore.bind(objA.offsetX, objB, 0)`): This uses the `_` namespace from Underscore.js and the `bind()` method to create a bound function.
* Lodash.js binding (using `_lodash.bind(objA.offsetX, objB, 0)`): This also uses the `_` namespace from Lodash.js and the `bind()` method to create a bound function.

**Pros and Cons of each approach:**

* Native binding:
	+ Pros: No additional library overhead, straightforward implementation.
	+ Cons: May not be as efficient or convenient as using a library.
* Underscore.js binding:
	+ Pros: Uses a well-known and widely-used library, provides additional utility functions.
	+ Cons: Introduces additional library overhead, may require more setup.
* Lodash.js binding:
	+ Pros: Similar to Underscore.js, uses a popular and widely-used library.
	+ Cons: Same as Underscore.js, introduces additional library overhead.

**Library usage:**

In this benchmark, both Underscore.js and Lodash.js are used extensively. These libraries provide utility functions for functional programming, data manipulation, and other tasks that may be useful in certain scenarios. However, they also introduce additional complexity and overhead compared to native binding.

**Special JS feature/syntax:**

None mentioned in the provided benchmark definition.

**Other considerations:**

* Memory usage: The benchmark results will likely show varying memory usage patterns depending on which approach is used.
* Readability and maintainability: Native binding may be more readable and maintainable for simple use cases, while library bindings may introduce additional complexity and abstraction layers.

**Alternatives:**

If you're looking for alternative approaches to binding functions in JavaScript, some options include:

* Using a different library or framework that provides similar functionality (e.g., jQuery, Ramda)
* Implementing custom binding logic using JavaScript's `Function.prototype.bind()` method
* Using async/await or promises to create bound functions without the need for explicit binding.

Keep in mind that these alternatives may have their own pros and cons, depending on your specific use case and requirements.

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 15_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.5 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 15 on iOS 15.5

View result in a separate tab

Test name	Executions per second
Native	3493399.8 Ops/sec
Underscore	1391553.5 Ops/sec
Lodash	514156.7 Ops/sec

Related benchmarks:

Bind: Native vs Underscore vs Lodash (version: 0)

Comparing performance of: Native vs Underscore vs Lodash

Created: 4 years ago by: Registered User

Jump to the latest result

Native

Underscore

Lodash

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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