Fonctions callback
******************

.[perex]
[api:Nette\Utils\Callback] est une classe statique contenant des fonctions pour travailler avec les [callbacks PHP |https://www.php.net/manual/en/language.types.callable.php].


Installation :

```shell
composer require nette/utils
```

Tous les exemples supposent que l'alias de classe suivant est défini :

```php
use Nette\Utils\Callback;
```


check($callable, bool $syntax=false): callable .[method]
--------------------------------------------------------

Vérifie que `$callable` est un callback PHP valide. Sinon, lève `Nette\InvalidArgumentException`. Si `$syntax` vaut `true`, la fonction vérifie seulement que `$callable` a la structure d'un callback valide, sans contrôler que la classe ou la méthode existe réellement. Retourne le `$callable` d'origine.

```php
Callback::check('trim'); // ne lève pas d'exception
Callback::check(['NonExistentClass', 'method']); // lève Nette\InvalidArgumentException
Callback::check(['NonExistentClass', 'method'], true); // ne lève pas d'exception
Callback::check(function () {}); // ne lève pas d'exception
Callback::check(null); // lève Nette\InvalidArgumentException
```


toString(callable $callable): string .[method]
----------------------------------------------

Convertit un callback PHP en sa représentation textuelle. La classe ou la méthode n'a pas besoin d'exister.

```php
Callback::toString('trim');                // 'trim'
Callback::toString(['MyClass', 'method']); // 'MyClass::method'
```


toReflection(callable $callable): \ReflectionMethod|\ReflectionFunction .[method]
---------------------------------------------------------------------------------

Retourne une réflexion de la méthode ou de la fonction employée dans le callback PHP. Lève `\ReflectionException` si la méthode ou la fonction référencée n'existe pas.

```php
$ref = Callback::toReflection('trim');
// $ref est ReflectionFunction('trim')

$ref = Callback::toReflection(['MyClass', 'method']);
// $ref est ReflectionMethod('MyClass', 'method')
```


isStatic(callable $callable): bool .[method]
--------------------------------------------

Détermine si le callback PHP est une fonction globale ou une méthode statique.

```php
Callback::isStatic('trim');                // true
Callback::isStatic(['MyClass', 'method']); // true
Callback::isStatic([$obj, 'method']);      // false
Callback::isStatic(function () {});        // false
```


unwrap(\Closure $closure): callable|array .[method]
---------------------------------------------------

Déballe une closure créée par `Closure::fromCallable()`. Retourne le tableau ou la chaîne callable d'origine.

```php
$closure = Closure::fromCallable(['MyClass', 'method']);
Callback::unwrap($closure);     // ['MyClass', 'method']
```


invokeSafe(string $function, array $args, callable $onError): mixed .[method]
-----------------------------------------------------------------------------

Appelle la fonction PHP native `$function` avec les arguments `$args`, en capturant par son propre gestionnaire les avertissements ou erreurs qu'elle émet. Cela vous permet de réagir à des problèmes que les fonctions natives ne signalent d'ordinaire que par un avertissement. Le callback `$onError` reçoit deux arguments : le message d'erreur (débarrassé du préfixe `function():` initial) et sa gravité. S'il retourne `false`, l'erreur est transmise au gestionnaire d'erreurs standard.

```php
$result = Callback::invokeSafe('file_get_contents', ['file.txt'], function (string $message, int $severity) {
	throw new Exception($message);
});
```