PHP Cast to my class - php

Question

why this is not possible:
$user = (User) $u[0];
but this is possible
$bool = (boolean) $res['success'];
I use PHP 7.0.

Answer 1

As I know, in PHP you can only cast to some types:
(int), (integer) - cast to integer
(bool), (boolean) - cast to boolean
(float), (double), (real) - cast to float (real deprecated in PHP 8.0)
(string) - cast to string
(binary) - cast to binary string (PHP 6)
(array) - cast to array
(object) - cast to object
(unset) - cast to NULL (PHP 5) (depracted in PHP 7.2) (removed in 8.0)
(see Type Casting)
Instead you could use instanceof to check of specific type:
if($yourvar instanceof YourClass) {
//DO something
} else {
throw new Exception('Var is not of type YourClass');
}
EDIT
As mentioned by Szabolcs Páll in his answer, it is also possible to declare a return type or parameter type, but in that cases an exception (TypeError) will be throwen, if the type does not match.
function test(): string
{
return 'test';
}
function test(string $test){
return "test" . $test;
}
Since PHP 7.2 it is also possible to make the types nullable by adding ? in front of them:
function test(): ?string
{
return null;
}

Answer 2

You can use PHPDoc
/** #var User $user */
$user = $u[0];

Answer 3

If you just want to ensure a variable is instance of YourClass and let exception handling to the typesystem you can use the following function:
function implicitFakeCast($myClass): YourClass
{
return $myClass;
}
Note: this will not actually do any casting, rather it throws exceptions in case of class mismatch and lets intellisense treat it as an instance of the target class.

Answer 4

For people that do want to be able to cast to a class type. I've found a gist by #borzilleri that uses serialize and unserialize to achieve this: https://gist.github.com/borzilleri/960035.
TL;DR:
// make sure to include the namespace when casting
$className = "Some\\NameSpace\\SomeClassName";
$classNameLength = strlen( $className );
$castedItem = unserialize(
preg_replace(
'/^O:\d+:"[^"]++"/',
"O:$classNameLength:\"$className\"",
serialize( $item )
)
)

Answer 5

It's really simple in php8:
$item = (fn($item):YourClass=>$item)($item);

Answer 6

Objects and primitive types are different. Since it's called as primitive types, they are really simple, maybe only 1 byte, 2 bytes, or 4 bytes, and at most 8 bytes.
When we are talking about object, this object can have different attributes with the others. Then the question from PHP will be is, "is this object really from my Class?" "How to convert this object to my Class?". Thus, you can't parse right away the object using
$myObject = (ClassName) $variable
Then how to cast it? Dunno, but usually the approach is like this:
Create constructor for the class
In the class, make a method that specifically accept certain parameters, maybe array
here is sample:
public class MyAwesomeClass{
function __construct($thisIsArray){
$this->attributeA = $thisIsArray["A"];
$this->attributeB = $thisIsArray["B"];
......
}
static function fromArray($thisIsArray){
return MyAwesomeClass($thisIsArray);
}
}
$obj = MyAwesomeClass::fromArray($attributes);

Answer 7

In addition to the answer on why this is not possible, I would suggest that you write a builder function that creates an object, based on your input. so it would look something like
$user = User::buildFromSomeArrayInput($u[0]);
And then have a builder create a new User object, assign the right properties, etc. You could just do all this in-place of course, but having a builder function makes sure you won't be doing this on several locations, AND you can set private properties as it is a class-member function. It is a bit more work then having it magically work, but not that much.
The only issue you might have is when you do have a different object that does not expose all the internals you might need. But this is for a reason, as internals might change -> you don't want to rely on that.
There are hacks out there that suggest doing this with serialization. I would suggest to steer away from them, as they are hackish and as far as i'm concerned, not very clear.