Reflexão
Note that you cannot add a type hint and give a default value, apart from arrays. You will get an internal server error, or fatal error.
e.g.
<?php
//Wont work
function test(ObjName $obj = ''){
//.....
}
//Will work
function test(Array $obj = array()){
//.....
}
?>
Even if you have Daniel's implementation of type hinting, a string typehint will still not work if you give it an empty string default too.
Indução de Tipo
PHP 5 introduz Indução de Tipo. Funções podem forçar que os parâmetros sejam objetos (especificando o nome da classe no protótipo da função) ou array (a partir do PHP 5.1). Contudo, se NULL é usado como o valor padrão do parametro, ele será permitido como um argumento nas chamadas à função.
Exemplo #1 Exemplo Indução de Tipo
<?php
// Uma classe de exemplo
class MinhaClasse
{
/**
* Uma função de teste
*
* Primeiro parâmetro deve ser um objeto do tipo OutraClasse
*/
public function teste(OutraClasse $outraclasse) {
echo $outraclasse->var;
}
/**
* Outra função de teste
*
* Primeiro parâmetro deve ser um array
*/
public function testa_array(array $array_de_entrada) {
print_r($array_de_entrada);
}
}
// Outro classe de exemplo
class OutraClasse {
public $var = 'Alô Mundo';
}
?>
Não satisfazer a indução de tipo resulta em erro fatal (Catchable fatal error).
<?php
// Uma instância de cada classe
$minhaclasse = new MinhaClasse;
$outraclasse = new OutraClasse;
// Erro Fatal: Argumento 1 deve ser um objeto da classe OutraClasse
$minhaclasse->teste('hello');
// Erro Fatal: Argumento 1 deve ser uma instância de OutraClasse
$foo = new stdClass;
$minhaclasse->teste($foo);
// Erro Fatal: Argumento 1 deve ser diferente de null
$minhaclasse->teste(null);
// Funciona: Imprime Alô Mundo
$minhaclasse->teste($outraclasse);
// Erro Fatal: Argumento 1 deve ser um array
$minhaclasse->testa_array('a string');
// Funciona: Imprime o array
$minhaclasse->testa_array(array('a', 'b', 'c'));
?>
Indução de tipo também funciona com funções:
<?php
// Um exemplo de classe
class MinhaClasse {
public $var = 'Alô Mundo';
}
/**
* Uma função de teste
*
* Primeiro parâmetro deve ser um objeto do tipo MinhaClasse
*/
function MinhaFuncao (MinhaClasse $foo) {
echo $foo->var;
}
// Funciona
$minhaclasse = new MinhaClasse;
MinhaFuncao($minhaclasse);
?>
Type hinting permitindo valor NULL:
<?php
/* Aceitando valor NULL value */
function test(stdClass $obj = NULL) {
}
test(NULL);
test(new stdClass);
?>
Indução de tipo só pode ser usado com tipos objetos. Indução tradicional com int e string não são suportados.
add a note
User Contributed NotesIndução de Tipo
comments at ignorethis netweblogic com
17-Jul-2008 04:39
17-Jul-2008 04:39
marcus at ignorethis netweblogic dot com
14-Jul-2008 03:18
14-Jul-2008 03:18
Love the typehint object Daniel. Great effort!
However, it still throws catchable fatal errors, which is not what I want, so I added one line to handleTypehint() so it throws an Exception.
<?php
public static function handleTypehint($ErrLevel, $ErrMessage) {
if ($ErrLevel == E_RECOVERABLE_ERROR) {
if (preg_match ( TYPEHINT_PCRE, $ErrMessage, $ErrMatches )) {
list ( $ErrMatch, $ThArgIndex, $ThClass, $ThFunction, $ThHint, $ThType ) = $ErrMatches;
if (isset ( self::$Typehints [$ThHint] )) {
$ThBacktrace = debug_backtrace ();
$ThArgValue = NULL;
if (self::getTypehintedArgument ( $ThBacktrace, $ThFunction, $ThArgIndex, $ThArgValue )) {
if (call_user_func ( self::$Typehints [$ThHint], $ThArgValue )) {
return TRUE;
}
}
}
throw new Exception($ErrMessage);
}
}
return FALSE;
}
?>
madness
11-Jul-2008 12:09
11-Jul-2008 12:09
I must admit that Daniel's implementation is quite awesome (after all we'd be omonyms if I was english, omen nomen ;-) ), for everyone that already has a function/class to handle errors, this is a quick method to integrate the TypeHint class:
<?php
public static function handleError($errno, $errstr, $errfile, $errline){
// Implements just-in-time classes for broad type hinting
if (TypeHint::handleTypehint($errno, $errstr)){
return true;
}
// do your usual stuff here
/*
* ...
*/
}
?>
The initializeHandler method and the Typehint::initializeHandler(); call are rendered useless in this case. Enjoy.
Daniel dot L dot Wood at Gmail dot Com
26-May-2008 08:00
26-May-2008 08:00
People often ask about scalar/basic typehints. Here is a drop in class that I use in my MVC framework that will enable typehints through the use of a custom error handler.
Note: You should include this code above all other code in your include headers and if you are the using set_error_handler() function you should be aware that this uses it as well. You may need to chain your set_error_handlers()
Why?
1) Because people are sick of using the is_* functions to validate parameters.
2) Reduction of redundant coding for defensive coders.
3) Functions/Methods are self defining/documenting as to required input.
Also..
Follow the discussion for typehints in PHP 6.0 on the PHP Internals boards.
<?php
define('TYPEHINT_PCRE' ,'/^Argument (\d)+ passed to (?:(\w+)::)?(\w+)\(\) must be an instance of (\w+), (\w+) given/');
class Typehint
{
private static $Typehints = array(
'boolean' => 'is_bool',
'integer' => 'is_int',
'float' => 'is_float',
'string' => 'is_string',
'resrouce' => 'is_resource'
);
private function __Constrct() {}
public static function initializeHandler()
{
set_error_handler('Typehint::handleTypehint');
return TRUE;
}
private static function getTypehintedArgument($ThBackTrace, $ThFunction, $ThArgIndex, &$ThArgValue)
{
foreach ($ThBackTrace as $ThTrace)
{
// Match the function; Note we could do more defensive error checking.
if (isset($ThTrace['function']) && $ThTrace['function'] == $ThFunction)
{
$ThArgValue = $ThTrace['args'][$ThArgIndex - 1];
return TRUE;
}
}
return FALSE;
}
public static function handleTypehint($ErrLevel, $ErrMessage)
{
if ($ErrLevel == E_RECOVERABLE_ERROR)
{
if (preg_match(TYPEHINT_PCRE, $ErrMessage, $ErrMatches))
{
list($ErrMatch, $ThArgIndex, $ThClass, $ThFunction, $ThHint, $ThType) = $ErrMatches;
if (isset(self::$Typehints[$ThHint]))
{
$ThBacktrace = debug_backtrace();
$ThArgValue = NULL;
if (self::getTypehintedArgument($ThBacktrace, $ThFunction, $ThArgIndex, $ThArgValue))
{
if (call_user_func(self::$Typehints[$ThHint], $ThArgValue))
{
return TRUE;
}
}
}
}
}
return FALSE;
}
}
Typehint::initializeHandler();
?>
An are some examples of the class in use:
<?php
function teststring(string $string) { echo $string; }
function testinteger(integer $integer) { echo $integer; }
function testfloat(float $float) { echo $float; }
// This will work for class methods as well.
?>
You get the picture..
Darby
28-Dec-2007 04:50
28-Dec-2007 04:50
Correction to previous note:
"Failing to satisfy the type hint results in a catchable fatal error."
This only seems to be the case for PHP >= 5.2.0.
jesdisciple @t gmail -dot- com
07-Nov-2007 04:50
07-Nov-2007 04:50
The manual's sample code says:
<?php
//...
// Fatal Error: Argument 1 must not be null
$myclass->test(null);
//...
?>
And this is true, unless a default value of NULL is given; in fact, this is the only way to give a default value for object arguments (as a default value must be a constant expression):
<?php
$mine = new MyClass();
$mine->test(NULL);
class MyClass{
public function __construct(OtherClass $arg = NULL){
if(is_null($arg)){
//Apply default value here.
}
}
public function test(array $arr = NULL){
print_r($arr);
}
}
class OtherClass{
}
?>
Jazz
16-Oct-2007 06:20
16-Oct-2007 06:20
To Nikivich and Edorian:
There are many times when you would use an equals() method other than to find out if the two objects are the same object. Think of all the primitive wrapper classes in Java, for example -- if you create two new Integer()'s with identical values, equals() returns true, even though they are two different objects. There would be no reason to allow someone to perform an equals() between an Integer and, say, a GregorianCalendar -- it just doesn't make sense. In Java you would attempt this and probably get a ClassCastException, but in PHP no such facility exists, so the best way to prevent this would be through type hinting.
The point Nicholas was making is that you can't specify a stricter type hint on an inherited method, and despite your arguments, that would be a truly useful thing to be able to do.
(True overloading would be a better way, IMHO, but *shrug*)
ldebuyst->brutele.be
28-Feb-2007 03:52
28-Feb-2007 03:52
In reply to Nikivich and Edorian:
Although it isn't quite clear from his post, I believe that the point nicholas is trying to make is that, if you typehint an abstract function, you MUST use that same typehint for all classes extending the abstract class.
As his example shows, if you typehint (Object $object), then you must use the exact same typehint in the extending class. Using the typehint (Table $table) or (Chair $chair) will give fatal errors, even if Table and Chair are subclasses of Object.
In other words, type hinting allows for descendants, as caliban at darklock dot com has shown, except when you're subclassing.
See http://bugs.php.net/bug.php?id=36601 for a bit more info. Flagged as wontfix, though, so something to keep in mind.
Nikivich
23-Feb-2007 04:28
23-Feb-2007 04:28
In reply to Nicolas
I don't think you exactly understand the inheritance principles
If you want to do the equals thing in a decent OO way, you would do something like this:
class Object {
public equals(Object &o) {
return this == &o; //perform default equals check, one could arguably say that === is the correct default, but doesnt matter for the example
}
}
class Chair extends Object {
}
class Table extends Object {
}
$chair = new Chair();
$table = new Table();
$chair->equals($table); //will print false (zero)
This is actually a correct implementation of an equals method. Since you want to take a chair for example and just call equals() on it WITH ANY OBJECT, you should only hint Object, not an implementation, since the whole point of the equals method is to find out whether it is actually the same object :-) I want to be able to pass a table (which implements Object too, so is perfectly allowed as a parameter to equals).
Hope this clears it up a bit for you... :-)
Edorian
07-Feb-2007 07:12
07-Feb-2007 07:12
In response to nicholas at nicholaswilliams dot info:
Of course this doesn't work. Not in Php nor in Java.
You can't put a Chair into Table just because there both implementing "Object"
It wouldn't make any sense to say "i'm expecting an argument that implements the same object that i'm implementing" with type hinting.
You say: "I'm expection an Object of that Class or a Object of a Subclass of that Class " like you do in every OO languange.
nicholas at nicholaswilliams dot info
13-Nov-2006 09:53
13-Nov-2006 09:53
Please note that the following will not work:
<?php
abstract class Object
{
public abstract function toString( );
public abstract function equals( Object &$o );
}
class Chair extends Object
{
public function toString( )
{
return 'This is a chair.';
}
public function equals( Chair &$o )
{
return TRUE;
}
}
class Table extends Object
{
public function toString( )
{
return 'This is a table.';
}
public function equals( Table &$o )
{
return TRUE;
}
}
$chair = new Chair();
$table = new Table();
echo $chair->equals( $table );
?>
The expected output is "Fatal error: Argument 1 passed to Chair::equals() must be an instance of Chair, called in [filename] on line 38 and defined in [filename] on line 16" but instead you get "Fatal error: Declaration of Chair::equals() must be compatible with that of Object::equals() in [filename] on line 20".
This is unlike other OO languages (secifically Java) which not only allow but expect this type of code. It is in the nature of abstraction. However, you can get similar results using the following code instead:
<?php
abstract class Object
{
public abstract function toString( );
public abstract function equals( self &$o );
}
class Chair extends Object
{
public function toString( )
{
return 'This is a chair.';
}
public function equals( self &$o )
{
return TRUE;
}
}
class Table extends Object
{
public function toString( )
{
return 'This is a table.';
}
public function equals( self &$o )
{
return TRUE;
}
}
$chair = new Chair();
$table = new Table();
echo $chair->equals( $table );
?>
This code gives the expected result "Fatal error: Argument 1 passed to Chair::equals() must be an instance of Chair, called in [filename] on line 38 and defined in [filename] on line 16". This is the proper behavior but isn't the most intuitive approach for those of us used to OO programming.
Hope this helps someone :-).
Nicholas
02-Sep-2006 05: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.
mlovett at morpace dot com
06-Jul-2005 12:54
06-Jul-2005 12: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 04:34
23-Feb-2005 04: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);
?>