instance(object, type) returns true, should it not be false?

  • Last Update :
  • Techknowledgy :

Remote Work 2022 , Remote Work 2022


var myVar = objectName instanceof objectType


var = ["Apple", "Mango", "Banana"];

console.log(fruits instanceof Array);
console.log(fruits instanceof Object);
console.log(fruits instanceof Number);
console.log(fruits instanceof String);


Syntax and explanation

obj instanceof Class

Suggestion : 2

type() can be used in two ways as shown below:

 type(namr, bases, dict)

In this, example we have a string value, number , float value, a complex number, list, tuple , dict and set. We will use the variables with type to see the output for each of them.

str_list = "Welcome to Guru99"
age = 50
pi = 3.14
c_num = 3 j + 10
my_list = ["A", "B", "C", "D"]
my_tuple = ("A", "B", "C", "D")
my_dict = {
   "A": "a",
   "B": "b",
   "C": "c",
   "D": "d"
my_set = {

print("The type is : ", type(str_list))
print("The type is : ", type(age))
print("The type is : ", type(pi))
print("The type is : ", type(c_num))
print("The type is : ", type(my_list))
print("The type is : ", type(my_tuple))
print("The type is : ", type(my_dict))
print("The type is : ", type(my_set))


The type is :<class 'str'>
   The type is :<class 'int'>
      The type is :<class 'float'>
         The type is :<class 'complex'>
            The type is :<class 'list'>
               The type is :<class 'tuple'>
                  The type is :<class 'dict'>
                     The type is :<class 'set'>


class MyClass:
   x = 'Hello World'
y = 50

t1 = type('NewClass', (MyClass, ), dict(x = 'Hello World', y = 50))


<class 'type'>
{'x': 'Hello World', 'y': 50, '__module__': '__main__', '__doc__': None}
class A:
   my_listA = [1, 2, 3]

class B(A):
   my_listB = [1, 2, 3]

print(type(A()) == A)
print(type(B()) == A)


class A:
   my_listA = [1, 2, 3]

class B(A):
   my_listB = [1, 2, 3]

print(isinstance(A(), A))
print(isinstance(B(), A))



Suggestion : 3

Last modified: Aug 5, 2022, by MDN contributors

object instanceof constructor
// defining constructors
function C() {}

function D() {}

const o = new C();

// true, because: Object.getPrototypeOf(o) === C.prototype
o instanceof C

// false, because D.prototype is nowhere in o's prototype chain
o instanceof D

o instanceof Object // true, because:
C.prototype instanceof Object // true

// Re-assign `constructor.prototype`: you should
// rarely do this in practice.
C.prototype = {};
const o2 = new C();

o2 instanceof C // true

// false, because C.prototype is nowhere in
// o's prototype chain anymore
o instanceof C

D.prototype = new C() // add C to [[Prototype]] linkage of D
const o3 = new D();
o3 instanceof D // true
o3 instanceof C // true since C.prototype is now in o3's prototype chain
class A {}
class B extends A {}

const o1 = new A();
// true, because Object.getPrototypeOf(o1) === A.prototype
o1 instanceof A
// false, because B.prototype is nowhere in o1's prototype chain
o1 instanceof B

const o2 = new B();
// true, because Object.getPrototypeOf(Object.getPrototypeOf(o2)) === A.prototype
o2 instanceof A
// true, because Object.getPrototypeOf(o2) === B.prototype
o2 instanceof B
// This class allows plain objects to be disguised as this class's instance,
// as long as the object has a particular flag as its property.
class Forgeable {
   static isInstanceFlag = Symbol("isInstanceFlag");

   static[Symbol.hasInstance](obj) {
      return Forgeable.isInstanceFlag in obj;

const obj = {
   [Forgeable.isInstanceFlag]: true
console.log(obj instanceof Forgeable); // true
const literalString = 'This is a literal string';
const stringObject = new String('String created with constructor');

literalString instanceof String; // false, string primitive is not a String
stringObject instanceof String; // true

literalString instanceof Object; // false, string primitive is not an Object
stringObject instanceof Object; // true

stringObject instanceof Date; // false
const myDate = new Date();

myDate instanceof Date; // true
myDate instanceof Object; // true
myDate instanceof String; // false

Suggestion : 4

If a method declares a non-void return type, it must return a value compatible with the declared return type.,A method must declare a return type. A void return type means the method doesn’t return anything.,Methods can return values. Every method is declared with a return type, but until now we’ve made all of our methods with a void return type, which means they don’t give anything back.,If you declare a method to return a value, you must return a value of the declared type! (Or a value that is compatible with the declared type. We’ll get into that more when we talk about polymorphism in Chapter 7 and Chapter 8.)

void play() {
void go() {}
class ElectricGuitar {

   String brand;
   int numOfPickups;
   boolean rockStarUsesIt;

   String getBrand() {
      return brand;

   void setBrand(String aBrand) {
      brand = aBrand;

   int getNumOfPickups() {
      return numOfPickups;

   void setNumOfPickups(int num) {
      numOfPickups = num;

   boolean getRockStarUsesIt() {
      return rockStarUsesIt;

   void setRockStarUsesIt(boolean yesOrNo) {
      rockStarUsesIt = yesOrNo;
theCat.height = 27;
Dog[] pets;
pets = new Dog[7];

Suggestion : 5

Last modified: June 24, 2022

The instanceof operator's basic syntax is:

(object) instanceof(type)
public class Round {
   // implementation details

Next, we'll create a class Ring that extends Round:

public class Ring extends Round {
   // implementation details

To demonstrate this, we'll create a Shape interface:

public interface Shape {
   // implementation details
public class Circle extends Round implements Shape {
   // implementation details

Suggestion : 6

Supports all classes in the .NET class hierarchy and provides low-level services to derived classes. This is the ultimate base class of all .NET classes; it is the root of the type hierarchy.,Because all classes in .NET are derived from Object, every method defined in the Object class is available in all objects in the system. Derived classes can and do override some of these methods, including:,The following example defines a Point type derived from the Object class and overrides many of the virtual methods of the Object class. In addition, the example shows how to call many of the static and instance methods of the Object class.,Although it is sometimes necessary to develop general purpose classes that accept and return Object types, you can improve performance by also providing a type-specific class to handle a frequently used type. For example, providing a class that is specific to setting and getting Boolean values eliminates the cost of boxing and unboxing Boolean values.

public ref class System::Object
public ref class System::Object
public class Object
public class Object
public class Object
public class Object
type obj = class
type obj = class
      type obj = class