Benchmark: Object.is vs trick is vs direct is

Script Preparation code:

var is = Object.is
var trickIs = (a, b) => a === b || (Number.isNaN(a) && Number.isNaN(b))
var driectIs = (a, b) => a === b

Tests:

Object.is
is(NaN, NaN) is(100000000, 100000001) is('100000000', '100000000')
trick is
trickIs(NaN, NaN) trickIs(100000000, 100000001) trickIs('100000000', '100000000')
direct is
driectIs(NaN, NaN) driectIs(100000000, 100000001) driectIs('100000000', '100000000')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.is
trick is
direct is

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 114 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.is	3891970.2 Ops/sec
trick is	2119860.0 Ops/sec
direct is	3885056.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The benchmark in question tests three different approaches to equality checking in JavaScript: `Object.is`, "trick is", and "direct is". The goal is to determine which approach is the fastest, most efficient, or preferably, "best" for equality checks.

**Options being compared:**

1. **`Object.is()`**: A built-in JavaScript method that compares two values for strict equality, including NaN (Not a Number) handling.
2. **"trick is"**: A custom implementation using the `Number.isNaN()` function to handle NaN cases.
3. **"direct is"`**: Another custom implementation without relying on `Number.isNaN()`, likely attempting to optimize performance.

**Pros and Cons of each approach:**

* **`Object.is()`**:
	+ Pros: Built-in, widely supported, and well-tested.
	+ Cons: May be slower due to its explicit checking mechanism.
* **"trick is"`: 
	+ Pros: Optimized for NaN cases, potentially faster than `Object.is()`.
	+ Cons: Custom implementation, may not be as widely supported or tested.
* **"direct is"`:
	+ Pros: Attempting to optimize performance by avoiding explicit checks.
	+ Cons: May not handle NaN cases correctly, which could lead to incorrect results.

**Library and its purpose (none in this case)**

There are no external libraries used in this benchmark.

**Special JS feature or syntax**

None mentioned. This benchmark focuses on the three equality checking approaches rather than any specific JavaScript features or syntax.

**Other alternatives**

If you're looking for alternative methods, consider:

* Using `===` (equality operator) for simple cases.
* Implementing your own custom equality function with a balanced approach to handling NaN and other edge cases.
* Utilizing modern JavaScript features like `BigInt` for precise comparisons in certain scenarios.

Keep in mind that the best approach depends on specific requirements, performance needs, and compatibility constraints. MeasureThat.net's benchmark helps determine which method is generally faster or more efficient across various browsers and devices.

Related benchmarks:

Object.is vs trick is vs direct is (version: 0)

Comparing performance of: Object.is vs trick is vs direct is

Created: one year ago by: Registered User

Jump to the latest result

Object.is

trick is

direct is

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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