Salut à tous,

J'avais besoin dernièrement de bindée une valeur à la volée. Voir post original ici : php-avance/clause-limit-pdo-t259263.html

Mais question de clarté dans mon code : je souhaitais bien séparer mon tableau, et ne pas avoir à bindé mes valeurs à coté. Et de plus je ne pouvais pas utilisé la méthode execute($myarray); et faire des bindValue() à coté, ça ne fonctionnait pas. J'ai donc fait une petite fonction pour lier mes valeurs automatiquement sur un tableau entier.

    
     //$array = tableau contenant les valeurs à bindé
    //$req = la requête sur laquelle bindé les valeurs
    //$typeArray = tableau contenant la valeur souhaité pour sa clé correspondante dans $array
function bindArrayValue($array,$req,$typeArray = false)
{
    if(is_object($req) && ($req instanceof PDOStatement))
    {
        foreach($array as $key => $value)
        {
            if($typeArray)
                $req->bindValue(":$key",$value,$typeArray[$key]);
            else
            {
                if(is_int($value))
                    $param = PDO::PARAM_INT;
                elseif(is_bool($value))
                    $param = PDO::PARAM_BOOL;
                elseif(is_null($value))
                    $param = PDO::PARAM_NULL;
                elseif(is_string($value))
                    $param = PDO::PARAM_STR;
                else
                    $param = FALSE;
                    
                if($param)
                    $req->bindValue(":$key",$value,$param);
            }
        }
    }
}

Comment s'en servir, c'est très simple :
$array :
Représente le tableau avec les valeurs que vous souhaitez liées.
Exemple : $array = array('elephant' => 'php','pingouin' => 'linux', 'random' => 254);

$req :
La requête avec laquelle on doit liées les valeurs de notre tableau $array.

Optionnel :

$typeArray :

$typeArray représente un tableau où vous pouvez directement assigné un type parmi ces constantes :

PDO::PARAM_BOOL
PDO::PARAM_NULL
PDO::PARAM_INT
PDO::PARAM_STR

Sauf :
PDO::PARAM_LOB #J'ai pas su comment faire pour PDO::PARAM_LOB, qui représente un objet large. J'ai pas trop compris ce que c'était.

Avec $typeArray vous pouvez préciser à l'avance le couple [valeur / type] en assignant la même clé dans le tableau $typeArray que dans le tableau $array.

Par exemple : $typeArray = array('elephant' => PDO::PARAM_STR,'nombre' => PDO::PARAM_INT,'nombre' =>PDO::PARAM_BOOL);
Avec un tableau $array comme lui : $array = array('elephant' => 'php','nombre' => 254, 'boolValue' => true);

Pour la clé "elephant" de valeur "php" dans le tableau $array ira prendre le type dans le tableau $typeArray possèdant comme nom de clé "elephant" soit : PDO::PARAM_STR ici.

Ce qui représente en fait version codée avec la méthode bindValue uniquement :

$req->bindValue(:elephant,'php',PDO::PARAM_STR);
$req->bindValue(:nombre,254,PDO::PARAM_INT);
$req->bindValue(:boolValue,true,PDO::PARAM_BOOL);

Mais avec la fonction çà le fait automatiquement.

Voilà. Toutes améliorations et critiques sont bien les bienvenues.

[1/07/11] Edit : Modifications de $typeArray en tableau associatif d'après stealth35.
[2/07/11] Edit : Vérification du type de $req d'après moogli.

tu n'as pas a mettre un addslashes lors d'une requete préparé, pour le type array je mettrai plus une correspondance :

array('elephant' => PDO::PARAM_STR)

ca sera plus joli que de faire un $i, surtout si les valeur n'existe pas

Voilà c'est modifier ! Et pour le addslashes, je sais pas trop pourquoi j'en ai mis un, il devait être tard quand j'ai codé ça. :p

juste pour la critique autant vérifier que $req soit un objet de la bonne classe pour éviter les soucis de chose qui n'existe pas

=> is_object pour vérifier que c'est un objet et instanceof pour vérifier que l'objetc est bien du type voulu (ici pdostatement http://fr.php.net/manual/fr/class.pdostatement.php )

@+

Merci moogli c'est modifié. C'est vrai qu'apporté des vérifications aussi là dessus est mieux. Est ce que je devrais rajouter un renvoi d'erreur quand c'est pas ce qu'il faut ?

soit tu part du fait que ta fonction retourne true ou un message d'erreur et a l'utilisation tu test if ($retourfonction!=true) echo $retourfonction;
soit tu lève une erreur php directement et retourne false.

avec une classe tu aurais retourné false et mis un message d'erreur dans une variables membre dédiée aux erreurs (+ un getter pour les obtenir )


@+

Je pensais justement à faire une classe mais je suis justement en train d'apprendre la programmation orientée objet.
Mais je ne vois pas trop comment faire pour réaliser une implémentation facile par la suite.

Je comprend tout à fait le concept d'héritage ou de composition qui me semble être plus approprié pour intégrer juste une fonction.
A moins que ce soit beaucoup plus simple que ca ? Sauriez vous me mettre sur la voie ? (Je ne tiens pas particulièrement à voir cette fonction en classe, c'est juste pour apprendre )

Héritage, composition ou autre ? (que je ne connais point encore )

heu ben ça dépend de ce que tu souhaite en faire en fait

Tu pourrais imaginer la mettre dans une classe statique qui te sert de bibliothèques de fonction.

Tu peux imaginer étendre la classe PDO avec ta classe et donc utiliser le système d'exception pour gérer proprement l'erreur (si c'est le cas).

il y a plein de solution suivant ce que tu souhaite en faire

@+