Type Hinting

PHP 5 introduces Type Hinting. Functions are now able to force parameters to be objects (by specifying the name of the class in the function prototype) or arrays (since PHP 5.1).

例子 19-39. Type Hinting examples


<?php
// An example class
class MyClass
{
    /**
     * A test function
     *
     * First parameter must be an object of type OtherClass
     */
    public function test(OtherClass $otherclass) {
        echo $otherclass->var;
    }


    /**
     * Another test function
     *
     * First parameter must be an array
     */
    public function test_array(array $input_array) {
        print_r($input_array);
    }
}

// Another example class
class OtherClass {
    public $var = 'Hello World';
}
?>

Failing to satisfy the type hint results in a fatal error.


<?php
// An instance of each class
$myclass = new MyClass;
$otherclass = new OtherClass;

// Fatal Error: Argument 1 must be an object of class OtherClass
$myclass->test('hello');

// Fatal Error: Argument 1 must be an instance of OtherClass
$foo = new stdClass;
$myclass->test($foo);

// Fatal Error: Argument 1 must not be null
$myclass->test(null);

// Works: Prints Hello World
$myclass->test($otherclass);

// Fatal Error: Argument 1 must be an array
$myclass->test_array('a string');

// Works: Prints the array
$myclass->test_array(array('a', 'b', 'c'));
?>

Type hinting also works with functions:


<?php
// An example class
class MyClass {
    public $var = 'Hello World';
}

/**
 * A test function
 *
 * First parameter must be an object of type MyClass
 */
function MyFunction (MyClass $foo) {
    echo $foo->var;
}

// Works
$myclass = new MyClass;
MyFunction($myclass);
?>

Type Hints can only be of the object and array (since PHP 5.1) type. Traditional type hinting with int and string isn't supported.

add a note User Contributed Notes

13-Sep-2006 06:00


If one is type hinting for a specific class type but wishes for there to be a default option of no object at all (e.g., to work on the object if it exists, or do something else (e.g., print out data) if it doesn't exist), this can be done by (and only by) NULL:



<?php

function printBreadcrumbs(Smarty &$smarty = NULL) {



   $breadcrumbs = <add code here to make or obtain breadcrumbs>;



   if ($smarty != NULL) {

      $smarty->assign('breadcrumbs', $breadcrumbs);

   }

   else {

      print $breadcrumbs;

   }

}

?>



If one tries to change NULL to '' or the like, one will get this error message:



     Default value for parameters with a class type hint can only be NULL

02-Sep-2006 11:59


The type hinting system can also be used for interfaces.  Example:



<?php

interface fooface

{

    public function foo ();

}



class fooclass implements fooface

{

    public function foo ()

    {

        echo ('foo<br>');

    }

}

class barclass implements fooface

{

    public function foo ()

    {

        echo ('bar<br>');

    }

}

class bazclass implements fooface

{

    public function foo ()

    {

        echo ('baz<br>');

    }

}



class quuxclass

{

    public function foo ()

    {

        echo ('quux<br>');

    }

}



function callfoo (fooface $myClass)

{

    $myClass -> foo ();

}



$myfoo = new fooclass;

$mybar = new barclass;

$mybaz = new bazclass;

$myquux = new quuxclass;



callfoo ($myfoo);

callfoo ($mybar);

callfoo ($mybaz);

callfoo ($myquux); // Fails because the quuxclass doesn't implement the fooface interface

?>



Using this syntax you can allow a function to work with different classes as long as they all implement the same interfaces.  An example might be an online shop that implements a plugin system for payment.  If the creator of the script provides a payment module interface then functions can check if it has been implemented in a given payment class.  This means that the details of the class are unimportant, so it doesn't matter if it interfaces with PayPal, HSBC, ProTX or any other payment system you care to name, but if it doesn't properly provide all the functionality a payment module requires a fatal error is generated.  



Unfortunately, it doesn't seem possible to use type hinting with new.  In java you could do a "fooface myfoo = new fooclass" which would fail if you tried it with quuxclass instead, but as far as I can tell you can't do a similar test on create with PHP.

mega-squall at caramail dot com
16-May-2006 03:11


Type hinting cannot be used with array of instances of a given class. When submited to PHP Team, idea got this answer :



" That's impossible and never will be. But you can do that more or less yourself. Derive a class that implements ArrayAccess or reuse ArrayObject/ArrayIterator. And overload its offsetSet(). In the method body you add the check to ensure only what you want can go in. Now if that class accepts only B's (B beeing an examble classname, ndla) you may call it ArrayOfB and the use ArrayOfB as you typehint. "



This is obviously reaching the limit between "typing" and "type hinting" ...

mlovett at morpace dot com
06-Jul-2005 06:54


Type hinting works with interfaces too. In other words, you can specify the name of an interface for a function parameter, and the object passed in must implement that interface, or else type hinting throws an exception.

caliban at darklock dot com
23-Feb-2005 11:34


In case you're worried, type hinting does allow descendants. Extending the documentation example:



<?php

   // Example class

   class MyClass

   {

      public function test(OtherClass $otherclass) 

      {

          if(is_callable(array($otherclass,$otherclass->var)))

          {

             $otherclass->{$otherclass->var}();

          }

          else

          {

             echo $otherclass->var;

          }

      }

   }



   // Another example class

   class OtherClass 

   {

      public $var = 'Hello World';

   }



   // Yet another example class

   class DerivedClass extends OtherClass 

   {

      function __construct() 

      { 

         $this->var="Planet"; 

      }



      public function Planet()

      {

         echo "Hello ".$this->var;

      }

   }



   $myclass = new MyClass;

   $otherclass = new OtherClass;

   $derivedclass = new DerivedClass;



   // Works - prints "Hello World"

   $myclass->test($otherclass);



   // Works - calls DerivedClass::Planet()

   //    which prints "Hello Planet"

   $myclass->test($derivedclass);

?>

add a note