You are an array
Tags: javascript, array, browser, webdev
Published: 2021-11-27 18:11:20

---
title: You are an array
published: true
description: you are an array
tags: javascript,Array,browser,webdev
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/40n5kmvw1m86doiidlox.png
---

Javascript always has some surprises in store. for example, `typeof []` return **object** and not **array**.

{% youtube r3FEhHF_fzM %}

Non ? Si ! Oh !!!! 

This has historical reasons. But this can be very confusing

How can you then properly check if something is an array?

## Constructor

For example, you could check if the constructor is an array.

```javascript
([]).constructor === Array // true
(new Array).constructor === Array // true
({}).constructor === Array // false
(true).constructor === Array // false
(null).constructor === Array // TypeError
(undefined).constructor === Array // TypeError
```

As you can see this has a problem. With null and undefined a TypeError is thrown. 

You could catch this for example with a try/catch. 

```javascript
try {
  (undefined).constructor === Array // true
} catch(e) {
}
```

But you don't want that.


## Exotic

There is also this exotic possibility to check if it is an array. You can missuse the `toString()` method for this.

```javascript
Object.prototype.toString.call([]).indexOf('Array')!==-1
     // => true
Object.prototype.toString.call({}).indexOf('Array')!==-1
     // => false
Object.prototype.toString.call("").indexOf('Array')!==-1
     // => false
Object.prototype.toString.call(null).indexOf('Array')!==-1
   // => false
Object.prototype.toString.call(true).indexOf('Array')!==-1
   // => false Object.prototype.toString.call(undefined).indexOf('Array')!==-1
   // => false
``` 

But it doesn't just look awkward, it is awkward.

## instanceOf

Alternatively, the instanceof operator, which is also known from other languages, can of course be used here.

```javascript
[]  instanceof Array // => true
{} instanceof Array // => false
"" instanceof Array // => false
null instanceof Array // => false
true instanceof Array // => false
10 instanceof Array // => false
undefined instanceof Array // => false
```

Already looks pretty good. But there is also a problem here.

All these checks work only if the array was created by the original array constructor in the current environment.

```javascript
const iframe = document.createElement('iframe');
document.body.appendChild(iframe);
const iframeArray = window.frames[window.frames.length-1].Array;
const array = new iframeArray(1,2,3); 
```

Here the two array instances do not match.

```javascript
array instanceof Array; // false
```

But there is a real solution.

## Array.isArray

For these reasons, since ECMAScript 5 there is a method `Array.isArray()`.

This also works with different instances.

```javascript
Array.isArray([])  // => true
Array.isArray(Array.prototype)  // => surprise; true
Array.isArray({}) // => false
Array.isArray("") // => false
Array.isArray(null)  // => false
Array.isArray(true)  // => false
Array.isArray(undefined)  // => false
```

If it (isArray) is supported, it is the solution!


_hope you enjoy it!_



## References

* [MSN isArray()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray)
* [we are hiring](https://about.schukai.com/de/jobs/)
* [Monster](https://monsterjs.org/)