M-au nedumerit aici să scriu un demon în PHP. Acestea. un script care va efectua anumite acțiuni de un anumit număr de ori într-un anumit număr de ore la un moment aleator (întotdeauna aleatoriu), și toate acestea fără a utiliza cron „a.

Înainte de asta, nu m-am deranjat niciodată, dar apoi după setarea sarcinii, am început să cred că este imposibil, că scriptul php ar trebui apelat de browser... ei bine, sarcina a fost setată, trebuie efectuată.

Primul gând este să dezactivați limita de timp de execuție a scriptului. Interzis de gazdă.

Al doilea gând este să repetați periodic cererea Ajax (da, cel puțin o dată pe secundă) folosind Javascript. - nu este posibil (cerința clientului).

S-a dovedit, de fapt, că browserul nu ar trebui să fie deschis, iar crons nu ar trebui să fie folosit, iar scriptul ar trebui să funcționeze independent de utilizator, pe termen nelimitat. Desigur, ar trebui să încarce cel puțin sistemul.

1. Pachet de țigări, noapte, Google, docuri, cărți, manuale….
treci la 1...

La ieșire primesc:
Sarcina 1:
Implementați un generator de timp de execuție a scripturilor bazat pe numărul de ori și numărul de ore date. Păstrați aceste timpuri undeva.

Sarcina_2:
Lucrați după închiderea browserului

Sarcina_3:
Nu blocați după expirarea limitei de timp de execuție a scriptului

Sarcina_4:
Luați măsuri la momentul potrivit.

Asa de…
Scriem datele inițiale în configurație:

sesiune_start(); // Începutul sesiunii $num_starts = 120; // Numărul de rulări de scripturi pe interval de timp $ore = 1; // Numărul de ore pentru a rula scriptul $num_starts ori. $time_sec = $ore*3600; // Numărul de secunde în ciclul de rulare $time_to_start = array(); // De fapt, o matrice cu timpi de lansare ignore_user_abort(1); // Ignoră deconectarea browserului

În continuare, scriem o funcție care ne va ajuta să generăm orele de pornire.
În ea generăm Număr aleatoriu de la 0 la numărul de secunde din intervalul inițial.
/***** * @desc Generați un interval între rulări. */ funcția add_time2start() ( global $time_sec, $time_to_start; $new_time = time()+rand(0, $time_sec); if (!in_array($new_time, $time_to_start)) ( // Dacă nu există un astfel de timp în matrice - adăugați $time_to_start = $new_time; ) else (add_time2start(); // Dacă un astfel de timp există deja, regenerați. ) )

$k = 1; if ($_SESSION["num_st"] == "" || $_SESSION["num_st"][$num_starts-1]< time()) { // проверка, что в сессию не записаны данные и что эти данные не устарели. do { add_time2start($k); $k++; } while ($k < = $num_starts); sort($time_to_start, SORT_NUMERIC); $_SESSION["num_st"] = $time_to_start; }

Acum trebuie să facem ca scriptul să funcționeze, indiferent de timpul maxim de execuție stabilit de server.
Principiul este:
1) Determinați ora de începere a scriptului;
2) Noi definim stabiliți o limită la momentul executării.
3) Începem ciclul, în interiorul căruia numărăm timpul curent și calculăm timpul total în care rulează scriptul, verificăm ora curentă cu valorile din matricea orelor de început și, dacă există o potrivire, efectuăm acțiunile specificate (le am în fișierul exec.php). Folosim socket-uri pentru a rula fișiere.
4) Repetați ciclul până când timpul de rulare a scriptului se apropie de maximul permis. Am setat - până când timpul maxim este de 5 secunde.

Deci... luăm în considerare datele inițiale în timp:

$start_time = microtime(); // Aflați ora de începere a scriptului $start_array = explode(" ",$start_time); // Separați secunde și milisecunde $start_time = $start_array; // obține ora de începere a scriptului $max_exec = ini_get("max_execution_time"); //Obțineți timpul maxim de rulare posibil al scriptului
Practic, un ciclu. Comentarii în cod.

Do( $nowtime = time(); // Ora curentă //// Dacă ora curentă este în matricea cu timpii de execuție a scriptului...... if (in_array($nowtime, $_SESSION["num_st"]) ) ( // Ne agățăm de fișierul cu conținutul principal al acțiunilor $http = fsockopen("test.ru",80); /// în același timp îi transmitem datele sesiunii și ora la care ar trebui fputs de lucru($http, "GET http://test .ru/exec.php?".session_name()."=".session_id()."&nowtime=$nowtime HTTP/1.0\r\n"); fputs ($http, "Gazdă: test.ru\r\ n"); fputs($http, "\r\n"); fclose($http); ) //// a efectuat acțiunea specificată // Aflați ora curentă pentru a verifica dacă se continuă bucla sau repornirea $now_time = microtime(); $now_array = explode(" ",$now_time); $now_time = $now_array; // scade inițialul $exec_time = $now_time - $start_time+$ exec_time; /// încetinește pentru o secundă usleep(1000000); //Oprește rularea scriptului în fundal. Nu m-am gândit la nici un alt mod. if (file_exists("stop.txt")) exit; //Verificați timpul de rulare, dacă au mai rămas mai puțin de 5 secunde înainte de sfârșitul scriptului, //terminăm bucla. ) while($exec_time< ($max_exec - 5));

Ei bine, dacă timpul permis se termină, atunci completăm ciclul și rulăm în siguranță același script printr-un alt proces (ne vom întâlni cu siguranță 5 secunde)

// Rulați același script cu un nou proces și părăsiți cel curent $http = fsockopen("test.ru",80); fputs($http, "GET http://test.ru/index.php?".session_name()."=".session_id()."&bu=$max_exec HTTP/1.0\r\n"); fputs($http, „Gazdă: test.ru\r\n”); fputs($http, "\r\n"); fclose($http);

Când am terminat totul, am rămas nedumerit de aplicația utilă... O poți folosi ca serviciu. Poate monitoriza ceva în rețea și vă poate notifica, de exemplu, prin poștă. Și nu aveți nevoie de nici un cron.

Scriptul poate fi încă optimizat - nu a fost finalizat.
Apropo, de asta nu m-am putut desprinde - browserul încă trebuie deschis pentru a rula inițial scriptul.

Indiferent de serverul puternic pe care rulează scriptul tău, toată lumea este preocupată de viteza de execuție a acestuia. Încărcarea pe server depinde, de asemenea, de acest lucru (la unele hosting gratuit dat cantitate specifică timpul de procesare pe lună) și timpul după care site-ul va fi afișat utilizatorului (iar utilizatorii moderni sunt foarte critici cu privire la timpul de încărcare a site-ului).

Această viteză poate fi determinată foarte simplu folosind funcția microtime().
În mod implicit, funcția returnează un șir în formatul „msec sec”, unde sec este numărul de secunde de la începutul epocii Unix (Epoca Unix, 1 ianuarie 1970, 00:00:00 GMT) și msec este partea fracționată.
Dar dacă funcția este apelată cu parametrul opțional microtime([ bool $get_as_float ] ), atunci cu condiția ca argumentul transmis get_as_float, egal cu TRUE sau 1 , va returna un număr real, adică:

echo microtime(); //get 0.79687900 1234083984 echo microtime(0); //get 0.79687900 1234083984 echo microtime(false); //get 0.79687900 1234083984 echo microtime(1); //obține 1234083984.79 echo microtime(true); //obține 1234083984.79
De aici rezultă că, după ce a scris chiar la început script php linia:
$time_start_script = microtime(1);
iar la sfârșitul scenariului:
$time_stop_script = microtime(1); $time_script_work = $time_stop_script - $time_start_script; echo $time_script_work;

vom obține timpul de execuție al scriptului, care este suficient pentru a evalua în mod adecvat viteza de execuție a acestuia.

Ei bine, dacă vă amintiți despre „bicicletă”, atunci puteți obține ora cu o precizie de 10-15 zecimale (cel puțin am obținut exact atât de mult în funcție de timpul de execuție a scriptului), dar acest lucru va afecta în mare măsură execuția scriptului timp, spre deosebire de exemplul de mai sus, dar veți afla despre o altă caracteristică utilă.
Să scriem o linie chiar la începutul scriptului php:
$time_start_script = microtime(); $time_start_script = explode(" ", $time_start_script); $time_start_script = $time_start_script["0"] + $time_start_script["1"];
iar la sfârșitul scenariului:
$time_stop_script = microtime(); $time_stop_script = explode(" ", $time_stop_script); $time_stop_script = $time_stop_script["0"] + $time_stop_script["1"]; $time_script_work = $time_stop_script - $time_start_script; echo $time_script_work." sec";
Acest exemplu iese în cazul meu 0,000353097915649 sec.
Acum să vedem ce este această funcție ciudată explode().
array explode(șir $separator, șir $șir[, int $limită])
Funcția returnează o matrice de șiruri obținute prin împărțirea șirului de caractere folosind separator ca delimitator. Dacă argumentul limită este trecut, tabloul va conține maximum de elemente limit, ultimul element conținând restul șirului.
Dacă separatorul este șirul gol (""), explode() returnează FALSE. Dacă separatorul nu este conținut în șir, atunci explode() returnează o matrice care conține un element din șir.
Exemplu de utilizare: $pizza = "bucata1 bucata2 bucata3 bucata4 bucata5 bucata6"; $bucăți = explode(" ", $pizza); eco $bucăți; // bucată1 echo $bucăți; // bucata2
Practic asta este. Acum puteți evalua viteza scripturilor pe care le-ați scris.
Fișierul atașat are codurile sursă scripturile date aici, în timp ce, pentru ca scriptul să ruleze mai mult, conține o buclă goală care se execută de un milion de ori :).
Noroc!

Salutări, dragi cititori ai blogului webcodius! Deci, direct la obiect. În primul rând, voi răspunde la a doua parte a întrebării: de ce ai putea avea nevoie măsoară timpul de execuție a scriptului?.Când lucrați la depanarea proiectelor web, un factor important care trebuie luat în considerare este timpul de execuție al scripturilor. Acest parametru este necesar pentru a înțelege cât de rapid și eficient funcționează această sau acea bucată de cod. Determinând timpul petrecut de server pentru a executa script-ul php, puteți concluziona dacă optimizarea codului este necesară sau nu. Să vedem cum să o facem în continuare.

Pentru a analiza performanța scripturilor php, există diverse extensii și biblioteci, cum ar fi XDebug, care pot depana scripturile și le pot profila în funcție de timpul de execuție. Dar pentru a folosi astfel de extensii, trebuie să petreceți timp instalându-le și configurându-le. Desigur, pentru a optimiza munca proiectelor mari cu o arhitectură complexă, un număr mare de scripturi și milioane de linii de cod, este mai bine să folosiți astfel de extensii. Dar dacă trebuie să optimizați 3-4 scripturi cu una sau două sute de linii de cod, atunci puteți utiliza doar instrumente php pentru a măsura timpul de rulare a scriptului.

cum se verifică timpul de execuție a scriptului în php

Învață să creezi motoare profesionale în PHP și MySQL

Această sarcină este ușor de rezolvat folosind funcții de dată și oră, și anume funcția încorporată microtime(), care returnează numărul de secunde care au trecut de la miezul nopții 01/01/1970. Apelând de două ori această funcție, putem calcula timpul scurs între apeluri:

Dacă rulați scriptul, rezultatul va fi cam așa:

Timp de execuție a scriptului: 0,00059400000000001

Pe scurt cum funcționează. Folosind funcția microtime(true), stocăm marcajul de timp al începerii scriptului în variabila $start. Urmează codul de lucru care efectuează unele acțiuni. În acest exemplu, funcția usleep() este apelată pur și simplu, ceea ce încetinește scriptul cu numărul specificat de microsecunde. Și apoi obținem ora de încheiere a scriptului, o stocăm în variabila $end și calculăm timpul de execuție a codului scăzând $start din $end . Ca rezultat, am obținut timpul de execuție al scriptului.

Acum știind cum să determine timpul de execuție a scriptului php, puteți începe optimizarea diferitelor blocuri de cod. Succes și ne vedem în următoarele postări!

La depanarea scripturilor, un factor obligatoriu care trebuie luat în considerare în primul rând este timpul de executare a scriptului. Și în acest scurt articol voi arăta o modalitate foarte bună și simplă, cum se verifică timpul de execuție al unui script.

Se bazează pe funcții pentru lucrul cu data și ora. Să aruncăm o privire la un exemplu pentru a înțelege cum funcționează. calculul timpului de executare a scriptului:

$start = microtime(true);
$sum = 0;
pentru ($i = 0; $i< 100000; $i++) $sum += $i;
echo "Timp executie script: ".(microtime(true) - $start);
?>

Ca urmare, vom vedea asta timpul de executare a scriptului ar fi, de exemplu: 0.014652967453 ". Dacă este rotunjită, atunci aceasta 0.015 secunde. Acesta este timpul de execuție a scriptului.

Acum despre cum funcționează. Funcţie microtimp() cu valoarea transmisă Adevărat returnează numărul de secunde de la miezul nopții 01.01.1970 , iar această valoare este calculată la sutimi de secundă.

Urmează scriptul obișnuit, pe care îl verificăm. În loc de acesta, desigur, va fi scenariul tău. Și, în sfârșit ultima linie există o diferență între ora curentă (după execuția scriptului) și ceea ce am înregistrat la începutul scriptului. Diferența dintre timpul de după execuția scriptului și timpul de dinainte de începerea lucrului său, și există timpul de executare a scriptului.

Cred că aici este simplu. Dar iti recomand cu caldura sa folosesti aceasta metoda de a numara timpul. De exemplu, când îmi depanam motorul, pe care se bazează acest site, i-am accelerat activitatea aproape 2 ori.

Indiferent cât de mult folosim PHP, apar încă unele funcții despre care nici nu am auzit. Unele dintre ele ne-ar fi foarte utile. Am creat o listă mică caracteristici utile, care ar trebui să fie în arsenalul fiecărui programator PHP.

1. Crearea de funcții cu un număr variabil de argumente

Probabil știți deja că PHP ne permite să creăm funcții cu argumente opționale. Acum voi arăta o funcție în care numărul de argumente se poate schimba de la caz la caz.

Dar mai întâi, să ne amintim cum creăm funcții în mod obișnuit:

// funcția cu doi parametri opționali function foo($arg1 = "", $arg2 = "") ( echo "arg1: $arg1\n"; echo "arg2: $arg2\n"; ) foo("bună", "lume"); /* ieșire: arg1: salut arg2: lume */ foo(); /* ieșire: arg1: arg2: */

Acum să vedem cum puteți scrie o funcție cu un număr nelimitat de argumente. Pentru aceasta, se va folosi metoda func_get_args():

// nu specifica argumente function foo() ( // returneaza o matrice de argumente trecute $args = func_get_args(); foreach ($args ca $k => $v) ( echo "arg".($k+1) ." : $v\n"; ) ) foo(); /* nu scoate nimic */ foo("bună ziua"); /* ieșire arg1: salut */ foo("bună", "lume", "din nou"); /* ieșire arg1: salut arg2: lume arg3: din nou */

2. Folosiți Glob() pentru a găsi fișiere

Adesea, numele funcțiilor vorbesc de la sine. Nu același lucru se poate spune despre funcția glob().

Fără a intra în detalii, funcționalitatea sa este similară cu metoda scandir(). Vă permite să găsiți fișierul necesar după model:

// găsiți toate fișierele php $fișiere = glob("*.php"); print_r($fisiere); /* ieșire: Array ( => phptest.php => pi.php => post_output.php => test.php) */

Pentru a găsi fișiere de mai multe tipuri, trebuie să scrieți astfel:

// găsiți toate fișierele php și txt $fișiere = glob("*.(php,txt)", GLOB_BRACE); print_r($fisiere); /* ieșire: Array ( => phptest.php => pi.php => post_output.php => test.php => log.txt => test.txt) */

De asemenea, puteți specifica calea în șablon:

$fișiere = glob("../images/a*.jpg"); print_r($fisiere); /* ieșire: Array ( => ../images/apple.jpg => ../images/art.jpg) */

Pentru a obține calea completă către un document, utilizați metoda realpath():

$fișiere = glob("../images/a*.jpg"); // Aplică funcția „realpath” fiecărui element al matricei $fișiere = array_map(„realpath”,$fișiere); print_r($fisiere); /* ieșire: Array ( => C:\wamp\www\images\apple.jpg => C:\wamp\www\images\art.jpg) */

3. Informații despre memoria utilizată

Dacă urmăriți cantitatea de memorie consumată de scripturile dvs., atunci probabil că le veți optimiza mai des.

PHP are un instrument puternic de urmărire a memoriei. În diferite părți ale scriptului, încărcările pot fi diferite. Pentru a obține valoarea memoriei utilizate în acest moment, ar trebui să folosim metoda memory_get_usage(). Pentru a fixa cantitatea maximă de memorie utilizată, utilizați memory_get_peak_usage()

echo „Inițial: „.memory_get_usage().” octeți \n”; /* Inițial: 361400 octeți */ // oferă o încărcare mică pentru ($i = 0; $i< 100000; $i++) { $array = md5($i); } // и ещё for ($i = 0; $i < 100000; $i++) { unset($array[$i]); } echo "Final: ".memory_get_usage()." bytes \n"; /* Final: 885912 bytes */ echo "Peak: ".memory_get_peak_usage()." bytes \n"; /* Peak: 13687072 bytes */

4. Informații despre procesor

Pentru a face acest lucru, trebuie să utilizați metoda getrusage(). Dar rețineți că această caracteristică nu va funcționa pe Windows.

Print_r(getrusage()); /* imprimă Array ( => 0 => 0 => 2 => 3 => 12692 => 764 => 3864 => 94 => 0 => 1 => 67 => 4 => 0 => 0 => 0 => 6269 => 0) */

Imaginea prezentată mai sus va fi clară pentru cei care au experiență în acest domeniu administrarea sistemului. Pentru toți ceilalți, oferim o decriptare:

• ru_oubloc: numărul de scrieri în bloc
• ru_inblock: numărul de citiri de bloc
• ru_msgsnd: numărul de mesaje trimise
• ru_msgrcv: numărul de mesaje primite
• en_maxrss: dimensiune maximă set nepaginabil
• ru_ixrss: memorie totală partajată
• ru_idrss: cantitatea totală de date nepartajate
• ru_minflt: numărul de pagini de memorie utilizate
• ru_majflt: numărul de erori de pagină
• ru_nsignals: numărul de semnale primite
• ru_nvcsw: numărul de comutări de context în funcție de proces
• ru_nivcsw: numărul de comutări de context forțate
• ru_nswap: numărul de accesări la disc în timpul paginii
• ru_utime.tv_usec: timpul petrecut în modul utilizator (microsecunde)
• ru_utime.tv_sec: timpul petrecut în modul utilizator (secunde)
• ru_stime.tv_usec: timp în modul privilegiat (microsecunde)
• ru_stime.tv_sec: timp în modul privilegiat (secunde)

Pentru a afla ce resurse ale procesorului dumneavoastră sunt folosite de script, aveți nevoie de valoarea „user time” (timp în modul utilizator) și „system time” (timpul în modul privilegiat). Puteți obține rezultatul atât în ​​secunde, cât și în microsecunde. Pentru a converti numărul total de secunde într-un număr zecimal, trebuie să împărțiți valoarea microsecundelor la 1 milion și să adăugați secunde la valoare.

Cumva confuz. Iată un exemplu:

// odihnă 3 secunde somn(3); $date = getrusage(); echo „Timp utilizator:”. ($date["ru_utime.tv_sec"] + $data["ru_utime.tv_usec"] / 1000000); echo „Ora sistemului: „. ($date["ru_stime.tv_sec"] + $date["ru_stime.tv_usec"] / 1000000); /* imprimă Ora utilizator: 0,011552 Ora sistem: 0 */

Deși scriptul a durat aproximativ 3 secunde, procesorul nu a fost încărcat foarte mult. Problema este că la un apel (sleep) scriptul practic nu consumă resurse ale procesorului. În general, există multe sarcini care necesită o perioadă semnificativă de timp, dar nu folosesc procesorul. De exemplu, așteptarea operațiunilor legate de disc. Deci nu folosiți întotdeauna timpul CPU în scripturile dvs.

Iată un alt exemplu:

// mers de 10 milioane de ori 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); /* выводит User time: 1.424592 System time: 0.004204 */

Scriptul a durat 1,4 secunde de timp CPU. În acest caz, timpii apelurilor de sistem sunt în general mici.

Timpul modului privilegiat (System Time) este timpul pe care procesorul îl petrece executând cereri de sistem către nucleu în numele programului. Exemplu:

$start = microtime(true); // apel microtime la fiecare 3 secunde în timp ce(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); /* выводит User time: 1.088171 System time: 1.675315 */

Acum, timpul sistemului a fost cheltuit mult mai mult decât în ​​exemplul anterior. Totul datorită metodei microtime (), care utilizează resurse de sistem.

Cu toate acestea, trebuie remarcat faptul că ora afișată poate să nu fie exactă, deoarece. în acest moment, resursele procesorului sunt folosite și de alte programe, ceea ce poate duce la o mică eroare.

5. Constante magice

Există multe constante magice în PHP, cum ar fi numărul de linie curent (__LINE__), calea fișierului (__FILE__), calea directorului (__DIR__), numele funcției (__FUNCTION__), numele clasei (__CLASS__), numele metodei (__METHOD__) și spațiile de nume (__NAMESPACE__) .

Nu le vom lua în considerare pe toate. Să ne uităm doar la câteva:

// acest script depinde de locația curentă a fișierului și // poate cauza probleme dacă este folosit din directoare diferite require_once("config/database.php"); // acest script nu va cauza probleme require_once(dirname(__FILE__) . "/config/database.php");

Utilizați __LINE__ când depanați scripturile:

// cod // ... my_debug("un mesaj de depanare", __LINE__); /* ieșire Linia 4: un mesaj de depanare */ // mai mult cod // ... my_debug("un alt mesaj de depanare", __LINE__); /* ieșire Linia 11: un alt mesaj de depanare */ function my_debug($msg, $line) ( echo "Line $line: $msg\n"; )

6. Generarea de ID-uri unice

Există momente când trebuie să generați un șir unic. De multe ori am văzut că funcția md5() este folosită pentru a rezolva această problemă:

// generează un șir aleatoriu echo md5(time() . mt_rand(1,1000000));

Dar, de fapt, PHP are o funcție specială uniqid() în acest scop.

// generează un șir aleatoriu echo uniqid(); /* scoate 4bd67c947233e */ // încă o dată echo uniqid(); /* imprimă 4bd67c9472340 */

Cu ochiul liber, puteți vedea că primele caractere sunt cel puțin asemănătoare... Acest lucru se datorează faptului că această metodă folosește timpul serverului pentru a genera caractere. Este chiar util, pentru că. toate valorile generate sunt obținute în ordine alfabetică, ceea ce face posibilă sortarea rapidă a acestora.

Pentru a reduce șansele de a obține un duplicat, putem adăuga un prefix sau folosim un al doilea parametru (mărește numărul de caractere):

// prefixat cu echo uniqid("foo_"); /* ieșire foo_4bd67d6cd8b8f */ // cu al doilea parametru echo uniqid("",true); /* iese 4bd67d6cd8b926.12135106 */ // ambele echo uniqid("bar_",true); /* printează bar_4bd67da367b650.43684647 */

Această metodă generează linii mai mici decât md5, astfel încât să puteți economisi spațiu.

7. Serializare

Ați fost nevoit vreodată să stocați date complexe într-o bază de date sau într-un fișier? Pentru a converti un obiect într-un șir, PHP oferă o funcție specială.

În general, aceste metode sunt 2: serialize() și unserialize()

// matrice complexă $myvar = array("bună ziua", 42, matrice(1,"două"), "măr"); // convertesc în șir $șir = serialize($myvar); echo $șir; /* ieșire a:4:(i:0;s:5:"bună ziua";i:1;i:42;i:2;a:2:(i:0;i:1;i:1;s :3:"două";)i:3;s:5:"măr";) */ // obține valoarea inițială $newvar = unserialize($string); print_r($newvar); /* imprimă Array ( => salut => 42 => Array ( => 1 => doi) => Apple) */

Așa funcționează aceste funcții. Cu toate acestea, datorită creșterii rapide a popularității JSON, 2 metode json_encode() și json_decode() au fost adăugate în PHP 5.2. Munca lor este similară cu serialize():

// matrice complexă $myvar = array("bună ziua", 42, matrice(1,"două"), "măr"); // convertește în șir $șir = json_encode($myvar); echo $șir; /* afișează ["hello",42,,"apple"] */ // restabilește valoarea originală $newvar = json_decode($string); print_r($newvar); /* imprimă Array ( => salut => 42 => Array ( => 1 => doi) => Apple) */

Această opțiune este mai compactă și compatibilă cu alte limbi, cum ar fi JavaScript. Cu toate acestea, atunci când lucrați cu obiecte foarte sofisticate, poate apărea pierderea de date.

8. Compresia șirurilor

Când vorbim despre compresie, arhivați fișierele în Format ZIP. PHP oferă capacitatea de a comprima șiruri lungi fără fișiere.

În următorul exemplu, vom demonstra funcționarea funcțiilor gzcompress() și gzuncompress():

$string = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc ut elit id mi ultricies adipiscing. Nulla facilisi. Praesent pulvinar, sapien vel feugiat vestibulum, nulla dui pretium orci, non ultricies elit lacus quis ante. Lorem ipsum dolor sit amet , consectetur adipiscing elit. Aliquam pretium ullamcorper urna quis iaculis. Etiam ac massa sed turpis tempor luctus. Curabitur sed nibh eu elit mollis congue. Praesent ipsum diam, consectetur vitae ornare a, aliquam a nunc. In id magnare pellentes seded non mipis pos magnaere seded non metus, at lacinia augue. Sed magna nisi, ornare in mollis in, mollis sed nunc. Etiam at justo in leo congue mollis. Nullam in neque eget metus hendrerit scelerisque eu non enim. Ut malesuada lacus eu nulla bibendum id euismod urna sodales ." ; $comprimat = gzcompress($șir); echo „Dimensiune originală:”. strlen($șir)."\n"; /* imprimă Dimensiunea originală: 800 */ echo "Dimensiune comprimată: ". strlen($comprimat)."\n"; /* ieșire Dimensiune comprimată: 418 */ // return $original = gzuncompress($compressed);

Putem reduce cantitatea de text cu 50%. În același scop, puteți utiliza metodele gzencode() și gzdecode(), care folosesc un alt algoritm de compresie.

9. Rulați înainte de finalizare

PHP are o funcție register_shutdown_function() care vă va permite să executați un anumit cod înainte ca scriptul să se încheie.

Să presupunem că doriți să aflați câteva informații... Timpul de rulare a scriptului:

// obține ora de începere $start_time = microtime(true); // unele operații // ... // imprimă timpul de rulare echo "execuția a durat: ". (microtime(true) - $start_time). „secunde.”;

La prima vedere, aceasta poate părea o sarcină banală. În aceste scopuri, puteți pune codul la sfârșitul fișierului. Cu toate acestea, dacă funcția exit() undeva funcționează înainte, acest cod nu va funcționa niciodată. De asemenea, nu va funcționa dacă există o eroare pe pagină sau utilizatorul întrerupe încărcarea paginii (făcând clic pe butonul corespunzător din browser);

Când utilizați metoda register_shutdown_function(), codul va fi executat oricum:

$start_time = microtime(true); register_shutdown_function ("închiderea_mea"); funcția my_shutdown() ( global $start_time; ecou "execuția a durat: ". (microtime(true) - $start_time). " secunde."; )

Ieșire

PHP este o întreagă planetă care nu încetează să ne uimească cu conținutul său. Ce părere aveți despre aceste caracteristici?