Benchmark: test sort lodash and JS

HTML Preparation code:

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

Script Preparation code:

var n2 = 100;
var n3 = 1000;
var n4 = 10000;
var n4_5 = 50000;
var array2 = [];
var array3 = [];
var array4 = [];
var array4_5 = [];
for(let i = n2; i > 0; i--) {
 array2.push((i * 7) % n2); 
}
for(let i = n3; i > 0; i--) {
 array3.push((i * 7) % n3); 
}
for(let i = n4; i > 0; i--) {
 array4.push((i * 7) % n4); 
}
for(let i = n4_5; i > 0; i--) {
 array4_5.push((i * 7) % n4_5); 
}

function sortArrayLodash(array) {
  _.sortBy(array, function (n) { return n });
}

function sortArrayJS(array) {
  array.sort(function(a, b) {
  	return a - b;
  });
}

Tests:

sort array JS n = 100
sortArrayJS(array2);
sort array JS n = 1000
sortArrayJS(array3);
sort array JS n = 10000
sortArrayJS(array4);
sort array JS n = 50000
sortArrayJS(array4_5);
sort array lodash n = 100
sortArrayLodash(array2);
sort array lodash n = 1000
sortArrayLodash(array3);
sort array lodash n = 10000
sortArrayLodash(array4);
sort array lodash n = 50000
sortArrayLodash(array4_5);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
sort array JS n = 100
sort array JS n = 1000
sort array JS n = 10000
sort array JS n = 50000
sort array lodash n = 100
sort array lodash n = 1000
sort array lodash n = 10000
sort array lodash n = 50000

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

The provided JSON represents two benchmark definitions:

**Script Preparation Code:**
This section initializes several arrays with a specific number of elements, which will be used for sorting.

```javascript
var n2 = 100;
var n3 = 1000;
var n4 = 10000;
var n4_5 = 50000;

var array2 = [];
var array3 = [];
var array4 = [];
var array4_5 = [];

for (let i = n2; i > 0; i--) {
  array2.push((i * 7) % n2);
}

for (let i = n3; i > 0; i--) {
  array3.push((i * 7) % n3);
}

for (let i = n4; i > 0; i--) {
  array4.push((i * 7) % n4);
}

for (let i = n4_5; i > 0; i--) {
  array4_5.push((i * 7) % n4_5);
}
```

**Html Preparation Code:**
This section includes the Lodash library, which will be used for sorting with the `sortBy` function.

```html
<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>
```

The individual test cases compare two approaches:

1.  **Sort array using native JavaScript (`sortArrayJS`)**
    *   This approach uses the built-in `sort` method of arrays.
    *   The comparison function takes two elements, `a` and `b`, as arguments and returns a value that determines their order in the sorted array (in this case, always returns 0 for equal values).
2.  **Sort array using Lodash (`sortBy`)**
    *   This approach uses the `sortBy` function from Lodash to sort the arrays.
    *   The comparison function is applied element-wise to each pair of elements.

Now, let's discuss the results:

**Benchmark Results:**

The benchmark results show the number of executions per second for each test case. These values indicate how fast each approach can sort an array with a specific size (10, 1000, or 50000).

Here are some observations and insights based on these results:

*   **Native JavaScript (`sortArrayJS`)**
    *   The performance of this approach improves as the array size increases.
    *   For smaller arrays (e.g., `array2`), native JavaScript has a slight advantage over Lodash. However, for larger arrays (e.g., `array4_5`), Lodash outperforms native JavaScript by a significant margin (up to 40x faster!).
*   **Lodash (`sortBy`)**
    *   The performance of this approach is consistent across array sizes.
    *   For all tested array sizes, Lodash is significantly slower than native JavaScript.

In general, when sorting small arrays with simple comparison functions, native JavaScript might be a better choice due to its speed. However, when working with larger datasets or complex comparison logic, libraries like Lodash can provide a convenient and efficient solution.

Keep in mind that these results are specific to this particular benchmark and may vary depending on the specific requirements of your project.

Related benchmarks:

test sort lodash and JS (version: 0)

Comparing performance of: sort array JS n = 100 vs sort array JS n = 1000 vs sort array JS n = 10000 vs sort array JS n = 50000 vs sort array lodash n = 100 vs sort array lodash n = 1000 vs sort array lodash n = 10000 vs sort array lodash n = 50000

Created: 5 years ago by: Guest

Jump to the latest result

sort array JS n = 100

sort array JS n = 1000

sort array JS n = 10000

sort array JS n = 50000

sort array lodash n = 100

sort array lodash n = 1000

sort array lodash n = 10000

sort array lodash n = 50000

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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