Benchmark: is this string a single number? array.indexOf VS in array VS in map VS char code VS !isNaN VS +num < 10

Tests:

array.indexOf
const NumberArray = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'] NumberArray.indexOf('5') >= 0
in array
const NumberArray = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'] '5' in NumberArray
in map
const NumberMap = { 0: true, 1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, } NumberMap['5'] === true
char code
const n = '5'.charCodeAt(0); n <58 && n>46
!isNaN
Number.isNaN(+'5')
+num < 10
+'5' < 10
equal all
'5' === '0' || '5' === '1' || '5' === '2' || '5' === '3' || '5' === '4' || '5' === '5' || '5' === '6' || '5' === '7' || '5' === '8' || '5' === '9'

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array.indexOf
in array
in map
char code
!isNaN
+num < 10
equal all

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Definition**
The benchmark definition is a JSON object that describes what needs to be tested. It consists of a name, description, script preparation code, and HTML preparation code (which are empty in this case). The actual benchmarking is performed using multiple test cases.

**Individual Test Cases**
There are six individual test cases:

1. `array.indexOf`: Tests the speed of `Array.prototype.indexOf()` on an array containing numbers.
2. `in array`: Tests the speed of checking if a value is present in an array using the `in` operator.
3. `in map`: Tests the speed of checking if a value is present in a Map object using the `in` operator.
4. `char code`: Tests the speed of extracting the ASCII code of a character using the `charCodeAt()` method.
5. `!isNaN`: Tests the speed of `Number.isNaN()` on an empty string with numeric values wrapped in quotes.
6. `+num < 10`: Tests the speed of a simple arithmetic expression comparing a number to 10.
7. `equal all`: This test case is not directly related to the other operations, but rather tests if two strings are equal by checking for equality with multiple numbers.

**Options Compared**
The following options are compared:

1. `Array.prototype.indexOf()`
2. The `in` operator on arrays and Maps
3. `charCodeAt()` method
4. `Number.isNaN()`
5. Simple arithmetic expressions (`+num < 10`)
6. String equality checks using multiple numbers (`equal all`)

**Pros and Cons of Each Approach**

1. **Array.prototype.indexOf()**: This is a built-in method that traverses the array to find the index of the value. It's generally slower than other methods because of its overhead.
	* Pros: Widely supported, easy to use
	* Cons: Slower, may not be suitable for very large arrays
2. `in` operator on arrays and Maps:
	* Pros: Fast, efficient way to check if a value is present
	* Cons: May not work as expected with certain types of values (e.g., NaN)
3. `charCodeAt()` method:
	* Pros: Fast, efficient way to extract ASCII code
	* Cons: Limited to characters and may not work correctly for non-ASCII codes
4. `Number.isNaN()`: This function checks if a value is NaN (Not a Number).
	* Pros: Simple, fast, and reliable
	* Cons: May return incorrect results for certain numeric values
5. Simple arithmetic expressions (`+num < 10`): These are generally the fastest way to perform basic arithmetic operations.
	* Pros: Fast, simple, and efficient
	* Cons: Limited to numerical comparisons only
6. String equality checks using multiple numbers (`equal all`):
	* Pros: Easy to understand, suitable for string comparison tasks
	* Cons: May be slower than other methods due to the overhead of string comparison

**Conclusion**
The choice of approach depends on the specific use case and performance requirements. For general-purpose JavaScript development, `Number.isNaN()` and simple arithmetic expressions (`+num < 10`) are likely to be the fastest options. For array-based operations, using built-in methods like `Array.prototype.indexOf()` or the `in` operator may be more suitable. String equality checks should use a custom implementation if possible.

I hope this explanation helps! Let me know if you have any further questions.

Latest run results:

Run details: (Test run date: 2 months ago)

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

Browser/OS: Chrome 127 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
array.indexOf	82038384.0 Ops/sec
in array	170567792.0 Ops/sec
in map	175120224.0 Ops/sec
char code	185987744.0 Ops/sec
!isNaN	15939185.0 Ops/sec
+num < 10	172903184.0 Ops/sec
equal all	171324704.0 Ops/sec

Related benchmarks:

is this string a single number? array.indexOf VS in array VS in map VS char code VS !isNaN VS +num < 10 (version: 0)

Comparing performance of: array.indexOf vs in array vs in map vs char code vs !isNaN vs +num < 10 vs equal all

Created: 2 months ago by: Registered User

Jump to the latest result

array.indexOf

in array

in map

char code

!isNaN

+num < 10

equal all

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