Mixing
Type casting for user defined objects
Clash Royale CLAN TAG#URR8PPP Type casting for user defined objects
Just like we do with __ToString, is there a way to define a method for casting?
$obj = (MyClass) $another_class_obj;
You can't call those methods if they don't exist in the class -- you may need to typecast one user class to another in order to call the functions directly using the -> operator
– Josh
Jul 18 '09 at 15:47
Josh, in that case, there must be something wrong in the application flow.
– Ionuț G. Stan
Jul 18 '09 at 19:25
I feel your judgement may be hasty; however I would agree that gnarf's solution for creating a new object is better as it allows logic for converting between classes.
– Josh
Jul 18 '09 at 20:59
8 Answers
8
There is no need to type cast in php.
Edit: Since this topic seems to cause some confusion, I thought I'd elaborate a little.
In languages such as Java, there are two things that may carry type. The compiler has a notion about type, and the run time has another idea about types. The compilers types are tied to variables, whereas the run time engine tracks the type of values (Which are assigned to variables). The variable types are known at compile time, whereas the value types are only known at run time.
If a piece of input code violates the compilers type system, the compiler will barf and halt compilation. In other words, it's impossible to compile a piece of code that violates the static type system. This catches a certain class of errors. For example, take the following piece of (simplified) Java code:
class Alpha
class Beta extends Alpha
public void sayHello()
System.out.println("Hello");
If we now did this:
Alpha a = new Beta();
we would be fine, since Beta is a subclass of Alpha, and therefore a valid value for the variable a of type Alpha. However, if we proceed to do:
Beta
Alpha
a
Alpha
a.sayHello();
The compiler would give an error, since the method sayHello isn't a valid method for Alpha - Regardless that we know that a is actually a Beta.
sayHello
Alpha
a
Beta
Enter type casting:
((Beta) a).sayHello();
Here we tell the compiler that the variable a should - in this case - be treated as a Beta. This is known as type casting. This loophole is very useful, because it allows polymorphism in the language, but obviously it is also a back door for all sorts of violations of the type system. In order to maintain some type safety, there are therefore some restrictions; You can only cast to types that are related. Eg. up or down a hierarchy. In other words, you wouldn't be able to cast to a completely unrelated class Charlie.
a
Beta
Charlie
It's important to note that all this happens in the compiler - That is, it happens before the code even runs. Java can still get in to run time type errors. For example, if you did this:
class Alpha
class Beta extends Alpha
public void sayHello()
System.out.println("Hello");
class Charlie extends Alpha
Alpha a = new Charlie();
((Beta) a).sayHello();
The above code is valid for the compiler, but at run time, you'll get an exception, since the cast from Beta to Charlie is incompatible.
Beta
Charlie
Meanwhile, back at the PHP-farm.
The following is valid to the PHP-compiler - It'll happily turn this into executable byte code, but you'll get a run time error:
class Alpha
class Beta extends Alpha
function sayHello()
print "Hello";
$a = new Alpha();
$a->sayHello();
This is because PHP variables don't have type. The compiler has no idea about what run time types are valid for a variable, so it doesn't try to enforce it. You don't specify the type explicitly as in Java either. There are type hints, yes, but these are simply run time contracts. The following is still valid:
// reuse the classes from above
function tellToSayHello(Alpha $a)
$a->sayHello();
tellToSayHello(new Beta());
Even though PHP variables don't have types, the values still do. A particular interesting aspect of PHP, is that it is possible to change the type of a value. For example:
// The variable $foo holds a value with the type of string
$foo = "42";
echo gettype($foo); // Yields "string"
// Here we change the type from string -> integer
settype($foo, "integer");
echo gettype($foo); // Yields "integer"
This feature some times confused with type casting, but that is a misnomer. The type is still a property of the value, and the type-change happens in runtime - not at compile time.
The ability to change type is also quite limited in PHP. It is only possible to change type between simple types - not objects. Thus, it isn't possible to change the type from one class to another. You can create a new object and copy the state, but changing the type isn't possible. PHP is a bit of an outsider in this respect; Other similar languages treat classes as a much more dynamic concept than PHP does.
Another similar feature of PHP is that you can clone a value as a new type, like this:
// The variable $foo holds a value with the type of string
$foo = "42";
echo gettype($foo); // Yields "string"
// Here we change the type from string -> integer
$bar = (integer) $foo;
echo gettype($bar); // Yields "integer"
Syntactically this looks a lot like how a typecast is written in statically typed languages. It's therefore also often confused with type casting, even though it is still a runtime type-conversion.
To summarise: Type casting is an operation that changes the type of a variable (not the value). Since variables are without type in PHP, it is not only impossible to do, but a nonsensical thing to ask in the first place.
Well then, don't keep it to yourself.
– VolkerK
Jul 18 '09 at 12:24
Variables in PHP are untyped; Only the objects they refer to have types. As such you can't typecast a variable in php.
– troelskn
Jul 18 '09 at 17:35
That would seem to contradict the PHP manual
– Josh
Jul 18 '09 at 20:57
This is an excellent answer. I feel you could improve it by mentioning that in PHP values have types. This is interesting because the value could have its type changed - an Alpha object could be told "become a Beta object". Python and Javascript support this for example (in Python by changing its
__class__ field). However, PHP does not, and has a static class hierarchy. So while it would make sense to allow a PHP value to change its type, it is just not allowed in the language.– Paul Biggar
Sep 26 '09 at 13:14
__class__
troelskn, I agree, this is an excellent answer and very clearly explains typecasting and the lack of it in PHP.
– Josh
Sep 29 '09 at 12:12
Here's a function to change the class of an object:
/**
* Change the class of an object
*
* @param object $obj
* @param string $class_type
* @author toma at smartsemantics dot com
* @see http://www.php.net/manual/en/language.types.type-juggling.php#50791
*/
function changeClass(&$obj,$new_class)
if(class_exists($class_type,true))
$obj = unserialize(preg_replace("/^O:[0-9]+:"[^"]+":/i",
"O:".strlen($class_type).":"".$new_class."":", serialize($obj)));
In case it's not clear, this is not my function, it was taken from a post by "toma at smartsemantics dot com" on http://www.php.net/manual/en/language.types.type-juggling.php#50791
Why the downvote?
– Josh
Jul 18 '09 at 12:41
That is not a typecast. That is changing the type of the object - not the variable. In PHP, you can't typecast, since variables don't have types.
– troelskn
Jul 18 '09 at 17:33
I agree, my function changes the class of the object. WHich is what the question's author intended. And according to the PHP manual, variables do have types and typecasting is possible: us.php.net/manual/en/…
– Josh
Jul 18 '09 at 20:56
Fair enough; You can change the type of a primitive. But you can't change the type of an object. Regardless of the wording in the manual, variables do not have type in php. They refer to values which have type.
– troelskn
Jul 18 '09 at 21:59
I see your point -- I'll edit my post to make it clear tha it changes the class of an object.
– Josh
Jul 18 '09 at 22:59
Although there's no need to type cast in PHP, you might come across a situation where you would like to convert a parent object into a child object.
//Example of a sub class
class YourObject extends MyObject
public function __construct(MyObject $object)
foreach($object as $property => $value)
$this->$property = $value;
$my_object = new MyObject();
$your_object = new YourObject($my_object);
So all you do is pass the parent object down to the child object's constructor, and let the constructor copy over the properties. You can even filter / change them as needed.
//Class to return standard objects
class Factory
public static function getObject()
$object = new MyObject();
return $object;
//Class to return different object depending on the type property
class SubFactory extends Factory
public static function getObject()
$object = parent::getObject();
switch($object->type)
case 'yours':
$object = new YourObject($object);
break;
case 'ours':
$object = new OurObject($object);
break;
return $object;
//Example of a sub class
class YourObject extends MyObject
public function __construct(MyObject $object)
foreach($object as $property => $value)
$this->$property = $value;
It's not type casting, but it does what you need.
I reworked the function Josh posted (which will error because of the undefined $new_class variable). Here's what I got:
function changeClass(&$obj, $newClass)
$obj = unserialize(preg_replace // change object into type $new_class
( "/^O:[0-9]+:"[^"]+":/i",
"O:".strlen($newClass).":"".$newClass."":",
serialize($obj)
));
function classCast_callMethod(&$obj, $newClass, $methodName, $methodArgs=array())
$oldClass = get_class($obj);
changeClass($obj, $newClass);
// get result of method call
$result = call_user_func_array(array($obj, $methodName), $methodArgs);
changeClass(&$obj, $oldClass); // change back
return $result;
It works just like you'd expect a class cast to work. You could build something similar for accessing class members - but I don't think I would ever need that, so i'll leave it to someone else.
Boo to all the jerks that say "php doesn't cast" or "you don't need to cast in php". Bullhockey. Casting is an important part of object oriented life, and I wish I could find a better way to do it than ugly serialization hacks.
So thank you Josh!
Just a note, I would add a thrown exception into changeClass if the class casted to is not a parent class. This would include classes that don't exist. But the code i have above is pretty much the simplest you can get for a working cast that I know of.
– B T
Aug 19 '09 at 1:37
The only thing I would use the casting for in php, is to let the IDE know the type of the object.. so the IDE can autocomplete the properties of a class instance.. That's all.
– Janov Byrnisson
Aug 4 '10 at 8:56
Well thats all well and good for you Janov, but if you're building a complex interface that isn't incredibly verbose, you sometimes need a little trickery. I had to use class casting for a database abstraction layer I created. Otherwise there would have been no way to adequately handle subclassing.
– B T
Aug 5 '10 at 0:36
php doesnt cast means php have no native method to cast. Serialization deserialization a method to over come the issue.
– nerkn
Dec 19 '10 at 14:32
Is there a chance this needs to be modified for PHP5.3?
– Prasad
Jul 10 '17 at 5:36
I do not believe there is a overloading operator in PHP to handle that, however:
<?php
class MyClass
protected $_number;
static public function castFrom($obj)
$new = new self();
if (is_int($obj))
$new->_number = $obj;
else if ($obj instanceOf MyNumberClass)
/// some other type of casting
return $new;
$test = MyClass::castFrom(123123);
var_dump($test);
Is one way to handle it.
I think you need to type cast in order to make a better IDE. But php the language itself doesn't need type casting it does however support runtime type changes to the values in the variables. Take a look at autoboxing and unboxing. That's what php inherently does. So sorry no better than already are IDEs.
If casting for type hinting is all you're after, this works.
if( is_object($dum_class_u_want) && $dum_class_u_want instance of ClassYouWant )
//type hints working now
$dum_class_u_want ->is_smart_now();
Yep.
I think you mean Type-Hinting.
As of PHP 7.2, you can type-hint arguments in functions:
function something(Some_Object $argument) ... # Type-hinting object on function arguments works on PHP 7.2+
But you can't type-hint it like this:
(Some_Object) $variable = get_some_object($id); # This does not work, even in PHP 7.2
The alternative for type-hinting objects while it isn't implemented officialy in PHP, is:
$variable = get_some_object($id); # We expect Some_Object to return
is_a($argument, 'Some_Object') || die('get_some_object() function didn't return Some_Object');
By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.
Why would you ever want to cast anything in PHP? You can just call whatever methods you want anyway.
– n3rd
Jul 18 '09 at 11:14