Closures, de la Scheme la Javascript la PHP
Notiunea de closure in PHP, desi a aparut in PHP 5.3, a fost realizata intr-un mod adecvat abia in 5.4, asa cum am mai spus-o si pe blogul meu.
Wikipedia ne spune:
In computer science, a closure (also lexical closure or function closure) is a function or reference to a function together with a referencing environment—a table storing a reference to each of the non-local variables (also called free variables) of that function.
In PHP nu este un concept foarte popular sau foarte cunoscut. De multe ori acesta este confundat cu Anonymous Functions. In limbajele functionale totusi, acest concept este foarte popular, pentru ca acolo este cu adevarat nevoie de el!
Scheme
Cand Brendan Eich a conceput JavaScript, s-a bazat pe limbajul Scheme si a ajuns sa faca o implementare a acestuia cu o sintaxa de C. Sintaxa C era si este in continuare mult mai populara, iar atunci (1995) limbajul Java era foarte “la moda”.
Sintaxa Scheme este similara cu sintaxa Lisp, in sensul ca se folosesc paranteze in jurul expresiilor pentru a le rula. Operatorii sunt definiti ca si functii si la fel ca o si in cazul functiilor, se pun in partea stanga a parantezei.
Sa luam un exemplu de closure in Scheme:
1(define (make-counter)
2 (let ((count (begin
3 (display "run parent function and return 0")
4 )))
5 (lambda ()
6 (set! count (+ count 1))
7 (begin
8 (display "inside child function ")
9 count))))
Functia principala seteaza o variabila “count”, cu valoarea 0 si afisaza “run parent function and return 0”, apoi intoarce o alta functie lambda, care incrementeaza variabila definita in functia principala si apoi afisaza “inside child function”.
Functia rezultata din executia functiei principale o stochez intr-o variabila pentru a o putea rula ulterior de mai multe ori:
1> (define counter (make-counter))
2run parent function and return 0
3> (counter)
4inside child function 1
5> (counter)
6inside child function 2
Cu alte cuvinte, de fiecare data cand apelez (make-couter), acesta va intoarce o functie noua care are acces la mediul in care a fost creata. Daca pare ciudat din pricina sintaxei, promit ca in JavaScript va parea mult mai natural.
Acest concept este foarte interesant pentru incapsulare. Mediul la tipul cand functia parinte este executata se poate incapsula, iar ulterior se va folosi de accest mediu fara grija ca acesta se poate schimba din cauze exterioare.
Pentru limbajele functionale acesta este un concept foarte interesant. Cand vine vorba de limbaje obiectuale totusi, conceptul aproape inutil, pentru ca obiectele au si ele rolul de incapsulare.
JavaScript
JavaScript a fost de la inceput un hibrid, un limbaj functional, orientat obiect, cu mostenire bazata pe prototype. Iar daca acestea nu erau suficiente, sintaxa a fost preluata din Java (C).
JavaScript nu a mostenit multe de la Scheme, dar a mostenit conceptul de closure.
Un motiv pentru care era nevoie de closure in Scheme este acela ca daca o functie nu gaseste o variabila in mediul in care se afla, o va cauta in mediul superior. Sa luam un exemplu:
1(define x 1)
2(define (add-in-env y) (+ x y))
Daca apelam add-in-env cu 2:
1(add-in-env 2) -> 3
Pare la fel de ambiguu ca si in JavaScript, dar nu este tocmai asa. In Scheme sa faci mutatie nu e la fel de usor, simplu si transparent, deci o operatie ulterioara de:
1(define x 2)
va rezulta intr-o eroare.
In JavaScript a rezultat un hibrid. Mutatia este permisa, dar notiunea de a cauta o variabila in mediul in care te afli a ramas:
1var x = 1;
2var add_in_env = function (y) {
3 return x + y;
4}
5
6add_in_env(2); // rezulta 3
Pana aici e ok, dar pentru:
1x = 2;
2add_in_env(2); // rezulta 4
In acest caz, lucrurile scapa foarte usor de sub control.
Dar, ca sa rezolvam problema, putem pur si simplu sa definim variabila in mediul care isi va termina executia (se va inchide = will close):
1var make_counter = function () {
2 console.log("run parent function and set counter to 0")
3 var count = 0;
4
5 return function () {
6 count = count + 1;
7 console.log("inside child function");
8 return count;
9 }
10}
11
12var counter = make_counter();
13console.log(counter());
14console.log(counter());
15
16var counter2 = make_counter();
17console.log(counter2());
18console.log(counter());
19console.log(counter2());
Outputul va fi:
1run parent function and set counter to 0
2inside child function
31
4inside child function
52
6run parent function and set counter to 0
7inside child function
81
9inside child function
103
11inside child function
122
Chiar daca functia principala si-a terminat executia, mediul din interiorul ei este pastrat ca un closure pentru functia care a fost intoarsa. Doar in momentul in care si subfunctia nu mai are referinte catre ea memoria alocata pentru closure va fi dezalocata.
Chiar daca JavaScript are obiecte, acestea nu au metode private. O abordare este sa pui un “_” (underscore) in fata numelui functiei si sa o consideri privata. Din punctul meu de vedere asta este ca si cum ii rogi pe cei care vin dupa tine sa o considere o functie privata. Evident acest lucru nu este tocmai consistent.
Sa luam un exemplu:
1var obj = {
2 _secretFunction : function (key) { console.log(‘do secret ’ + key) },
3 doStuff : function (key) { this._secretFunction(key) }
4}
5
6obj.doStuff(‘stuff’); // do secret stuff
Aparent avem o metoda publica “doStuff” si una privata “_secretFunction”. Totusi nu poti preveni un utilizator sa apeleze “_secretFunction”, sau mai rau, sa o modifice:
1obj._secretFunction = function (key) { console.log('new secret ' + key); }
2
3obj.doStuff('stuff'); // new secret stuff
Daca vrem ca functia sa fie ascunsa, iar acest lucru sa fie evident pentru toata lumea, din nou putem folosi un closure:
1var obj = (function () {
2 var secretFunction = function (key) { console.log(‘do secret ’ + key) }
3
4 return {
5 doStuff : function (key) {
6 secretFunction(key)
7 }
8 }
9})();
10
11obj.doStuff(‘stuff’); // do secret stuff
Pentru ca functia parinte se va executa la inceput, practic spatiul in care a fost definit secretFunction si-a terminat deja executia, incapsuland logica. Obiectul intors poate sa apeleze functia pentru ca este definit in acelasi mediu ca si obiectul.
Pare complicat prima data, dar de fapt este foarte simplu cand intelegi conceptul.
Si apoi a fost… PHP
PHP inglobeaza multe optiuni diferite. PHP s-a dezvoltat initial ca un framework Perl, ulterior engine-ul fiind scris in C.
PHP este un limbaj dinamic care inglobeaza foarte multe concepte, de la obiecte, interfete si functii anonime, pana la goto labels. Nu este foarte clara directia in care ar trebui sa se dezolte limbajul, mai degraba ofera posibilitatea pentru abordari diferite.
In istoria ciudata a PHP, undeva in versiunea 4 a fost introdusa o sintaxa pentru Anonymous Functions, dar abia in PHP 5.3 a aparut o versiune mai “normala“.
Tot in versiunea 5.3 a fost introdusa si prima varianta de closures:
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
Versiunea functioneaza in mare parte, dar trebuie sa specifici ce vei trimite catre closure.
Si mai exista cateva inconveniente:
1<?php
2class Foo {
3 private function privateMethod() {
4 return 'Inside private method';
5 }
6
7 public function bar() {
8 $obj = $this;
9 return function () use ($obj) {
10 return $obj->privateMethod();
11 };
12 }
13}
14
15$obj = new Foo();
16$closure = $obj->bar();
17echo $closure();
18
19Fatal error: Call to private method Foo::privateMethod() from context '' in [...][...] on line 10
Nu functioneaza pentru ca nu poti trimite $this ca parametru la closure, iar daca faci artificiul de mai sus tot nu vei putea accesa metodele private. Nu uitati, asta se intampla in PHP 5.3.
Ideea de a introduce acest tip de closure mi se pare bizara. Nu este prima daca cand in PHP se introduce un feature “bizar”, dupa cum vorbeam mai sus si de Anonymous Function. Pare work in progress.
Cred ca toata lumea se astepta ca acest feature sa functioneze la fel ca in JavaScript. Cred ca doar datorita JavaScript conceptul de closure a devenit atat de popular.
In versiunea PHP 5.4 lucrurile s-au mai schimbat, avem in sfarsit closures asa cum ne asteptam:
1class Foo {
2 private function privateMethod() {
3 return 'Inside private method';
4 }
5
6 public function bar() {
7 return function () {
8 return $this->privateMethod();
9 };
10 }
11}
12
13$obj = new Foo();
14$closure = $obj->bar();
15echo $closure(); // Inside private method
Functioneaza!
Poti chiar sa spui:
1unset($obj);
2echo $closure();
si va functiona, pentru ca obiectul in interiorul caruia a fost definit closure-ul a ramas in memorie pana cand se va termina executia scriptului, sau se va apela:
1unset($closure);
Pentru mai multe detalii despre cum functioneaza closure in PHP 5.4, puteti citi acest blog.