Closure::bindTo

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

Closure::bindTo — Duplica la closure con una nuova associazione all'oggetto e alla visibilità della classe

Descrizione

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

Crea e restituisce una nuova funzione anonima come questa con lo stesso corpo e con le stesse variabili associate, ma possibilmente con un altro oggetto associato e una nuova visibilità della classe.

“L'oggetto associato” determina il valore che avrà $this nel corpo della funzione e la “visibilità della classe” rappresenta una classe che determina a quali membri private e protected la funzione sarà in grado di accedere. Ossia, i membri che saranno visibili sono gli stessi che sarebbero se la funzione anonima fosse un metodo della classe data come valore dal parametro newScope.

Le closure statiche non possono avere nessun oggetto associato (il valore del parametro newThis deve essere null), ma questa funzione può comunque essere utilizzata per cambiare la loro visibilità.

Questa funzione si assicurerà che per una closure non-statica, avere un'istanza associata implicherà essere convertita e viceversa. A tal fine, le closure non-statiche a cui sono date una visibilità diversa da un'istanza null sono rese statiche e le closure non-statiche senza visibilità a cui sono date un'istanza non null sono convertite in una classe non specificata.

Nota:
Se hai soltanto intenzione di duplicare la funzione anonima, invece puoi usare la clonazione.

Elenco dei parametri

newThis: L'oggetto al quale la funzione anonima data dovrebbe essere associata, o null per le closure da dissociare.
newScope: L'ambito della classe a cui deve essere associata la closure, o 'static' per mantenere il corrente. Se invece viene dato un oggetto, verrà usato il tipo dell'oggetto. Questo determina la visibilità dei metodi protected e private dell'oggetto associato. Non è consentito passare (un oggetto di) una classe interna come valore di questo parametro.

Valori restituiti

Restituisce un nuovo oggetto Closure creato o null in caso di fallimento.

Esempi

Example #1 Esempio di Closure::bindTo()

<?php

class A {
    private $val;
    function __construct($val) {
        $this->val = $val;
    }
    function getClosure() {
        //restituisce la closure associata con il suo oggetto e con la sua visibilità
        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";
?>

Il precedente esempio visualizzerà qualcosa simile a:

1
2

Vedere anche:

Funzioni anonime
Closure::bind() - Duplicates a closure with a specific bound object and class scope

add a note

User Contributed Notes 9 notes

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

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

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

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

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

malferov at gmail dot com ¶

11 months ago


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

The documentation is about the object of the Closure itself:

<?php

class A {}

$a = new A();

$closure = fn() => null;

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

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"
}

down

-31

anthony bishopric ¶

12 years ago


Closures can rebind their $this variable, but private/protected methods and functions of $this are not accessible to the closures. 

<?php
$fn = function(){
    return $this->foo;
};

class Bar{
    private $foo = 3;
}

$bar = new Bar();

$fn = $fn->bindTo($bar);

echo $fn(); // Fatal error: Cannot access private property Bar::$foo

add a note