<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof">instanceof</a> and <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof">typeof</a> are two JavaScript operators used for type checking, but they serve different purposes and have different use cases.
<h2><code>typeof</code></h2>
<blockquote>
The typeof operator returns a string indicating the type of the operand's value.
</blockquote>
It is used to check the data type of a value or variable. It returns a string indicating the type of the operand. It is useful for checking primitive data types (e.g., string, number, boolean, undefined, symbol, and bigint).
It is not very useful for complex object data types like arrays or objects because it will simply return "object" for both of them.
<pre class="shiki github-dark shaku"><code>console.log(typeof "Hello"); // "string"console.log(typeof 42); // "number"console.log(typeof true); // "boolean"console.log(typeof undefined); // "undefined"console.log(typeof {}); // "object"console.log(typeof []); // "object" (Array is an object in JavaScript)</code></pre>
<hr />
<h2><code>instanceof</code> Operator</h2>
<blockquote>
The instanceof operator tests to see if the prototype property of a constructor appears anywhere in the prototype chain of an object.
</blockquote>
<code>instanceof</code> is used to check if an object is an instance of a particular class or constructor function. It is more suitable for checking the type of complex objects, especially when dealing with custom-defined classes or constructor functions. It works by checking if an object's prototype chain includes the prototype property of a constructor.
<pre class="shiki github-dark shaku"><code>class Person { constructor(name) { this.name = name; }}const john = new Person("John");console.log(john instanceof Person); // trueconst numbers = [1, 2, 3];console.log(numbers instanceof Array); // true</code></pre>
<hr />
<h3>How <code>instanceof</code> works internally ?</h3>
<ul>
<li>When you use <code>instanceof</code>, it checks if the prototype property of the constructor function (e.g., <code>Person.prototype</code>) is present in the prototype chain of the object being checked.</li>
<li>It does this by traversing the prototype chain of the object until it reaches the prototype of the constructor function. If it finds a match, it returns <code>true</code>; otherwise, it returns <code>false</code>.</li>
</ul>
<hr />
<h3>Alternative to <code>instanceof</code></h3>
One alternative to <code>instanceof</code> is the <code>Object.prototype.isPrototypeOf()</code> method. It checks if an object is in the prototype chain of another object. It's less commonly used than <code>instanceof</code> but serves a similar purpose.
<pre class="shiki github-dark shaku"><code>class Person { // ...constructor and methods}const john = new Person("John");console.log(Person.prototype.isPrototypeOf(john)); // true</code></pre>
In summary, <code>typeof</code> is used for basic type checking, while <code>instanceof</code> is used for checking if an object is an instance of a specific class or constructor function. When dealing with custom-defined classes or constructor functions, <code>instanceof</code> is more suitable for type checking complex objects.

typeof vs instanceof

typeof is commonly used but it is not so useful in case of complex object data types. It would be a shining point if you could mention some alternativ…