Benchmark: isArray vs instanceof vs Symbol.iterator vs Object.prototype.toString.call

Script Preparation code:

var types = {
  array: [1,2,3],
  number: 123,
  string: '123',
  map: new Map([[1,1],[2,2],[3,3]]),
  set: new Set([1,2,3]),
  buffer: new ArrayBuffer([1,2,3]),
  boolean: true,
  arrow: () => {},
  function: function () {},
  object: {},
  u8: new Uint8Array(),
  u16: new Uint16Array(),
  u32: new Uint32Array(),
  i8: new Int8Array(),
  i16: new Int16Array(),
  i32: new Int32Array()
}

var keys = Object.keys(types)

Tests:

isArray
keys.map(key => Array.isArray(types[key]) === true)
instanceof
keys.map(key => (types[key] instanceof Array) === true)
Symbol.iterator
keys.map(key => types[key][Symbol.iterator] !== undefined)
Object.prototype.toString.call
keys.map(key => Object.prototype.toString.call(types[key]) === '[object Array]')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
isArray
instanceof
Symbol.iterator
Object.prototype.toString.call

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 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
isArray	485318.4 Ops/sec
instanceof	476577.8 Ops/sec
Symbol.iterator	309269.8 Ops/sec
Object.prototype.toString.call	405624.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring JavaScript performance is a fascinating topic, and MeasureThat.net provides a valuable resource for benchmarking different approaches.

**Benchmark Definition**

The provided JSON represents a microbenchmark that tests the performance of four different approaches to check if an object is an array:

1. `isArray`: Uses the `Array.isArray()` method.
2. `instanceof`: Uses the `instanceof` operator.
3. `Symbol.iterator`: Uses the `Symbol.iterator` property.
4. `Object.prototype.toString.call`: Uses the `toString()` method of the `Object.prototype`.

**Options Comparison**

The four options are compared to determine which one is the most efficient.

* `isArray`: This method checks if an object is an instance of `Array`. It's a simple and straightforward approach, but it may not be the fastest since it involves creating a new array and comparing it with the original object.
* `instanceof`: This operator checks if an object is an instance of a specific constructor. In this case, it's used to check if an object is an instance of `Array`. It's slightly slower than `isArray` because it involves invoking the constructor function.
* `Symbol.iterator`: This property returns an iterator object that defines the iteration protocol for an object. Checking if this property exists allows us to determine if an object supports iteration, which includes arrays. However, this approach may be slower due to the overhead of creating and managing iterators.
* `Object.prototype.toString.call`: This method calls the `toString()` method on the `Object.prototype` with the object as an argument. It's a relatively slow approach since it involves calling a method that returns a string representation of the object.

**Pros and Cons**

Here are some pros and cons for each approach:

* `isArray`:
	+ Pros: Simple, fast, and widely supported.
	+ Cons: May not be reliable if the array is deeply nested or has complex structure.
* `instanceof`:
	+ Pros: Reliable, but slightly slower than `isArray`.
	+ Cons: May not work correctly with non-array objects that inherit from `Array`.
* `Symbol.iterator`:
	+ Pros: Supports iteration on arrays and other object types.
	+ Cons: May be slower due to iterator overhead.
* `Object.prototype.toString.call`:
	+ Pros: Works on all objects, but relatively slow.
	+ Cons: Not the most efficient approach.

**Library Usage**

In this benchmark, no libraries are explicitly mentioned. However, some of the data types used (e.g., `Map`, `Set`, `Buffer`) rely on built-in JavaScript APIs or external libraries.

* `Map` and `Set`: These data structures are part of the ECMAScript standard and don't require any additional libraries.
* `Buffer`: This is a built-in type in Node.js, but it's not included by default in other browsers. If you need to use `Buffer`, you'll need to include the Node.js library or use a polyfill.

**Special JS Features**

In this benchmark, no special JavaScript features are used beyond those that are part of the ECMAScript standard.

**Alternatives**

If you're looking for alternative approaches to check if an object is an array, you can consider:

* Using `Array.isArray()` with a try-catch block to catch any exceptions thrown by non-array objects.
* Implementing your own custom function to check if an object is an array.
* Using a library like Lodash or Ramda, which provide utility functions for working with arrays.

Keep in mind that these alternatives may not be as efficient or reliable as the built-in `Array.isArray()` method.

Related benchmarks:

isArray vs instanceof vs Symbol.iterator vs Object.prototype.toString.call (version: 0)

Symbol.iterator also matches TypedArray, Map, and such

Comparing performance of: isArray vs instanceof vs Symbol.iterator vs Object.prototype.toString.call

Created: 4 years ago by: Registered User

Jump to the latest result

isArray

instanceof

Symbol.iterator

Object.prototype.toString.call

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