Benchmark: Array vs Set (Large)

HTML Preparation code:

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

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

Script Preparation code:

var directAddresses = [];
for(var i=1; i< 100; i++) {
  directAddresses.push(`${i}deliverymanage@direct.com`);
}

var mySetDomains = new Set();
for(var i=1; i< 10000; i++) {
  mySetDomains.add(`${i}direct.com`);
}

var usingArrayDomains = [];
for(var j=1; j< 10000; j++) {
  usingArrayDomains.push(`${j}direct.com`);
}

​x
 
var directAddresses = [];for(var i=1; i< 100; i++) {  directAddresses.push(`${i}deliverymanage@direct.com`);}​var mySetDomains = new Set();for(var i=1; i< 10000; i++) {  mySetDomains.add(`${i}direct.com`);}​var usingArrayDomains = [];for(var j=1; j< 10000; j++) {  usingArrayDomains.push(`${j}direct.com`);}​

Tests:

Array

_.map(directAddresses, (da) => {
  const domain = da.split('@')[1];
  _.includes(usingArrayDomains, domain);
});

 
_.map(directAddresses, (da) => {  const domain = da.split('@')[1];  _.includes(usingArrayDomains, domain);});

Set

_.map(directAddresses, (da) => {
  const domain = da.split('@')[1];
  mySetDomains.has(domain);
});

 
_.map(directAddresses, (da) => {  const domain = da.split('@')[1];  mySetDomains.has(domain);});

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
Array
Set

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 81 on Mac OS X 10.15.4

View result in a separate tab

Test name	Executions per second
Array	319.4 Ops/sec
Set	20741.7 Ops/sec

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

Overview of the Benchmark

The provided JSON represents a JavaScript benchmarking test case on MeasureThat.net. The test measures the performance difference between using an Array and a Set data structure in JavaScript for a specific use case: checking if an element exists in an array.

What is tested?

In this benchmark, two test cases are compared:

Array: The first test case uses an Array (usingArrayDomains) to store domain names and checks if each domain name exists in the array using _.includes(usingArrayDomains, domain). This approach requires a linear search through the array for each iteration.
Set: The second test case uses a Set (mySetDomains) to store unique domain names and checks if each domain name exists in the set using mySetDomains.has(domain). This approach allows for constant-time lookups since Sets use hash tables.

Options compared

The two approaches are compared in terms of their performance characteristics:

Array: Requires a linear search through the array, which has a time complexity of O(n). This means that as the size of the array increases, the search time will also increase.
Set: Allows for constant-time lookups since Sets use hash tables, which have an average time complexity of O(1).

Pros and Cons

Here are some pros and cons of each approach:

Array:
- Pros: Simple to implement, easy to understand.
- Cons: Linear search can be slow for large datasets.
Set:
- Pros: Constant-time lookups, efficient for large datasets.
- Cons: Requires more memory to store the Set, may have additional overhead.

Library and purpose

The lodash library is used in both test cases. Lodash is a popular JavaScript utility library that provides a set of functional programming helpers, including _.includes(). The purpose of using Lodash is to simplify the implementation of the benchmark and make it more concise.

Special JS feature or syntax

There are no special JS features or syntax used in this benchmark other than the use of Arrays and Sets.

Other alternatives

If an alternative approach was needed, here are some options:

Using a Map: Instead of using an Array or Set, you could use a Map to store domain names. Maps have constant-time lookups similar to Sets.
Using a binary search algorithm: For larger datasets, you could implement a binary search algorithm to find the existence of a domain name in the array. This would have a time complexity of O(log n).

Keep in mind that these alternatives may add complexity to the implementation and may not offer significant performance benefits for small datasets.

I hope this explanation helps! Let me know if you have any further questions.

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

**What is tested?**

In this benchmark, two test cases are compared:

1. **Array**: The first test case uses an Array (`usingArrayDomains`) to store domain names and checks if each domain name exists in the array using `_.includes(usingArrayDomains, domain)`. This approach requires a linear search through the array for each iteration.
2. **Set**: The second test case uses a Set (`mySetDomains`) to store unique domain names and checks if each domain name exists in the set using `mySetDomains.has(domain)`. This approach allows for constant-time lookups since Sets use hash tables.

**Options compared**

The two approaches are compared in terms of their performance characteristics:

* **Array**: Requires a linear search through the array, which has a time complexity of O(n). This means that as the size of the array increases, the search time will also increase.
* **Set**: Allows for constant-time lookups since Sets use hash tables, which have an average time complexity of O(1).

**Pros and Cons**

Here are some pros and cons of each approach:

* **Array**:
	+ Pros: Simple to implement, easy to understand.
	+ Cons: Linear search can be slow for large datasets.
* **Set**:
	+ Pros: Constant-time lookups, efficient for large datasets.
	+ Cons: Requires more memory to store the Set, may have additional overhead.

**Library and purpose**

The `lodash` library is used in both test cases. Lodash is a popular JavaScript utility library that provides a set of functional programming helpers, including `_.includes()`. The purpose of using Lodash is to simplify the implementation of the benchmark and make it more concise.

**Special JS feature or syntax**

There are no special JS features or syntax used in this benchmark other than the use of Arrays and Sets.

**Other alternatives**

If an alternative approach was needed, here are some options:

* **Using a Map**: Instead of using an Array or Set, you could use a Map to store domain names. Maps have constant-time lookups similar to Sets.
* **Using a binary search algorithm**: For larger datasets, you could implement a binary search algorithm to find the existence of a domain name in the array. This would have a time complexity of O(log n).

Keep in mind that these alternatives may add complexity to the implementation and may not offer significant performance benefits for small datasets.

I hope this explanation helps! Let me know if you have any further questions.

Related benchmarks:

Array vs Set (Large) (version: 1)

Comparing performance of: Array vs Set

Created: 5 years ago by: Registered User

Jump to the latest result