Benchmark: Boolean vs !! vs ternary vs custom vs ==

Script Preparation code:

var string = '1234';
function toBoolean(value){
  return !!value
}

Tests:

Implicit coercion
!!string
Ternary
string ? true : false
Boolean
Boolean(string)
Custom function
toBoolean(string)
Equation
string == true

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Implicit coercion
Ternary
Boolean
Custom function
Equation

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36

Browser/OS: Chrome 129 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Implicit coercion	14691265.0 Ops/sec
Ternary	14697823.0 Ops/sec
Boolean	7992826.0 Ops/sec
Custom function	7705164.5 Ops/sec
Equation	13728237.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

The benchmark conducted in this test evaluates various methods of coercing a string into a boolean value in JavaScript, comparing performance across different approaches. The string used for testing is `'1234'`, which in JavaScript is considered a truthy value.

### Options Compared

1. **Implicit Coercion (`!!string`)**:
   - This method involves using the double negation operator (`!!`) to coerce a value to a boolean. The first negation (`!`) converts the truthy value to `false`, and the second (`!`) flips it back to `true`.
   - **Pros**: Very concise and performant.
   - **Cons**: May be less readable for those unfamiliar with the double negation trick.

2. **Ternary Operator (`string ? true : false`)**:
   - This approach uses a ternary conditional operator to explicitly return `true` or `false` based on the truthiness of the string.
   - **Pros**: Readable and clear in its intention.
   - **Cons**: Slightly more overhead than implicit coercion, albeit still efficient.

3. **Boolean Constructor (`Boolean(string)`)**:
   - This method uses the `Boolean` constructor to convert the string to a boolean value.
   - **Pros**: Very clear in intention; directly communicates that the goal is to get a boolean representation.
   - **Cons**: Might be less efficient compared to other methods, as it incurs a function call overhead.

4. **Custom Function (`toBoolean(string)`)**:
   - A user-defined function that uses the `!!` operator to convert the value.
   - **Pros**: Flexibility to modify the function later on to incorporate additional logic if needed.
   - **Cons**: Function call overhead leads to reduced performance compared to inline methods.

5. **Equality Check (`string == true`)**:
   - This method checks if the string is equal to `true`. JavaScript will coerce both sides to a common type before making the comparison.
   - **Pros**: Could be intuitive for those familiar with equality checks.
   - **Cons**: This method is generally inefficient for this purpose, can lead to unexpected results due to type coercion behavior, and is less recommended for strict boolean conversion.

### Benchmark Results

The benchmark results showed the following `Executions Per Second` for each of the methods tested in the Chrome 130 browser on a desktop platform running Windows:

- **Implicit Coercion (`!!string`)**: 14,737,535
- **Ternary**: 14,647,867
- **Boolean**: 12,507,961
- **Custom Function**: 7,699,720.5
- **Equation**: 5,523,271.5

From these results, **Implicit Coercion** emerged as the fastest method, slightly ahead of the **Ternary** approach. **Custom Function** and **Boolean** were significantly slower, with **Equation** being the least performant.

### Other Considerations

- **Readability vs Performance**: While performance is an important consideration, it should be balanced with code readability and maintainability. For example, while `!!` is the fastest, it can be less understandable for those unfamiliar with JavaScript.
- **Context of Use**: In a performance-critical section of the code where many boolean checks are necessary (e.g., within loops), one might prioritize speed and use implicit coercion. In user-facing code or where maintainability is paramount, the ternary or Boolean constructor could be preferred for clarity.

### Alternatives

- One alternative for coercing truthy and falsy in JavaScript that wasn't mentioned in the benchmarks is using the `Boolean` function call with conditions (`if(condition) { ... }`), which can convey intent in specific contexts, albeit with less efficiency.
- Libraries such as Lodash provide utility methods (like `_.isBoolean(val)`) but eventually transform the values down to a standard boolean context. However, doing so usually introduces unnecessary overhead for this simple operation.

In conclusion, the benchmark effectively highlights the performance differences among the various methods of converting a string to a boolean in JavaScript, revealing trade-offs between speed and clarity. Instead of defaulting to one method, developers should choose based on the specific context of use and code readability requirements.

Related benchmarks:

Boolean vs !! vs ternary vs custom vs == (version: 2)

Best boolean coercion

Comparing performance of: Implicit coercion vs Ternary vs Boolean vs Custom function vs Equation

Created: 2 months ago by: Registered User

Jump to the latest result

Implicit coercion

Ternary

Boolean

Custom function

Equation

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):