Benchmark: ramda vs javascript

HTML Preparation code:

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

Script Preparation code:

var data = [];
for (var i = 0; i < 100000; i++) {
    data.push({
        counter: i
    });
}

var condition = {
    field: {
        comparator: "IS_TIMERANGE"
    }
};

var propertyCell = {
    condition: {
        field: {
            comparator: "IS_TIMERANGE",
            end: [{
                value: 1
            }]
        }
    }
};

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:

regular javascript
const result = new Array(); for (var i = 0; i < data.length; i++) { const counter = data[i].counter; const propertyValue = propertyCell.condition.field.end[0].value; if (isOdd(counter + propertyValue)){ const r = square(counter); if (lessThanThreeDigits(r)) { result.push(r); } } }
ramda
const result = new Array(); for (var i = 0; i < data.length; i++) { const counter = R.propOr("", "counter", data); const propertyValueLast = R.last(R.pathOr([], ["condition", "field", "end"], propertyCell)); const propertyValue = R.prop("value", propertyValueLast); if (isOdd(counter + propertyValue)){ const r = square(counter); if (lessThanThreeDigits(r)) { result.push(r); } } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
regular javascript
ramda

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36

Browser/OS: Chrome 122 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
regular javascript	70.3 Ops/sec
ramda	17.7 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided benchmark compares the performance of regular JavaScript and Ramda, a popular functional programming library for JavaScript, in executing a specific microbenchmark.

**Benchmark Definition**

The benchmark defines two test cases:

1. **Regular JavaScript**: This test case uses plain JavaScript to iterate over the `data` array, apply various operations (e.g., `isOdd`, `square`, and `lessThanThreeDigits`) to each element, and filter the results.
2. **Ramda**: This test case uses Ramda's functional programming API to perform the same operations as the regular JavaScript version, but with a more concise and composable syntax.

**Comparison of Options**

The two test cases differ in their approach:

* Regular JavaScript:
	+ Uses explicit loops and conditionals to iterate over the data.
	+ Applies operations directly to the data elements.
	+ Filters results using a combination of functions.
* Ramda:
	+ Utilizes Ramda's functional programming API, which abstracts away iteration and filtering using higher-order functions.
	+ Performs operations on the `data` array using `R.propOr`, `R.last`, and `R.pathOr` functions from Ramda.

**Pros and Cons**

Here are some pros and cons of each approach:

* Regular JavaScript:
	+ Pros: Easy to understand and modify for specific use cases. Can be optimized with manual loop unrolling or other optimizations.
	+ Cons: More verbose, prone to errors due to the explicit nature of the code.
* Ramda:
	+ Pros: Concise, expressive, and easier to maintain due to its functional programming principles. Reduces boilerplate code and makes it easier to compose functions.
	+ Cons: Steeper learning curve due to the abstracted syntax. May require additional setup or library imports.

**Library and Syntax**

* Ramda:
	+ A popular functional programming library for JavaScript, providing a concise and composable API for common tasks like data manipulation, filtering, and mapping.
	+ The `R.propOr`, `R.last`, and `R.pathOr` functions are used to access nested properties in the `propertyCell` object.

**Special JS Features or Syntax**

Neither of the test cases uses any special JavaScript features or syntax that is not widely available. However, Ramda's functional programming API might be unfamiliar to developers without prior experience with functional programming concepts.

**Alternatives**

Other alternatives for similar microbenchmarks could include:

* Lodash: A popular utility library that provides a comprehensive set of functions for common tasks like data manipulation and filtering.
* Jest or other unit testing frameworks: Which can also include benchmarking capabilities to compare the performance of different implementations.
* Other functional programming libraries, such as lo-dash or mu.js.

In summary, the benchmark compares the performance of regular JavaScript and Ramda in executing a specific microbenchmark. The choice between these approaches depends on personal preference, familiarity with functional programming concepts, and the desired trade-off between conciseness and maintainability.

Related benchmarks:

ramda vs javascript (version: 0)

Comparing performance of: regular javascript vs ramda

Created: 2 years ago by: Guest

Jump to the latest result

regular javascript

ramda

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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