Share
De două ori pe lună, revizuim câteva postări favorite ale cititorilor noștri de-a lungul istoriei Nettuts+.
Chiar și după ce am folosit PHP de ani de zile, ne împiedicăm funcțiile și trăsăturile despre care nu știm. Unele dintre acestea pot fi destul de utile, dar sunt puțin utilizate. În acest sens, am compilat o listă cu nouă funcții și caracteristici PHP extrem de utile, pe care ar trebui să le cunoașteți.
S-ar putea să știți deja că PHP vă permite să definiți funcții cu argumente opționale. Dar există, de asemenea, o metodă pentru a permite un număr complet arbitrar de argumente funcționale.
Mai întâi, iată un exemplu cu doar argumente opționale:
Accentsconagua
// funcția cu 2 argumente opționale funcția foo ($ arg1 = ", $ arg2 =") echo "arg1: $ arg1 \ n"; echo "arg2: $ arg2 \ n"; foo ("salut", "lume"); / * printuri: arg1: hello arg2: lume * / foo (); / * printuri: arg1: arg2: * / Acum, să vedem cum putem construi o funcție care acceptă orice număr de argumente. De data aceasta vom folosi func_get_args ():
// da, lista de argumente poate fi goală funcția foo () // returnează o matrice a tuturor argumentelor transmise $ args = func_get_args (); foreach ($ args ca $ k => $ v) echo "arg". ($ k + 1) ": $ v \ n"; foo (); / * nu imprimă nimic * / foo ('hello'); / * tipări arg1: salut * / foo ('salut', 'lume', 'din nou'); / * tipări arg1: salut arg2: lume arg3: din nou * / Multe funcții PHP au nume lungi și descriptive. Cu toate acestea, este greu de spus ce înseamnă o funcție numită glob () dacă nu sunteți deja familiarizat cu acest termen din altă parte.
Gândiți-vă la aceasta ca la o versiune mai bună a funcției scandir (). Acesta vă permite să căutați fișiere utilizând modele.
// obține toate fișierele php $ files = glob ('*. php'); print_r ($ fișiere); / * ieșirea arata ca: Array ([0] => phptest.php [1] => pi.php [2] => post_output.php [3] => test.php) Puteți prelua mai multe tipuri de fișiere, cum ar fi:
// primi toate fișierele php și fișierele txt $ files = glob ('*. php, txt', GLOB_BRACE); print_r ($ fișiere); / * ieșirea arată ca: Array ([0] => phptest.php [1] => pi.php [2] => post_output.php [3] => test.php [4] => log.txt [5 ] => test.txt) * / Rețineți că fișierele pot fi returnate cu o cale, în funcție de interogare:
$ fișiere = glob ('? /images/a*.jpg'); print_r ($ fișiere); / * ieșirea arată ca: Array ([0] =>? /images/apple.jpg [1] =>? /images/art.jpg) * / Dacă doriți să obțineți calea completă la fiecare fișier, puteți apela funcția realpath () pe valorile returnate:
$ fișiere = glob ('? /images/a*.jpg'); // aplică funcția pentru fiecare element de array $ files = array_map ('realpath', $ files); print_r ($ fișiere); / * ieșirea arata ca: Array ([0] => C: \ wamp \ www \ images \ apple.jpg [1] Observând utilizarea memoriei scripturilor dvs., este posibil să vă optimizați codul mai bine.
PHP are un colector de gunoi și un manager de memorie destul de complex. Cantitatea de memorie utilizată de scenariul dvs. poate merge în sus și în jos în timpul executării unui scenariu. Pentru a obține utilizarea curentă a memoriei, putem folosi funcția memory_get_usage (), iar pentru a obține cea mai mare cantitate de memorie utilizată în orice moment, putem folosi funcția memory_get_peak_usage ().
echo "inițial:" .memory_get_usage () "bytes \ n"; / * prints Initial: 361400 bytes * / // sa folosim o memorie pentru ($ 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 */
Pentru aceasta, vom folosi funcția getrusage (). Rețineți că acest lucru nu este disponibil pe platformele Windows.
print_r (getrusage ()); / * imprimă Array (ru_oublock] => 0 [ru_inblock] => 0 [ru_msrg] => 2 [ru_msgrcv] => 3 [ru_maxrss] = [0] [ru_numps] => 0 [ru_model] => 1 [ru_nvcsw] => ru_stime.tv_usec] => 6269 [ru_stime.tv_sec] => 0) * /
Acest lucru poate părea un pic cam critic dacă nu aveți deja un background de administrare a sistemului. Iată explicația fiecărei valori (nu este nevoie să le memorați):
Pentru a vedea cât de multă putere CPU a consumat scenariul, trebuie să ne uităm la valorile "timp de utilizator" și "timp de sistem". Secțiunile secunde și microsecunde sunt furnizate separat în mod prestabilit. Puteți împărți valoarea microsecundelor cu 1 milion și adăugați-le la valoarea secunde, pentru a obține numărul total de secunde ca număr zecimal.
Să vedem un exemplu:
// somn pentru 3 secunde (non-ocupat) de somn (3); date $ = getrusage (); ecou "Timp utilizator:". ($ data ['ru_utime.tv_sec'] + $ date ['ru_utime.tv_usec'] / 1000000); ecou "Timp sistem:". ($ date ['ru_stime.tv_sec'] + date ['ru_stime.tv_usec'] / 1000000); / * prints Timp de utilizare: 0.011552 Timp de sistem: 0 * /
Chiar dacă scenariul a durat aproximativ 3 secunde, utilizarea procesorului a fost foarte scăzută. Deoarece în timpul operației de somn scriptul nu consumă resurse CPU. Există multe alte sarcini care pot dura în timp real, dar nu pot folosi timp CPU, cum ar fi așteptarea operațiilor pe disc. Așa cum vedeți, utilizarea procesorului și durata efectivă a runtimei nu sunt întotdeauna aceleași.
Iată un alt exemplu:
// bucla de 10 milioane de ori (ocupat) pentru ($ 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 */
A fost nevoie de aproximativ 1,4 secunde de timp CPU, aproape toate fiind timp de utilizator, deoarece nu au existat apeluri de sistem.
Timpul sistemului este perioada de timp pe care CPU-ul o cheltuiește pentru a efectua apeluri de sistem pentru kernel în numele programului. Iată un exemplu în acest sens:
$ start = microtime (adevărat); // continuă să sune microtime timp de aproximativ 3 secunde în timp ce (microtime (adevărat) - $ 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 */
Acum avem destul de mult timp de utilizare a sistemului. Acest lucru se datorează faptului că scriptul numește funcția microtime () de mai multe ori, care execută o cerere prin sistemul de operare pentru a prelua timpul.
De asemenea, este posibil să observați că numerele nu adaugă până la 3 secunde. Acest lucru se datorează faptului că au existat probabil și alte procese pe server, iar scriptul nu folosea CPU 100% pe întreaga durată a celor 3 secunde.
PHP oferă constante magice utile pentru preluarea numărului liniei curente (__LINIA__), calea fișierului (__FIŞIER__), calea catre director (__DIR__), numele funcției (__FUNCŢIE__), numele clasei (__CLASĂ__), numele metodei (__METHOD__) și spațiul de nume (__NAMESPACE__).
Nu vom acoperi fiecare dintre acestea în acest articol, dar vă voi arăta câteva cazuri de utilizare.
Când includeți alte scripturi, este o idee bună să utilizați
__FIŞIER__constanta (sau, de asemenea__DIR__, din PHP 5.3):
// aceasta este relativă la calea scriptului încărcat // poate provoca probleme când rulează scripturi din diferite directoare requ_once ('config / database.php'); // aceasta este întotdeauna relativă la calea acestui fișier // indiferent unde a fost inclusă din requ_once (dirname (__FILE__). /config/database.php '); Utilizarea __LINIA__ face depanarea mai ușoară. Puteți urmări numerele de linie:
// un cod / /? my_debug ("un mesaj de depanare", __LINE__); / * imprimă Linia 4: un mesaj de depanare * / // ceva mai mult cod // //? my_debug ("un alt mesaj de depanare", __LINE__); / * imprimă Linia 11: un alt mesaj de depanare * / funcția my_debug ($ msg, $ line) echo "Line $ line: $ msg \ n"; Pot exista situații în care trebuie să generați un șir unic. Am văzut mulți utilizatori md5 () funcția pentru aceasta, chiar dacă nu este exact menită pentru acest scop:
// generează unic șir de ecouri md5 (time () .mt_rand (1,1000000));
Există de fapt o funcție PHP numită uniqid (), care este destinată utilizării pentru aceasta.
// genera unic șir de ecouri uniqid (); / * imprimă 4bd67c947233e * / // generează un alt șir unic echo uniqid (); / * imprimate 4bd67c9472340 * /
Puteți observa că, chiar dacă șirurile sunt unice, ele par asemănătoare pentru primele câteva personaje. Acest lucru se datorează faptului că șirul generat este legat de timpul serverului. Acest lucru are de fapt un efect secundar frumos, deoarece fiecare id nou generat vine mai târziu în ordine alfabetică, astfel încât să poată fi sortate.
Pentru a reduce șansele de obținere a unui duplicat, puteți trece un prefix sau al doilea parametru pentru a crește entropia:
// cu prefixul echo uniqid ('foo_'); / * imprimă foo_4bd67d6cd8b8f * / // cu mai multă entropie echo uniqid (", true); / * imprimă 4bd67d6cd8b926.12135106 * / // ambii echo uniqid ('bar _', true); / * prints bar_4bd67da367b650.43684647 * / Această funcție va genera șiruri mai scurte decât md5 (), care vă va economisi spațiu.
Ați trebuit vreodată să stocați o variabilă complexă într-o bază de date sau într-un fișier text? Nu trebuie să veniți cu o soluție fantezie pentru a converti matricele sau obiectele în șiruri de caractere formatate, deoarece PHP are deja funcții în acest scop.
Există două metode populare de serializare a variabilelor. Iată un exemplu care folosește serialize () și unserialize ():
// array complex $ myvar = array ('hello', 42, array (1, 'două'), 'apple'); // convertiți la un șir $ string = serialize ($ myvar); echo $ string; / * imprimă a: 4: i: 0; s: 5: "salut"; i: 1; i: 42; i: 2; : 3: "2"; i: 3; s: 5: "apple"; * / // puteți reproduce variabila inițială $ newvar = unserialize ($ string); print_r ($ newvar); / * imprimă array ([0] => salut [1] => 42 [2] => Array ([0] => 1 [ Aceasta a fost metoda de serializare PHP nativă. Cu toate acestea, din moment ce JSON a devenit atât de popular în ultimii ani, ei au decis să adauge sprijin pentru acesta în PHP 5.2. Acum puteți folosi json_encode () și json_decode () și funcțiile:
// array complex $ myvar = array ('hello', 42, array (1, 'două'), 'apple'); // convertiți la un șir $ string = json_encode ($ myvar); echo $ string; / * imprimă ["hello", 42, [1, "two"], "apple"]] * / // puteți reproduce variabila originală $ newvar = json_decode ($ string); print_r ($ newvar); / * imprimă array ([0] => salut [1] => 42 [2] => Array ([0] => 1 [ Este mai compact și, cel mai bine, compatibil cu javascript și multe alte limbi. Cu toate acestea, pentru obiectele complexe, unele informații pot fi pierdute.
Când vorbim despre compresie, ne gândim, de obicei, la fișiere, cum ar fi arhivele ZIP. Este posibil să comprimați șiruri lungi în PHP, fără a implica fișiere de arhivă.
În următorul exemplu, vom folosi funcțiile gzcompress () și gzuncompress ():
$ string = "Lorem ipsum dolor stai amet, consectetur adipiscing elit.Nunc ut elit id mi ultrricies adipiscing.Nulla faciliti.Presentativul pulvinar, sapien vel feuil vestibulum, nulla dui pretium orci, nu ultritori elit lacus quis ante.Lorem ipsum dolor sit amet , în cazul în care se utilizează un elicopter care conține o cantitate mai mare de particule, se poate adăuga o cantitate mai mare de substanțe care conțin o cantitate mai mare sau mai mică decât cea a compușilor. nu mi metus, la lacinia augue.La sediul magna nisi, ornare in mollis, in mollis sed nunc. . "; $ comprimat = gzcompress ($ șir); ecou "Dimensiunea originală:". strlen ($ string) "\ n".; / * Prints Dimensiune original: 800 * / echo "Dimensiune comprimat:". strlen ($ comprimat) "\ n".; / * prints Dimensiune comprimat: 418 * / // obtinerea inapoi $ original = gzuncompress ($ comprimat);
Am reușit să obținem o reducere a dimensiunii de aproape 50%. De asemenea, funcțiile gzencode () și gzdecode () realizează rezultate similare, utilizând un algoritm de compresie diferit.
Există o funcție numită register_shutdown_function (), care vă va permite să executați un cod chiar înainte ca scriptul să se termine.
Imaginați-vă că doriți să capturați câteva statistici de referință la sfârșitul executării scenariului dvs., cum ar fi cât timp a durat executarea:
// capturați timpul de începere $ start_time = microtime (true); // face unele chestii //? // afișați cât timp scriptul a luat ecou "execuția a luat:". (microtime (adevărat) - $ start_time). "secunde";
La început acest lucru poate părea trivial. Trebuie doar să adăugați codul în partea de jos a scriptului și acesta să fie executat înainte ca acesta să se termine. Cu toate acestea, dacă ați sunat la funcția exit (), acel cod nu va funcționa niciodată. De asemenea, dacă există o eroare fatală sau dacă scriptul este terminat de utilizator (prin apăsarea butonului Stop din browser), este posibil ca acesta să nu se execute.
Când utilizați register_shutdown_function (), codul dvs. va executa indiferent de ce scriptul a încetat să ruleze:
$ start_time = microtime (adevărat); register_shutdown_function ( 'my_shutdown'); // face unele chestii //? funcția my_shutdown () global $ start_time; ecou "a luat:". (microtime (adevărat) - $ start_time). "secunde";
Ești conștient de orice alte caracteristici PHP care nu sunt cunoscute pe scară largă, dar pot fi destul de utile? Vă rugăm să ne comunicați în comentarii. Și vă mulțumesc pentru lectură!
