Benchmark: Object Values Filtering

Script Preparation code:

datasets = {
    trailer: {},
    location: {}
  },
  uuidv4 = () => {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
      var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
      return v.toString(16);
    });
  },
  count = 10000

for(let step = 0; step < 1000; step++){
  const
    location = {
      uuid: uuidv4(),
      number: Math.random(),
      number1: Math.random(),
      number2: Math.random(),
      number3: Math.random(),
      number4: Math.random()
    }

  datasets.location[location.uuid] = location
}

for(let step = 0; step < count; step++ ){
  const
    trailer = {
      uuid: uuidv4(),
      number: Math.random(),
      number1: Math.random(),
      number2: Math.random(),
      number3: Math.random(),
      number4: Math.random(),
      number5: Math.random(),
      number6: Math.random(),
      number7: Math.random(),
      number8: Math.random(),
      number9: Math.random(),
      number10: Math.random(),
      number11: Math.random(),
      number12: Math.random(),
      number13: Math.random(),
      number14: Math.random(),
      number15: Math.random(),
      location: step%10 == 0 ? Object.keys(datasets.location)[Math.random()*100|0] : null
    }

  datasets.trailer[trailer.uuid] = trailer
}

trailers = Object.values(datasets.trailer)

Tests:

[key]
trailers.filter(trailer => datasets.location[trailer.location])
truthy and [key]
trailers.filter(trailer => trailer.location && datasets.location[trailer.location])
in
trailers.filter(trailer => trailer.location in datasets.location)
truthy and in
trailers.filter(trailer => trailer.location && trailer.location in datasets.location)
not null and in
trailers.filter(trailer => trailer.location !== null && trailer.location in datasets.location)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
[key]
truthy and [key]
in
truthy and in
not null and in

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Object Values Filtering Benchmark: Overview and Analysis

The provided benchmark measures the performance of different filtering approaches for selecting objects from an array based on their properties. The goal is to identify which approach is the most efficient.

**Benchmark Definition JSON**

The benchmark definition consists of two parts:

1. **Script Preparation Code**: This code generates a large dataset of objects with various properties and filters them into two arrays: `trailers` and `datasets.location`. Each object in the `trailers` array has a reference to its corresponding location in the `datasets.location` array.
2. **Html Preparation Code**: This field is empty, indicating that no additional HTML-related code needs to be executed before running the benchmark.

**Individual Test Cases**

There are five test cases:

1. **"trailers.filter(trailer => datasets.location[trailer.location])"`**: This approach uses a simple property access and an index lookup in the `datasets.location` array.
2. **"trailers.filter(trailer => trailer.location && datasets.location[trailer.location])"`**: This approach adds a truthy check for the `location` property before performing the index lookup.
3. **"trailers.filter(trailer => trailer.location in datasets.location)"``` : This approach uses the `in` operator to check if the `location` property exists in the `datasets.location` array.
4. **"trailers.filter(trailer => trailer.location && trailer.location in datasets.location)"**: Similar to the previous test case, but with an additional truthy check for the `location` property.
5. **"trailers.filter(trailer => trailer.location !== null && trailer.location in datasets.location)"**: This approach adds a null check before performing the index lookup.

**Comparison of Approaches**

Here's a brief analysis of each approach:

* **Simple Property Access and Index Lookup (1)**: This is likely to be the fastest approach, as it involves the least number of operations.
* **Truthy Check + Property Access and Index Lookup (2)**: Adding a truthy check before performing the index lookup may introduce some overhead, but it's still relatively efficient.
* **`in` Operator (3)**: The `in` operator is generally slower than property access and index lookups because it involves a more complex operation to determine membership. However, modern JavaScript engines have optimized the `in` operator for performance.
* **Truthy Check + `in` Operator (4)**: This approach combines the overhead of two separate checks, making it likely to be slower than the first two options.
* **Null Check + Property Access and Index Lookup (5)**: Adding a null check before performing the index lookup may introduce additional overhead.

**Pros and Cons**

The pros and cons of each approach are:

* Simple Property Access and Index Lookup:
	+ Pros: Fast, efficient
	+ Cons: None significant
* Truthy Check + Property Access and Index Lookup:
	+ Pros: Still relatively fast, avoids null pointer exceptions
	+ Cons: Introduces some overhead due to the truthy check
* `in` Operator:
	+ Pros: Optimized for performance in modern JavaScript engines
	+ Cons: Generally slower than property access and index lookups
* Truthy Check + `in` Operator:
	+ Pros: None significant
	+ Cons: Slower due to combined checks
* Null Check + Property Access and Index Lookup:
	+ Pros: Avoids null pointer exceptions, still relatively fast
	+ Cons: Introduces additional overhead due to the null check

**Conclusion**

Based on the analysis, the top three fastest approaches are:

1. Simple Property Access and Index Lookup (1)
2. Truthy Check + Property Access and Index Lookup (2)

These two approaches are likely to be close in terms of performance, with a small advantage for approach (1) due to its simplicity.

The `in` Operator (3) is slower than the top three options but still relatively fast due to optimizations in modern JavaScript engines. Approach (4) with the combined truthy check and `in` operator is likely to be slower due to the increased overhead.

Approach (5) with a null check is slower than approaches (1) and (2), but it avoids null pointer exceptions, making it a reasonable choice if you prioritize robustness over raw performance.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.1 Safari/605.1.15

Browser/OS: Safari 13 on Mac OS X 10.15.4

View result in a separate tab

Test name	Executions per second
[key]	716.0 Ops/sec
truthy and [key]	5246.4 Ops/sec
in	664.6 Ops/sec
truthy and in	4247.5 Ops/sec
not null and in	4448.1 Ops/sec

Related benchmarks:

Object Values Filtering (version: 1)

Comparing performance of: [key] vs truthy and [key] vs in vs truthy and in vs not null and in

Created: 4 years ago by: Registered User

Jump to the latest result

[key]

truthy and [key]

in

truthy and in

not null and in

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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