Closure::bind() и bindTo() в PHP

Простой

5 мин

1.7K

Обзор

Привет, Хабр.

Сегодня рассмотрим, как в PHP управлять контекстом замыканий: подменять $this, менять область видимости, получать доступ к приватным свойствам, оборачивать методы, реализовывать мини-AOP и использовать замыкания как ленивые фабрики в DI-контейнерах.

bind и bindTo

PHP представляет замыкания через специальный класс Closure, экземпляры которого можно модифицировать. У этого класса есть два метода:

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

Оба метода делают одно и то же: создают новое замыкание, которое выполняется с другим значением $this и другим объёмом видимости (scope), определяющим, к каким приватным/защищённым членам класс имеет доступ.

Если вы путаетесь: bindTo — это instance-метод, применяется к конкретному Closure. bind — статический метод, применяется к замыканию, переданному первым аргументом. Отличий по сути нет — дело вкуса.

Контекст $this

По умолчанию, если вы создаёте замыкание вне методов класса, внутри него нет $this. Но если вы создаёте его в контексте метода, $this определяется автоматически. Пример:

class Demo {
    public function makeClosure(): Closure {
        return function () {
            return $this;
        };
    }
}

$demo = new Demo();
$closure = $demo->makeClosure();

var_dump($closure()); // object(Demo)

Теперь попробуем создать closure вне класса:

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

$closure(); // Fatal error: Using $this when not in object context

Чтобы в таком случае привязать $this, мы можем использовать bindTo:

$bound = $closure->bindTo(new StdClass());
var_dump($bound()); // object(stdClass)

Всё просто: вручную подвязали $this к замыканию.

Доступ к приватным свойствам через scope binding

Это второй аргумент метода bind или bindTo. Он определяет, к каким приватным и защищённым членам классов замыкание получит доступ. Если scope не указан, используется 'static', то есть доступ будет только к публичному API.

Посмотрим:

class Secret {
    private string $value = 'classified';
}

$secret = new Secret();

$closure = function () {
    return $this->value;
};

$bound = Closure::bind($closure, $secret, 'Secret');
echo $bound(); // classified

Здесь мы получили доступ к приватному полю без всякой рефлексии. Важно: это не баг, это официально поддерживаемое поведение, хотя и потенциально опасное с точки зрения инкапсуляции.

Если передать 'static' как $scope, то доступ к приватным и защищённым членам будет невозможен:

$bound = Closure::bind($closure, $secret, 'static');
$bound(); // Fatal error

Привязка к null — отключение $this

Можно также привязать замыкание к null, чтобы убрать привязку к объекту и избавиться от $this вообще:

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

$unbound = $closure->bindTo(null);
var_dump($unbound()); // false

Примеры применения

AOP: обернуть метод до/после

Допустим, есть объект с методом, и хочется повесить на него логгирование:

class Service {
    public function execute($arg) {
        return "Result: " . $arg;
    }
}

$service = new Service();

$originalMethod = function (...$args) {
    return call_user_func_array([$this, 'execute'], $args);
};

$wrapper = function (...$args) {
    echo "[LOG] before\n";
    $result = call_user_func_array($this->original, $args);
    echo "[LOG] after\n";
    return $result;
};

$boundOriginal = Closure::bind($originalMethod, $service, Service::class);

$proxy = new class($service, $boundOriginal, $wrapper) {
    public Closure $original;
    public Closure $wrapped;

    public function __construct($target, Closure $original, Closure $wrapper) {
        $this->original = $original;
        $this->wrapped = $wrapper->bindTo($this, self::class);
    }

    public function __call($name, $args) {
        if ($name === 'execute') {
            return ($this->wrapped)(...$args);
        }
        throw new \BadMethodCallException();
    }
};

echo $proxy->execute('foo'); 
// [LOG] before
// [LOG] after
// Result: foo

Создали мини-AOP, не меняя исходный класс и не прибегая к eval или рефлексии. Только Closure::bind().

DI-контейнер

Многие контейнеры в PHP (например, Laravel) позволяют регистрировать сервисы в виде замыканий. С bindTo можно удобно управлять контекстом:

class App {
    public function makeDatabase() {
        return new PDO('sqlite::memory:');
    }
}

$app = new App();

$instantiator = function () {
    return $this->makeDatabase();
};

$boundInstantiator = $instantiator->bindTo($app, App::class);

$db = $boundInstantiator(); // полноценный lazy-loading

DI-контейнер может хранить $boundInstantiator и вызывать его по мере надобности.

Нужно знать

Сериализация замыканий

В стандартном PHP замыкания не сериализуемы:

$fn = function () {};
serialize($fn); // Fatal error

С 7.4+ можно использовать сторонние решения, например, opis/closure, которые умеют сериализовывать даже привязанные замыкания. Но есть важный момент: bindTo() не сериализует scope, только объект $this. При восстановлении bindTo()-замыкание может потерять доступ к приватным членам, если не использовать специальный сериализатор.

Если важно сохранить контекст и scope — используйте Closure::bind() + OpisClosure::serialize().

Почему bindTo не может менять scope

Это ограничение встроено в движок PHP. Метод bindTo() специально блокирует смену области видимости по соображениям безопасности. Чтобы изменить scope, необходимо использовать Closure::bind(), потому что он создаёт полностью новую структуру, а bindTo() лишь привязывает $this к существующей:

$fn->bindTo($obj, 'AnotherClass'); // Fatal error
Closure::bind($fn, $obj, 'AnotherClass'); // OK

ZVAL и VM

На уровне движка каждое замыкание — это ZVAL с типом IS_OBJECT, обёрнутый в zend_closure. Когда вы вызываете bind(), движок создаёт новый объект zend_closure, копируя handler, opcodes, статические переменные и — главное — новую this_ptr и called_scope.

Таким образом:

$this — это this_ptr;
scope — это called_scope.

Историческая справка

Возможность Closure::bind() появилась в PHP 5.4 — вместе с анонимными функциями как полноценными объектами.

До этого момента замыкания не были полноценными first-class citizen'ами: можно было передавать функцию как коллбэк, но нельзя было сделать вот это:

$fn = function () {};
$fn = $fn->bindTo($obj, 'Scope');

Тогда же появился класс Closure, возможность создавать замыкания с сохранением контекста и — как побочный эффект — доступ к приватному API через scope.

Когда использовать, а когда нет

Да, если:

вы пишете фреймворк или контейнер;
вам нужно обернуть поведение метода (логгирование, транзакции, AOP);
вы мокаете приватные зависимости в тестах;
вы делаете ленивую инициализацию зависимостей;
вам нужен доступ к внутренностям объекта без рефлексии.

Нет, если:

вы просто хотите сэкономить на геттере;
вы делаете это без нужды — привязка closure стоит ресурсов.

А вы использовали bind() в проде или тестах? Делитесь опытом в комментах.

Если вы хотите углубить свои знания в современных инструментах разработки и архитектуры приложений, предлагаю обратить внимание на открытые уроки в Otus, которые помогут улучшить навыки и познакомиться с новыми подходами в работе с PHP и мониторингом. Темы уроков:

8 апреля: Продвинутая архитектура приложений на PHP.
Подробнее
15 апреля: Организация мониторинга с помощью Grafana.
Подробнее

Хабы: