Need a Built-in `is_assigned()` to distinguish between declared-but-uninitialized and assigned-null

[HichemTab-tech]

Description

TL;DR

PHP has no built-in way to check whether a variable or property has actually been assigned, as opposed to simply being null or not existing. isset() can’t tell the difference between “assigned null” and “not assigned,” and nothing else works consistently. A function like is_assigned() would solve this.

Full

Right now PHP has no reliable way to check if a variable, array key, or object property has actually been assigned, independent of its value.

isset() doesn’t help, because it returns false for both cases:

• when the variable/property is not defined
• when it’s defined but explicitly set to null

property_exists() doesn’t help either, because it reports properties as existing even if they were never assigned (just declared on the class).

get_object_vars() kind of works for objects, because it only lists assigned properties, even if they're assigned null. But this only works for objects, not variables. Reflection can detect uninitialized typed properties, but not untyped ones, and not variables or arrays.

So there’s no general solution in PHP today to tell the difference between:

• a variable/property that was never assigned
• a variable/property that was assigned null

This distinction matters when building DTOs, serializers, hydrators, ORMs, or anything where “user assigned null” is different from “value was never provided.”

It would help a lot if PHP had something like:

is_assigned($var);
// or
is_assigned($myClass->prop);

which returns true if the variable/property/array key has ever been assigned, even if the assigned value is null, and false if it was never assigned or doesn’t exist.

This wouldn’t break anything and would fill a long-standing gap in the language where userland code simply cannot make this distinction.

[jack-worman]

This done by: https://www.php.net/manual/en/reflectionproperty.isinitialized.php

[HichemTab-tech]

Thanks for the reply! 🙏
ReflectionProperty::isInitialized() may be a solution for part of this, and I agree it works well for object properties (typed ones).

The issue I'm bringing up is mainly outside that scope:

• It doesnt help with normal variables.
There's still no way to check whether a variable has ever been assigned, since isset() cant distinguish “assigned null” from “never assigned,” and there's no reflective API for variables the way there is for properties.

• It requires referencing properties by string name.
That becomes fragile for refactoring, static analysis, and IDE tooling. A language-level check (like is_assigned($var)) would avoid that probelm entirely.

So while ReflectionProperty::isInitialized() is definitely useful, it only solves a smaller part of the overall need. A unified built-in would cover variables, arrays, and properties without relying on string lookups.

Anyway, I hope this makes sense, and of course, maybe this just isnt a very common need and I'm one of the few running into it. I really appreciate the feedback and the time you took to reply. 🙏

[fds242]

Wouldn't something along these lines work for your purpose?

$defined_variable = null;

foreach (['defined_variable', 'undefined_variable'] as $varname) {
	error_clear_last();
	if (@!is_null($$varname) || error_get_last() === null) {
		echo "$varname was defined\n";
	}
}

foreach (['defined_variable', 'undefined_variable'] as $varname) {
	if (isset($$varname) || array_key_exists($varname, get_defined_vars())) {
		echo "$varname was defined\n";
	}
}

[iluuu1994]

Hi @HichemTab-tech. Many of us would generally like to see less "undefined" in the language. Local variables are generally easy to control, i.e. you can avoid null so it can be used as a sentinel, or you can even create a custom single-value enum to use as a sentinel that you can be fairly certain won't be accidentally stored as an actual value. For properties, ReflectionProperty::isInitialized() may be used.

Regardless, if you'd like to see this progress, please send an e-mail to the internals mailing list to get a feeling about how your proposal is received.

[HichemTab-tech]

Thank you for the clarification.

I understand the intention to reduce undefined states in PHP, and I see why approaches like sentinels or isInitialized() can make sense in specific contexts. In my situation these approaches don’t fully resolve the need, but your explanation helped me understand the design direction of php.

Thanks again for the guidance.