PHP: Erkennung, wenn die den Wert einer Variablen geändert wurde

Wenn Sie möchten, dass zur Umsetzung eigener event-Handler /Trigger in der Reihe, oder irgendetwas anderes, dann könnte man vielleicht verwenden Sie Klassen-wrapper.

Für eine variable __get() und __set() Magische Methoden sind genug, wie Sie bemerkt.
Für Arrays gibt es eine bessere hf: ArrayAccess. Es ermöglicht das emulieren array Aktionen mit Klassen-Methoden und gemeinsamen array-Semantik (wie Sammlungen in einigen anderen Sprachen).

<?php
header('Content-Type: text/plain');

//ArrayAccess for Array events
class TriggerableArray implements ArrayAccess {
    protected $array;      //container for elements
    protected $triggers;   //callables to actions

    public function __construct(){
        $this->array    = array();

        //predefined actions, which are availible for this class:
        $this->triggers = array(
            'get'    => null,     //when get element value
            'set'    => null,     //when set existing element's value
            'add'    => null,     //when add new element
            'exists' => null,     //when check element with isset()
            'unset'  => null      //when remove element with unset()
        );
    }

    public function __destruct(){
        unset($this->array, $this->triggers);
    }

    public function offsetGet($offset){
        $result = isset($this->array[$offset]) ? $this->array[$offset] : null;

        //fire "get" trigger
        $this->trigger('get', $offset, $result);

        return $result;
    }

    public function offsetSet($offset, $value){
        //if no offset provided
        if(is_null($offset)){
            //fire "add" trigger
            $this->trigger('add', $offset, $value);

            //add element
            $this->array[] = $value;
        } else {
            //if offset exists, then it is changing, else it is new offset
            $trigger = isset($this->array[$offset]) ? 'set' : 'add';

            //fire trigger ("set" or "add")
            $this->trigger($trigger, $offset, $value);

            //add or change element
            $this->array[$offset] = $value;
        }
    }

    public function offsetExists($offset){
        //fire "exists" trigger
        $this->trigger('exists', $offset);

        //return value
        return isset($this->array[$offset]);
    }

    public function offsetUnset($offset){
        //fire "unset" trigger
        $this->trigger('unset', $offset);

        //unset element
        unset($this->array[$offset]);
    }

    public function addTrigger($trigger, $handler){
        //if action is not availible and not proper handler provided then quit
        if(!(array_key_exists($trigger, $this->triggers) && is_callable($handler)))return false;

        //assign new trigger
        $this->triggers[$trigger] = $handler;

        return true;
    }

    public function removeTrigger($trigger){
        //if wrong trigger name provided then quit
        if(!array_key_exists($trigger, $this->triggers))return false;

        //remove trigger
        $this->triggers[$trigger] = null;

        return true;
    }

    //call trigger method:
    //first arg  - trigger name
    //other args - trigger arguments
    protected function trigger(){
        //if no args supplied then quit
        if(!func_num_args())return false;

        //here is supplied args
        $arguments  = func_get_args();

        //extract trigger name
        $trigger    = array_shift($arguments);

        //if trigger handler was assigned then fire it or quit
        return is_callable($this->triggers[$trigger]) ? call_user_func_array($this->triggers[$trigger], $arguments) : false;
    }
}

function check_trigger(){
    print_r(func_get_args());
    print_r(PHP_EOL);
}

function check_add(){
    print_r('"add" trigger'. PHP_EOL);
    call_user_func_array('check_trigger', func_get_args());
}

function check_get(){
    print_r('"get" trigger'. PHP_EOL);
    call_user_func_array('check_trigger', func_get_args());
}

function check_set(){
    print_r('"set" trigger'. PHP_EOL);
    call_user_func_array('check_trigger', func_get_args());
}

function check_exists(){
    print_r('"exists" trigger'. PHP_EOL);
    call_user_func_array('check_trigger', func_get_args());
}

function check_unset(){
    print_r('"unset" trigger'. PHP_EOL);
    call_user_func_array('check_trigger', func_get_args());
}

$victim = new TriggerableArray();

$victim->addTrigger('get', 'check_get');
$victim->addTrigger('set', 'check_set');
$victim->addTrigger('add', 'check_add');
$victim->addTrigger('exists', 'check_exists');
$victim->addTrigger('unset', 'check_unset');

$victim['check'] = 'a';
$victim['check'] = 'b';

$result = $victim['check'];

isset($victim['check']);
unset($victim['check']);

var_dump($result);
?>

Zeigt:

"add" trigger
Array
(
    [0] => check
    [1] => a
)

"set" trigger
Array
(
    [0] => check
    [1] => b
)

"get" trigger
Array
(
    [0] => check
    [1] => b
)

"exists" trigger
Array
(
    [0] => check
)

"unset" trigger
Array
(
    [0] => check
)

string(1) "b"

Ich gehe davon aus, dass Sie ändern können-Konstruktor in diesem code mit array-Referenz argument übergeben können es superglobale array, wie $_COOKIE. Ein anderer Weg ist, zu ersetzen $this->array mit $_COOKIE direkt innerhalb der Klasse. Es gibt auch einen Weg, Sie zu ersetzen callables mit anonyme Funktionen.

Ich glaube, Sie haben einige Fehler in Ihrem denken, weil Sie nur so eine variable kann seinen Wert ändern, in php ist, wenn Sie ändern. Daher, wenn Sie ändern Ihre Variablen, ausführen von code.

Wenn Sie eine generische Möglichkeit, dies zu tun, würde ich vorschlagen, Verkapselung von entweder array oder seine Werte in der a-Klasse. Aber es gibt wirklich keinen guten Grund, Sie können nicht nur laufen sendCookie() nach jedem Wert ändern.

Change-Listener für multi-threaded-Programmierung, denke ich.