Benchmark: Filter vs. set - MeasureThat.net

Script Preparation code:

requirements = [
  'hasNumber',
  'hasSpecialChar',
  'hasUppercaseLetter'
];

passwordRequirements = [
  {
    key: 'hasNumber',
    label: "Has a number 0-9",
    validate: password => {
      const trimmedPassword = password.trim();

      if (trimmedPassword && trimmedPassword.length) {
        return /[0-9]/.test(trimmedPassword);
      }

      return false;
    }
  },
  {
    key: 'hasSpecialChar',
    label: "Has a special char !@#$%^&*",
    validate: password => {
      const trimmedPassword = password.trim();

      if (trimmedPassword && trimmedPassword.length) {
        return /[!@#$%^&*]/.test(trimmedPassword);
      }

      return false;
    }
  },
  {
    key: 'hasUppercaseLetter',
    label: "Has uppercase Letter",
    validate: password => {
      const trimmedPassword = password.trim();

      if (trimmedPassword && trimmedPassword.length) {
        return /[A-Z]/.test(trimmedPassword);
      }

      return false;
    }
  }
];

Tests:

Filter
passwordRequirements.filter(pwdReq => requirements.includes(pwdReq.key));
Set
set2 = new Set(requirements); passwordRequirements.filter(element => set2.has(element.key));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Filter
Set

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.

**Benchmark Overview**

The provided benchmark measures the performance difference between two approaches: filtering an array using `Array.prototype.filter()` and converting the array to a Set, then using the `has` method to check for existence.

**Options Compared**

There are two options being compared:

1. **Filtering Array**: This approach uses the `filter()` method to create a new array that includes only the elements from the original array that pass the test implemented by the provided function.
2. **Using Set**: This approach creates a Set from the original array and then uses the `has` method to check if each element of the Set exists in the original array.

**Pros and Cons**

### Filtering Array

Pros:

* Easy to understand and implement
* Can be used with any type of data (not limited to numbers)

Cons:

* Creates a new array, which can be memory-intensive for large datasets
* The `filter()` method iterates over the entire array, which can lead to performance issues for very large arrays

### Using Set

Pros:

* More efficient than filtering an array for large datasets, as Sets only store unique values and have faster lookup times
* Can reduce memory usage by avoiding unnecessary copies of data

Cons:

* Requires converting the array to a Set, which can be more complex to implement
* Limited to numeric keys; non-numeric keys will not work correctly with `Set`

**Library/Functions Used**

In this benchmark, no specific libraries or functions are used beyond JavaScript's built-in `Array.prototype.filter()` and `Set` constructors.

**Special JS Features/Syntax**

None of the provided code utilizes any special JavaScript features or syntax, such as async/await, Promises, or modern syntax like arrow functions.

**Other Alternatives**

If you were to optimize this benchmark further, you might consider:

* Using `Array.prototype.every()` instead of `filter()`, which could potentially be faster for small arrays
* Using a more efficient data structure, like a `Map`, if the array contains key-value pairs and you need to frequently look up values by key
* Using a just-in-time (JIT) compiler or other optimization techniques specific to your JavaScript engine

Related benchmarks:

Filter vs. set (version: 0)

Comparing performance of: Filter vs Set

Created: 2 years ago by: Guest

Jump to the latest result

Filter

Set

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):