Benchmark: t9834yt9h43 - MeasureThat.net

Script Preparation code:

var type = (value) => Object.prototype.toString.call(value).slice(8, -1);

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)
Object.prototype.toString.call
keys.map(key => Object.prototype.toString.call(types[key]) === '[object Array]')
type
keys.map(key => type(types[key]) === 'Array')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
isArray
instanceof
Object.prototype.toString.call
type

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 113 on Windows

View result in a separate tab

Test name	Executions per second
isArray	703196.0 Ops/sec
instanceof	688872.9 Ops/sec
Object.prototype.toString.call	560452.3 Ops/sec
type	368959.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring JavaScript performance can be a fascinating topic.

**Benchmark Definition:**

The benchmark definition is a JSON object that contains the setup code for each test case. It defines a `types` object with various data types (arrays, numbers, strings, maps, sets, booleans, and functions) and extracts their keys using `Object.keys(types)`.

In essence, this benchmark tests the performance of different JavaScript operators on arrays:

*   `Array.isArray()`
*   `instanceof Array` (not directly used in the benchmark, but inferred from `instanceof`)
*   `Object.prototype.toString.call()` with `[object Array]` as a string literal
*   `type()` function, which returns the constructor name of an object

**Options Compared:**

The benchmark compares the performance of these four different approaches:

1.  `Array.isArray()`
2.  `instanceof Array` (not directly used in the benchmark)
3.  `Object.prototype.toString.call()` with `[object Array]` as a string literal
4.  `type()` function

**Pros and Cons:**

Here's a brief overview of each approach:

*   **`Array.isArray()`**: This method is efficient and widely supported across browsers. However, it may be slower for very large arrays due to its additional overhead.
*   **`instanceof Array`**: While this method is more explicit than `Array.isArray()`, it's not directly used in the benchmark. Instead, it's inferred from the context. This approach can be less efficient due to its additional checks and potential overhead.
*   **`Object.prototype.toString.call()` with `[object Array]` as a string literal**: This approach uses the `toString()` method to check if an object is an array. While it's widely supported, it may incur additional overhead due to the creation of a new string object.
*   **`type()` function**: The `type()` function is not part of the standard JavaScript API but can be implemented using `Object.prototype.toString.call()`. It provides explicit and efficient checks for array types.

**Other Considerations:**

In general, performance differences between these approaches are relatively small. However, if you need to optimize specific use cases:

*   For very large arrays or performance-critical code, consider using the most efficient method (`Array.isArray()`).
*   If you're working with older browsers that don't support `Array.isArray()`, use a fallback like `instanceof Array`.
*   Avoid using `Object.prototype.toString.call()` when possible due to its additional overhead.

**Library Usage:**

The benchmark uses the `type()` function, which is not part of the standard JavaScript API. The implementation of `type()` in this case likely uses `Object.prototype.toString.call()`, making it a wrapper around the built-in method.

**Special JS Features/Syntax:**

There are no special JavaScript features or syntax mentioned in the benchmark definition.

Related benchmarks:

t9834yt9h43 (version: 0)

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

Created: one year ago by: Guest

Jump to the latest result

isArray

instanceof

Object.prototype.toString.call

type

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