Benchmark: Lodash vs. Ramda vs. VanillaJS

Lodash vs. Ramda vs. VanillaJS (version: 7)

Compares performance on the same task using Lodash vs two styles of Ramda vs two styles of "native" Javascript. In all cases the task is pulling "counter" property from each item in an array, filtering out odd items, squaring them, then returning those squared values that have less than two digits. Comparing performance of: Lodash funcional style (idiomatic) vs Lodash funcional style (performance optimized with spread) vs Ramda without relying on currying or composition vs Ramda with currying and composition vs Ramda with transducers vs VanillaJS funcional style (idiomatic) vs VanillaJS funcional style (performance optimized with spread) vs VanillaJS procedural.

Comparing performance of: Lodash funcional style (idiomatic) vs Lodash functional style (performance optimized with spread) vs Ramda without relying on currying or composition vs Ramda with currying and composition vs Ramda with transducers vs VanillaJS funcional style (idiomatic) vs VanillaJS functional style (performance optimized with spread) vs VanillaJS procedural

Created: 2 months ago by: Registered User

Jump to the latest result

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.27.0/ramda.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js"></script>

Script Preparation code:

var data = [];
for (var i = 0; i < 10000; i++) {
     data.push({ counter: i });
}

function isOdd(num) {
  return num % 2 === 1;
}

function square(num) {
  return num * num;
}

function lessThanThreeDigits(num) {
  return num.toString().length < 3;
}

var expected = data.map(o => o.counter).filter(isOdd).map(square).filter(lessThanThreeDigits);

Tests:

Lodash funcional style (idiomatic)
var result = _.chain(data) .map('counter') .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .value();
Lodash functional style (performance optimized with spread)
var result = _.reduce(data, function(acc, d) { var c = d.counter; return (isOdd(c) && lessThanThreeDigits(square(c))) ? [...acc, square(c)] : acc; }, []);
Ramda without relying on currying or composition
var result = R.filter(lessThanThreeDigits, R.map(square, R.filter(isOdd, R.pluck('counter', data))));
Ramda with currying and composition
var result = R.pipe( R.pluck('counter'), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits) )(data);
Ramda with transducers
const xf = R.compose( R.map(R.prop('counter')), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits) ); const result = R.transduce(xf, R.flip(R.append), [], data);
VanillaJS funcional style (idiomatic)
var result = data.map(o => o.counter).filter(isOdd).map(square).filter(lessThanThreeDigits);
VanillaJS functional style (performance optimized with spread)
var result = data.reduce((acc, d) => { var c = d.counter; return (isOdd(c) && lessThanThreeDigits(square(c))) ? [...acc, square(c)] : acc; }, []);
VanillaJS procedural
var result = new Array(); for (var i = 0; i < data.length; i++) { var c = data[i].counter; if (isOdd(c)) { var r = square(c); if (lessThanThreeDigits(r)) { result.push(r); } } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash funcional style (idiomatic)
Lodash functional style (performance optimized with spread)
Ramda without relying on currying or composition
Ramda with currying and composition
Ramda with transducers
VanillaJS funcional style (idiomatic)
VanillaJS functional style (performance optimized with spread)
VanillaJS procedural

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36

Browser/OS: Chrome 132 on Windows

View result in a separate tab

Test name	Executions per second
Lodash funcional style (idiomatic)	2907.0 Ops/sec
Lodash functional style (performance optimized with spread)	5210.2 Ops/sec
Ramda without relying on currying or composition	880.6 Ops/sec
Ramda with currying and composition	864.6 Ops/sec
Ramda with transducers	759.1 Ops/sec
VanillaJS funcional style (idiomatic)	2703.3 Ops/sec
VanillaJS functional style (performance optimized with spread)	5908.4 Ops/sec
VanillaJS procedural	6313.7 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

The benchmark compares the performance of various JavaScript approaches to handling data manipulation tasks, specifically focusing on extracting and processing the `counter` property from a list of objects. The overall task consists of filtering out odd numbers, squaring them, and then filtering the results to retain only those values with less than two digits.

### Options Compared

1. **Lodash Functional Style (Idiomatic)**
   - Utilizes Lodash's chaining feature to perform a series of operations in a functional style.
   - **Pros**: Readable and expressive syntax; familiar to developers experienced with Lodash.
   - **Cons**: May have overhead due to multiple chained calls, which can impact performance compared to other methods.

2. **Lodash Functional Style (Performance Optimized with Spread)**
   - Similar to the idiomatic version but optimizes performance by using spread operators to construct intermediate arrays.
   - **Pros**: Potentially better performance due to reduced overhead in chain calls.
   - **Cons**: May sacrifice some readability for performance.

3. **Ramda without Relying on Currying or Composition**
   - This approach uses Ramda library functions but does not leverage its currying or functional composition features heavily.
   - **Pros**: Straightforward implementation for those familiar with basic Ramda functions.
   - **Cons**: Avoiding the core strengths of Ramda (currying and composition) limits potential performance and clarity benefits.

4. **Ramda with Currying and Composition**
   - Uses Ramda’s currying and composition to build the operations in a functional style.
   - **Pros**: More concise and readable; harnesses Ramda’s functional strengths.
   - **Cons**: Potential learning curve for those unfamiliar with functional programming paradigms.

5. **Ramda with Transducers**
   - Utilizes transducers, a concept for composing operations that can be combined efficiently.
   - **Pros**: Highly efficient as it allows for processing the data in a single pass, rather than creating intermediary structures.
   - **Cons**: More complex and may be harder to understand for developers unfamiliar with the concept of transducers.

6. **VanillaJS Functional Style (Idiomatic)**
   - Uses native JavaScript methods like `map`, `filter`, and avoids any external libraries.
   - **Pros**: No dependencies, straightforward and simple to use.
   - **Cons**: For very large datasets or complex operations, native functions may be slower than optimized library methods.

7. **VanillaJS Functional Style (Performance Optimized with Spread)**
   - Similar to the idiomatic vanilla approach but uses the spread operator to optimize performance.
   - **Pros**: Enhances performance through better memory usage; leverages modern JavaScript syntax.
   - **Cons**: Could be less readable for those not familiar with the spread operator.

8. **VanillaJS Procedural**
   - Implements the logic in a traditional procedural style.
   - **Pros**: Very clear and straightforward; anyone familiar with basic loops can understand it.
   - **Cons**: May be less elegant compared to functional programming styles and could lead to more cumbersome code with added complexity.

### Libraries Used

- **Lodash**: A JavaScript utility library that provides functions for common programming tasks. It helps simplify coding with functions for array manipulation, object manipulation, and other aspects of JavaScript programming using a functional style.
  
- **Ramda**: A functional programming library in JavaScript designed for a functional programming style, promoting immutability and side-effect-free functions. It provides functions like `map`, `filter`, and `compose` that enable developers to create more predictable and maintainable code.

### Additional Considerations

- **Performance**: When choosing between these options, it is essential to consider the trade-off between readability and performance. In scenarios where performance is critical (e.g., with large datasets), it may be beneficial to prioritize more optimized approaches, even at the cost of some readability.
  
- **Maintainability**: Code events that are easily understandable are typically easier to maintain. For teams communicating frequently and changing code, more conventional methods might be preferred.

### Alternatives to Consider

- **RxJS**: If the operations are tied to streams of data or events, using a reactive programming library like RxJS could offer powerful alternatives for managing and transforming data.
  
- **Immutable.js**: For cases requiring immutability, Immutable.js can provide structures that enhance performance while reducing side effects commonly associated with mutable data.
  
- **Functional Libraries (e.g., folktale)**: Other functional programming libraries that specialize in side-effect-free functions could also be considered for developers wanting to explore beyond Lodash or Ramda.

In summary, developers can select from several approaches based on their functional programming proficiency, need for performance, and personal or team coding style preferences while weighing the pros and cons of each method.

Related benchmarks:

Lodash vs. Ramda vs. VanillaJS (version: 7)

Created: 2 months ago by: Registered User

Jump to the latest result

Lodash funcional style (idiomatic)

Lodash functional style (performance optimized with spread)

Ramda without relying on currying or composition

Ramda with currying and composition

Ramda with transducers

VanillaJS funcional style (idiomatic)

VanillaJS functional style (performance optimized with spread)

VanillaJS procedural

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):