Sviluppo PHP
  1. Sviluppo PHP
  3. php – Annulla $ questo
Intereting Posts
Come documentare una variabile che non è realmente presente in Doxygen? Unisci due file CSV di grandi size con PHP Qual è il modo più veloce per trovare l'occorrenza di una string in un'altra string? Data PHP escluso il fine settimana Come mettere il controller nella cartella in laravel 5.1.3? Cache image generata da PHP finché non cambia Problema concettuale di Symfony2: bundle generali rispetto a quelli specifici Come installare / abilitare le estensioni intl e xsl dopo l'installazione di PHP 7 php json_decode che rimuove i tag html Cosa significa <? = Significato? Come caricare le classi sulla base di URL carini nella pagina MVC? casella a discesa dynamic da mysql carica un file di visualizzazione all'interno di una function in php / codeigniter Crittografia di Laravel 5: vengono forniti valori diversi per la stessa string? Registra il stream radio / audio (asx / asf) con un server web

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 "