Share
Due volte al mese, rivisitiamo alcuni dei post preferiti dei nostri lettori da tutta la storia di Nettuts+.
Anche dopo aver usato PHP per anni, ci imbattiamo in funzioni e caratteristiche che non sapevamo. Alcuni di questi possono essere abbastanza utili, ma sottoutilizzati. Con questo in mente, ho compilato un elenco di nove funzioni e caratteristiche PHP incredibilmente utili che dovresti avere familiarità con.
Potresti già sapere che PHP ti permette di definire funzioni con argomenti opzionali. Ma esiste anche un metodo per consentire il numero completamente arbitrario di argomenti di funzione.
Innanzitutto, ecco un esempio con argomenti opzionali:
Accentsconagua
// funzione con 2 argomenti opzionali function foo ($ arg1 = ", $ arg2 =") echo "arg1: $ arg1 \ n"; echo "arg2: $ arg2 \ n"; foo ('ciao', 'mondo'); / * prints: arg1: ciao arg2: world * / foo (); / * stampe: arg1: arg2: * / Ora, vediamo come possiamo costruire una funzione che accetta un numero qualsiasi di argomenti. Questa volta utilizzeremo func_get_args ():
// sì, la lista degli argomenti può essere vuota function foo () // restituisce una matrice di tutti gli argomenti passati $ args = func_get_args (); foreach ($ args come $ k => $ v) echo "arg". ($ k + 1). ": $ v \ n"; foo (); / * stampa nulla * / foo ('ciao'); / * stampa arg1: ciao * / foo ('ciao', 'mondo', 'nuovo'); / * stampa arg1: ciao arg2: world arg3: again * / Molte funzioni PHP hanno nomi lunghi e descrittivi. Tuttavia può essere difficile dire quale sia una funzione denominata glob () a meno che tu non abbia già familiarità con quel termine da altrove.
Pensalo come una versione più capace della funzione scandir (). Può farti cercare i file usando i pattern.
// recupera tutti i file php $ files = glob ('*. php'); print_r (file $); / * l'output è simile a: Array ([0] => phptest.php [1] => pi.php [2] => post_output.php [3] => test.php) * / Puoi recuperare più tipi di file come questo:
// trova tutti i file php E i file txt $ files = glob ('*. php, txt', GLOB_BRACE); print_r (file $); / * l'output è simile a: Array ([0] => phptest.php [1] => pi.php [2] => post_output.php [3] => test.php [4] => log.txt [5 ] => test.txt) * / Si noti che i file possono essere effettivamente restituiti con un percorso, a seconda della query:
$ files = glob ('? /images/a*.jpg'); print_r (file $); / * l'output è simile a: Array ([0] =>? /images/apple.jpg [1] =>? /images/art.jpg) * / Se si desidera ottenere il percorso completo per ogni file, è sufficiente chiamare la funzione realpath () sui valori restituiti:
$ files = glob ('? /images/a*.jpg'); // applica la funzione a ciascun elemento dell'array $ files = array_map ('realpath', $ files); print_r (file $); / * l'output è simile a: Array ([0] => C: \ wamp \ www \ images \ apple.jpg [1] => C: \ wamp \ www \ images \ art.jpg) * / Osservando l'uso della memoria dei tuoi script, potresti essere in grado di ottimizzare meglio il tuo codice.
PHP ha un garbage collector e un gestore di memoria piuttosto complesso. La quantità di memoria utilizzata dal tuo script. può andare su e giù durante l'esecuzione di uno script. Per ottenere l'attuale utilizzo della memoria, possiamo usare la funzione memory_get_usage (), e per ottenere la massima quantità di memoria utilizzata in qualsiasi momento, possiamo usare la funzione memory_get_peak_usage ().
echo "Iniziale:" .memory_get_usage (). "byte \ n"; / * stampe Iniziale: 361400 byte * / // usiamo un po 'di memoria per ($ i = 0; $ i < 100000; $i++) $array []= md5($i); // let's remove half of the array for ($i = 0; $i < 100000; $i++) unset($array[$i]); echo "Final: ".memory_get_usage()." bytes \n"; /* prints Final: 885912 bytes */ echo "Peak: ".memory_get_peak_usage()." bytes \n"; /* prints Peak: 13687072 bytes */
Per questo, utilizzeremo la funzione getrusage (). Tieni presente che questo non è disponibile su piattaforme Windows.
print_r (getrusage ()); / * stampa Array ([ru_oublock] => 0 [ru_inblock] => 0 [ru_msgsnd] => 2 [ru_msgrcv] => 3 [ru_maxrss] => 12692 [ru_ixrss] => 764 [ru_idrss] => 3864 [ru_minflt] => 94 [ru_majflt] => 0 [ru_nsignals] => 1 [ru_nvcsw] => 67 [ru_nivcsw] => 4 [ru_nswap] => 0 [ru_utime.tv_usec] => 0 [ru_utime.tv_sec] => 0 [ ru_stime.tv_usec] => 6269 [ru_stime.tv_sec] => 0) * /
Potrebbe sembrare un po 'criptico, a meno che tu non abbia già uno sfondo di amministrazione del sistema. Ecco la spiegazione di ciascun valore (non è necessario memorizzarli):
Per vedere quanta potenza della CPU ha consumato lo script, abbiamo bisogno di guardare i valori di 'user time' e 'system time'. Le parti dei secondi e dei microsecondi sono fornite separatamente per impostazione predefinita. Puoi dividere il valore dei microsecondi di 1 milione e aggiungerlo al valore dei secondi, per ottenere i secondi totali come numero decimale.
Vediamo un esempio:
// sleep per 3 secondi (non occupato) sleep (3); $ data = getrusage (); echo "Ora utente:". ($ data ['ru_utime.tv_sec'] + $ data ['ru_utime.tv_usec'] / 1000000); echo "Ora di sistema:". ($ data ['ru_stime.tv_sec'] + $ data ['ru_stime.tv_usec'] / 1000000); / * stampe Ora utente: 0,011552 Ora di sistema: 0 * /
Anche se lo script ha impiegato circa 3 secondi per funzionare, l'utilizzo della CPU era molto basso. Perché durante l'operazione sleep, lo script in realtà non consuma risorse della CPU. Ci sono molte altre attività che possono essere eseguite in tempo reale, ma potrebbero non utilizzare il tempo della CPU, ad esempio attendere le operazioni del disco. Quindi, come vedete, l'utilizzo della CPU e la durata effettiva del runtime non sono sempre gli stessi.
Ecco un altro esempio:
// loop 10 milioni di volte (occupato) per ($ i = 0; $ i<10000000;$i++) $data = getrusage(); echo "User time: ". ($data['ru_utime.tv_sec'] + $data['ru_utime.tv_usec'] / 1000000); echo "System time: ". ($data['ru_stime.tv_sec'] + $data['ru_stime.tv_usec'] / 1000000); /* prints User time: 1.424592 System time: 0.004204 */
Ci sono voluti circa 1,4 secondi di tempo della CPU, quasi tutti a disposizione dell'utente, poiché non c'erano chiamate di sistema.
System Time è la quantità di tempo che la CPU spende per effettuare chiamate di sistema per il kernel per conto del programma. Ecco un esempio di questo:
$ start = microtime (true); // continua a chiamare il microtime per circa 3 secondi mentre (microtime (true) - $ start < 3) $data = getrusage(); echo "User time: ". ($data['ru_utime.tv_sec'] + $data['ru_utime.tv_usec'] / 1000000); echo "System time: ". ($data['ru_stime.tv_sec'] + $data['ru_stime.tv_usec'] / 1000000); /* prints User time: 1.088171 System time: 1.675315 */
Ora abbiamo un bel po 'di utilizzo del tempo di sistema. Questo perché lo script chiama la funzione microtime () molte volte, che esegue una richiesta attraverso il sistema operativo per recuperare il tempo.
Inoltre potresti notare che i numeri non aggiungono fino a 3 secondi. Questo perché probabilmente c'erano altri processi sul server e lo script non utilizzava il 100% della CPU per l'intera durata dei 3 secondi.
PHP fornisce costanti magiche utili per il recupero del numero di riga corrente (__LINEA__), percorso del file (__FILE__), percorso della directory (__DIR__), nome della funzione (__FUNZIONE__), nome della classe (__CLASSE__), nome del metodo (__METHOD__) e spazio dei nomi (__NAMESPACE__).
Non copriremo ognuno di questi in questo articolo, ma vi mostrerò alcuni casi d'uso.
Quando includi altri script, è una buona idea utilizzare il
__FILE__costante (o anche__DIR__, da PHP 5.3):
// questo è relativo al percorso dello script caricato // potrebbe causare problemi durante l'esecuzione di script da directory diverse require_once ('config / database.php'); // questo è sempre relativo al percorso di questo file // indipendentemente da dove è stato incluso da require_once (dirname (__ FILE__). '/config/database.php'); utilizzando __LINEA__ rende più facile il debug. Puoi rintracciare i numeri di riga:
// qualche codice //? my_debug ("qualche messaggio di debug", __LINE__); / * stampa la riga 4: qualche messaggio di debug * / // un altro codice //? my_debug ("un altro messaggio di debug", __LINE__); / * stampa la riga 11: un altro messaggio di debug * / function my_debug ($ msg, $ line) echo "Riga $ line: $ msg \ n"; Potrebbero esserci situazioni in cui è necessario generare una stringa univoca. Ho visto molte persone usare il md5 () funzione per questo, anche se non è esattamente inteso per questo scopo:
// genera una stringa unica echo md5 (time (). mt_rand (1,1000000));
In realtà esiste una funzione PHP chiamata uniqid () che deve essere utilizzata per questo.
// genera una stringa unica echo uniqid (); / * stampa 4bd67c947233e * / // genera un'altra stringa univoca echo uniqid (); / * stampa 4bd67c9472340 * /
Si può notare che anche se le stringhe sono uniche, sembrano simili per i primi diversi caratteri. Questo perché la stringa generata è correlata al tempo del server. Questo ha in realtà un bell'effetto collaterale, poiché ogni nuovo ID generato viene in seguito in ordine alfabetico, in modo che possano essere ordinati.
Per ridurre le possibilità di ottenere un duplicato, puoi passare un prefisso o il secondo parametro per aumentare l'entropia:
// con prefisso echo uniqid ('foo_'); / * stampa foo_4bd67d6cd8b8f * / // con più entropia echo uniqid (", true); / * stampa 4bd67d6cd8b926.12135106 * / // entrambi eco uniqid ('bar _', vero); / * stampa bar_4bd67da367b650.43684647 * / Questa funzione genererà stringhe più brevi di md5 (), che ti farà risparmiare spazio.
Hai mai avuto bisogno di memorizzare una variabile complessa in un database o in un file di testo? Non devi trovare una soluzione di fantasia per convertire i tuoi array o oggetti in stringhe formattate, dato che PHP ha già delle funzioni per questo scopo.
Esistono due metodi diffusi per serializzare le variabili. Ecco un esempio che utilizza serialize () e unserialize ():
// un array complesso $ myvar = array ('hello', 42, array (1, 'two'), 'apple'); // converti in una stringa $ string = serialize ($ myvar); echo $ string; / * stampa a: 4: i: 0; s: 5: "ciao"; i: 1; i: 42; i: 2; a: 2: i: 0; i: 1; i: 1; s : 3: "two"; i: 3; s: 5: "apple"; * / // è possibile riprodurre la variabile originale $ newvar = unserialize ($ string); print_r ($ newvar); / * stampa Array ([0] => ciao [1] => 42 [2] => Matrice ([0] => 1 [1] => due) [3] => mela) * / Questo era il metodo di serializzazione PHP nativo. Tuttavia, dal momento che JSON è diventato così popolare negli ultimi anni, hanno deciso di aggiungerne il supporto in PHP 5.2. Ora puoi usare il json_encode () e json_decode () funzioni pure:
// un array complesso $ myvar = array ('hello', 42, array (1, 'two'), 'apple'); // converti in una stringa $ string = json_encode ($ myvar); echo $ string; / * stampa ["ciao", 42, [1, "due"], "mela"] * / // è possibile riprodurre la variabile originale $ newvar = json_decode ($ string); print_r ($ newvar); / * stampa Array ([0] => ciao [1] => 42 [2] => Matrice ([0] => 1 [1] => due) [3] => mela) * / È più compatto e, soprattutto, compatibile con javascript e molti altri linguaggi. Tuttavia, per oggetti complessi, alcune informazioni potrebbero andare perse.
Quando parliamo di compressione, solitamente pensiamo ai file, come gli archivi ZIP. È possibile comprimere stringhe lunghe in PHP, senza coinvolgere alcun file di archivio.
Nel seguente esempio utilizzeremo le funzioni gzcompress () e gzuncompress ():
$ string = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.Nunc ut elit id mi ultricies adipiscing.Nulla facilisi.Preventivo pulvinar, sapien vel feugiat vestibulum, nulla dui pretium orci, non ultricies elit lacus quis ante. Aliquam pretium ullamcorper urna quis iaculis Etiam ac massa sed turpis tempor luctus Curabitur sed nibh eu elit mollis congue, l 'adorazione ipsum diam, consectetur vitae ornare a, aliquam a nunc. In id magna pellentesque tellus posuere adipiscing. non mi metus, a lacinia augue, sed magna nisi, ornare in mollis in, mollis sed nunc, etiam a justo in leo congue mollis, nullam in neque eget metus hendrerit scelerisque eu non enim, ut maschiuada lacus eu nulla bibendum id euismod urna sodales . "; $ compresso = gzcompress ($ stringa); echo "Dimensione originale:". strlen ($ string) "\ n".; / * stampe Formato originale: 800 * / echo "Dimensione compressa:". strlen ($ compressi) "\ n".; / * stampe Dimensione compressa: 418 * / // recuperarlo $ originale = gzuncompress ($ compresso);
Siamo stati in grado di ottenere una riduzione delle dimensioni di quasi il 50%. Anche le funzioni gzencode () e gzdecode () ottengono risultati simili, usando un diverso algoritmo di compressione.
C'è una funzione chiamata register_shutdown_function (), che ti permetterà di eseguire del codice prima che lo script finisca di funzionare.
Immagina di voler acquisire alcune statistiche di benchmark alla fine dell'esecuzione dello script, ad esempio il tempo necessario per l'esecuzione:
// cattura l'ora di inizio $ start_time = microtime (true); // fai qualcosa //? // mostra per quanto tempo lo script ha preso eco "l'esecuzione ha richiesto:". (microtime (true) - $ start_time). "secondi";
All'inizio questo può sembrare banale. Basta aggiungere il codice alla fine dello script e viene eseguito prima che finisca. Tuttavia, se si chiama la funzione exit (), quel codice non verrà mai eseguito. Inoltre, se c'è un errore fatale, o se lo script è terminato dall'utente (premendo il pulsante Stop nel browser), di nuovo potrebbe non funzionare.
Quando si utilizza register_shutdown_function (), il codice verrà eseguito indipendentemente dal motivo per cui lo script ha smesso di funzionare:
$ start_time = microtime (true); register_shutdown_function ( 'my_shutdown'); // fai qualcosa //? function my_shutdown () global $ start_time; echo "l'esecuzione ha richiesto:". (microtime (true) - $ start_time). "secondi";
Sei a conoscenza di altre funzionalità PHP che non sono ampiamente conosciute ma che possono essere abbastanza utili? Si prega di condividere con noi nei commenti. E grazie per aver letto!
