# Callback (fonction de rappel)

`Zend_Validate_Callback` permet de fournir une fonction de rappel utilisée pour valider la valeur.

## Utilisation classique

Le plus simple est de posséder une fonction classique, qui sera utilisée pour valider la donnée. Soit la fonction ci-après :

    function myMethod($value)
    {
        // ici de la validation à effectuer
        return true;
    }

Pour l'utiliser avec`Zend_Validate_Callback` vous devez simplement effectuer votre appel comme ceci:

    $valid = new Zend_Validate_Callback('myMethod');
    if ($valid->isValid($input)) {
        // input semble valide
    } else {
        // input est invalide
    }

## Utilisation avec les fonctions anonymes (closures)

PHP 5.3 introduit les fonctions anonymes ou fonctions de fermeture. PHP traite les fonctions anonymes comme des fonctions de rappel valides, et il est donc possible d'utiliser celles-ci avec `Zend_Validate_Callback`. Exemple:

    $valid = new Zend_Validate_Callback(function($value){
        // Validation ici
        return true;
    });

    if ($valid->isValid($input)) {
        // input semble valide
    } else {
        // input est invalide
    }

## Utilisation avec les méthodes de rappel

Bien sûr, il est aussi possible d'utiliser des méthodes de rappel:

    class MyClass
    {
        public function myMethod($value)
        {
            // Validation ici
            return true;
        }
    }

La définition de la fonction de rappel se fait alors dans un tableau contenant un objet de la classe et la méthode à appeler:

    $object = new MyClass;
    $valid = new Zend_Validate_Callback(array($object, 'myMethod'));
    if ($valid->isValid($input)) {
        // input semble valide
    } else {
        // input est invalide
    }

Il est aussi possible d'utiliser une méthode statique comme fonction de rappel:

    class MyClass
    {
        public static function test($value)
        {
            // Validation ici
            return true;
        }
    }

    $valid = new Zend_Validate_Callback(array('MyClass', 'test'));
    if ($valid->isValid($input)) {
        // input semble valide
    } else {
        // input est invalide
    }

Enfin, PHP 5.3 définit la méthode magique `__invoke()`. Si vous l'utilisez, alors un simple objet suffira comme fonction de rappel:

    class MyClass
    {
        public function __invoke($value)
        {
            // Validation ici
            return true;
        }
    }

    $object = new MyClass();
    $valid = new Zend_Validate_Callback($object);
    if ($valid->isValid($input)) {
        // input semble valide
    } else {
        // input est invalide
    }

## Ajouter des options

`Zend_Validate_Callback` permet d'utiliser des options, celles-ci seront alors passées comme argument supplémentaires à la fonction de callback.

Soit la définition suivante:

    class MyClass
    {
        function myMethod($value, $option)
        {
            // De la validation ici
            return true;
        }
    }

Il extsite deux manières d'indiquer des options au validateur : via le constructeur ou sa méthode `setOptions()`.

Via le constructeur, passez un tableau contenant les clés "callback" et "options":

    $valid = new Zend_Validate_Callback(array(
        'callback' => array('MyClass', 'myMethod'),
        'options'  => $option,
    ));

    if ($valid->isValid($input)) {
        // input semble valide
    } else {
        // input est invalide
    }

Sinon, vous pouvez passer les options après:

    $valid = new Zend_Validate_Callback(array('MyClass', 'myMethod'));
    $valid->setOptions($option);

    if ($valid->isValid($input)) {
        // input semble valide
    } else {
        // input est invalide
    }

Si des valeurs supplémentaires sont passées à `isValid()` elles seront utilisées comme arguments supplémentaires lors de l'appel à la fonction de rappel, mais avant les options `$options`.

    $valid = new Zend_Validate_Callback(array('MyClass', 'myMethod'));
    $valid->setOptions($option);

    if ($valid->isValid($input, $additional)) {
        // input semble valide
    } else {
        // input est invalide
    }

Lors de l'appel à la fonction de rappel, la valeur à valider sera toujours passée comme premier argument à la fonction de rappel suivie de toutes les autres valeurs passées à `isValid()`; les autres options suivront. Le nombre et le type d'options qui peuvent être utilisées est illimité.