PHP - existe-t-il un moyen de différencier entre unset et null?

Dans le cas des objets, vous pouvez utiliser property_exists () .

<?php
class Test {
    public $definedButNotSet;
}

$test = new Test();

var_dump(property_exists($test, 'definedButNotSet')); // bool(true)

Je me réfère à cela comme une commutation nulle et je le prédicat sur une carte de propriété interne. Par exemple:

class Test {
    public $define; // null
    public $redefine; // null

    public function define(?bool $something = null): ?bool {
        return $this->define = $this->define ?? $something;
    }

    public function redefine(?bool $something = null): ?bool {
        return $this->redefine = $something ?? $this->redefine;
    }
}

$test = function(?bool $value) {
    var_export($value ?? 'Not set!' ?: 'False!');
    echo PHP_EOL;
};

$foo = new Test();

$test($foo->define());
$test($foo->define(true));
$test($foo->define());
$test($foo->define(false));
$test($foo->define());

$test($foo->redefine());
$test($foo->redefine(true));
$test($foo->redefine());
$test($foo->redefine(false));
$test($foo->redefine());

https://3v4l.org/PFXqi

Pour contester légèrement le cadrage du problème, ce que vous souhaitez faire est de distinguer deux types d'écriture sur une même propriété: celles déclenchées automatiquement par votre ORM, et celles déclenchées manuellement par l'utilisateur. Les valeurs qui seront fournies par défaut lors de l'insertion en sont un sous-ensemble, mais les valeurs extraites de la base de données peuvent également devoir être gérées différemment de celles fournies par l'utilisateur (par exemple pour savoir si une mise à jour est nécessaire).

La façon de faire est de rendre la propriété privée et de fournir des getters et des setters, ou de simuler des accesseurs de propriété à l'aide des __get magiques __get et __set (et des annotations @property à utiliser par les IDE). Ensuite, vous pouvez stocker une carte des propriétés qui ont été écrites en dehors de votre code d'initialisation.

Une implémentation simple et probablement boguée pour montrer l'idée générale:

/**
 * This doc-block will be read by IDEs and provide auto-complete
 * @property int|null $id
 * @property string|null $name
 */
class Test {
    private ?int $id = null;
    private ?string $name = null;

    private array $updatedFields = [];

    /**
     * @internal Only to be called by the ORM
     */
    public function construct(?int $id, ?string $name) {
        $this->id = $id;
        $this->name = $name;
    }

    public function __get(string $property) {
        if ( property_exists($property, $this) ) {
             return $this->$property;
        }
        else {
             throw new LogicError("No such property '$property'");
        }
    }

    public function __set(string $property, $newValue) {
        if ( property_exists($property, $this) ) {
             $this->$property = $newValue;
             $this->updatedFields[ $property ] = true;
        }
        else {
             throw new LogicError("No such property '$property'");
        }
    }

    /**
     * Standard meaning of isset() for external code 
     */
    public function __isset(string $property) {
        if ( property_exists($property, $this) ) {
             return isset($this->$property);
        }
        else {
             throw new LogicError("No such property '$property'");
        }
    }

    /**
     * Special function for ORM code to determine which fields have changed
     */
    public function hasBeenWritten(string $property): bool {
        if ( property_exists($property, $this) ) {
             return $this->updatedFields[ $property ] ?? false;
        }
        else {
             throw new LogicError("No such property '$property'");
        }
    }
}