Benchmark: bool check - MeasureThat.net

Script Preparation code:

var b = true;

Tests:

Check strict equal of possibilities
b === true || b === false
typeof
typeof b === 'boolean'
convert bool using double not
!!b === b
convert bool using Boolean
Boolean(b) === b

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Check strict equal of possibilities
typeof
convert bool using double not
convert bool using Boolean

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36

Browser/OS: Chrome 122 on Windows

View result in a separate tab

Test name	Executions per second
Check strict equal of possibilities	11686872.0 Ops/sec
typeof	12071184.0 Ops/sec
convert bool using double not	7527145.0 Ops/sec
convert bool using Boolean	3694200.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The provided benchmark tests various methods of checking and converting boolean values in JavaScript, focusing on performance and determining which approach is more efficient. Here’s a breakdown of the individual test cases, their implications, pros/cons, and alternative considerations:

### Test Cases Overview

1. **Check strict equal of possibilities (`b === true || b === false`)**
   - **Purpose**: This test checks if the value `b` strictly equals either `true` or `false`.
   - **Considerations**: 
     - **Pros**: This method is straightforward and clearly expresses the intention of checking for boolean values.
     - **Cons**: It includes two separate comparisons, which may take longer than methods that require only a single evaluation.

2. **Typeof (`typeof b === 'boolean'`)**
   - **Purpose**: This method uses the `typeof` operator to evaluate whether `b` is of the boolean type.
   - **Considerations**: 
     - **Pros**: Reliable and directly checks the type of the variable. This works in all JavaScript environments.
     - **Cons**: It requires the `typeof` operator, which might have some overhead due to its operation, although typically negligible for primitive type checks.

3. **Convert bool using double not (`!!b === b`)**
   - **Purpose**: This tests a common technique in JavaScript where the double negation (`!!`) converts a value to its boolean equivalent, and then it checks if it equals the original boolean `b`.
   - **Considerations**: 
     - **Pros**: Very concise and is a popular idiomatic JavaScript usage.
     - **Cons**: It might be less readable for those unfamiliar with the double negation trick and can lead to misunderstandings about its purpose.

4. **Convert bool using Boolean (`Boolean(b) === b`)**
   - **Purpose**: This test uses the `Boolean` constructor to convert `b` to a boolean and checks if it matches the original.
   - **Considerations**: 
     - **Pros**: Very explicit in its intention and doesn't require special syntax. It clearly conveys that you are converting a value to boolean.
     - **Cons**: Slightly less performant than the other conversions due to the function call overhead involved with the `Boolean` constructor.

### Performance Insights

From the results, the `typeof` method shows the highest execution speed, followed closely by the strict equality check. The double negation method is substantially slower, followed by the use of the `Boolean` constructor. This hierarchy provides insights into which methods are most performant in JavaScript for checking boolean values.

### Alternative Considerations

- **Logical Operations**: Given that all boolean checks involve conditions, other alternatives include logical operations (like `if (b) { ... }`) to trigger branches based on truthiness. However, these might not be suitable for pure type checks.
- **Object Wrapping**: Wrapping boolean values in an object can ensure type consistency, although not typically necessary for primitive types like booleans.
- **Using Libraries**: While this benchmark doesn’t use any specific libraries, frameworks and utilities like Lodash or Underscore.js can offer more robust type-checking functionalities, although typically they add overhead.

Overall, for a broad variety of use cases, the `typeof` operator and strict equality checks are generally safest, while the idiomatic double negation can be employed for performance-sensitive contexts where brevity is valued.

Related benchmarks:

bool check (version: 0)

check bool type check variante

Comparing performance of: Check strict equal of possibilities vs typeof vs convert bool using double not vs convert bool using Boolean

Created: one month ago by: Guest

Jump to the latest result

Check strict equal of possibilities

typeof

convert bool using double not

convert bool using Boolean

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):