Closure::bindTo

(PHP 5 >= 5.4.0, PHP 7, PHP 8)

Closure::bindTo — Dupliziert eine Closure mit einem neuen gebundenen Objekt und Geltungsbereich einer Klasse

Beschreibung

public Closure::bindTo(?object $newThis, object|string|null $newScope = "static"): ?Closure

Erzeugt eine neue anonyme Funktion mit demselben Funktionskörper und denselben gebundenen Variablen wie diese und gibt sie zurück, aber möglicherweise mit einem anderen gebundenen Objekt und einem neuen Geltungsbereich der Klasse.

Das "gebundene Objekt" bestimmt den Wert, den $this im Funktionskörper haben wird, und der "Klassenbereich" ist eine Klasse, die bestimmt, auf welche private und protected Mitglieder die anonyme Funktion zugreifen kann. Das heißt, die für die Funktion sichtbaren Mitglieder sind dieselben, als ob die anonyme Funktion eine Methode der im Parameter newScope übergebenen Klasse wäre.

Eine statische Closure kann zwar kein Objekt binden (der Wert des Parameters newThis muss null sein), aber diese Methode kann trotzdem verwendet werden, um den Geltungsbereich ihrer Klasse zu ändern.

Diese Methode stellt sicher, dass eine nicht-statische Closure mit einer gebundenen Instanz einen Geltungsbereich hat und umgekehrt. Zu diesem Zweck wird eine nicht-statische Closure, der zwar ein Geltungsbereich, dafür aber nur eine eine null-Instanz gegeben wird, statisch gemacht, und eine nicht-statische Closure ohne Geltungsbereich, die eine Nicht-null-Instanz erhält, kommt in den Geltungsbereich einer nicht spezifizierte Klasse.

Hinweis:
Wenn nur anonyme Funktionen dupliziert werden sollen, kann stattdessen cloning verwendet werden.

Parameter-Liste

newThis: Das Objekt, an das die angegebene anonyme Funktion gebunden werden soll, oder null wenn die Closure nicht gebunden werden soll.
newScope: Der Bereich der Klasse, dem die Closure zugeordnet werden soll, oder 'static', um den aktuellen Bereich beizubehalten. Wenn ein Objekt angegeben wird, wird stattdessen der Typ des Objekts verwendet. Dieser bestimmt die Sichtbarkeit der protected und private Methoden des gebundenen Objekts. Es ist nicht erlaubt, eine interne Klasse (oder ein Objekt einer solchen) als Parameter zu übergeben.

Rückgabewerte

Gibt ein neu erstelltes Closure-Objekt zurück oder null, wenn ein Fehler auftritt.

Beispiele

Beispiel #1 Closure::bindTo()-Beispiel

<?php

class A
{
    private $val;

    public function __construct($val)
    {
        $this->val = $val;
    }

    public function getClosure()
    {
        // Gibt eine Closure zurück, die an dieses Objekt und diesen
        // Bereich gebunden ist
        return function() {
            return $this->val;
        };
    }
}

$ob1 = new A(1);
$ob2 = new A(2);

$cl = $ob1->getClosure();
echo $cl(), "\n";

$cl = $cl->bindTo($ob2);
echo $cl(), "\n";

?>

Das oben gezeigte Beispiel erzeugt eine ähnliche Ausgabe wie:

1
2

Siehe auch

Anonyme Funktionen
Closure::bind() - Dupliziert eine Closure mit einem bestimmten gebundenen Objekt und Geltungsbereich einer Klasse

Improve This Page

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 8 notes

down

Nezar Fadle ¶

9 years ago

We can use the concept of bindTo to write a very small Template Engine:

#############
index.php
############

<?php

class Article{
    private $title = "This is an article";
}

class Post{
    private $title = "This is a post";
}

class Template{

    function render($context, $tpl){

        $closure = function($tpl){
            ob_start();
            include $tpl;
            return ob_end_flush();
        };

        $closure = $closure->bindTo($context, $context);
        $closure($tpl);

    }

}

$art = new Article();
$post = new Post();
$template = new Template();

$template->render($art, 'tpl.php');
$template->render($post, 'tpl.php');
?>

#############
tpl.php
############
<h1><?php echo $this->title;?></h1>

down

tatarynowicz at gmail dot com ¶

11 years ago

You can do pretty Javascript-like things with objects using closure binding:

<?php
trait DynamicDefinition {
    
    public function __call($name, $args) {
        if (is_callable($this->$name)) {
            return call_user_func($this->$name, $args);
        }
        else {
            throw new \RuntimeException("Method {$name} does not exist");
        }
    }
    
    public function __set($name, $value) {
        $this->$name = is_callable($value)? 
            $value->bindTo($this, $this): 
            $value;
    }
}

class Foo {
    use DynamicDefinition;
    private $privateValue = 'I am private';
}

$foo = new Foo;
$foo->bar = function() {
    return $this->privateValue;
};

// prints 'I am private'
print $foo->bar();

?>

down

safakozpinar at gmail dot com ¶

12 years ago

Private/protected members are accessible if you set the "newscope" argument (as the manual says).

<?php
$fn = function(){
    return ++$this->foo; // increase the value
};

class Bar{
    private $foo = 1; // initial value
}

$bar = new Bar();

$fn1 = $fn->bindTo($bar, 'Bar'); // specify class name
$fn2 = $fn->bindTo($bar,  $bar); // or object

echo $fn1(); // 2
echo $fn2(); // 3

down

Anonymous ¶

6 years ago

If you want to unbind completely the closure and the scope you need to set both to null:

<?php
class MyClass
{
    public $foo = 'a';
    protected $bar = 'b';
    private $baz = 'c';

    /**
     * @return array
     */
    public function toArray()
    {
        // Only public variables
        return (function ($obj) {
            return get_object_vars($obj);
        })->bindTo(null, null)($this);
    }
}
?>

In this example, only the public variables of the class are exported (foo).

If you use the default scope (->bindTo(null)) also protected and private variables are exported (foo, bar and baz).

It was hard to figure it out because there is nowhere mentioned in the documentation that you can use null as a scope.

down

luc at s dot illi dot be ¶

8 years ago

Access private members of parent classes; playing with the scopes:
<?PHP
class Grandparents{ private $__status1 = 'married'; }
class Parents extends Grandparents{ private $__status2 = 'divorced'; }
class Me extends Parents{ private $__status3 = 'single'; }

$status1_3 = function()
{
    $this->__status1 = 'happy';
    $this->__status2 = 'happy';
    $this->__status3 = 'happy';
};

$status1_2 = function()
{
    $this->__status1 = 'happy';
    $this->__status2 = 'happy';
};

// test 1:
$c = $status1_3->bindTo($R = new Me, Parents::class);            
#$c();    // Fatal: Cannot access private property Me::$__status3

// test 2:
$d = $status1_2->bindTo($R = new Me, Parents::class);
$d();
var_dump($R);
/*
object(Me)#5 (4) {
  ["__status3":"Me":private]=>
  string(6) "single"
  ["__status2":"Parents":private]=>
  string(5) "happy"
  ["__status1":"Grandparents":private]=>
  string(7) "married"
  ["__status1"]=>
  string(5) "happy"
}
*/

// test 3:
$e = $status1_3->bindTo($R = new Me, Grandparents::class);    
#$e(); // Fatal: Cannot access private property Me::$__status3

// test 4:
$f = $status1_2->bindTo($R = new Me, Grandparents::class);    
$f();
var_dump($R);
/*
object(Me)#9 (4) {
  ["__status3":"Me":private]=>
  string(6) "single"
  ["__status2":"Parents":private]=>
  string(8) "divorced"
  ["__status1":"Grandparents":private]=>
  string(5) "happy"
  ["__status2"]=>
  string(5) "happy"
}
*/
?>

Clear the stack trace:
<?PHP
use Exception;
use ReflectionException;

$c = function()
{
    $this->trace = [];
};

$c = $c->bindTo($R = new ReflectionException, Exception::class);
$c();

try
{
    throw $R;
}
catch(ReflectionException $R)
{
    var_dump($R->getTrace());
}
/*
array(0) {
}
*/
?>

down

amica at php-resource dot de ¶

12 years ago

With rebindable $this at hand it's possible to do evil stuff:

<?php
    class A {
        private $a = 12;
        private function getA () {
            return $this->a;
        }
    }
    class B {
        private $b = 34;
        private function getB () {
            return $this->b;
        }
    }
    $a = new A();
    $b = new B();
    $c = function () {
        if (property_exists($this, "a") && method_exists($this, "getA")) {
            $this->a++;
            return $this->getA();
        }
        if (property_exists($this, "b") && method_exists($this, "getB")) {
            $this->b++;
            return $this->getB();
        }
    };
    $ca = $c->bindTo($a, $a);
    $cb = $c->bindTo($b, $b);
    echo $ca(), "\n"; // => 13
    echo $cb(), "\n"; // => 35
?>

down

malferov at gmail dot com ¶

1 year ago

If you, like me, did not immediately understand what exactly "(an object of) an internal class" in the documentation about the 'newScope' parameter:



By an internal class, the documentation means any internal PHP class such as 'stdClass', 'Closure', 'WeakMap', and etc:



<?php



class A {}

$a = new A();

$closure = fn() => null;



$binded = $closure->bindTo($a, 'stdClass',); // Cannot bind closure to scope of internal class stdClass

$binded = $closure->bindTo($a, $closure,); // Warning: Cannot bind closure to scope of internal class Closure etc.

down

Olexandr Kalaidzhy ¶

2 years ago

Get all object vars without using Reflection:

<?php

declare(strict_types=1);

class A
{
    private $foo = 'foo';
    protected $bar = 'bar';
    public $buz = 'buz';
}

function get_object_vars_all($object): array
{
    if (!\is_object($object)) {
        throw new \InvalidArgumentException(sprintf('The argument should be an object, "%s" given.', get_debug_type($object)));
    }

    $closure = function () {
        return get_object_vars($this);
    };

    return $closure->bindTo($object, $object)();
}

$a = new A();

var_dump(get_object_vars($a));
var_dump(get_object_vars_all($a));

?>

The output: 

array(1) {
  ["buz"]=>
  string(3) "buz"
}
array(3) {
  ["foo"]=>
  string(3) "foo"
  ["bar"]=>
  string(3) "bar"
  ["buz"]=>
  string(3) "buz"
}

＋add a note