在私有类方法中定义的php闭包中的静态变量

Question

So I re-wrote this to hopefully be clearer about what I'm attempting. During some parsing of data someValue(s) associated with someCode(s) are received. The intent is to capture a particularValue of a someCode having the lowest precedence, irrespective of the order the someCode/someValue (s) received. The issue keeping this from working is that the closure is created every time the private function is called and the value of $precedenceOfCodeCaptured therefore is always reset to null. If I could keep the closure around then things might work as intended.

private function Foo($particularValue, $someValue, $someCode) {

    switch ($someCode) {
        case:
            CODE1:
        case:
            CODE2:

            $c = function () use ($someCode, $someValue) {
                static $precedenceOfCodeCaptured = null;
                $precedenceArray = array(
                    CODE2 => 1,
                    CODE1 => 2
                );

                if ((is_null($someValue))) {//first time the case statement matched because $someValue==null
                    $precedenceOfCodeCaptured = $precedenceArray[$someCode];
                    $particularValue = someValue;
                } else if ($precedenceArray[$someCode] <= $precedenceOfCodeCaptured) {
                    $particularValue = someValue;
                }

            };

            $c();
            break;
            ...
    }

}//end of private method

Answer 1

Every time Foo is called, you create a new function/closure, since you evaluate a function(), and that's what evaluating function() does!

If you'd like to have Foo() return the same function/closure each time, only evaluate it once. Perhaps use a singleton pattern, where you'll check if some higher-scoped variable that holds the function has been initialized, and initialize it if not.

For example:

$c = null;

private function Foo(){

  if ($c == null) {
  $c = function() use ( $whatever){  
               static $x = 0;
               echo "x= $x";
               $x++; 
  ...
  };
}   

$c(); }//end of private method

(but please don't use globals in your actual code!)

Answer 2

Try this:

static $x = 0;
private function Foo() {
  $c = function() use ( $whatever){  
    echo "x= $x";
    self::$x++;
   ...
  };
  $c();
}

Answer 3

<?php

class example{
    private function foo(){
        static $_closure;
        if( ! $_closure ){
            $_closure = function(){
                static $_state;
                /*  . . .  */
            };
        }
        $_closure();
    }
}

Note that the closure is static (it is created on first use, and not again), as is the variable that holds state inside the closure.

However, as stated in other answers, this is "pointless" at best. $_closure should be another class method; $_state should be a class property (there is no need for static anything in the closure, in foo() , nor in the class). It is not "cleaner" or more readable or performant (in fact, the opposite is likely true) to use a closure like this.

It might make sense if you were doing something like:

• returning the closure for use elsewhere
• dynamically creating the function at runtime (ie, based on foo() args)
• something else dynamic and interesting

…but as it stands, this is simply the wrong approach. The tools to do this already exist.