Benchmark: query test new - MeasureThat.net

Script Preparation code:

const obj= {
	test1: {},
  	test2: {},
  	test3: {},
  	test4: {},
  	test5: {},
  	test6: {},
  	test7: {},
}

 function getTypes(queryTypes) {
    const filterTypes = [];
    if (queryTypes && typeof queryTypes === 'string') {
      const types = queryTypes.split(',');
      for (let type of types) {
        filterTypes.push(type.toLowerCase());
      }
    }
    return Object.keys(obj).filter(
      t => !filterTypes.length || filterTypes.includes(t.toLowerCase())
    );
  }

const keys = Object.keys(obj).map(i => i.toLowerCase())
function getTypes2(queryTypes) {
    const filterTypes = [];
    if (queryTypes && typeof queryTypes === 'string') {
      const types = queryTypes.split(',');
      for (let type of types) {
        filterTypes.push(type.toLowerCase());
      }
    }
    return keys.filter(
      t => !filterTypes.length || filterTypes.includes(t)
    );
  }

const map = Object.keys(obj).map(i => i.toLowerCase()).reduce((acc, i) => ({ ...acc, [i]: true }), {})
function getTypes3(queryTypes) {    
    if(!queryTypes || typeof queryTypes !== 'string') {
      return keys;
    }
  
    return queryTypes.split(',').filter(i => map[i.toLowerCase()])
  }

Tests:

pr
getTypes('test2,test3,test6,test4,test5')
move outside keys
getTypes2('test2,test3,test6,test4,test5')
new
getTypes3('test2,test3,test6,test4,test5')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
pr
move outside keys
new

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 break down the provided benchmark definition and test cases.

**Benchmark Definition**

The benchmark definition is represented as a JSON object that contains three different functions: `getTypes`, `getTypes2`, and `getTypes3`. These functions are designed to filter keys from an object based on a given query string.

Here's what each function does:

1. **`getTypes(queryTypes)`**: This function filters the keys of an object (`obj`) that match the query string `queryTypes`. The query string can be either a comma-separated list of strings or a single string. If `queryTypes` is a comma-separated list, it's converted to lowercase and compared with the lowercase versions of the keys in the object using `includes()`.
2. **`getTypes2(queryTypes)`**: This function is similar to `getTypes`, but instead of using `Object.keys(obj)`, it uses an array `keys` that contains the lowercase versions of the object's keys. The comparison is done between the query string (converted to lowercase) and the lowercase version of each key in the `keys` array.
3. **`getTypes3(queryTypes)`**: This function checks if `queryTypes` is a valid string. If not, it returns an empty array. Otherwise, it splits the query string into individual strings, converts them to lowercase, and filters the keys of the object using a map (`map`) that contains the lowercase versions of the object's keys.

**Options Compared**

The three functions compare different approaches to filtering keys:

1. **`getTypes`**: Compares the case-insensitive comparison between the query string and the keys in the object.
2. **`getTypes2`**: Moves the key comparison outside the `Object.keys()` call, using an explicit array of keys instead.
3. **`getTypes3`**: Uses a map to filter the keys based on the presence of the query string in the lowercase version of each key.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. **`getTypes`**:
	* Pros: Simple, efficient, and straightforward.
	* Cons: Can be slow for large objects due to the `includes()` method.
2. **`getTypes2`**:
	* Pros: Faster than `getTypes` since it avoids the `includes()` method.
	* Cons: Requires an explicit array of keys, which can be error-prone.
3. **`getTypes3`**:
	* Pros: Fast and efficient, especially for small objects or query strings.
	* Cons: May require additional setup (e.g., creating the `map`) and is more complex than the other two functions.

**Library and Special JS Features**

There are no external libraries used in this benchmark definition. The functions only utilize built-in JavaScript features, such as `Object.keys()`, `includes()`, and `map()`.

No special JavaScript features or syntax are used in these functions.

**Other Alternatives**

Some alternative approaches to filtering keys could be explored:

1. Using a more advanced data structure, like a trie or a suffix tree, to filter keys efficiently.
2. Utilizing a library like Lodash or Ramda for functional programming and filtering.
3. Implementing a custom filtering algorithm using a different approach, such as regular expressions.

Keep in mind that these alternatives may have different trade-offs in terms of performance, complexity, and maintainability.

Related benchmarks:

query test new (version: 0)

Comparing performance of: pr vs move outside keys vs new

Created: 3 years ago by: Guest

Jump to the latest result

pr

move outside keys

new

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