Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
Ramda Uniq Vs Set 2
(version: 0)
testing ramda uniq vs set
Comparing performance of:
Ramda vs JS SET
Created:
2 years ago
by:
Guest
Go to the latest result
HTML Preparation code:
<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.min.js"></script>
Script Preparation code:
var arr = Array.from({length: 40}, () => Math.floor(Math.random() * 40));
Tests:
Ramda
R.uniq(arr)
JS SET
Array.from(new Set(arr))
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
Ramda
JS SET
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
one year ago
)
User agent:
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 YaBrowser/24.7.0.0 Safari/537.36
Browser/OS:
Yandex Browser 24 on Windows
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=560730" width="100%" height="500px"></iframe>
JS SET
1.3M/s
Ramda
1.1M/s
View exact numbers
Test name
Executions per second
✓
JS SET
1,339,096 Ops/sec
Ramda
1,088,215 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
I'd be happy to explain the benchmark and its results. **Benchmark Overview** The benchmark is testing the performance of two approaches to remove duplicates from an array: Ramda's `R.uniq` function and the built-in JavaScript `Set` object. The test case creates a large array with random integers, measures the execution time of each approach, and compares the results. **Options Compared** Two options are compared: 1. **Ramda's `R.uniq`**: This is a functional programming library that provides various functions for manipulating arrays and objects. In this case, it uses a custom implementation to remove duplicates from an array. 2. **JavaScript Set object**: The built-in JavaScript `Set` object can be used to remove duplicates from an array by converting the array to a set and then back to an array. **Pros and Cons of Each Approach** 1. **Ramda's `R.uniq`**: * Pros: Can handle large datasets, provides a more functional programming approach. * Cons: May have overhead due to the use of a custom implementation, can be slower than built-in JavaScript options for small datasets. 2. **JavaScript Set object**: * Pros: Built-in and optimized for performance, handles small to medium-sized datasets well. * Cons: Can become inefficient for very large datasets, requires conversion between array and set. **Library Used** In this benchmark, the Ramda library is used for its `R.uniq` function. Ramda provides a range of functional programming tools for manipulating arrays, objects, and other data structures. **Special JS Feature or Syntax** There are no special JavaScript features or syntax mentioned in this benchmark. The test simply uses standard JavaScript constructs to create an array and compare the performance of different approaches. **Other Considerations** When choosing between these two approaches, consider the size of your dataset and the trade-off between performance and ease of use. If you need to handle very large datasets, Ramda's `R.uniq` might be slower due to its custom implementation. However, if you're working with smaller datasets, the JavaScript Set object is likely a better choice. **Alternative Options** Other alternatives for removing duplicates from an array include: * Lodash's `uniqBy` function * The `filter()` method in combination with the `includes()` method * Using the `Map` object to keep track of unique values These approaches may have varying performance characteristics and trade-offs, so it's worth exploring each option depending on your specific use case.
Related benchmarks
flatten : Array.flat() vs Ramda
Ramda range vs Array.from
Ramda uniq vs JS set
lodash uniq vs Array.from(new Set()) vs spread new Set() vs for vs for memory optimized 4
Comments
Confirm delete:
Do you really want to delete benchmark?