PHP 5.4.31 Released

Operatori di tipi

instanceof è utilizzato per determinare se una variabile PHP è un oggetto istanza di una certa classe:

Example #1 Utilizzo di instanceof con le classi

<?php
class MyClass
{
}

class 
NotMyClass
{
}
$a = new MyClass;

var_dump($a instanceof MyClass);
var_dump($a instanceof NotMyClass);
?>

Il precedente esempio visualizzerà:

bool(true)
bool(false)

instanceof può essere usato anche per determinare se una variabile è un oggetto istanziato da una classe che eredita da una classe parente:

Example #2 Utilizzo di instanceof con le classi ereditate

<?php
class ParentClass
{
}

class 
MyClass extends ParentClass
{
}

$a = new MyClass;

var_dump($a instanceof MyClass);
var_dump($a instanceof ParentClass);
?>

Il precedente esempio visualizzerà:

bool(true)
bool(true)

Al fine di controllare se un oggetto non è un instanceof di una classe, si può usare l'operatore logico not .

Example #3 Utilizzo di instanceof per controllare se un oggetto non è un'instanceof di una classe

<?php
class MyClass
{
}

$a = new MyClass;
var_dump(!($a instanceof stdClass));
?>

Il precedente esempio visualizzerà:

bool(true)

Infine, instanceof può essere usato anche per deretmnare se una variable è un oggetto istanziato da una classe che implementa una interfaccia:

Example #4 Utilizzo di instanceof per una classe

<?php
interface MyInterface
{
}

class 
MyClass implements MyInterface
{
}

$a = new MyClass;

var_dump($a instanceof MyClass);
var_dump($a instanceof MyInterface);
?>

Il precedente esempio visualizzerà:

bool(true)
bool(true)

Anche se instanceof è normalmente usata con un nome di classe letterale, può essere usata con un altro oggetto o con una variabile stringa:

Example #5 Utilizzo di instanceof con altre variabili

<?php
interface MyInterface
{
}

class 
MyClass implements MyInterface
{
}

$a = new MyClass;
$b = new MyClass;
$c 'MyClass';
$d 'NotMyClass';

var_dump($a instanceof $b); // $b è un oggetto di classe MyClass
var_dump($a instanceof $c); // $c è la stringa 'MyClass'
var_dump($a instanceof $d); // $d è la stringa 'NotMyClass'
?>

Il precedente esempio visualizzerà:

bool(true)
bool(true)
bool(false)

instanceof non genera errori se la variabile che viene controllata non è un oggetto, ma ritorna semplicemente FALSE. Le costanti non sono comunque ammesse.

Example #6 Utilizzo di instanceof per controllare altre variabili

<?php
$a 
1;
$b NULL;
$c imagecreate(55);
var_dump($a instanceof stdClass); // $a è un integer
var_dump($b instanceof stdClass); // $b è NULL
var_dump($c instanceof stdClass); // $c è una risorsa
var_dump(FALSE instanceof stdClass);
?>

Il precedente esempio visualizzerà:

bool(false)
bool(false)
bool(false)
PHP Fatal error:  instanceof expects an object instance, constant given

Ci sono alcune trappole da evitare. Prima di PHP 5.1.0, instanceof chiama __autoload() se il nome della classe non esiste. Inoltre, se la classe non è stata caricata, viene generato un errore fatale. Ciò può essere evitato usando un riferimento dinamico alla classe, o una variabile stringa che contenga il nome della classe:

Example #7 Evitare richerce del nome della classe ed errori fatali con instanceof in PHP 5.0

<?php
$d 
'NotMyClass';
var_dump($a instanceof $d); // l'errore fatale non avviene
?>

Il precedente esempio visualizzerà:

bool(false)

L'operatore instanceof è stato introdotto in PHP 5. Prima di questo si utilizzava is_a(), ma ora is_a() è deprecata in favore di instanceof. Si noti che dal PHP 5.3.0, is_a() non è più deprecata.

Vedere anche get_class() e is_a().

add a note add a note

User Contributed Notes 18 notes

up
7
knarlin at yahoo dot com dot au
1 year ago
Checking an object is not an instance of a class, example #3 uses extraneous parentheses.

<?php
var_dump
(!($a instanceof stdClass));
?>

Because instanceof has higher operator precedence than ! you can just do

<?php
var_dump
( ! $a instanceof stdClass );
?>
up
5
Sudarshan Wadkar
2 years ago
I don't see any mention of "namespaces" on this page so I thought I would chime in. The instanceof operator takes FQCN as second operator when you pass it as string and not a simple class name. It will not resolve it even if you have a `use MyNamespace\Bar;` at the top level. Here is what I am trying to say:

## testinclude.php ##
<?php
namespace Bar1;
{
class
Foo1{ }
}
namespace
Bar2;
{
class
Foo2{ }
}
?>
## test.php ##
<?php
include('testinclude.php');
use
Bar1\Foo1 as Foo;
$foo1 = new Foo(); $className = 'Bar1\Foo1';
var_dump($foo1 instanceof Bar1\Foo1);
var_dump($foo1 instanceof $className);
$className = 'Foo';
var_dump($foo1 instanceof $className);
use
Bar2\Foo2;
$foo2 = new Foo2(); $className = 'Bar2\Foo2';
var_dump($foo2 instanceof Bar2\Foo2);
var_dump($foo2 instanceof $className);
$className = 'Foo2';
var_dump($foo2 instanceof $className);
?>
## stdout ##
bool(true)
bool(true)
bool(false)
bool(true)
bool(true)
bool(false)
up
2
julien plee using g mail dot com
7 years ago
Response to vinyanov at poczta dot onet dot pl:

You mentionned "the instanceof operator will not accept a string as its first operand". However, this behavior is absolutely right and therefore, you're misleading the meaning of an instance.

<?php 'ClassA' instanceof 'ClassB'; ?> means "the class named ClassA is an instance of the class named ClassB". This is a nonsense sentence because when you instanciate a class, you ALWAYS obtain an object. Consequently, you only can ask if an object is an instance of a class.

I believe asking if "a ClassA belongs to a ClassB" (or "a ClassA is a class of (type) ClassB") or even "a ClassA is (also) a ClassB" is more appropriate. But the first is not implemented and the second only works with objects, just like the instanceof operator.

Plus, I just have tested your code and it does absolutely NOT do the same as instanceof (extended to classes)! I can't advise anyone to reuse it. The use of <?php is_instance_of ($instanceOfA, 'ClassB'); ?> raises a warning "include_once(Object id #1.php) …" when using __autoload (trying to look for $instanceOfA as if it was a class name).

Finally, here is a fast (to me) sample function code to verify if an object or class:

<?php
function kind_of (&$object_or_class, $class)
{
    return
is_object ($object_or_class) ?
       
$object_or_class instanceof $class
       
: (is_subclass_of ($object_or_class $class)
           ||
strtolower ($object_or_class) == strtolower ($class));
}
?>
up
2
dava
7 months ago
You are also able to compare 2 objects using instanceOf. In that case, instanceOf will compare the types of both objects. That is sometimes very useful:

<?php

class A { }
class
B { }

$a = new A;
$b = new B;
$a2 = new A;

echo
$a instanceOf $a; // true
echo $a instanceOf $b; // false
echo $a instanceOf $a2; // true

?>
up
1
phil dot taylor at gmail dot com
4 years ago
It seems like instanceOf is using a string comparison. Longer class names take longer to check in conditional statements

eg.

if ($f instanceOf HelloWorldTestClass)

is much slower than

if ($f instanceOf HWT)
up
2
jtaal at eljakim dot nl
5 years ago
You can use "self" to reference to the current class:

<?php
class myclass {
    function
mymethod($otherObject) {
        if (
$otherObject instanceof self) {
           
$otherObject->mymethod(null);
        }
        return
'works!';
    }
}

$a = new myclass();
print
$a->mymethod($a);
?>
up
1
fbableus
3 years ago
If you want to test if a classname is an instance of a class, the instanceof operator won't work.

<?php
$classname
= 'MyClass';
if(
$classname instanceof MyParentClass) echo 'Child of it';
else echo
'Not child of it';
?>

Will always output
Not child of it

You must use a ReflectionClass :
<?php
$classname
= 'MyClass';
$myReflection = new ReflectionClass($classname);
if(
$myReflection->isSubclassOf('MyParentClass')) echo  'Child of it';
else echo
'Not child of it';
?>

Will output the good result.
If you're testing an interface, use implementsInterface() instead of isSublassOf().
up
0
CH
6 months ago
You can use instanceof also for interfaces.
up
0
info at pkrules dot in
8 months ago
use this to check instance of or you can add the else part inside the if making it nested if for dual varification.:-
<?php
class MyClass{}
class
Test extends MyClass{
public function
checkObjectArray(array $array,$classname,$strict=false){
if(!
$strict){
foreach(
$array as $element){
if(!(
$element instanceOf $classname)){//we can use typehint objects
INSIDE an array
echo
"false";
echo
"<br />";
break;
}
else{
print
"<br />true (if)";
}
}
}
else{
foreach(
$array as $element){
if(
get_class($element)!=$classname){// or we can use this function to
check the classes inside this array
echo
"false (else)";
}
}
}
echo
"<br />true";
}
}
$ob=new Test;

$a=new MyClass();
$array=array($a);
$ob->checkObjectArray($array,'MyClass');
?>
up
0
wbcarts at juno dot com
2 years ago
SIMPLE, CLEAN, CLEAR use of the instanceof OPERATOR

First, define a couple of simple PHP Objects to work on -- I'll introduce Circle and Point. Here's the class definitions for both:

<?php

class Circle
{
  protected
$radius = 1.0;

 
/*
   * This function is the reason we are going to use the
   * instanceof operator below.
   */
 
public function setRadius($r)
  {
   
$this->radius = $r;
  }

  public function
__toString()
  {
    return
'Circle [radius=' . $this->radius . ']';
  }
}

class
Point
{
  protected
$x = 0;
  protected
$y = 0;

 
/*
   * This function is the reason we are going to use the
   * instanceof operator below.
   */
 
public function setLocation($x, $y)
  {
   
$this->x = $x;
   
$this->y = $y;
  }

  public function
__toString()
  {
    return
'Point [x=' . $this->x . ', y=' . $this->y . ']';
  }
}

?>

Now instantiate a few instances of these types. Note, I will put them in an array (collection) so we can iterate through them quickly.

<?php

$myCollection
= array(123, 'abc', 'Hello World!',
  new
Circle(), new Circle(), new Circle(),
  new
Point(), new Point(), new Point());

$i = 0;
foreach(
$myCollection AS $item)
{
 
/*
   * The setRadius() function is written in the Circle class
   * definition above, so make sure $item is an instance of
   * type Circle BEFORE calling it AND to avoid PHP PMS!
   */
 
if($item instanceof Circle)
  {
   
$item->setRadius($i);
  }

 
/*
   * The setLocation() function is written in the Point class
   * definition above, so make sure $item is an instance of
   * type Point BEFORE calling it AND to stay out of the ER!
   */
 
if($item instanceof Point)
  {
   
$item->setLocation($i, $i);
  }

  echo
'$myCollection[' . $i++ . '] = ' . $item . '<br>';
}

?>

$myCollection[0] = 123
$myCollection[1] = abc
$myCollection[2] = Hello World!
$myCollection[3] = Circle [radius=3]
$myCollection[4] = Circle [radius=4]
$myCollection[5] = Circle [radius=5]
$myCollection[6] = Point [x=6, y=6]
$myCollection[7] = Point [x=7, y=7]
$myCollection[8] = Point [x=8, y=8]
up
0
mauritsdajong at gmail dot com
3 years ago
Sometimes you want to typehint objects INSIDE an array, but I think you can't.

Instead, you can use this function to check the classes inside this array:

<?php

public checkObjectsArray(array $array, $classname, $strict = false) {
    if (!
$strict) {
        foreach (
$array as $element) {
            if (!(
$element instanceof $classname)) {
                return
false;
            }
        }
    }
    else {
        foreach (
$array as $element) {
            if (
get_class($element) != $classname) {
                return
false;
            }
        }
    }
    return
true;
}

?>
up
0
kevin dot benton at beatport dot com
5 years ago
Example #5 could also be extended to include...

var_dump($a instanceof MyInterface);

The new result would be

bool(true)

So - instanceof is smart enough to know that a class that implements an interface is an instance of the interface, not just the class.  I didn't see that point made clearly enough in the explanation at the top.
up
0
ejohnson82 at gmail dot com
6 years ago
The PHP parser generates a parse error on either of the two lines that are commented out here. 
Apparently the 'instanceof' construct will take a string variable in the second spot, but it will NOT take a string... lame

class Bar {}
$b = new Bar;
$b_class = "Bar";
var_export($b instanceof Bar); // this is ok
var_export($b instanceof $b_class); // this is ok
//var_export($f instanceof "Bar"); // this is syntactically illegal
//var_export($f instanceof 'Bar'); // this is syntactically illegal
up
0
jphaas at gmail dot com
7 years ago
Posting this so the word typeof appears on this page, so that this page will show up when you google 'php typeof'.  ...yeah, former Java user.
up
0
jeanyves dot terrien at orange-ftgroup dot com
7 years ago
Cross version function even if you are working in php4
(instanceof is an undefined operator for php4)

   function isMemberOf($classename) {
      $ver = floor(phpversion());
      if($ver > 4) {
         $instanceof = create_function ('$obj,$classname','return $obj instanceof $classname;');
         return $instanceof($this,$classname);
      } else {
         // Php4 uses lowercase for classname.
         return is_a($this, strtolower($classname));
      }
   } // end function isMemberOf
up
0
soletan at toxa dot de
7 years ago
Please note: != is a separate operator with separate semantics. Thinking about language grammar it's kind of ridicilous to negate an operator. Of course, it's possible to negate the result of a function (like is_a()), since it isn't negating the function itself or its semantics.

instanceof is a binary operator, and so used in binary terms like this

terma instanceof termb

while ! (negation) is a unary operator and so may be applied to a single term like this

!term

And a term never consists of an operator, only! There is no such construct in any language (please correct me!). However, instanceof doesn't finally support nested terms in every operand position ("terma" or "termb" above) as negation does:

!!!!!!!!!!!!!!term == term

So back again, did you ever write

a !!!!!!!!!!!!= b

to test equivalence?
up
0
archanglmr at yahoo dot com
9 years ago
Negated instanceof doesn't seem to be documented. When I read instanceof I think of it as a compairson operator (which I suppose it's not).

<?php
class A {}
class
X {}

//parse error from !
if (new X !instanceof A) {
    throw new
Exception('X is not an A');
}
//proper way to negate instanceof ?
if (!(new X instanceof A)) {
    throw new
Exception('X is not an A');
}
?>
up
0
d dot schneider at 24you dot de
9 years ago
use this for cross-version development...

<?php

function is_instance_of($IIO_INSTANCE, $IIO_CLASS){
    if(
floor(phpversion()) > 4){
        if(
$IIO_INSTANCE instanceof $IIO_CLASS){
            return
true;
            }
        else{
            return
false;
            }
        }
    elseif(
floor(phpversion()) > 3){
        return
is_a($IIO_INSTANCE, $IIO_CLASS);
        }
    else{
        return
false;
        }
    }

?>
To Top