What's your use-case?

A language construct for this is very unlikely, but if this is a common and performance-critical operation, a plain function could be provided in lieu of going through reflection.

A simplified use case would be:

//orm with lazy loading from DB
class something {
 public ?<class|self> $parent;
....
function getParent() {
 if (! is_initialized($this->parent)) {
 $this->parent = //fetch from DB; value could be NULL
 }
 return $this->parent;
}
...
}


A plain function is indeed possible but the call parameters should be ($obj, 'prop) since ($obj->prop) would throw TypeError.

You can use `__get` to check if it's initialized. 

see the Overloaded Properties section of the RFC(https://wiki.php.net/rfc/typed_properties_v2) as an example.

I know that I can use __get but:
1. this is a workaround (which is also not simpler than a ReflectionProperty call).
2. this is only possible if the developer has control over the class. A counterexample would be a typed property in a class exposed by a third party library.

Once again: the target is "if (!is_initialized($obj->prop)) { ... }" similar to 
"if (!isset($obj->prop)) { ... }". Isset would not generate a notice if the property is not defined and similarly is_initialized should not trigger a TypeError if $obj->prop has not been yet initialized.

[2019-09-08 18:10 UTC] jhdxr@php.net writes:

You can use `__get` to check if it's initialized. 

That's not completely true - in PHP 7.4.11.

In the first example on https://wiki.php.net/rfc/typed_properties_v2#overloaded_properties

if you do not include `unset($this->typed);`, then that example still throws:

Fatal error: Uncaught Error: Typed property Test::$typed must not be accessed before initialization in test.php on line 24

That line is the first `var_dump($test->typed);`.

Apparently this little edge case was not covered when implementing the RFC.


Regarding this mentioned issue there is another option to test for initialized state: `array_key_exists('prop', get_object_vars($obj));`
Not very neat either.

Ah. With https://bugs.php.net/bug.php?id=78904 that behavior of `__get` changed. There's now a difference between uninitialized and unset properties.

That makes this request more apparent.

We used to mix types for micro cache properties; start as `false`, ending up with `null`, or an object instance. By strict checking for `false` retrieval is only done once.

Since mixing types is a bad practice, and not an option with typed properties anyway, it would be ideal if one could detect whether a property was actually uninitialized.

Sure, we can. Two ways are mentioned here. But both are verbose and require representing the property as a string.

I completely agree such is_initialized() would be useful for typed properties. Another use case would be for passing data to database.

Distinction would be useful:
If property hasn't been initialized - ignore it.
If property has been set to null - set database field to null.