Well Known Symbols : instanceof via custom Symbol.hasinstance

Symbol.hasinstance.js

/* Well Known Symbols : Symbol.hasinstance

sources: 
1 - https://www.keithcirkel.co.uk/metaprogramming-in-es6-symbols/
2 - http://exploringjs.com/es6/ch_symbols.html
3 - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof
4 - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance

Well Known Symbols are Reflection via implementation in ES6.  
Reflection in Metaprogramming: observing low level internals of a programming language/program.

One example of Well Known Symbols in JS is Symbol.hasInstance, which instanceof uses under the hood.
*/

// using instanceof :

function ClassyFunc() {}

let c = new ClassyFunc();

if (c instanceof ClassyFunc) {
  console.log('instanceof.')
}
else {
  console.log('not instanceof.')
}

// > instanceof 

/* Let's implement that by hand. 

Under the hood, instanceof uses (rhs)[Symbol.hasInstance](lhs),
where rhs is right hand side and lhs is left hand side. 

Symbol is static scoped.
*/

class ArrayClass {
  static [Symbol.hasInstance](input) {
    return Array.isArray(input)
  }
}

let a = []

let b = 3

console.log(a instanceof ArrayClass)
// > true

console.log(a instanceof ArrayClass)
// > false

Instanceof lies. Typing matters

https://medium.com/@_ericelliott/javascript-does-not-have-static-types-69492ce923b5

"JavaScript does not have static types. What you’re asking for does not exist in the language.
Therefore there is no way to do a static type check that you can rely on in JavaScript.

That’s why instanceof lies and can be the source of lots of bugs or awkward restrictions.

Nominal types (type checking based on the name or identity of a single class/interface)
will never work well in JavaScript.

That’s why TypeScript (which adds static annotations and analysis on top of JavaScript) uses structural types,
which is basically automated duck typing."

• Eric Elliott