Benchmark: predefined values to check

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

class Utility {
    static allowedValues = [true, false, 'true', 'false', 1, 0, '1', '0'];
    static isBooleanInline(value) {
        return value === true || value === false || value === 'true' || value === 'false' || value === 1 || value === 0 || value === '1' || value === '0';
    }
    static isBooleanPredefined(value) {
        return this.allowedValues.includes(value);
    }
}
let value = 2;

Tests:

use predefined (no cache, false)
const valid = Utility.isBooleanPredefined(++value);
use inline (no cache, false)
const valid = Utility.isBooleanInline(++value);
use predefined (cache, false)
const valid = Utility.isBooleanPredefined('a');
use inline (cache, false)
const valid = Utility.isBooleanInline('a');
use predefined (no cache, true)
const valid = Utility.isBooleanPredefined(++value % 2);
use inline (no cache, true)
const valid = Utility.isBooleanInline(++value % 2);
use predefined (cache, true)
const valid = Utility.isBooleanPredefined(1);
use inline (cache, true)
const valid = Utility.isBooleanInline(1);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
use predefined (no cache, false)
use inline (no cache, false)
use predefined (cache, false)
use inline (cache, false)
use predefined (no cache, true)
use inline (no cache, true)
use predefined (cache, true)
use inline (cache, true)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 9 days ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Linux

View result in a separate tab

Test name	Executions per second
use predefined (no cache, false)	15162271.0 Ops/sec
use inline (no cache, false)	16021370.0 Ops/sec
use predefined (cache, false)	67420488.0 Ops/sec
use inline (cache, false)	155750864.0 Ops/sec
use predefined (no cache, true)	15354675.0 Ops/sec
use inline (no cache, true)	16041618.0 Ops/sec
use predefined (cache, true)	97784024.0 Ops/sec
use inline (cache, true)	181689488.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 9 days ago):

LLMs can make mistakes. Check important info.

The benchmark provided in the JSON data evaluates two different approaches to checking if a value is a valid boolean representation using JavaScript functions: `isBooleanInline()` and `isBooleanPredefined()`. The performance of these functions is analyzed based on how they handle various inputs, their caching behavior, and general execution speed.

### **Comparison of Options**

1. **Inline Boolean Check (`isBooleanInline`)**:
   - **Function Definition**:
     ```javascript
     const isBooleanInline = function(value) {
         return value === true || value === false || value === 'true' || value === 'false' || value === 0 || value === 1 || value === '1' || value === '0';
     }
     ```
   - **Logic**: This function checks if the provided value strictly equals (or loosely matches) common representations of booleans, including booleans themselves and certain strings/numbers.
   - **Pros**:
     - Directly checks a range of types in a single function call, which may benefit from optimizations by modern JavaScript engines.
     - Every check is explicit, which some developers may find easier to understand.
   - **Cons**:
     - Could become harder to maintain as the list of acceptable values grows.
     - The performance may degrade if the logical checks become overly complex.

2. **Predefined Boolean Check (`isBooleanPredefined`)**:
   - **Function Definition**:
     ```javascript
     const isBooleanPredefined = function(value) {
         return allowedValues.includes(value);
     }
     ```
   - **Logic**: This function uses a preset array of valid boolean representations (`allowedValues`) and checks if the input value is included in that array.
   - **Pros**:
     - Easier to modify by simply adding or removing elements in the `allowedValues` array.
     - Increased readability and clearer intention, as it separates allowed values from the checking logic.
   - **Cons**:
     - The use of `Array.includes()` may introduce overhead compared to a series of direct comparisons since it effectively has to iterate over the array.
     - Not as flexible for highly dynamic checks, where the set of valid values might not be known ahead of time.

### **Test Cases Comparison**

The benchmark runs several test cases, each comparing the performance of the two different functions under various conditions including caching and different input values:

1. **No Cache Tests**:
   - Evaluates the functions with freshly incremented values (using `++value`).
   - A varying input (`'a'`) is also tested, showcasing how each method handles unexpected inputs.

2. **Cache Tests**:
   - Focuses on direct boolean representations (such as `1`), where previous evaluations may influence performance.

### **Performance Insights**

Based on the latest benchmark results, the performance in terms of executions per second for various test cases is recorded. Key observations:
- **Inline Functions Perform Better**: In the cases tested, `isBooleanInline` consistently outperforms `isBooleanPredefined`, especially with caching enabled.
- **Cache Benefit**: Both approaches benefit from caching, but inline checks appear to leverage optimizations more effectively under JavaScript engine executions.

### **Conclusion**

While both methods provide a way to determine valid boolean values, the choice between `isBooleanInline` and `isBooleanPredefined` depends on the context of use. The inline method provides speed and may suit performance-critical applications, especially when predictable inputs are used. Meanwhile, the predefined method favors maintainability and clarity, making it suitable for applications where the set of accepted values may need adjustment over time.

### **Alternatives**

Other alternatives to consider might include:
- **Type Checking**: Using JavaScript's `typeof` operator alongside type-checking functions could provide another approach to validating inputs, though it may require more extensive implementations.
- **Union Types**: If browsers support it, TypeScript's type-checking capabilities can enforce boolean checks at compile time, providing a safer coding paradigm.
- **Libraries**: Libraries like `lodash` offer robust utilities for deep checks and validations, though integrating such dependencies should be weighed against the needs of the project.

This benchmark serves as a reminder to consider both performance and maintainability when implementing validation logic in software applications.

Related benchmarks:

predefined values to check (version: 6)

Comparing performance of: use predefined (no cache, false) vs use inline (no cache, false) vs use predefined (cache, false) vs use inline (cache, false) vs use predefined (no cache, true) vs use inline (no cache, true) vs use predefined (cache, true) vs use inline (cache, true)

Created: 9 days ago by: Registered User

Jump to the latest result

use predefined (no cache, false)

use inline (no cache, false)

use predefined (cache, false)

use inline (cache, false)

use predefined (no cache, true)

use inline (no cache, true)

use predefined (cache, true)

use inline (cache, true)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 9 days ago):