Benchmark: InstanceOf vs key in obj vs !== null vs string in key

HTML Preparation code:

<script>
class TestClass {
    constructor() {
        this.a = 2;
        this.t = 'mesh';
    }
}
</script>

Script Preparation code:

var obj = new TestClass();

Tests:

instanceof
obj instanceof TestClass;
key
"t" in obj
double key
(obj.t === "other" || obj.t === "mesh")
obj maybe null
obj !== null
obj typeof "object"
typeof obj === "object"

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
instanceof
key
double key
obj maybe null
obj typeof "object"

Fastest: N/A

Slowest: N/A

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/133.0.0.0 Safari/537.36

Browser/OS: Chrome 133 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
instanceof	148382544.0 Ops/sec
key	163030768.0 Ops/sec
double key	174676048.0 Ops/sec
obj maybe null	182615984.0 Ops/sec
obj typeof "object"	171665968.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Definition and Preparation Code**

The benchmark definition is represented by the JSON object at the top, which describes a set of test cases to be run. The script preparation code initializes an instance of a `TestClass` class with two properties: `a` (an integer) and `t` (a string).

```javascript
var obj = new TestClass();
```

The HTML preparation code defines the `TestClass` class:

```html
<script>
    class TestClass {
        constructor() {
            this.a = 2;
            this.t = 'mesh';
        }
    }
</script>
```

**Individual Test Cases**

There are four test cases, each with a different comparison operation:

1. `obj instanceof TestClass;`
2. `"t" in obj` (or simply "key")
3. `(obj.t === "other" || obj.t === "mesh")` (or double key)
4. `obj !== null`
5. `typeof obj === "object"`

Let's analyze each test case:

**1. instanceof**

This test checks if an object is an instance of a specific class. In this case, it checks if the `obj` instance is an instance of `TestClass`. The `instanceof` operator performs a runtime check to see if the object is an instance of the given constructor.

Pros: Fast and efficient, as it relies on the JavaScript engine's internal type checking.
Cons: May be slower for small objects or when used with arrays, as it has to traverse the prototype chain.

**2. "key"**

This test checks if a property exists in an object using the `in` operator. It's equivalent to saying "does 't' exist in obj?".

Pros: Fast and simple.
Cons: May be slower than other methods like `hasOwnProperty()` or bracket notation, as it relies on a lookup table.

**3. double key**

This test checks if an object has multiple properties with the same name using the `in` operator.

```javascript
(obj.t === "other" || obj.t === "mesh")
```

Pros: Fast and simple.
Cons: May be slower than other methods like `hasOwnProperty()` or bracket notation, as it relies on a lookup table.

**4. obj !== null**

This test checks if an object is not null or undefined using the strict equality operator (`!==`).

Pros: Fast and efficient.
Cons: May be slower for small objects or when used with arrays, as it has to traverse the prototype chain.

**5. typeof obj === "object"`

This test checks if an object is of type `Object`, which is the default type for all JavaScript objects.

Pros: Fast and simple.
Cons: May not work as expected for custom objects or when using `typeof` with a specific type, like `Array`.

**Other Alternatives**

Some alternative methods to achieve similar results include:

* Using `hasOwnProperty()` instead of `in` operator
* Using bracket notation (`obj['t']`) instead of `in`
* Using `===` and `!null` instead of `!==`
* Using `typeof obj === 'object'` instead of checking the type string

**Library Usage**

The benchmark definition does not explicitly mention any libraries being used. However, it's likely that the `TestClass` class is defined using a JavaScript runtime like V8 (used by Chrome) or SpiderMonkey (used by Firefox).

**Special JS Features/Syntax**

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

Overall, these test cases cover various aspects of JavaScript object comparisons and can be useful for optimizing JavaScript performance.

Related benchmarks:

InstanceOf vs key in obj vs !== null vs string in key (version: 0)

Comparing performance of: instanceof vs key vs double key vs obj maybe null vs obj typeof "object"

Created: one year ago by: Registered User

Jump to the latest result

instanceof

key

double key

obj maybe null

obj typeof "object"

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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