Home
About
Search
🌐
English Română
  • Closures and lambda functions in PHP vs. JavaScript

    Citește postarea în română

    Apr 16, 2011 anonymous functions closures JavaScript lambda PHP php5.3
    Share on:

    JavaScript and PHP support both lambda functions and closures. But the terms are poorly understood in both programming languages ​​and are often confused with each other.

    Lambda functions

    Also called anonymous functions. They refer to functions that can be called without being bound to an identifier. One of their purposes is to be passed as arguments. The Lambda name was introduced by Alonzo Church, inventor of lambda calculus in 1936. In lambda calculus all functions are anonymous.

    JavaScript

    In JavaScript lambdas are part of the standard set and there are the preferred method of defining functions.

    For instance:

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

    Lambda functions are used almost in any context when it comes to JavaScript, like:

    1window.onload = function (e) {
    2     alert('The page has loaded!');
    3}
    

    PHP

    In PHP, lambda functions were introduced in version 4.0.1 using create_function. In version 5.3+ a similar syntax to JavaScript was added, a much more readable and elegant way of defining a function.

    This means that in PHP there are two ways of creating a lambda function:

     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 $a(1,2); // 3
    

    Lambda functions can be used as parameter for other functions, such as 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});
    

    Even more, PHP 5.3+ allows calling an object as a anonymous function:

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

    Closures

    The closure is really the misunderstood concept of the two. In general confusion appears because closures may involve lambda functions. A closure refers to the ability of a function/object to access the scope in which it was created even if the parent function has ended it’s execution and returned. In other words, the function/object returned by a closure is running in the scope in which it was defined.

    In JavaScript the notion of closure is part of the standard arsenal, because the language is not based on the traditional object model, but rather on prototypes and functions. But JavaScript has some traditional object model parts, like the fact that you can use “new” to construct an object based on a function that plays the role of a class. In PHP closures are more of an new way to approach problems, because PHP is part of the traditional object model family.

    JavaScript

    In JavaScript the notion of closure is widely used, it’s so popular because JavaScript is not a traditional object orientated language, but rather a functional one, based on prototype inheritance.

    JavaScript doesn’t have Public, Private and Protected, but rather only Public and Private and objects an inherit from each other, without using classes.

    Another issue is the scope, because the global scope is used by default. This issues can be fixed in an elegant fashion using closures:

     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 the example above, sum is a private property and in theory can only be accessed and modified by the closure function. The interesting part is that the parentheses from the end of the function definition, signify that this function will be immediately  executed and therefore will return the result which is an object. At this point the original function will only exist for serving the return object, encapsulating therefor the private variable.

    Although the function has finished execution, through this closure the returned object can still access the variables defined in the function scope, because that was the environment in which it was created.

    This becomes even more interesting when a function returns another function:

     1var counter = function () {
     2    var counter = 0;
     3    console.log('in closure');
     4    return function () {
     5        console.log('in the anonymous function');
     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
    

    The output will be:

    1in closure
    2in the anonymous function
    31
    4in closure
    5in the anonymous function
    61
    7in the anonymous function
    82
    

    What actually happens is that the first function is executed and returns an anonymous function that can still access the environment in which it was created. In my opinion this is where the confusion between closures and lambda functions comes from, because a function returns another function.

    The difference between examples is that in the first one the closure function executes immediately, and in the second example when counter is executed it’s returning a result that is actually a function definition, which in turn can be executed. Of course the second example can be modified to act just like in the first example using parenthesis.

    PHP

    As I said above, the notion of closure in PHP is not as important as in JavaScript.

    Considering that lambda functions are available in the language since version 4, closures only appeared with PHP 5.3+.

    Because of the block scope nature of PHP, there is a better encapsulation but there is a lot less flexibility compared to JavaScript. Basically in PHP you must specify using the use instruction what will the anonymous function be able to access from the closure scope.

     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);
    

    Unlike JavaScript, in PHP closures can not return objects, or rather the object can not be bound to the scope in which it was created, unless you send the variables as a reference to the constructor, in which case is not very elegant and I can’t imagine a scenario that would absolutely need closure for this.

    Like in the JavaScript examples, instead of parentheses “()” at the end of the function, in PHP to run a function immediately after defining it call_user_func() or call_user_func_array() can be used:

     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);
    
  • Passing Zend PHP5.3 Certified Engineer Exam

    Citește postarea în română

    Jan 8, 2011 certificare certification certified php5.3 zce ZCE5.3 zend
    Share on:

    As I was saying in a previous blog, when Zend launched the new ZCE 5.3 certification I’ve received an discount voucher code, available until the end of year 2010. I wanted to use this opportunity, so in the last week of the year I’ve bought the voucher.

    I already had the experience of the ZCE 5 certification, about which I’ve blogged at that time.

    I wanted to take the exam before the end of the vacation, that is 7-I.

    The period was a little short, in theory, I had about two weeks to prepare, but because they ware around the hollydays the time was in fact way shorter.

    Zend PHP5 Certification Study Guide – 2nd Edition

    I’ve begin my study with Zend PHP5 Certification Study Guide – 2nd Edition. The book even though it does not have the latest 5.3 features is not outdated. Because it wasn’t the first time I was reading it, it felt more like a recap. I’ve tried for each chapter to create an example that will show the functionality and one that shows the cases where the functionality was not as expected. With all this in 4 days I was able to go through the entire book.

    As a suggestion, for streams and SPL for instance where is a little difficult to study directly form the manual, the guide looks like a good start.

    Because after all the book is a guide, as I was reading the book, I’ve looked in the corresponding chapters in the php.net manual for a more detailed view on the subjects.

    Mock tests

    Before I finished reading the first book I’ve took a PHP5 mock test and to my surprise the result was “Excellent”. I got the mock tests from when I took the ZCE 5 exam, and because a lot of the questions are repeat quite frequently, I’ve only used 3 back then. This time I’ve only took a couple of them for the same reason. The tests are quite useful for the PHP5 part because, just like there ware described, they are usual more complicated then the exam itself. But don’t take to many of them, especially if the first results are poor, because they may lead you in a false self trust because of the repetitive questions.

    Zend PHP 5.3 Study Guide

    When I’ve finished reading the first book I started reading the free Zend PHP 5.3 Study Guide, which can be downloaded from the certification page, in the right. The guide is in beta version and you can really feel that. Everyone who’s been talking (blogging) about it is saying that it is full of bugs, and after all that is true. One of the funniest bugs in my opinion is at page 109, question 12, the answer is D… which is not displayed in the page. But I believe that where there are bugs they will be easily discovered and will not mislead.

    It feels a lot more like a guide then the previous book, is a lot more concise and abstract and if forces you to study the manual.

    At the end of each chapter there are questions, I only had 100% on a couple of chapters. The questions a quite difficult, even more difficult then the questions in the actual exam in my opinion. You have to read each question carefully because in the exam there are the same type of questions.

    To go through the entire guide it took me another couple of days because I was already warmed up from the precedent book.

    The day before the exam

    I’ve read on Lorna “lornajane” Mitchell‘s blog that before the exam is good to recap some delicate subjects. In the day before the test I’ve started to recap some subjects that need more memory then intellect, like the tens of functions for string si array manipulation. Also I think is a good idea to recap SPL.

    The exam it self

    After not a lot of studding the moment of the exam was here.

    Just like the last time, I’ve schedule my exam over the Internet a day before and just went to the Pearson VUE center.

    The exam itself didn’t feel more difficult then the PHP 5 one. In my opinion there is more focus on high level OOP and SPL then the previous exam. The style of the questions is quite similar, maybe a little more “type in” questions, but that can be just my luck because the questions are dynamically selected from a question pool with different difficulty levels.

    The 90 minutes time has quite enough to go through all the questions whit all the attention required and to review the answers I wasn’t sure about. At the ZCE5 exam I’ve finished about a half of hour before the time. This time for ZCE 5.3 I’ve finished only 10 minutes early because I’ve tried not to rush at all.

    READ CAREFULLY! Is very important to read each question carefully and read in again until you are sure you understand what is required of you. Some questions have a quite awkward formulation and can mislead very easy. Don’t panic, if you have doubts maybe you should mark the question for review and come back to it in the end.

    I usually mark the first question of the exam for review because I’m nervous and I can’t focus enough.

    Unlike 2 years ago, when I was working a lot more with raw PHP and even had some PHP 4 servers, last year I’ve worked most of the time with open-source frameworks. This can be a disadvantage because I’ve didn’t use just as much the core functions. But unlike the first certification I must admit I didn’t study as much, probably is because of experience and the fact that occasionally I flick through the pages of the guide.

    And with that being said it is time to put the first check on the year resolution and add a new logo to my blog.

    For those who are preparing, I wish you the best of luck!

  • Another year has passed and PHP 6 will not arrive

    Citește postarea în română

    Dec 31, 2010 linux php5.3 php6 Symfony zce zend framework
    Share on:

    Another year has passed and PHP 6 will not arrive.

    Actually for the last couple of years I’ve been expecting PHP 6, and I believe this is more of a traditional blog for me to close the year.

    PHP 6 will not come because the trunk was abandoned and rebuild from a 5.3.

    Even if PHP 6 will not be out for a while now, PHP 5.3 is gaining popularity. Frameworks like Zend Framework and Symfony are each preparing in 2011 a 2.0 version that will need PHP 5.3+ to run. Even CodeIgniter, a framework that is was traditional PHP 4 compatible will need at least PHP 5.1.6 for version 2.0.

    Even more, the official Zend certification for PHP is now ZCE 5.3, and it’s becoming very popular, even if it was released just few months back.

    But a new year is ending and is time to check achievement from last year’s resolution and to write a new one.

    Last year I’ve finished my masters, and with it I’ve finished way to many years to want to count of school. In fact this is the firs winter that I’m not in some form of school, maybe this is why I feel like I have so much free time :).

    I’ve change my work place, and with it I was forced to use some things that were on my TODO list for quite some time:

    • Linux
    • Symfony Framework Linux was a subject around I was gravitating inevitable for years, but never got to in to deep. It was always on my “todo” list, but never got the time or patience to really get into much detail with it, or didn’t have the continuity when I did it. When I got to my new work place I found my self in front of a Ubuntu computer, and I’ve started to panic a little.

    After few months I’ve made a new step, and for the first time in my life I went to a professional course. The course was organised by Info Academy. Paid from my own pocket and a little overlapped with my work hours. But I’ve reached the conclusion that I had to do it. Probably it does not sound like a big deal, but I usually study on my own, and it was quite weird for me. Now that is over I can say that it was a great investment and I recommend it (to all from Romania that can go to this centre).

    Sometime during that course I’ve realised that it was time to boot in linux from time to time even at home. The next step was to reconfigure the boot manager to boot directly to linux. Now that I’m almost exclusively use linux, I’ve reached the conclusion that is user friendly enough to be a real alternative to Windows.

    Symfony framework is another dusty entry on my “todo” list. Even if I’ve been playing around before with CodeIgniter and Zend Framework, I’ve never even got near to Symfony until last year. I’ve felt the fundamental difference of concept between ZF and Symfony. This was another reason to panic at my new work place, and after all: “all frameworks suck”.

    Is not a very easy to learn framework because of the concepts, but I thing it worth it. What I like most about this framework is the CRUD generating, that is very easy to do but is very powerful and flexible. Another thing is the use of YML files, which was taken from Ruby on Rails, is a way better alternative to the PHP’s native ini files.

    In the end, 2010 was a good year, with lot’s of achievements, even if I didn’t check everything on my last year’s resolution, I think I’ve checked enough.

    And now I wish you a great and full of achievements 2011! Happy new year!

  • The new ZCE PHP 5.3 certification

    Citește postarea în română

    Oct 17, 2010 certification php5 php5.3 zce
    Share on:

    Since PHP 5.3 was released last year I’ve been wandering if Zend was going to introduce a new ZCE certification for this version.

    Seems like with the version PHP 6 abandoned some time back the direction was to a PHP 5.3 certification.

    I don’t think the time was random considering that Zend Con, the biggest PHP conference, is near.

    What’s new?

    Differences between PHP 5 and PHP 5.3 are in the manual here.

    Some of the most important once:

    • Namespaces
    • Late static binding
    • Lambda Functions and Closures

    Materials

    The certification information is on the Zend website.

    After finding that the certification for Zend Framework has a study guide completely free for registered users, I was wandering why there isn’t one for the regular PHP certification. It looks like now there is: Zend-PHP-5.3-Study-Guide-v1-3.pdf, in beta version! And is free for download!

    Of course the most important material remains the manual manualul PHP, because the guide is used in conjunction with it.

    It looks like the mock tests are out, as for the Zend Framework never existed anyway.

    Price

    The price has gone up, it isn’t 160$ anymore but 190$! The price remains a very small one anyway considering that an exam at Sun was 200$, and now at Oracle is 300$.

    The already certified users receive an 20% discount until the end of the year, so if you are already certified you will pay 152$.

    Best of luck!

  • Factory method pattern using PHP 5.3 and late static bindings

    Citește postarea în română

    Jan 24, 2010 Design patterns PHP php5 php5.3
    Share on:

    Factory method design pattern introduced by GoF (Gang of Four) which I’ve talked about in a previous blog, has the base idea of a method that generates objects. Most implementations are “poor”, because they use a lot of hard-coding for the factory (just like me in the previous blog).

    PHP 5.3 offers the possibility of a very interesting implementation using “Late static bindings“.

    The classes from which the objects will be generated are:

     1// abstract base class that will be inherited
     2abstract class Drink {
     3
     4    // ingredients
     5    protected $ingredients;
     6
     7    // public method for producing the drink
     8    abstract public function MakeDrink();
     9}
    10
    11// a child class for tea
    12class Tea_Drink extends Drink {
    13
    14    // ingredients for tea
    15    protected $ingredients = array('tea', 'sugar', 'mink', 'water');
    16
    17    // make tea
    18    public function MakeDrink() {
    19
    20        // make tea
    21    }
    22}
    23
    24// another class for Bloody Mary
    25class BloodyMary_Drink extends Drink {
    26
    27    // ingredients for Bloody Mary
    28    protected $ingredients = array('votka', 'salt', 'tomato juice');
    29
    30    // make Bloody Mary
    31    public function MakeDrink() {
    32
    33        // make BloodyMary
    34
    35    }
    36}
    

    The idea is to have an abstract factory class to extend as simple as possible when creating each new factory class.

    PHP 5

    In PHP 5 the class will look something like this:

     1// abstract Factory class
     2abstract class absFactory {
     3
     4    // name of the base class
     5    static protected $base_class = '';
     6
     7    // factory method
     8    public static function getInstance($type) {
     9
    10        // name of the resulting class
    11        $class_name = $type . '_' . self::$base_class;
    12
    13        // check if class exists
    14        // here you can add an autoloader
    15        if(!class_exists($class_name)) {
    16            throw new Exception( 'Class ' . $class_name . ' not loaded!');
    17        }
    18
    19        // check to see if the class inherits the base class
    20        if(!is_subclass_of($class_name, self::$base_class)) {
    21            throw new Exception(
    22                'Class ' . $class_name . ' is not a child of ' . self::$base_class
    23            );
    24        }
    25
    26        // new object
    27        return new $class_name;
    28
    29    }
    30
    31}
    

    Because the getInstance() method is static the property will be static too.

    If we try:

     1class DrinkFactory extends absFactory {
     2
     3    static protected $base_class = 'Drink';
     4}
     5
     6try {
     7
     8    $obj = DrinkFactory::getInstance('Tea');
     9
    10} catch (Exception $e) {
    11
    12    echo $e->getMessage();
    13}
    

    The output will be:

    1Class Tea_ not loaded!
    

    Because of the “self”, we can’t just call the method using the child class because the value of $base_class will be “” and not “Drink”, we must overwrite the getInstance() method. Which is quite “complicated”.

    A working version in PHP 5 will be:

     1class DrinkFactory extends absFactory {
     2
     3    public static function getInstance($type) {
     4
     5        self::$base_class = 'Drink';
     6
     7        // factory method of the base factory class
     8        parent::getInstance($type);
     9
    10    }
    11
    12}
    13
    14try {
    15
    16    $obj = DrinkFactory::getInstance('Tea');
    17
    18} catch (Exception $e) {
    19
    20    echo $e->getMessage();
    21}
    

    But is not exactly “elegant”.

    PHP 5.3

    Here we have “Late static bindings”, which is basically introducing the work “static”.

    The base factory class will look something like this:

     1// abstract Factory class
     2abstract class absFactory {
     3
     4    // name of the base class
     5    static protected $base_class = '';
     6
     7    // factory method
     8    public static function getInstance($type) {
     9
    10        // name of the resulting class
    11        $class_name = $type . '_' . static::$base_class;
    12
    13        // check if class exists
    14        // here you can add an autoloader
    15        if(!class_exists($class_name)) {
    16            throw new Exception( 'Class ' . $class_name . ' not loaded!');
    17        }
    18
    19        // check to see if the class inherits the base class
    20        if(!is_subclass_of($class_name, static::$base_class)) {
    21            throw new Exception(
    22                'Class ' . $class_name . ' is not a child of ' . static::$base_class
    23            );
    24        }
    25
    26        // new object
    27        return new $class_name;
    28
    29    }
    30
    31}
    

    A change so small allows us to create a much “nicer” factory class:

     1class DrinkFactory extends absFactory {
     2
     3     static protected $base_class = 'Drink';
     4
     5}
     6
     7try {
     8
     9    $obj = DrinkFactory::getInstance('Tea');
    10
    11} catch (Exception $e) {
    12
    13    echo $e->getMessage();
    14}
    

    Basically in this version only the relevant property in this context is overwritten.

    • ««
    • «
    • 1
    • 2
    • 3
    • »
    • »»

Claudiu Perșoiu

Programming, technology and more
Read More

Recent Posts

  • Is PHP dead in 2026?
  • 30 years of PHP
  • HTTPS certificate monitoring in Home Assistant
  • Adding a slider to Tasmota using BerryScript
  • The future proof project
  • Docker inside wsl2
  • Moving away from Wordpress
  • Custom path for Composer cache

PHP 51 MISCELLANEOUS 47 JAVASCRIPT 14 MAGENTO 7 MYSQL 7 BROWSERS 6 DESIGN PATTERNS 5 HOME AUTOMATION 3 LINUX-UNIX 2 WEB STUFF 2 GO 1

PHP 37 JAVASCRIPT 15 PHP5.3 11 MAGENTO 7 PHP6 7 MYSQL 6 PHP5.4 6 ZCE 6 CERTIFICARE 5 CERTIFICATION 5 CLOSURES 4 DESIGN PATTERNS 4 HACK 4 ANDROID 3
All tags
3D1 ADOBE AIR2 ANDROID3 ANGULAR1 ANONYMOUS FUNCTIONS3 BERRYSCRIPT1 BOOK1 BROWSER2 CARTE1 CERTIFICARE5 CERTIFICATION5 CERTIFIED1 CERTIFIED DEVELOPER1 CHALLENGE1 CHM1 CLASS1 CLI2 CLOSURES4 CODE QUALITY1 CODEIGNITER3 COFFEESCRIPT1 COLLECTIONS1 COMPOSER1 CSS1 DEBUG1 DESIGN PATTERNS4 DEVELOPER1 DEVELOPMENT TIME1 DOCKER2 DOCKER-COMPOSE1 DOUGLAS CROCKFORD2 ELEPHPANT2 FACEBOOK2 FFI1 FINALLY1 FIREFOX3 GAMES1 GENERATOR1 GO1 GOOGLE1 GOOGLE CHROME1 GOOGLE MAPS1 HACK4 HOMEASSISTANT3 HTML2 HTML HELP WORKSHOP1 HTML51 HUG1 HUGO1 INFORMATION_SCHEMA1 INI1 INTERNET EXPLORER3 IPV41 IPV61 ITERATOR2 JAVASCRIPT15 JQUERY1 LAMBDA1 LINUX1 MAGENTO7 MAGENTO22 MAP1 MINESWEEPER1 MOTIVATION1 MYSQL6 NGINX1 NODE.JS2 NOSQL1 OBSERVER3 OBSERVER PATTERN1 OOP1 OPERA1 OPTIMIZATION1 ORACLE1 PAGESPEED1 PAIR1 PARSE_INI_FILE1 PHONEGAP2 PHP37 PHP ELEPHANT2 PHP FOR ANDROID1 PHP-GTK1 PHP42 PHP53 PHP5.311 PHP5.46 PHP5.53 PHP5.61 PHP67 PHP7.41 PROGRAMMING1 REVIEW1 ROMANIAN STEMMER2 SAFARY1 SCALAR TYPE HINTING1 SCHEME1 SET1 SHOPPING CART PRICE RULE1 SINGLETON1 SOAP1 SPL2 SQLITE1 SSH1 STACK TRACE1 STDERR1 STDIN1 STDOUT1 SUN1 SYMFONY2 TASMOTA1 TEST TO SPEECH1 TITANIUM2 TRAITS1 TTS1 UBUNTU1 UNICODE2 UTF-82 VECTOR1 WEBKIT1 WINBINDER1 WINDOWS2 WORDPRESS1 WSL21 YAHOO3 YAHOO MAPS1 YAHOO OPEN HACK1 YSLOW1 YUI1 ZCE6 ZCE5.31 ZEND3 ZEND FRAMEWORK3
[A~Z][0~9]

Copyright © 2008 - 2026 CLAUDIU PERȘOIU'S BLOG. All Rights Reserved