Benchmark: .prototype.isPrototypeOf vs .prototype.isPrototypeOf.bind vs Object.prototype.toString.call vs shorthand for Object.prototype.toString

.prototype.isPrototypeOf vs .prototype.isPrototypeOf.bind vs Object.prototype.toString.call vs shorthand for Object.prototype.toString (version: 1) Benchmark.js

Comparing performance of: `.prototype.isPrototypeOf vs .prototype.isPrototypeOf.bind vs Object.prototype.toString.call vs shorthand for Object.prototype.toString`

Created: 2 years ago by: Registered User

Go to the latest result

Script Preparation code:

var isPro = o => o.prototype.isPrototypeOf.bind(o.prototype),
    isRx = isPro(RegExp),
    objType = o => Object.prototype.toString.call(o).slice(8, -1),
    oPTS = Object.prototype.toString,
    objType2 = o => oPTS.call(o).slice(8, -1),
    arr = [0, 1, 2, "", /a/],
    noShortHand = a =>
      typeof a === "string"               ? 1
      : RegExp.prototype.isPrototypeOf(a) ? 2
                                          : 3,
    shortHand = a =>
      typeof a === "string" ? 1
      : isRx(a)             ? 2
                            : 3,
    useObjType = a =>(
      t = objType(a),
      t === "String"   ? 1
      : t === "RegExp" ? 2
                       : 3
    ),
    useObjType2 = a =>(
      t = objType2(a),
      t === "String"   ? 1
      : t === "RegExp" ? 2
                       : 3
    );

Tests:

.prototype.isPrototypeOf
arr.forEach(e=>noShortHand(e));
.prototype.isPrototypeOf.bind
arr.forEach(e=>shortHand(e));
Object.prototype.toString.call
arr.forEach(e=>useObjType(e));
shorthand for Object.prototype.toString
arr.forEach(e=>useObjType2(e));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
.prototype.isPrototypeOf
.prototype.isPrototypeOf.bind
Object.prototype.toString.call
shorthand for Object.prototype.toString

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 121 on Windows

View result in a separate tab

.prototype.isPrototypeOf.bind

1.3M/s

.prototype.isPrototypeOf

897K/s

shorthand for Object.prototype.toString

287K/s

Object.prototype.toString.call

258K/s

View exact numbers

Test name	Executions per second
✓ .prototype.isPrototypeOf.bind	1,287,118 Ops/sec
.prototype.isPrototypeOf	897,471 Ops/sec
shorthand for Object.prototype.toString	287,006 Ops/sec
Object.prototype.toString.call	257,948 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a JavaScript microbenchmark that tests four different approaches for determining the type of an object:

1. `prototype.isPrototypeOf`
2. `prototype.isPrototypeOf.bind`
3. Shorthand for `Object.prototype.toString.call` (e.g., `typeof a === "string" ? 1 : ...`)
4. Using `Object.prototype.toString`

**Test Case Breakdown**

The benchmark consists of four individual test cases, each with a different approach:

1. **`.prototype.isPrototypeOf`**: This test case uses the original `isPrototypeOf` method on the prototype chain to determine the type of an object.
2. **`.prototype.isPrototypeOf.bind`**: This test case uses the `bind` method to create a new bound function that calls `isPrototypeOf` with the object as its context.
3. **Shorthand for `Object.prototype.toString.call`**: This test case uses a shorthand approach that checks if an object is a string, RegExp, or neither, and returns a corresponding number (1-3).
4. **Using `Object.prototype.toString`**: This test case uses the `toString` method on the `Object.prototype` to determine the type of an object.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

* **`.prototype.isPrototypeOf`**: Pros: simple, widely supported. Cons: can be slow for large objects or complex prototype chains.
* **`.prototype.isPrototypeOf.bind`**: Pros: can avoid some overhead associated with `bind`, but may still incur performance costs due to function creation. Cons: adds unnecessary complexity and potential performance issues.
* **Shorthand for `Object.prototype.toString.call`**: Pros: concise, easy to read. Cons: may be slower than other approaches due to repeated calls to `toString` and `typeof`.
* **Using `Object.prototype.toString`**: Pros: can be faster than other approaches since it uses a native method, but may still incur some overhead due to the call. Cons: less readable than other approaches.

**Library and Special JS Features**

There is no specific library mentioned in this benchmark. However, the use of `bind` and `toString` methods implies that the JavaScript engine being tested supports these features.

No special JavaScript features are used in this benchmark beyond those built into the standard language specification.

**Other Alternatives**

If you're looking for alternatives to this benchmark or want to explore other approaches, here are a few options:

* Use a more specialized library like `type-of` or `typecheck` that provides optimized implementations of type detection.
* Experiment with different method calls, such as `instanceof` or `constructor.name`, which may offer alternative performance profiles.
* Consider using a Just-In-Time (JIT) compiler like V8 or SpiderMonkey to optimize the benchmark for specific use cases.

Keep in mind that these alternatives may require additional setup and testing to ensure accurate results.