Exista momente cand ai nevoie sa vezi stack trace-ul, sa stii cum ai ajuns pana la un anumit punct. PHP are doua functii native pentru a realiza acest lucru: debug_backtrace() si debug_print_backtrace. Prima intoarce un array iar a doua afisaza stacktrace-ul pe ecran.

Problema in sine este ca acestea trebuie customizate pentru Magento, pentru ca este foarte posibil cand rulezi debug_backtrace() sa ramai fara memorie inainte sa poti trimite rezultatul catre un fisier de log.

Magento are o functie nativa pentru acest lucru: Varien_Debug::backtrace([bool $return = false], [bool $html = true], [bool $withArgs = true]). Pentru a trimite catre log stacktrace-ul se apeleaza pur si siplu:

1Mage::log(Varien_Debug::backtrace(true, false));

Aceasta tehnica este foarte utila in momentul in care vrei sa vezi de unde se initializeaza anumite obiecte si ce metode se ruleaza pana in acel moment.

Notiunea de Closure, a fost introdusa in PHP 5.3, o data cu o noua sintaxa, “mai traditionala” pentru functiile anonime.

PHP 5.3

In 5.3, un closure se baza pe termenul “use”, care transmite anumite variabile functiei anonime, transformand-o intr-un closure.

Problema este ca functia anonima nu va avea acces decat la variabilele trimise folosind “use”. In cazul obiectelor ele sunt trimise prin referinta, dar in cazul variabilelor scalare (int, string, etc.) acestea se transmit prin valoare, asa cum face implicit in PHP 5+:

 1$scalar = 5;
 2
 3$closure = function () use ($scalar) {
 4     return 'Scalar: ' . $scalar . PHP_EOL;
 5};
 6
 7echo $closure(); // Scalar: 5
 8
 9$scalar = 7;
10
11echo $closure(); // Scalar: 5

O alta problema este ca nu se pot trimite $this in cadrul obiectelor, deci doar proprietatile sau metodele care sunt publice nu pot fi accesate de closure.

PHP 5.4

In PHP 5.4 folosirea cuvantului “use” este optionala, iar tot mediul in care functia anonima a fost creata este disponibil in interiorul functiei.

Avantajul este ca atunci cand functia anonima este generata in interiorul unei alte functii, sau a unei metode, functia anonima va putea accesa mediul in care aceasta a fost creata chiar si dupa terminarea executiei acestuia. Obiectele din mediul creat se vor dezaloca de abea dupa ce se ultima referinta catre closure se va sterge:

 1class testClass {
 2
 3        private $changeableVar = 1;
 4        private $bigVar;
 5
 6        public function __construct() {
 7                // Allocate a big variable so we can see the changes in memory
 8                $this->bigVar = str_repeat("BigWord", 5000);
 9        }
10
11        /**
12         * O metoda care intoarce un closure
13         */
14        public function closure() {
15
16                return function () {
17                        // Display the value of a private property of the object
18                        echo 'Private property: ' . $this->changeableVar.PHP_EOL;
19
20                        // Change the value of a private property of the object
21                        $this->changeableVar = 2;
22                };
23        }
24
25        /**
26         * O metoda care afisaza o variabila privata
27         */
28        public function showChangeableVar() {
29                echo 'Private property in method: ' . $this->changeableVar.PHP_EOL;
30        }
31
32}
33
34// Memoria inainte sa fie alocat obiectul
35echo "Memory: " . memory_get_usage() . PHP_EOL; // Memory: 229896
36
37// Creare obiect
38$testObj = new testClass();
39
40// Creare closure
41$closure = $testObj->closure();
42
43// Executie closure
44$closure(); // Private property: 1
45
46// Afisare valoare curenta a proprietatii private
47$testObj->showChangeableVar(); // Private property in method: 2
48
49// Memoria inainte sa fie desalocat obiectul
50echo "Memory: ". memory_get_usage() . PHP_EOL; // Memory: 266240
51
52// Dezalocare obiect
53unset($testObj);
54
55// Memoria dupa ce a fost dezalocat obiectul, nu este o diferenta mare in memorie
56echo "Memory: ". memory_get_usage() . PHP_EOL; // Memory: 266152
57
58// Executie closure dupa ce obiectul in care a fost creata a fost dezalocat
59echo $closure(); // Private property: 2
60
61// Dezalocat closure si o data cu el mediul in care a fost generat
62unset($closure);
63
64// Memoria dupa ce a fost stearsa ultima referinta catre obiect
65echo "Memory: " . memory_get_usage() . PHP_EOL; // Memory: 230416

Callable type hinting

Inca un nou lucru introdus legat de closures introdus in PHP 5.4 este un nou “type hint”: “callable”. De fapt “callable” se refera la orice functie anonima, chiar si la un nou mod de a apela o metoda a unui obiect:

 1<?php
 2// O functie care foloseste type hinting
 3function typeHinting(callable $a) {
 4     echo $a() . PHP_EOL;
 5}
 6
 7// Un closure
 8$closure = function () {
 9     return __FUNCTION__;
10};
11
12// Apelare functie cu type hinting cu un closure ca argument
13typeHinting($closure); // {closure}
14
15class testClass {
16     public function testMethod() {
17          return __METHOD__;
18     }
19}
20
21// Un obiect de test
22$testObj = new testClass();
23
24// Noua forma de apelare a unei metode dintr-un obiect
25$objCallable = array($testObj, 'testMethod');
26
27// Apelare functie type hinting cu noua forma de apelare ca argument
28typeHinting($objCallable); // testClass::testMethod

Cred ca de abea acum este momentul sa spunem ca PHP suporta closures cu adevarat!

Intr-una din aventurile mele prin codul Magento, m-am lovit de urmatoarea problema: trebuia sa adaug un link la breadcrumb.

Cum documentatia nu e foarte bogata, dupa putin debug-ing (nu foarte mult), am ajuns in core la Mage_Page_Block_Html_Breadcrumbs.

Metoda este foarte auto-explicativa: addCrumb($crumbName, $crumbInfo, $after = false). Daca tot eram acolo am zis sa arunc un ochi in ea:

1function addCrumb($crumbName, $crumbInfo, $after = false)
2{
3  $this->_prepareArray($crumbInfo, array('label', 'title', 'link', 'first', 'last', 'readonly'));
4  if ((!isset($this->_crumbs[$crumbName])) || (!$this->_crumbs[$crumbName]['readonly'])) {
5    $this->_crumbs[$crumbName] = $crumbInfo;
6  }
7  return $this;
8}

Ce este interesant este parametul $after, dupa cum se poate observa, desi are chiar si o valoare default, nu se foloseste nicaieri. In rest functia functioneaza asa cum este de asteptat, probabil de asta nu se plange lumea atat de des.

JavaScript si PHP suporta atat functii lambda cat si closures. Dar termenii sunt putin intelesi in ambele libaje de programare si de multe ori sunt confundati.

Functii Lambda

Mai sunt numite si functii anonime. Acestea se refera la functii care pot fi apelate fara sa fie neaparat legate de un identificator. Unul din scopurile lor este de a fi pasate ca argumente. Numele de Lambda li se trage de la Alonzo Church, inventatorul lambda calculus in 1936. In lambda calculus toate functiile sunt anonime.

JavaScript

In JavaScript functiile lambda fac parte din setul de baza si reprezinta metoda preferata de creare a unei functii.

De exemplu:

1var add = function (a, b) {
2     return a + b;
3}
4alert(add(1, 2)); // 3

Functiile lambda sunt folosite aproape in orice context cand vine vorba de JavaScript, un exemplu este:

1window.onload = function (e) {
2     alert('Pagina s-a incarcat!');
3}

PHP

In PHP, functiile lambda au fost introduse de la versiune 4.0.1 folosind create_function. In versiunea 5.3+ a fost adaugata si sintaxa similara cu JavaScript, un mod mult mai lizibil si elegant de a definii o functie.

Asta inseamna ca in PHP exista doua moduri de a genera o functie lambda:

 1// PHP 4.0.1+
 2$add = create_function('$a, $b', 'return $a + $b;');
 3
 4// vs.
 5
 6// PHP 5.3+
 7$add = function ($a, $b) {
 8     return $a + $b;
 9};
10
11echo $add(1,2); // 3

Functiile lambda pot fi folosite ca parametru pentru alte functii, cum ar fi usort:

1$array = array(4, 3, 5, 1, 2);
2usort($array, function ($a, $b) {
3     if ($a == $b) {
4          return 0;
5     }
6     return ($a < $b) ? -1 : 1;
7});

Chiar mai mult, PHP 5.3+ permite apelarea unui obiect ca o functie anonima:

1class test {
2     function __invoke($a) {
3          echo $a;
4     }
5}
6$a = new test();
7$a('test'); // 'test'

Closures

Notiunea de closure este notiunea cu adevarat neinteleasa dintre cele doua. In general confuzia apare pentru ca implementarea de cloasure poate presupune si functii lambda. Un closure se refera la capacitatea unei functii/obiect de a accesa mediul in care aceasta a fost creat(a) chiar daca executia functiei parinte s-a terminat. Cu alte cuvinte functia/obiectul intors de un cloasure pastreaza mediul in care a fost definita.

In JavaScript notiunea de closure face parte din arsenalul de baza, pentru ca limbajul nu are la baza un model obiectual traditional ci unul bazat pe prototype si functii. Dar JavaScript mai are si cateva reminescente, cum ar fi faptul ca poti folosi “new” pentru a construi un obiect pe baza unei functii care joaca roul de clasa. In PHP este mai degraba o noua posibilitate de abordare a problemelor, PHP facand parte din familia de limbaje cu model obiectual traditional.

JavaScript
In JavaScript notiunea de closure este foarte folosita, iar popularitatea se datoreaza faptului ca JavaScript nu este un limbaj obiectual traditional, ci unul functional, bazat pe mostenire prototype.

In JavaScript nu exista notiunea de Public, Private si Protected, exista doar Public si Private iar obiectele pot mostenii unele de la altele, fara sa foloseasca clase.

O alta problema este mediul (scope), care in mod implicit este cel global. Prin closure aceste probleme pot fi rezolvate intr-un mod elegant:

 1var closure = function () {
 2     var sum = 0;
 3     return {
 4          add: function (nr) {
 5               sum += nr;
 6          },
 7          getSum: function () {
 8               return sum;
 9          }
10     }
11}();
12
13closure.add(1);
14closure.add(2);
15console.log(closure.getSum());

In exemplul de mai sus, sum este o proprietate privata iar aceasta teoretic, putea fi accesata si modificata doar din functia closure. Partea interesanta este ca parantezele de la finalul definitiei de functiei semnifica faptul ca aceasta functie se va si executa si deci va intoarce rezultatul care este un obiect. In acest moment functia initiala nu mai exista decat pentru a servi obiectul intors, incapsuland astfel variabila privata.

Desi functia si-a terminat executia, prin intermediu acestul closure obiectul returnat poate accesa variabilele definite in interiorul functiei, pentru ca este mediul in care a fost creeat.

Problema devine mai interesanta atunci cand o functie intoarce o alta functie:

 1var counter = function () {
 2    var counter = 0;
 3    console.log('in closure');
 4    return function () {
 5        console.log('in functia anonima');
 6        return ++counter;
 7    };
 8};
 9var counter1 = counter();
10
11console.log(counter1()); // 1
12
13var counter2 = counter();
14console.log(counter2()); // 1
15console.log(counter1()); // 2

Output-ul va fi:

1in closure
2in functia anonima
31
4in closure
5in functia anonima
61
7in functia anonima
82

Ce se intampla de fapt este ca prima functie se executa si intoarce o functie anonima care inca mai poate accesa mediul in care a fost creata. Dupa parerea mea de aici vine confuzia dintre closures si lambda functions, pentru ca o functie intoarce o alta functie.

Diferenta dintre exemple este ca in primul exemplu functia initiala de closure se executa imediat, iar in al doilea exemplu se poate vedea ca atunci cand counter se executa intoarce un rezultat, care este de fapt o definitie de functie, care la randul lui poate fi executata. Evident si acest exemplu poate fi adaptat sa se comporte precum cel precedent folosind paranteze la final.

PHP

Cum spuneam si mai sus, in PHP notiunea de closure nu este la fel de importanta ca in JavaScript.

Daca functiile lambda sunt disponibile in limbaj incepand cu versiunea 4, closure au aparut de abea dupa PHP 5.3+

Datorita mediului (scope) de executie care este de tip block in PHP se realizeaza o incapsulare mai buna dar si mai putin flexibila fata de JavaScript. Practic in PHP trebuie specificat cu ajutorul instructiunii use ce anume va putea accesa functia anonima din closure-ul care si-a terminat executia.

 1function closure () {
 2     $c = 0;
 3     return function ($a) use (&$c) {
 4          $c += $a;
 5          echo $a . ', ' . $c . PHP_EOL;
 6     };
 7}
 8
 9$closure = closure();
10
11$closure(1);
12$closure(2);

Spre deosebire de JavaScript in PHP nu se pot realiza closure care sa intoarca un obiect, sau mai bine zis obiectul nu poate fi legat de mediul in care a fost creat, decat sa zicem, daca nu se trimit parametrii la constructor prin referinta, metoda nu foarte eleganta care nu vad in ce scenariu ar avea neaparata nevoie de closure.

Ca o paralela la exemplele  de la JavaScript, in loc de parantezele “()” de la finalul functiei, in PHP pentru a executa functia imediat dupa definire se pot folosii call_user_func() sau call_user_func_array():

 1$closure = call_user_func(function () {
 2    $c = 0;
 3    return function ($a) use (&$c) {
 4        $c += $a;
 5        echo $a . ', ' . $c . PHP_EOL;
 6
 7    };
 8});
 9
10$closure(1);
11$closure(2);

De ce fisiere “ini”? Pentru ca sunt mult mai comode! Majoritatea serverelor din lumea *nix au fisiere de configurare de tip “ini” sau “conf”. In lumea PHP preferate sunt fisierele de configurare PHP, care in general sunt array-uri. Nu ar fi mult mai elegant sa fie un fisier ini care sa nu fie imbricat in cod PHP?

Din fericire PHP dispune de doua functii native care pot realiza acest lucru: parse_ini_file si parse_ini_string.

Principiul este foarte simplu, se da un fisier de configurare ini si functia va intoarce un array.

Un mic exemplu:

 1;config.ini
 2
 3[simple]
 4number = 1
 5another = 2
 6fraction = 0.2
 7
 8[escape]
 9path = /usr/bin/php
10url = https://blog.claudiupersoiu.ro
11error = '<a href="%path%">%error%</a>'
12
13[array]
141 = a
152 = b
163 = c

Pentru a parsa fisierul anterior:

1$config = parse_ini_file('config.ini', true);
2var_dump($config);

Parametrul al doilea specifica daca sectiunile vor deveni chei in array. Sincer nu vad in ce moment nu ar fi asta util.

Pare costisitor? De fapt pentru fisierul de mai sus este mai ieftin ca timp sa il parsezi din ini decat sa incluzi un array gata parsat. Diferenta pe calculatorul meu este de ~0.00002.

Dar fisierul de sus nu este tocmai mare, asa ca sa trecem la un fisier ini serios, cum ar fi php.ini. Aici diferenta a fost mai mare in favoarea array-ului care a castigat cu un avantaj de ~0.0003, adica aproximativ jumatate din parsare care a fost ~0.0006.

Avand in vedere ca masina mea este destul de puternica si multe cereri concurente pot adauga un overhead pentru un fisier mare, uneori este util un cache intr-un fisier de configurare.

Din fericire acest lucru este simplu de realizat in PHP.

1$cache = var_export($config, true);
2
3file_put_contents('cache/config.php', "<?php\n\$config = " . $cache . ';');

Acum nu mai trebuie inclus decat fisierul cache/config.php si evident regenerat atunci cand fisierul ini este modificat.

PHP trebuie sa aiba drept de scriere in directorul cache.