PHP
downloads | documentation | faq | getting help | mailing lists | licenses | wiki | reporting bugs | php.net sites | links | conferences | my php.net

search for in the

Les structures de contrôle> <Opérateurs de tableaux
Last updated: Fri, 23 Jan 2009

view this page in

Opérateurs de types

instanceof est utilisé pour déterminer si une variable PHP est un objet instancié d'une certaine classe :

Exemple #1 Utilisation de instanceof avec des classes

<?php
class MaClasse
{
}
class 
PasMaClasse
{
}
$a = new MaClasse;

var_dump($a instanceof MaClasse);
var_dump($a instanceof PasMaClasse);
?>

L'exemple ci-dessus va afficher :

bool(true)
bool(false)

instanceof peut également être utilisé pour déterminer si une variable est un objet instancié d'une classe qui hérite d'une classe parente :

Exemple #2 Utilisation de instanceof avec des classes héritées

<?php
class ParentClass
{
}
class 
MyClass extends ParentClass
{
}
$a = new MyClass;

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

L'exemple ci-dessus va afficher :

bool(true)
bool(true)

Pour vérifier si un objet n'est pas une instance d'une classe, l'opérateur logique not peut être utilisé.

Exemple #3 Utilisation de instanceof

<?php
class MyClass
{
}
$a = new MyClass;
var_dump(!($a instanceof stdClass));
?>

L'exemple ci-dessus va afficher :

bool(true)

Et finalement, instanceof peut être utilisé pour déterminer si une variable est un objet instancié d'une classe qui implémente une interface :

Exemple #4 Utilisation de instanceof pour une classe

<?php
interface MyInterface
{
}
class 
MyClass implements MyInterface
{
}
$a = new MyClass;

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

L'exemple ci-dessus va afficher :

bool(true)
bool(true)

Bien que instanceof soit habituellement utilisé avec un nom de classe littéral, il peut également être utilisé avec un autre objet ou une chaîne représentant une variable :

Exemple #5 Utilisation de instanceof avec d'autres variables

<?php
interface MyInterface
{
}
class 
MyClass implements MyInterface
{
}
$a = new MyClass;
$b = new MyClass;
$c 'MyClass';
$d 'NotMyClass';
var_dump($a instanceof $b); // $b est un objet de la classe MyClass
var_dump($a instanceof $c); // $c est une chaîne 'MyClass'
var_dump($a instanceof $d); // $d est une chaîne 'NotMyClass'
?>

L'exemple ci-dessus va afficher :

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

Il y a quelque piège à éviter. Avant PHP version 5.1.0, instanceof appellera __autoload() si le nom de la classe n'existe pas. De plus, si la classe n'a pas été chargée, une erreur fatale sera émise. Ceci peut fonctionner en utilisant une référence de classe dynamique, ou une chaîne représentant une variable contenant le nom de la classe :

Exemple #6 Pas de recherche sur le nom de la classe et une erreur fatale avec instanceof en PHP 5.0

<?php
$d 
'NotMyClass';
var_dump($a instanceof $d); // no fatal error here
?>

L'exemple ci-dessus va afficher :

bool(false)

L'opérateur instanceof a été introduit en PHP 5. Avant cette version, is_a() était utilisé mais is_a() est depuis devenu obsolète, en faveur de instanceof. Notez que depuis PHP 5.3.0, is_a() n'est de nouveau plus obsolète.

Voir aussi get_class() et is_a().



Les structures de contrôle> <Opérateurs de tableaux
Last updated: Fri, 23 Jan 2009
 
add a note add a note User Contributed Notes
Opérateurs de types
jtaal at eljakim dot nl
17-Nov-2008 01:37
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);
?>
kevin dot benton at beatport dot com
21-Aug-2008 04:31
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.
ejohnson82 at gmail dot com
18-Jan-2008 09:59
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
julien plee using g mail dot com
21-Jul-2007 01:56
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));
}
?>
jphaas at gmail dot com
11-Jul-2007 05:50
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.
vinyanov at poczta dot onet dot pl
19-Jun-2007 10:57
Unfortunately the instanceof operator will not accept a string as its first operand. So I wrote this function. It does exactly the same (ie, successively checks identicalness, inheritance and implementation). Just on strings.

<?php

function is_instance_of($sub, $super)
{
   
$sub = (string)$sub;
   
$super = is_object($super) ? get_class($super) : (string)$super;
   
    switch(
true)
    {
        case
$sub === $super; // well ... conformity
       
case is_subclass_of($sub, $super):
        case
in_array($super, class_implements($sub)):
            return
true;
        default:
            return
false;
    }
}

// testing

interface X {}
class
A {}
class
B extends A {}
class
C extends B {}
class
D implements X {}

$i = 'is_instance_of';
var_dump($i('A', 'A'), $i('B', 'A'), $i('C', 'A'), $i('D', 'X'));

?>
jeanyves dot terrien at orange-ftgroup dot com
13-Mar-2007 08:34
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
soletan at toxa dot de
03-Mar-2007 12:04
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?
mikael dot knutsson at gmail dot com
06-Dec-2006 04:34
I can confirm what thisbizness at gmail dot com said just below in PHP 5.2, furthermore, people looking to use this as a "if $a is not instance of A" for error throwing purposes or other, just type it like this:
<?php
if( !$a instanceof A ) {
    throw new
Exception( '$a is not instance of A.' );
}
?>

This also works if $a is not an object, or not even set (you will get an E_NOTICE if it isn't set though).
A note worth making is that if you are unsure of if class A is present when making this comparison, and you don't want to trigger the __autoload() magic method, scroll down for examples of how to get around this.

I was unsure about it at first since most other operators have their own negative (like !=) or they are/can be used as function calls (like !is_a()) but it is this simple. Hope it helps someone.

Until again!
archanglmr at yahoo dot com
18-Feb-2005 02:37
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');
}
?>
d dot schneider at 24you dot de
18-Dec-2004 08:42
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;
        }
    }

?>

Les structures de contrôle> <Opérateurs de tableaux
Last updated: Fri, 23 Jan 2009
 
 
show source | credits | stats | sitemap | contact | advertising | mirror sites