php – Annulla $ questo

Ho creato una class che si comport come un wrapper di file. Quando l'utente chiama il metodo delete, voglio rimuovere l'object (in realtà $ this). C'è un modo (soluzione alternativa) per farlo? Il manuale ha detto no, non c'è modo …

Per quanto ne so, non c'è modo di distruggere un'istanza di class all'interno della class stessa. Dovrai disinserire l'istanza nel suo ambito.

$myClass = new fooBar(); unset($myClass); 

Un po 'correlato: facendo quanto sopra richiamerai automaticamente qualsiasi metodo magico __destruct() esistente della class in modo da poter eseguire qualsiasi operazione di pulizia aggiuntiva. Ulteriori informazioni

Il manuale è giusto. Non c'è alcun modo.

unset è usato essenzialmente per dire "Ho finito di usare una particolare variabile, per quanto mi riguarda può essere considerato per la garbage collection .

Il guaio è che $this ha senso solo nel context di una chiamata di metodo comunque. Una volta che il metodo è stato completato, $this non rientrerà nello scope (essenzialmente) e non verrà più considerato come riferimento all'object. (Per scopi pratici.)

Quindi non devi preoccuparti di liberare $this . PHP si prenderà cura di questo.

Quello che probabilmente stai tentando di fare è unset le altre variables che potrebbero fare riferimento alla stessa istanza. E a less che tu non abbia accesso a quelli che fanno parte del metodo, non puoi toccarli, tanto less separarli.

Ho passato molto tempo a trovare un modo per impostare su NULL un object all'interno di se stesso.

Per favore prova questo codice:

 <?php class bike{ public $color = "black"; function destroySelf(bike &$me){ $me = NULL; //$me = new bike(); } } $iRide = new bike(); $iRide->color = "red"; var_dump($iRide);echo " -before <br>"; $iRide->destroySelf($iRide); var_dump($iRide);echo " -after <br>"; ?> 

Il trucco è $ questo non functionrà, è necessario passare il riferimento reale per riferimento alla class.

Un altro modo per accedere al riferimento reale senza passarlo è definire l'object come globale:

 class bike{ public $color = "black"; function destroySelf(){ global $iRide; $iRide = NULL; //$iRide = new bike(); } } $iRide = new bike(); $iRide->color = "red"; var_dump($iRide);echo " -before <br>"; $iRide->destroySelf(); var_dump($iRide);echo " -after <br>"; 

Inserisci il tuo codice di cancellazione nel distruttore se vuoi eliminare l'object e il file che lo avvolge allo stesso tempo. Quindi basta unset l'object invece di call un metodo di cancellazione.

Bene, No, solo al contrario, puoi usare la function __destruct ():

  public function __destruct() { //delete file } 

Questo verrà triggersto quando qualcuno disinserisce () l'object AND al termine dello script. Ma un object non può distruggere se stesso.

Ho lo stesso problema di te, a un certo punto voglio fare in modo che l'object si rimuova da solo ma non è ansible in php, quindi questa è una soluzione che può aiutarti.

Puoi impostare un flag privato e controllare che il flag in each metodo che richiede l'object esista ancora, qualcosa del tipo:

 <?php class Bar { // internal flag private $_removed = false; public function remove() { // ... some code $this->_removed = true; } private function checkExceptionRemoved() { if ($this->_removed) throw new RuntimeException("The object has been removed"); } public function show() { $this->checkExceptionRemoved(); // ... some code } } ?> 

Un altro modo potrebbe essere il sovraccarico del metodo call e rivedere il flag prima di call il metodo, questo potrebbe anche richiedere la ridenominazione dei methods con un prefisso come "pub " per effettuare la chiamata all'interno del metodo __call. Questo è un esempio:

 class Foo { private $_value; private $_valid = true; public function IsValid() { return $this->_valid; } private function IsValidException() { if (!$this->IsValid()) throw new RuntimeException("The object has been removed"); } public function __construct($value) { $this->_value = $value; } public function __call($name, $arguments) { if (!$this->IsValid()) throw new RuntimeException("The object has been removed"); if (!method_exists($this, "_$name")) throw new Exception("Invalid call, method '$name' does not exists"); return call_user_func_arrays(arrays($this, "_$name"), $arguments); } protected function _show() { echo print_r($this->_value, true)."\n"; } protected function _remove() { $this->_valid = false; } } $foo = new Foo("Foo Object"); $foo->show(); $foo->remove(); $foo->show(); // Exception !!! ?> 

IMHO è un vero problema che un object non può rimuovere se stesso dalla memory, ma è parte del design di PHP, non è C ++. Come un pensiero di sinistra, per questa e altre cose, potresti trasmettere la logica dell'applicazione in altre lingue / librerie sviluppate in altri linguaggi come C ++ / C # e usare PHP per consumare quella logica, qualcosa come "HTML / CSS / JS / PlainText <-> PHP <-> C # Cli <-> DB / File / Archiviazione "