Benchmark: find by id and replace in array [lodash vs js vs ramda]

HTML Preparation code:

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.min.js"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/lodash-fp/0.10.4/lodash-fp.min.js"></script>

AخA
 
<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.min.js"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/lodash-fp/0.10.4/lodash-fp.min.js"></script>

Script Preparation code:

var arr = [{id: 1, name: "Person 1"}, {id: 2, name: "Person 2"}];

 
var arr = [{id: 1, name: "Person 1"}, {id: 2, name: "Person 2"}];

Tests:

lodash map

var newArr = _.map(arr, function(a) {
  return a.id === 1 ? {id: 1, name: "Person New Name"} : a;
});

 
var newArr = _.map(arr, function(a) {  return a.id === 1 ? {id: 1, name: "Person New Name"} : a;});

es6 map

// ES6
var newArr = arr.map(function(a) {
  return a.id === 1 ? {id: 1, name: "Person New Name"} : a;
});

 
// ES6var newArr = arr.map(function(a) {  return a.id === 1 ? {id: 1, name: "Person New Name"} : a;});

lodash findIndex and splice
var index = _.findIndex(arr, {id: 1}); // Replace item at index using native splice arr.splice(index, 1, {id: 100, name: 'Person New Name'});
x

var index = _.findIndex(arr, {id: 1});

// Replace item at index using native splice
arr.splice(index, 1, {id: 100, name: 'Person New Name'});
ramda findIndex and splice
const index = R.findIndex(R.propEq('id', 1))(arr) arr.splice(index, 1, {id: 100, name: 'Person New Name'});
const index = R.findIndex(R.propEq('id', 1))(arr)
arr.splice(index, 1, {id: 100, name: 'Person New Name'});

ramda map

var newArr = R.map(function(a) {
  return a.id === 1 ? {id: 1, name: "Person New Name"} : a;
})(arr);

 
var newArr = R.map(function(a) {  return a.id === 1 ? {id: 1, name: "Person New Name"} : a;})(arr);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
lodash map
es6 map
lodash findIndex and splice
ramda findIndex and splice
ramda map

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 18 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0

Browser/OS: Firefox 137 on Windows

View result in a separate tab

Test name	Executions per second
lodash map	800214.8 Ops/sec
es6 map	42949436.0 Ops/sec
lodash findIndex and splice	5924058.5 Ops/sec
ramda findIndex and splice	2106770.0 Ops/sec
ramda map	9059769.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 7 months ago):

Overview of the Benchmark

The provided JSON represents a JavaScript microbenchmarking test case on MeasureThat.net, which compares the performance of different approaches for finding an item by ID in an array and replacing it with a new value.

Benchmark Definition

The benchmark definition consists of four individual test cases:

lodash map
ES6 map
lodash findIndex and splice
ramda findIndex and splice

These test cases demonstrate different ways to achieve the same goal using various JavaScript libraries: Lodash, Ramda, and native JavaScript.

Options Compared

The benchmark compares the performance of:

Lodash: A popular utility library for functional programming in JavaScript.
Ramda: Another functional programming library for JavaScript.
Native JavaScript: The built-in JavaScript functions map() and findIndex(), along with manual indexing and splicing.

Pros and Cons of Each Approach

Lodash:
- Pros: Easy to use, well-documented, and widely adopted.
- Cons: Additional dependency, may introduce unnecessary overhead due to its large size.
Ramda:
- Pros: Offers a more concise and expressive API than Lodash.
- Cons: Smaller community compared to Lodash, may have fewer features.
Native JavaScript:
- Pros: No additional dependencies, lightweight, and well-suited for performance-critical code.
- Cons: Requires manual indexing and splicing, which can be error-prone.

Library Purpose

The lodash library provides a comprehensive set of functional programming utilities, including the map() function used in the benchmark. It's designed to make common tasks easier and more efficient.

The ramda library offers a more concise API for functional programming, with features like higher-order functions and currying. It's intended to be a more expressive alternative to Lodash.

Special JS Features/Syntax

None of the test cases explicitly use any special JavaScript features or syntax that would require additional explanation.

Other Alternatives

If you're looking for alternatives to Lodash and Ramda, consider:

Underscore.js: Another popular utility library for functional programming in JavaScript.
MooTools: A comprehensive JavaScript framework with a range of utilities, including functional programming helpers.
RxJS: A reactive programming library that provides a different approach to handling data streams and transformations.

These libraries offer varying degrees of similarity to Lodash and Ramda, but may have their own strengths and weaknesses depending on your specific use case.

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

**Benchmark Definition**

The benchmark definition consists of four individual test cases:

1. `lodash map`
2. ES6 `map`
3. `lodash findIndex` and `splice`
4. `ramda findIndex` and `splice`

These test cases demonstrate different ways to achieve the same goal using various JavaScript libraries: Lodash, Ramda, and native JavaScript.

**Options Compared**

The benchmark compares the performance of:

1. **Lodash**: A popular utility library for functional programming in JavaScript.
2. **Ramda**: Another functional programming library for JavaScript.
3. **Native JavaScript**: The built-in JavaScript functions `map()` and `findIndex()`, along with manual indexing and splicing.

**Pros and Cons of Each Approach**

1. **Lodash**:
	* Pros: Easy to use, well-documented, and widely adopted.
	* Cons: Additional dependency, may introduce unnecessary overhead due to its large size.
2. **Ramda**:
	* Pros: Offers a more concise and expressive API than Lodash.
	* Cons: Smaller community compared to Lodash, may have fewer features.
3. **Native JavaScript**:
	* Pros: No additional dependencies, lightweight, and well-suited for performance-critical code.
	* Cons: Requires manual indexing and splicing, which can be error-prone.

**Library Purpose**

The `lodash` library provides a comprehensive set of functional programming utilities, including the `map()` function used in the benchmark. It's designed to make common tasks easier and more efficient.

The `ramda` library offers a more concise API for functional programming, with features like higher-order functions and currying. It's intended to be a more expressive alternative to Lodash.

**Special JS Features/Syntax**

None of the test cases explicitly use any special JavaScript features or syntax that would require additional explanation.

**Other Alternatives**

If you're looking for alternatives to Lodash and Ramda, consider:

1. **Underscore.js**: Another popular utility library for functional programming in JavaScript.
2. **MooTools**: A comprehensive JavaScript framework with a range of utilities, including functional programming helpers.
3. **RxJS**: A reactive programming library that provides a different approach to handling data streams and transformations.

These libraries offer varying degrees of similarity to Lodash and Ramda, but may have their own strengths and weaknesses depending on your specific use case.

Related benchmarks:

find by id and replace in array [lodash vs js vs ramda] (version: 0)

find by id and replace in array [lodash vs js vs ramda]

Comparing performance of: lodash map vs es6 map vs lodash findIndex and splice vs ramda findIndex and splice vs ramda map

Created: 3 years ago by: Registered User

Jump to the latest result