The following compiles fine:

      Object o = new Object();
      System.out.println(o instanceof Cloneable);

But this doesn&#39;t:

      String s = new String();
      System.out.println(s instanceof Cloneable);

A compiler error is thrown.

What is the problem?

instanceof - incompatible conditional operand types

I&#39;m debugging a C++ program with GDB.

I have a pointer to an object of certain class. The pointer is declared to be of some super class which is extended by several sub-classes.

There is no fields in the object to specify the precise class type of this object but some virtual functions (e.g. bool is_xxx()) are defined to tell the class type at runtime.

Is there some way to tell the precise class type of an object in GDB without calling these virtual functions. Calling such functions in GDB may generate confusing result when the program is multi-threaded.


How to determine if an object is an instance of certain derived C++ class from a pointer to a base class in GDB?

    &quot;foo&quot; instanceof String //=&gt; false
    &quot;foo&quot; instanceof Object //=&gt; false

    true instanceof Boolean //=&gt; false
    true instanceof Object //=&gt; false
    false instanceof Boolean //=&gt; false
    false instanceof Object //=&gt; false

    12.21 instanceof Number //=&gt; false
    /foo/ instanceof RegExp //=&gt; true

    // the tests against Object really don&#39;t make sense

Array literals and Object literals match...

    [0,1] instanceof Array //=&gt; true
    {0:1} instanceof Object //=&gt; true

Why don&#39;t all of them? Or, why don&#39;t they all _not_?  
And, what are they an instance of, then?

It&#39;s the same in FF3, IE7, Opera, and Chrome. So, at least it&#39;s consistent.

Why does instanceof return false for some literals?

I have a class `Child` that extends `Parent`.

    Parent child = new Child();
    
    if (child instanceof Parent){
        // Do something
    }

Does this returns true or false, and why?


Does instanceof return true if instance of a parent?

&gt; [What is the &amp;#39;instanceof&amp;#39; operator used for?](https://stackoverflow.com/questions/7313559/what-is-the-instanceof-operator-used-for)  

&lt;!-- End of automatically inserted text --&gt;

I learned that Java has the `instanceof` operator. Can you elaborate where it is used and what are its advantages?



Use of &quot;instanceof&quot; in Java

How can I find the variable type in Kotlin?
In Java there is `instanceof`, but Kotlin does not exist:

    val properties = System.getProperties() // Which type?

Get type of a variable in Kotlin

Is this the only way to check if an object is an instance of a class, in my case of the DateTime class?

    $cls = ReflectionClass(&quot;DateTime&quot;);
    if (! $cls-&gt;isInstance( (object) $var ) ) {
        // is not an instance
    }

It seems a bit heavy to me.

PHP check for instance of DateTime?

For this example:

    public class Foo{}
    
    public class Bar extends Foo{}

    ....

    void myMethod(Foo qux){
       if (checkInstance(qux,Foo.class)){
         ....
       }
    }

How can I check if `qux` is an instance of Foo (but not an instance of its subclass of foo)? That is:

 - checkInstance(qux,Foo.class)=true
 - checkInstance(qux,Bar.class)=false

Is there some kind of statement like `instanceof` for this check? or I should use `qux.getClass().equals(Foo.class)`


Check if an object is an instance of a class (but not an instance of its subclass)

In JavaScript, I can declare a string in the following ways;

    var a = &quot;Hello World&quot;;
    var b = new String(&quot;Hello World&quot;);

but a is not an instance of String...

    console.log(a instanceof String); //false;
    console.log(b instanceof String); //true;

So how do you find the type or &quot;`instanceof`&quot; a string literal?

Can JavaScript be forced to create a `new String()` for every string literal?

How to &quot;instanceof&quot; a primitive string (string literal) in JavaScript

In some of my own older code, I use the following:

    Object.prototype.instanceOf = function( iface )
    {
     return iface.prototype.isPrototypeOf( this );
    };

Then I do (for example)

    [].instanceOf( Array )

This works, but it seems the following would do the same:

    [] instanceof Array

Now, surely this is only a very simple example. My question therefore is:

Is `a instanceof b` *ALWAYS* the same as `b.prototype.isPrototypeOf(a)` ?



What&#39;s the difference between isPrototypeOf and instanceof in Javascript?

When I compile and run this code:

    public class Testing {
        public static void main(String... args) {
	        Object obj = null;
	        if (obj instanceof Object) {
		        System.out.println(&quot;returned true&quot;); 
    		} else {
    			System.out.println(&quot;returned false&quot;); 
    		}
    		System.out.println(&quot; &quot; + obj instanceof Object);
	    }
    }

I get this on the command line:

    C:\Users\xxxxxx\Desktop&gt;java Testing
    returned false
    true

Shouldn&#39;t &quot;null instanceof someType&quot; always return false?

Java - null instanceof Object evaluates to both true and false

This is a really basic question really just to satisfy my curiosity, but is there a way to do something like this:

    if(obj !instanceof Array) {
        //The object is not an instance of Array
    } else {
        //The object is an instance of Array
    }

The key here being able to use the NOT ! in front of instance. Usually the way I have to set this up is like this:

    if(obj instanceof Array) {
        //Do nothing here
    } else {
        //The object is not an instance of Array
        //Perform actions!
    }

And its a little annoying to have to create an else statement when I simply want to know if the object is a specific type.

Javascript !instanceof If Statement

What is the preferred method to achieve the C++ equivalent of java&#39;s `instanceof`?

C++ equivalent of java&#39;s instanceof

I&#39;m using Eclipse to generate `.equals()` and `.hashCode()`, and there is an option labeled &quot;Use &#39;instanceof&#39; to compare types&quot;.  The default is for this option to be unchecked and use `.getClass()` to compare types.  Is there any reason I should prefer `.getClass()` over `instanceof`?

Without using `instanceof`:

    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;

Using `instanceof`:

    if (obj == null)
      return false;
    if (!(obj instanceof MyClass))
      return false;

I usually check the `instanceof` option, and then go in and remove the &quot;`if (obj == null)`&quot; check. (It is redundant since null objects will always fail `instanceof`.)  Is there any reason that&#39;s a bad idea?

Any reason to prefer getClass() over instanceof when generating .equals()?

Dart specification states:

&gt; Reified type information reflects the types of objects at runtime and may always be queried by dynamic typechecking constructs (the
&gt; analogs of instanceOf, casts, typecase etc. in other languages).

Sounds great, but there is no `instanceof`-like operator. So how do we perform runtime type-checking in Dart? Is it possible at all?

How to perform runtime type checking in Dart?

Is there anyway to detect if a JavaScript object is a regex?

For example, I would like to do something like this:

    var t = /^foo(bar)?$/i;
    alert(typeof t); //I want this to return &quot;regexp&quot;

Is this possible?

Thanks!

EDIT: Thanks for all the answers. It seems I have two very good choices:

    obj.constructor.name === &quot;RegExp&quot;

or

    obj instanceof RegExp

Any major pros/cons to either method?

Thanks again!

typeof for RegExp

What is the `instanceof` operator used for? I&#39;ve seen stuff like

    if (source instanceof Button) {
        //...
    } else {
        //...
    }

But none of it made sense to me. I&#39;ve done my research, but came up only with examples without any explanations.

What is the &#39;instanceof&#39; operator used for in Java?

I wrote this code

    interface Foo {
        abcdef: number;
    }

    let x: Foo | string;

    if (x instanceof Foo) {
        // ...
    }

But TypeScript gave me this error:

    &#39;Foo&#39; only refers to a type, but is being used as a value here.

Why is this happening? I thought that `instanceof` could check whether my value has a given type, but TypeScript seems not to like this.

Why does &#39;instanceof&#39; in TypeScript give me the error &quot;&#39;Foo&#39; only refers to a type, but is being used as a value here.&quot;?

Before I look through my generic data structure for a value&#39;s index, I&#39;d like to see if it is even an instance of the type `this` has been parametrized to.

But Eclipse complains when I do this:

	@Override
	public int indexOf(Object arg0) {
		if (!(arg0 instanceof E)) {
			return -1;
		}


This is the error message:

&gt; Cannot perform instanceof check against type parameter E. Use instead its erasure Object since generic type information will be erased at runtime

What is the better way to do it?

Java: Instanceof and Generics

How to I test if `a` is a subclass of `b`?

    Class&lt;?&gt; a = A.class;
    Class&lt;?&gt; b = B.class;



How to test if one java class extends another at runtime?

I see gain in performance when using `getClass()` and `==` operator over `instanceOf` operator.
  
		
	Object  str = new Integer(&quot;2000&quot;);
	
	long starttime = System.nanoTime();

	if(str instanceof String) {
		System.out.println(&quot;its string&quot;);
	} else {
		if (str instanceof Integer) {
			System.out.println(&quot;its integer&quot;);
			
		}
	}

	System.out.println((System.nanoTime()-starttime));
	
	starttime = System.nanoTime();

	if(str.getClass() == String.class) {
		System.out.println(&quot;its string in equals&quot;);
	} else {
		if(str.getClass() == Integer.class) {
			System.out.println(&quot;its integer&quot;);
		}
	}

	System.out.println((System.nanoTime()-starttime));
	

Is there any guideline, which one to use `getClass()` or `instanceOf`?

Given a scenario: I know exact classes to be matched, that is `String`, `Integer` (these are final classes), etc.

Is using `instanceOf` operator bad practise ?


instanceof Vs getClass( )

How can I see in Java if an Object is an array without using reflection?
And how can I iterate through all items without using reflection?

I use Google GWT so I am not allowed to use reflection :(

I would love to implement the following methods without using refelection:

    private boolean isArray(final Object obj) {
      //??..
    }
    
    private String toString(final Object arrayObject) {
      //??..
    }

BTW: neither do I want to use JavaScript such that I can use it in non-GWT environments.

How to see if an object is an array without using reflection?

Having a chain of &quot;instanceof&quot; operations is considered a &quot;code smell&quot;.  The standard answer is &quot;use polymorphism&quot;.  How would I do it in this case?

There are a number of subclasses of a base class; none of them are under my control.  An analogous situation would be with the Java classes Integer, Double, BigDecimal etc.

    if (obj instanceof Integer) {NumberStuff.handle((Integer)obj);}
    else if (obj instanceof BigDecimal) {BigDecimalStuff.handle((BigDecimal)obj);}
    else if (obj instanceof Double) {DoubleStuff.handle((Double)obj);}

I do have control over NumberStuff and so on.

I don&#39;t want to use many lines of code where a few lines would do.  (Sometimes I make a HashMap mapping Integer.class to an instance of IntegerStuff, BigDecimal.class to an instance of BigDecimalStuff etc.  But today I want something simpler.)

I&#39;d like something as simple as this:

    public static handle(Integer num) { ... }
    public static handle(BigDecimal num) { ... }

But Java just doesn&#39;t work that way.

I&#39;d like to use static methods when formatting.  The things I&#39;m formatting are composite, where a Thing1 can contain an array Thing2s and a Thing2 can contain an array of Thing1s.  I had a problem when I implemented my formatters like this:

    class Thing1Formatter {
      private static Thing2Formatter thing2Formatter = new Thing2Formatter();
      public format(Thing thing) {
          thing2Formatter.format(thing.innerThing2);
      }
    }
    class Thing2Formatter {
      private static Thing1Formatter thing1Formatter = new Thing1Formatter();
      public format(Thing2 thing) {
          thing1Formatter.format(thing.innerThing1);
      }
    }

Yes, I know the HashMap and a bit more code can fix that too.  But the &quot;instanceof&quot; seems so readable and maintainable by comparison.  Is there anything simple but not smelly?

Note added 5/10/2010:

It turns out that new subclasses will probably be added in the future, and my existing code will have to handle them gracefully.  The HashMap on Class won&#39;t work in that case because the Class won&#39;t be found.  A chain of if statements, starting with the most specific and ending with the most general, is probably the best after all:

    if (obj instanceof SubClass1) {
        // Handle all the methods and properties of SubClass1
    } else if (obj instanceof SubClass2) {
        // Handle all the methods and properties of SubClass2
    } else if (obj instanceof Interface3) {
        // Unknown class but it implements Interface3
        // so handle those methods and properties
    } else if (obj instanceof Interface4) {
        // likewise.  May want to also handle case of
        // object that implements both interfaces.
    } else {
        // New (unknown) subclass; do what I can with the base class
    }


Avoiding instanceof in Java

I have the following expression:

    scheduleIntervalContainers.stream()
            .filter(sic -&gt; ((ScheduleIntervalContainer) sic).getStartTime() != ((ScheduleIntervalContainer)sic).getEndTime())
            .collect(Collectors.toList());

...where `scheduleIntervalContainers` has element type `ScheduleContainer`:

    final List&lt;ScheduleContainer&gt; scheduleIntervalContainers

Is it possible to check the type before the filter?

Check instanceof in stream

Why doesn&#39;t this code compile?

    	public boolean isOf(Class clazz, Object obj){
    		if(obj instanceof clazz){
      			return true;
    		}else{
    			return false;
    		}
    	}

Why I can&#39;t pass a class variable to `instanceof`?


Why can&#39;t a &quot;Class&quot; variable be passed to instanceof?

Which of the following is better?

    a instanceof B

or

    B.class.isAssignableFrom(a.getClass())

The only difference that I know of is, when &#39;a&#39; is null, the first returns false, while the second throws an exception. Other than that, do they always give the same result?

What is the difference between instanceof and Class.isAssignableFrom(...)?

Is there a way to determine if an object is an instance of a generic type?

    public &lt;T&gt; test(Object obj) {
        if (obj instanceof T) {
            ...
        }
    }

That clearly doesn&#39;t work. Is there an alternative? Like I want to use Java reflection to instantiate a class and then check to make sure it is of type generic `T`.


Test if object is instanceof a parameter type

I want to check if an object `o` is an instance of the class `C` or of a subclass of `C`.

For instance, if `p` is of class `Point` I want `x.instanceOf(Point.class)` to be `true` and also `x.instanceOf(Object.class)` to be `true`.

I want it to work also for boxed primitive types. For instance, if `x` is an `Integer` then `x.instanceOf(Integer.class)` should be `true`.

Is there such a thing? If not, how can I implement such a method?

Is there something like instanceOf(Class&lt;?&gt; c) in Java?

In my particular case:

    callback instanceof Function

or 

    typeof callback == &quot;function&quot;

does it even matter, what&#39;s the difference?

**Additional Resource:**

JavaScript-Garden [typeof][1] vs [instanceof][2]


  [1]: http://bonsaiden.github.com/JavaScript-Garden/#types.typeof
  [2]: http://bonsaiden.github.com/JavaScript-Garden/#types.instanceof

What is the difference between typeof and instanceof and when should one be used vs. the other?

I know of `is` and `as` for `instanceof`, but what about the reflective [isInstance()][1] method?

  [1]: http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Class.html#isInstance(java.lang.Object)


What is the C# equivalent to Java&#39;s isInstance()?

I would like to know regarding following behavior of `instanceof` operator in Java.

    interface C {}

    class B {}

    public class A {
        public static void main(String args[]) {
            B obj = new B();
            System.out.println(obj instanceof A);      //Gives compiler error
            System.out.println(obj instanceof C);      //Gives false as output
        }
    }

Why is it so? There is no relation between `interface C` and `class B`, but it gives false whereas in case of `obj instanceof A` it gives compiler error?


The &#39;instanceof&#39; operator behaves differently for interfaces and classes

How do I find out a name of class that created an instance of an object in Python if the function I am doing this from is the base class of which the class of the instance has been derived?

Was thinking maybe [the inspect module][1] might have helped me out here, but it doesn&#39;t seem to give me what I want. And short of parsing the `__class__` member, I&#39;m not sure how to get at this information.


  [1]: https://docs.python.org/2/library/inspect.html &quot;inspect — Inspect live objects&quot;

Getting the class name of an instance?

In an android app test suite I have a class like this where `B` is a view:

    public class A extends B {
    ... etc...
    }

now I have a list of view objects which may contain `A` objects but in this case I only care if they&#39;re subclasses or &quot;instances of&quot; `B`. I&#39;d like to do something like:

    ArrayList&lt;View&gt; viewList = getViews();
    Iterator&lt;View&gt; iterator = viewList.iterator();
    while (iterator.hasNext() &amp;&amp; viewList != null) {
    	View view = iterator.next();
    	if (view.getClass().isInstance(B.class)) {
    		// this is an instance of B
    	}
    }

The problem is that when the `if` encounters an `A` object it doesn&#39;t evaluate to an &quot;instance of `B`&quot;. Is there a way to do `isSubclassOf` or something?


How to check if a subclass is an instance of a class at runtime?

Over the years, I&#39;ve tried to avoid `instanceof` whenever possible. Using polymorphism or the visitor pattern where applicable. I suppose it simply eases maintenance in some situations... Are there any other drawbacks that one should be aware of?

I do however see it here and there in the Java libraries so I suppose it has its place? Under what circumstances is it preferable? Is it ever unavoidable?

Is instanceof considered bad practice? If so, under what circumstances is instanceof still preferable?

I&#39;m trying to know if a class is an Enum, but I think I&#39;m missing something:

    if (test.MyEnum.class instanceof Enum&lt;?&gt;.class)
     obj = resultWrapper.getEnum(i, test.MyEnum.class);
    else 
     obj = resultWrapper.getObject(i);

It gives me an error saying that Enum&lt;?&gt;.class is not valid. So how I can check if a class is a Enum? I&#39;m pretty sure it is possible to determine that, I&#39;m just unable to get it.

Thanks


Checking if a class is java.lang.Enum

I have the following (maybe common) problem and it absolutely puzzles me at the moment:

There are a couple of generated event objects which extends the abstract class `Event` and I want to divide them to Session Beans, like

	public void divideEvent(Event event) {
		if (event instanceof DocumentEvent) {
			documentGenerator.gerenateDocument(event);
		} else if (event instanceof MailEvent) {
			deliveryManager.deliverMail(event);
            ...
		}
        ...

	}

But there could be more than two event types in future, so the if-else will be long and maybe unreadable. Additionally I think `instanceof` is not really &quot;best practice&quot; in this case.

I could add an abstract method to the `Event` type and have them divide itself but then I have to inject the specific Session Beans within each entity.

Is there any hint to achieve a &quot;pretty&quot; solution for this problem?

Thanks for any help!

Avoiding &#39;instanceof&#39; in Java

The `instanceof` keyword in JavaScript can be quite confusing when it is first encountered, as people tend to think that JavaScript is not an object-oriented programming language.

 - What is it?
 - What problems does it solve?
 - When is it appropriate and when not?

What is the instanceof operator in JavaScript?

Is there any way to efficiently check if the variable is Object or Array, in NodeJS &amp; V8? 

I&#39;m writing a Model for MongoDB and NodeJS, and to traverse the object tree I need to know if the object is simple (Number, String, ...) or composite (Hash, Array).

It seems that V8 has fast built-in `Array.isArray`, but how to check if object is an Object? I mean complex object like hash `{}` or instance of class, not something like `new String()`?

Usually it may be done as this:

    Object.prototype.toString.call(object) == &quot;[object Object]&quot;

or this:

    object === Object(object)

But it seems that this operations aren&#39;t cheap, maybe there&#39;s some more efficient? It&#39;s ok if it&#39;s not universal and doesn&#39;t works on all engines, I need it only to work on V8.

How to efficiently check if variable is Array or Object (in NodeJS &amp; V8)?

I am working on an application and one design approach involves extremely heavy use of the `instanceof` operator. While I know that OO design generally tries to avoid using `instanceof`, that is a different story and this question is purely related to performance. I was wondering if there is any performance impact? Is is just as fast as `==`?

For example, I have a base class with 10 subclasses. In a single function that takes the base class, I do checks for if the class is an instance of the subclass and carry out some routine. 

One of the other ways I thought of solving it was to use a &quot;type id&quot; integer primitive instead, and use a bitmask to represent categories of the subclasses, and then just do a bit mask comparison of the subclasses &quot;type id&quot; to a constant mask representing the category.

Is `instanceof` somehow optimized by the JVM to be faster than that? I want to stick to Java but the performance of the app is critical. It would be cool if someone that has been down this road before could offer some advice. Am I nitpicking too much or focusing on the wrong thing to optimize?

The performance impact of using instanceof in Java

Which is the correct format for negating instanceof?

    if ( ! $a instanceof stdClass)

or



   
    if ( ! ($a instanceof stdClass) ) 

I&#39;ve convinced myself the latter is correct way, probably after reading a blog article several years ago, but after some command-line tests, they both seem equivalent. *Are* they?

instanceof negation

I have a question of using switch case for `instanceof` object:

For example: my problem can be reproduced in Java:

    if(this instanceof A)
        doA();
    else if(this instanceof B)
        doB();
    else if(this instanceof C)
        doC():

How would it be implemented using `switch...case`?

Is it possible to use the instanceof operator in a switch statement?

`instanceof` can be used to test if an object is a direct or descended instance of a given class. `instanceof` can also be used with interfaces even though interfaces can&#39;t be instantiated like classes. Can anyone explain how `instanceof` works?

All Instanceof Solutions on Gang of Coders

Total of 42 Instanceof Solutions