- Esercitazione
Non è un segreto che alle persone piaccia fare domande complicate durante le interviste. Non sempre adeguato, non sempre correlato alla realtà, ma il fatto resta un dato di fatto - si chiedono. Naturalmente la questione è diversa, e talvolta una domanda che a prima vista ti sembra stupida è in realtà volta a verificare quanto conosci la lingua in cui stai scrivendo.
Proviamo a smontare “pezzo per pezzo” una di queste domande - Cosa significa la parola “statico” in PHP e perché viene utilizzata?
La parola chiave statica ha tre significati diversi in PHP. Vediamoli in ordine cronologico, così come apparivano nella lingua.
Il primo valore è una variabile locale statica
funzione foo() ( $a = 0; echo $a; $a = $a + 1; ) foo(); // 0 foo(); // 0 foo(); // 0In PHP, le variabili sono locali. Ciò significa che una variabile definita e a cui viene assegnato un valore all'interno di una funzione (metodo) esiste solo durante l'esecuzione di quella funzione (metodo). Quando si esce dal metodo, la variabile locale viene distrutta e quando si rientra viene creata di nuovo. Nel codice precedente, tale variabile locale è la variabile $a: esiste solo all'interno della funzione foo() e viene creata di nuovo ogni volta che viene chiamata questa funzione. Incrementare una variabile in questo codice non ha senso, poiché nella riga di codice successiva la funzione finirà il suo lavoro e il valore della variabile andrà perso. Non importa quante volte chiamiamo la funzione foo(), restituirà sempre 0...
Tutto però cambia se mettiamo la parola chiave statica prima dell'assegnazione:
Funzione foo() ( static $a = 0; echo $a; $a = $a + 1; ) foo(); // 0 foo(); // 1 foo(); // 2
La parola chiave static, scritta prima di assegnare un valore ad una variabile locale, ha i seguenti effetti:
- L'assegnazione viene eseguita una sola volta, alla prima chiamata alla funzione
- Il valore di una variabile contrassegnata in questo modo viene salvato al termine della funzione.
- Nelle successive chiamate alla funzione, invece dell'assegnazione, la variabile riceve il valore precedentemente memorizzato
Insidie delle variabili statiche
Naturalmente, come sempre in PHP, ci sono alcune insidie.La prima pietra è che solo le costanti o le espressioni costanti possono essere assegnate a una variabile statica. Ecco il codice:
statico $a = bar();
porterà inevitabilmente a un errore del parser. Fortunatamente, a partire dalla versione 5.6, è diventato possibile assegnare non solo costanti, ma anche espressioni costanti (ad esempio “1+2” o “”), cioè espressioni che non dipendono da altro codice e possono essere calcolate in fase di compilazione
La seconda pietra è che i metodi esistono in un’unica copia.
Qui tutto è un po’ più complicato. Per capirne l'essenza, ecco il codice:
classe A ( funzione pubblica foo() ( static $x = 0; echo ++$x; ) ) $a1 = nuova A; $a2 = nuovo A; $a1->foo(); // 1 $a2->foo(); // 2 $a1->foo(); // 3 $a2->foo(); // 4
Contrariamente all’aspettativa intuitiva “oggetti diversi – metodi diversi”, vediamo chiaramente in questo esempio che i metodi dinamici in PHP “non si moltiplicano”. Anche se abbiamo un centinaio di oggetti di questa classe, il metodo esisterà in una sola istanza; è solo che ad ogni chiamata verrà inserito un $this diverso.
Questo comportamento può essere inaspettato per uno sviluppatore impreparato e può essere fonte di errori. Va notato che l'ereditarietà della classe (e del metodo) porta alla creazione di un nuovo metodo:
Classe A ( funzione pubblica foo() ( static $x = 0; echo ++$x; ) ) classe B estende A ( ) $a1 = nuova A; $b1 = nuova B; $a1->foo(); // 1 $b1->foo(); // 1 $a1->foo(); // 2 $b1->foo(); // 2
Conclusione: i metodi dinamici in PHP esistono nel contesto delle classi, non degli oggetti. E solo in fase di esecuzione si verifica la sostituzione "$this = current_object".
Il secondo significato riguarda le proprietà statiche e i metodi delle classi
Nel modello a oggetti PHP è possibile impostare proprietà e metodi non solo per gli oggetti - istanze di una classe, ma anche per la classe nel suo insieme. La parola chiave statica viene utilizzata anche per questo:Classe A ( public static $x = "foo"; funzione pubblica statica test() ( return 42; ) ) echo A::$x; // "pippo" echo A::test(); // 42
Per accedere a tali proprietà e metodi, vengono utilizzati costrutti con doppi due punti (“Paamayim Nekudotayim”), come CLASS_NAME::$Variablename e CLASS_NAME::Methodname().
Inutile dire che le proprietà statiche e i metodi statici hanno le loro caratteristiche e le loro insidie che devi conoscere.
La prima caratteristica è banale: non esiste $this. In realtà, ciò deriva dalla definizione stessa di metodo statico: poiché è associato a una classe, non a un oggetto, la pseudo-variabile $this, che punta all'oggetto corrente nei metodi dinamici, non è disponibile. Il che è del tutto logico.
Devi però sapere che, a differenza di altri linguaggi, PHP non rileva la situazione “$questo è scritto in un metodo statico” in fase di analisi o compilazione. Un errore come questo può verificarsi solo in fase di esecuzione se si tenta di eseguire codice con $this all'interno di un metodo statico.
Codice come questo:
classe A ( public $id = 42; funzione pubblica statica foo() ( echo $this->id; ) )
non causerà alcun errore, a patto che non provi a utilizzare il metodo foo() in modo inappropriato:
$a = nuova A; $a->foo(); (e ottieni immediatamente "Errore fatale: utilizzo di $this quando non nel contesto dell'oggetto")
La seconda caratteristica è che la statica non è un assioma!
classe A (funzione pubblica statica foo() ( echo 42; ) ) $a = nuova A; $a->foo();
Questo è tutto, sì. Un metodo statico, se non contiene $this nel codice, può essere chiamato in un contesto dinamico, come un metodo oggetto. Questo non è un bug in PHP.
Non è del tutto vero il contrario:
classe A (funzione pubblica foo() ( echo 42; ) ) A::foo();
Un metodo dinamico che non utilizza $this può essere eseguito in un contesto statico. Tuttavia, riceverai un avviso "Il metodo non statico A::foo() non deve essere chiamato staticamente" al livello E_STRICT. Sta a te decidere se seguire rigorosamente gli standard del codice o eliminare gli avvisi. Ovviamente è preferibile la prima.
E comunque, tutto quanto scritto sopra si applica solo ai metodi. L'utilizzo di una proprietà statica tramite "->" è impossibile e porta a un errore fatale.
Il terzo significato, che sembra essere il più difficile, è il legame statico tardivo
Gli sviluppatori del linguaggio PHP non si sono fermati ai due significati della parola chiave “static” e nella versione 5.3 hanno aggiunto un’altra “caratteristica” del linguaggio, che viene implementata con la stessa parola! Si chiama "late static binding" o LSB (Late Static Binding).Il modo più semplice per comprendere l'essenza di LSB è con semplici esempi:
Modello di classe (public static $table = "table"; public static function getTable() ( return self::$table; ) ) echo Model::getTable(); // "tavolo"
La parola chiave self in PHP significa sempre “il nome della classe in cui è scritta questa parola”. In questo caso, self viene sostituito con la classe Model e self::$table con Model::$table.
Questa funzionalità del linguaggio è chiamata "associazione statica anticipata". Perché presto? Perché l'associazione di self e un nome di classe specifico non avviene in fase di esecuzione, ma nelle fasi precedenti, durante l'analisi e la compilazione del codice. Bene, "statico" - perché stiamo parlando di proprietà e metodi statici.
Cambiamo un po' il nostro codice:
Modello di classe (public static $table = "table"; public static function getTable() ( return self::$table; ) ) class User extends Model ( public static $table = "users"; ) echo User::getTable() ; // "tavolo"
Ora capisci perché PHP si comporta in modo non intuitivo in questa situazione. self era associato alla classe Model quando non si sapeva nulla della classe User e quindi punta a Model.
Cosa dovrei fare?
Per risolvere questo dilemma, è stato inventato un meccanismo di associazione “tardivo” in fase di runtime. Funziona in modo molto semplice: basta scrivere "statico" invece della parola "self" e verrà stabilita la connessione con la classe che chiama questo codice e non con quella in cui è scritto:
class Modello ( public static $table = "table"; public static function getTable() ( return static::$table; ) ) class User extends Model ( public static $table = "users"; ) echo User::getTable() ; // "utenti"
Questo è il misterioso “legame statico tardivo”.
Va notato che per maggiore comodità in PHP, oltre alla parola “statico”, c'è anche una funzione speciale get_call_class(), che ti dirà nel contesto di quale classe sta attualmente funzionando il tuo codice.
Buone interviste!
Caratteristica molto importante Opsè la presenza proprietà statiche e metodi. La cosa principale è che devi capire immediatamente cosa sono questi proprietà e metodi non appartengono all'oggetto, ma alla classe. Questo deve essere compreso fin dall'inizio, ma utilizzando proprietà e metodi statici in PHP Ne parlerò in questo articolo.
L'esempio più classico è una classe responsabile delle funzioni matematiche. Se qualcuno lo sa Giava, allora sa che lì c'è una classe Matematica(V JavaScript esiste anche una classe del genere) contenente molte funzioni matematiche. E i metodi sono statici. Ciò significa che per calcolare qualsiasi seno o esponente non è necessario creare un oggetto di questa classe, il che è molto conveniente.
Scriviamo una copia più piccola di questa classe, ma solo per PHP:
classe matematica (
conteggio $ statico privato = 0;
funzione pubblica __construct() (
self::$conteggio++;
}
funzione statica pubblica calcSin($x) (
ritorna peccato($x);
}
funzione statica pubblica calcSQRT($x) (
restituire sqrt($x);
}
funzione statica pubblica getCount() (
return self::$count;
}
}
echo Matematica::calcSin(1);
eco "
";
echo Matematica::calcSQRT(9);
eco "
";
$matematica = nuova matematica();
$matematica_2 = nuova matematica();
echo Matematica::getCount();
?>
In questo codice ho mostrato utilizzando metodi e proprietà statiche. Tieni presente che ho implementato il classico metodo del contatore di oggetti. Ciò è accaduto solo a causa del fatto che il campo contareè statico e ha lo stesso valore per tutti gli oggetti.
Un altro esempio popolare utilizzando metodi e proprietà statiche- questa è la registrazione. Tutte le voci vengono aggiunte tramite metodi statici. È anche molto comune creare una classe composta da molte impostazioni e anche lì tutti i campi sono statici. Come puoi vedere, esempi di utilizzo metodi e proprietà statiche in PHP e altre lingue sono più che sufficienti, quindi è fondamentale poter lavorare con esse.
- Esercitazione
Non è un segreto che alle persone piaccia fare domande complicate durante le interviste. Non sempre adeguato, non sempre correlato alla realtà, ma il fatto resta un dato di fatto - si chiedono. Naturalmente la questione è diversa, e talvolta una domanda che a prima vista ti sembra stupida è in realtà volta a verificare quanto conosci la lingua in cui stai scrivendo.
Proviamo a smontare “pezzo per pezzo” una di queste domande - Cosa significa la parola “statico” in PHP e perché viene utilizzata?
La parola chiave statica ha tre significati diversi in PHP. Vediamoli in ordine cronologico, così come apparivano nella lingua.
Il primo valore è una variabile locale statica
funzione foo() ( $a = 0; echo $a; $a = $a + 1; ) foo(); // 0 foo(); // 0 foo(); // 0In PHP, le variabili sono locali. Ciò significa che una variabile definita e a cui viene assegnato un valore all'interno di una funzione (metodo) esiste solo durante l'esecuzione di quella funzione (metodo). Quando si esce dal metodo, la variabile locale viene distrutta e quando si rientra viene creata di nuovo. Nel codice precedente, tale variabile locale è la variabile $a: esiste solo all'interno della funzione foo() e viene creata di nuovo ogni volta che viene chiamata questa funzione. Incrementare una variabile in questo codice non ha senso, poiché nella riga di codice successiva la funzione finirà il suo lavoro e il valore della variabile andrà perso. Non importa quante volte chiamiamo la funzione foo(), restituirà sempre 0...
Tutto però cambia se mettiamo la parola chiave statica prima dell'assegnazione:
Funzione foo() ( static $a = 0; echo $a; $a = $a + 1; ) foo(); // 0 foo(); // 1 foo(); // 2
La parola chiave static, scritta prima di assegnare un valore ad una variabile locale, ha i seguenti effetti:
- L'assegnazione viene eseguita una sola volta, alla prima chiamata alla funzione
- Il valore di una variabile contrassegnata in questo modo viene salvato al termine della funzione.
- Nelle successive chiamate alla funzione, invece dell'assegnazione, la variabile riceve il valore precedentemente memorizzato
Insidie delle variabili statiche
Naturalmente, come sempre in PHP, ci sono alcune insidie.La prima pietra è che solo le costanti o le espressioni costanti possono essere assegnate a una variabile statica. Ecco il codice:
statico $a = bar();
porterà inevitabilmente a un errore del parser. Fortunatamente, a partire dalla versione 5.6, è diventato possibile assegnare non solo costanti, ma anche espressioni costanti (ad esempio “1+2” o “”), cioè espressioni che non dipendono da altro codice e possono essere calcolate in fase di compilazione
La seconda pietra è che i metodi esistono in un’unica copia.
Qui tutto è un po’ più complicato. Per capirne l'essenza, ecco il codice:
classe A ( funzione pubblica foo() ( static $x = 0; echo ++$x; ) ) $a1 = nuova A; $a2 = nuovo A; $a1->foo(); // 1 $a2->foo(); // 2 $a1->foo(); // 3 $a2->foo(); // 4
Contrariamente all’aspettativa intuitiva “oggetti diversi – metodi diversi”, vediamo chiaramente in questo esempio che i metodi dinamici in PHP “non si moltiplicano”. Anche se abbiamo un centinaio di oggetti di questa classe, il metodo esisterà in una sola istanza; è solo che ad ogni chiamata verrà inserito un $this diverso.
Questo comportamento può essere inaspettato per uno sviluppatore impreparato e può essere fonte di errori. Va notato che l'ereditarietà della classe (e del metodo) porta alla creazione di un nuovo metodo:
Classe A ( funzione pubblica foo() ( static $x = 0; echo ++$x; ) ) classe B estende A ( ) $a1 = nuova A; $b1 = nuova B; $a1->foo(); // 1 $b1->foo(); // 1 $a1->foo(); // 2 $b1->foo(); // 2
Conclusione: i metodi dinamici in PHP esistono nel contesto delle classi, non degli oggetti. E solo in fase di esecuzione si verifica la sostituzione "$this = current_object".
Il secondo significato riguarda le proprietà statiche e i metodi delle classi
Nel modello a oggetti PHP è possibile impostare proprietà e metodi non solo per gli oggetti - istanze di una classe, ma anche per la classe nel suo insieme. La parola chiave statica viene utilizzata anche per questo:Classe A ( public static $x = "foo"; funzione pubblica statica test() ( return 42; ) ) echo A::$x; // "pippo" echo A::test(); // 42
Per accedere a tali proprietà e metodi, vengono utilizzati costrutti con doppi due punti (“Paamayim Nekudotayim”), come CLASS_NAME::$Variablename e CLASS_NAME::Methodname().
Inutile dire che le proprietà statiche e i metodi statici hanno le loro caratteristiche e le loro insidie che devi conoscere.
La prima caratteristica è banale: non esiste $this. In realtà, ciò deriva dalla definizione stessa di metodo statico: poiché è associato a una classe, non a un oggetto, la pseudo-variabile $this, che punta all'oggetto corrente nei metodi dinamici, non è disponibile. Il che è del tutto logico.
Devi però sapere che, a differenza di altri linguaggi, PHP non rileva la situazione “$questo è scritto in un metodo statico” in fase di analisi o compilazione. Un errore come questo può verificarsi solo in fase di esecuzione se si tenta di eseguire codice con $this all'interno di un metodo statico.
Codice come questo:
classe A ( public $id = 42; funzione pubblica statica foo() ( echo $this->id; ) )
non causerà alcun errore, a patto che non provi a utilizzare il metodo foo() in modo inappropriato:
$a = nuova A; $a->foo(); (e ottieni immediatamente "Errore fatale: utilizzo di $this quando non nel contesto dell'oggetto")
La seconda caratteristica è che la statica non è un assioma!
classe A (funzione pubblica statica foo() ( echo 42; ) ) $a = nuova A; $a->foo();
Questo è tutto, sì. Un metodo statico, se non contiene $this nel codice, può essere chiamato in un contesto dinamico, come un metodo oggetto. Questo non è un bug in PHP.
Non è del tutto vero il contrario:
classe A (funzione pubblica foo() ( echo 42; ) ) A::foo();
Un metodo dinamico che non utilizza $this può essere eseguito in un contesto statico. Tuttavia, riceverai un avviso "Il metodo non statico A::foo() non deve essere chiamato staticamente" al livello E_STRICT. Sta a te decidere se seguire rigorosamente gli standard del codice o eliminare gli avvisi. Ovviamente è preferibile la prima.
E comunque, tutto quanto scritto sopra si applica solo ai metodi. L'utilizzo di una proprietà statica tramite "->" è impossibile e porta a un errore fatale.
Il terzo significato, che sembra essere il più difficile, è il legame statico tardivo
Gli sviluppatori del linguaggio PHP non si sono fermati ai due significati della parola chiave “static” e nella versione 5.3 hanno aggiunto un’altra “caratteristica” del linguaggio, che viene implementata con la stessa parola! Si chiama "late static binding" o LSB (Late Static Binding).Il modo più semplice per comprendere l'essenza di LSB è con semplici esempi:
Modello di classe (public static $table = "table"; public static function getTable() ( return self::$table; ) ) echo Model::getTable(); // "tavolo"
La parola chiave self in PHP significa sempre “il nome della classe in cui è scritta questa parola”. In questo caso, self viene sostituito con la classe Model e self::$table con Model::$table.
Questa funzionalità del linguaggio è chiamata "associazione statica anticipata". Perché presto? Perché l'associazione di self e un nome di classe specifico non avviene in fase di esecuzione, ma nelle fasi precedenti, durante l'analisi e la compilazione del codice. Bene, "statico" - perché stiamo parlando di proprietà e metodi statici.
Cambiamo un po' il nostro codice:
Modello di classe (public static $table = "table"; public static function getTable() ( return self::$table; ) ) class User extends Model ( public static $table = "users"; ) echo User::getTable() ; // "tavolo"
Ora capisci perché PHP si comporta in modo non intuitivo in questa situazione. self era associato alla classe Model quando non si sapeva nulla della classe User e quindi punta a Model.
Cosa dovrei fare?
Per risolvere questo dilemma, è stato inventato un meccanismo di associazione “tardivo” in fase di runtime. Funziona in modo molto semplice: basta scrivere "statico" invece della parola "self" e verrà stabilita la connessione con la classe che chiama questo codice e non con quella in cui è scritto:
class Modello ( public static $table = "table"; public static function getTable() ( return static::$table; ) ) class User extends Model ( public static $table = "users"; ) echo User::getTable() ; // "utenti"
Questo è il misterioso “legame statico tardivo”.
Va notato che per maggiore comodità in PHP, oltre alla parola “statico”, c'è anche una funzione speciale get_call_class(), che ti dirà nel contesto di quale classe sta attualmente funzionando il tuo codice.
Buone interviste!
Esistono due tipi di sviluppatori PHP nel mondo. Alcuni preferiscono i metodi statici perché sono facili da lavorare, mentre altri, al contrario, considerano i metodi statici un male e non li usano nella loro pratica.
In questo articolo cercherò, utilizzando la mia esperienza di lavoro con diversi framework, di spiegare perché alcuni sviluppatori ignorano le migliori pratiche e utilizzano tutta una serie di metodi statici.
Chi ama i metodi statici?
Sono particolarmente spesso utilizzati dagli sviluppatori che hanno mai utilizzato il framework CodeIgniter nel loro lavoro.Inoltre, la maggior parte degli sviluppatori Kohana e Laravel seguono metodi statistici.
Qui non possiamo fare a meno di menzionare il fatto che i programmatori che decidono di iniziare a scrivere le proprie cose solitamente rifiutano di utilizzare CodeIgniter.
Perchè lo chiedi?
CodeIgniter supportava PHP 4 prima che i metodi statici fossero aggiunti in PHP 5. Inoltre, CodeIgniter utilizza un "super oggetto" che fornisce uguale accesso a tutte le classi assegnate al controller. Pertanto, diventano disponibili per l'uso in tutto il sistema.
Ciò significa che è possibile accedere alle classi da qualsiasi modello utilizzando il metodo __get(), che cercherà la proprietà richiesta utilizzando get_istanza()->($var). In precedenza, quando la funzione __get() non era supportata in PHP 4, ciò veniva fatto utilizzando un costrutto foreach attraverso i parametri CI_Controller e quindi assegnandoli alla variabile $this nel modello.
Nella libreria devi chiamare get_instance. La libreria non impone l'ereditarietà delle classi, quindi non c'è modo di ignorare la funzione __get().
Volume…
Ciò si traduce in una struttura piuttosto macchinosa per l'accesso al codice. La stessa identica funzionalità può essere ottenuta con un metodo statico senza alcuno sforzo aggiuntivo.E non ha senso discutere di un simile progetto. Ok, puoi accedere ai dati della sessione nel tuo modello. Ma perché dovresti farlo?
"Soluzione"
Gli sviluppatori di Kohana sono stati i primi a lavorare seriamente su metodi statici. Hanno apportato le seguenti modifiche://era $this->input->get("foo"); // diventa Input::get("foo");
Per molti sviluppatori CodeIgniter con PHP 4 legacy che sono passati al framework Kohana per sfruttare tutti i vantaggi di PHP 5, questo non è niente di insolito. Ma meno personaggi sono, meglio è, giusto?
Allora, qual'è il problema?
Molti sviluppatori PHP (specialmente quelli esperti di Symfony e Zend) diranno: "È ovvio: usa Dependency Injection!" Ma non molti sviluppatori nella community di CodeIgniter hanno una reale esperienza con questo processo, poiché è piuttosto complesso.Un altro fatto relativo al framework Fuel PHP è che finora i metodi statici fungono da interfaccia. Ad esempio, la logica ha ancora problemi con la statica, soprattutto quando è coinvolto il concetto HMVC.
Questo è lo pseudocodice che non utilizzo in FuelPHP dalla versione 1.1:
classe ControllerA estende Controller ( public function action_foo() ( echo Input::get("param"); ) )
Codice piuttosto standard. Questo metodo restituirà il valore ?bar= nel metodo.
Cosa succede quando effettuiamo una richiesta HMVC a questo metodo?
class ControllerB estende Controller ( public function action_baz() ( echo Input::get("param"); echo " & "; echo Request::forge("controllera/foo?param=val1")->execute() ;) )
Chiamando nel browser controllerb/baz, vedrai l'output "val1" ma se digiti controllerb/baz?param=override, quindi ottieni entrambe le chiamate per ottenere il metodo che restituisce lo stesso valore.
Rilevanza
Il codice globale non ti fornirà alcuna relazione. Un esempio è meglio di qualsiasi parola:$this->request->input->get("param");
L'oggetto richiesto conterrà un'istanza completamente nuova per ogni richiesta, quindi per ogni richiesta verrà creato un oggetto di input che contiene solo i dati di input per la richiesta specifica. Questo è vero perché FuelPHP 2.0 prevede di funzionare e risolve il problema dell'iniezione di dipendenza così come i problemi HMVC.
Che dire della sintassi approssimativa?
Gli sviluppatori Symfony o Zend non ne soffrono, ma chi usa CodeIgniter avrà per molto tempo gli incubi di “tornare a PHP 4”.$questo si riferisce sempre all'oggetto "corrente" e sicuramente non dovresti usarlo per accedere al codice globale.
$this->request->input->get() può sembrare una forma lunga della sintassi di CodeIgniter, ma in realtà siamo solo nel controller. Quando il controller istanzia una nuova query annidata al suo interno, anche il costruttore della query riceve un'istanza come input.
Se ti trovi in un modello o in un'altra classe, un accesso come $this->request->input->foo() non funzionerà perché $this non è un controller.
Il costrutto Input::get("foo") crea una facciata per le istanze logiche in background. Ma questo non risolve i problemi legati al funzionamento del codice globale. Coloro che sono più pigri quando testano le applicazioni possono passare da una modalità all'altra senza dover utilizzare completamente un nuovo framework.
C'è un bellissimo video di Taylor Otwell (creatore di laravel 4) in cui descrive come sostituire il codice statico con una singola istanza testata tramite il suo contenitore DiC.
Laravel 4 - Iniezione del controller IoC e test unitari da UserScape su Vimeo.
Questa è un'ottima presentazione di come puoi farla franca senza utilizzare metodi statici in Laravel. Sebbene alcuni framework moderni, a prima vista, siano molto simili a Kohana, risolvono anche i problemi più standard in modi completamente diversi.
Su questa nota triste...
Attualmente sto convertendo PyroCMS da CodeIgniter a Laravel. Cercare di passare direttamente dal codice globale PHP 4 alla perfetta iniezione delle dipendenze è un suicidio assoluto. Un passaggio intermedio prima di utilizzare il caricatore CI consiste nell'utilizzare il codice del caricatore automatico PHP 5, PSR-2 con una serie di metodi statici. Bene, per ora siamo ancora in CodeIgniter.La transizione dal codice statico a quello DiC può essere facilmente dimostrata quando finalmente effettueremo la transizione a Laravel.
Passare dal codice CodeIgniter strettamente accoppiato al PSR-2 testabile è una sfida importante. Il team Pyro è in viaggio e sarà epico.
23 marzo 2010 dic5e
PHP 5.3 ha introdotto una funzionalità interessante chiamata late static binding. Quella che segue è una traduzione leggermente libera della descrizione dal manuale ufficiale.
A partire da PHP 5.3.0, il linguaggio ha introdotto una funzionalità chiamata late static binding, che può essere utilizzata per fare riferimento a una classe richiamabile nel contesto dell'ereditarietà statica.
Questa funzionalità è stata chiamata "associazione statica tardiva". "Late Binding" significa che static:: non verrà risolto rispetto alla classe in cui è definito il metodo, ma verrà valutato in fase di esecuzione. "Associazione statica" significa che può essere utilizzato nelle chiamate a metodi statici (ma non è limitato ad essi).
Limitazioni auto::
Esempio n.1: Utilizzo di self::
L'esempio restituirà:
Utilizzo dell'associazione statica tardiva
L'associazione statica successiva tenta di risolvere questa limitazione introducendo una parola chiave che fa riferimento alla classe originariamente chiamata in fase di esecuzione. Cioè, una parola chiave che consentirà di fare riferimento a B da test() nell'esempio precedente. Si è deciso di non introdurre una nuova parola, ma di utilizzare il già riservato static .
Esempio n.2: uso semplice di static::
L'esempio restituirà:
Nota: static:: non funziona come $this per i metodi statici! $this-> segue le regole di ereditarietà, ma static:: no. Questa distinzione viene chiarita di seguito.
Esempio n. 3: utilizzo di static:: in un contesto non statico
test(); ?>
L'esempio restituirà:
Nota: l'associazione statica tardiva interrompe il processo di risoluzione della chiamata. Le chiamate statiche che utilizzano le parole chiave parent:: o self:: trasmettono le informazioni sulla chiamata.
Esempio n. 4: trasferire e non trasferire le chiamate
Verrà visualizzato l'esempio
Casi limite
Esistono molti modi diversi per chiamare un metodo in PHP, come callback o metodi magici. Poiché l'associazione statica tardiva viene risolta in fase di esecuzione, ciò può portare a risultati imprevisti nei cosiddetti casi limite.
Esempio n.5 Legame statico tardivo nei metodi magici
pippo; ?>
