mais de rien :)

Merci moogli, ta solution a fonctionné.

<?php
class my_mysqli extends mysqli implements i_db{
    public function query($q){
        return new my_mysqli_result(parent::query($q));
    }
    // $dataAndType : [0=>['type'=>'s','data','xxx'] ...]
    public function preparedQuery($q, $dataAndType){
        $type = '';
        $data = [];
        foreach($dataAndType as $d){
            $type+=$d['type'];
            $data[] = $d['data'];
        }
        parent::bind_param($type,...$data);
        return new my_mysqli_result(parent::query($q));
    }
    // Ou en plus simple
    public function preparedQuery2($q, $type, ...$data){
        parent::bind_param($type, ...$data);
        return new my_mysqli_result(parent::query($q));
    }
}

avec PDO tu bind élément par élément, il "suffit" de faire pareil dans ton wrapper mysqli.
tu ajout un méthode "bind" qui prend en paramètre données et type ($data, 's' par exemple) voir un tableau pour tout. et a partir de la tu construit dynamique la chaîne pour le type et ensuite les paramètres.

ça conne un truc dans ce goût la (php 5.6+), a tester
[php]<?php
class my_mysqli extends mysqli implements i_db{
public function query($q){
return new my_mysqli_result(parent::query($q));
}
// $dataAndType : [0=>['type'=>'s','data','xxx'] ...]
public function preparedQuery($q, $dataAndType){
$type = '';
$data = [];
foreach($dataAndType as $d){
$type+=$d['type'];
$data[] = $d['data'];
}
parent::bind_param($type,...$data);
return new my_mysqli_result(parent::query($q));
}
// Ou en plus simple
public function preparedQuery2($q, $type, ...$data){
parent::bind_param($type, ...$data);
return new my_mysqli_result(parent::query($q));
}
}[/php]
A tester, mais le principe est la

l'utilisation des [b]...[/b] devrait faire le boulot.

c'est pour cela qu Genova ne préconise pas ce système :-)


@+

J'ai pas compris ta réponse :oops:
Pour le reste, bien sûr, ça n'a pas grand intérêt. Tout ceci a un but pédagogique, je "m'amuse", et en m'amusant je tombe souvent sur des situations bizarres et c'est comme ça que je progresse.
Ne t'inquiètes pas pour le query j'ai juste raccourci le code pour l'exemple, je ne fais pas comme ça en vrai.

salut,

tu peux prendre modèle sur ce que fait PDO et ne faire le bind qu'a la demande de l’exécution.

je vois deux arguments cotre ce que tu fais :
- Cela n'apporte pas de valeur ajouté aux extensions PDO et Mysqli (les deux sont objet
- Cela complexifie l'utilisation (tiens des nouvelles classes ...)
- Tu perd en fonctionnalité (fetchAll etc.)
- Tu ne respecte pas les recommandations PSR-1 et 2 :-)

si le but c'est le chaînage des méthodes (comme dans ton exemple) je ne pense pas que cela une bonne idée.
- c'est pas forcément lisible (regarde ton exemple, pas d'espace, tout en une ligne, imagine avec select 10 colonnes et jointure sur 3 tables; le select * c'est pas bien car il ne permet pas de savoir exactement ce que tu souhaites comme colonne et surtout un en ramène souvent trop ;) ).
- c'est un cas peu employé (retourner un élément c'est moins utilisé que retourner des listes).
- tu va faire des tonnes de connexion sur ton serveur mysql, ce qui n'est pas une bonne idée, il y a généralement une limite aux nombres de connexion simultané. Ce n'est pas non plus une bonne idée parce que la connexion c'est souvent le plus long dans la requête.
A limite si tu crée un singleton, voir une factory qui gère un pool de singleton OK. tu pourrais gagner en lisibilité, utiliser plusieurs connexion de façon simple (par exemple : dbFactory->getDB('id de la base'); )

bref pour l'exercice de style pourquoi pas, mais pas à utiliser pour un code maintenable.
Souvient de l'acronyme KISS (Keep it simple, stupide https://fr.wikipedia.org/wiki/Principe_KISS). Il y a cela aussi [url=https://fr.wikipedia.org/wiki/YAGNI]YAGNI[/url], mais le 1er est plus adapté :)


@+

Merci à vous,
Je pensais que ça répondrait à ma question mais je me suis trompé. En fait j'écris une interface afin de normaliser les méthodes de pdo et mysqli (injection de dépendance), quand il s'agit de requête simples c'est facile, par exemple:

[code]<?php
interface i_db{
public function myQuery($q);
}
interface i_res{
public function myFetch();
}
class my_pdo extends pdo implements i_db{
public function myQuery($q){
return new my_pdo_stmt(parent::query($q));
}
}
class my_pdo_stmt implements i_res{
protected $stmt;
public function __construct(pdostatement $stmt){
$this->stmt = $stmt;
}
public function myFetch(){
return $this->stmt->fetch(PDO::FETCH_ASSOC);
}
}
class my_mysqli extends mysqli implements i_db{
public function myQuery($q){
return new my_mysqli_result(parent::query($q));
}
}
class my_mysqli_result implements i_res{
protected $result;
public function __construct(mysqli_result $result){
$this->result = $result;
}
public function myFetch(){
return $this->result->fetch_assoc();
}
}
$db1 = new my_mysqli('localhost','root','','test');
$db2 = new my_pdo('mysql:host=localhost;dbname=test','root','');

var_dump($db1->myQuery("SELECT * FROM Onche")->myFetch(),$db2->myQuery("SELECT * FROM Onche")->myFetch());
[/code]

Mais pour les requêtes préparées je bloque sur la méthode bind_param de mysqli. Comment la réécrire puisqu'elle prend des références comme paramètres ? Comment reconstruire l'appelle de cette méthode ? eval() ne fonctionnera pas...

A ne pas reproduire dans son code par contre, l'utilisation de tableaux reste bien plus propre.

Bonjour,

Voici comment déclarer une fonction en PHP avec un nombre d'arguments variable :
- en PHP 5.6+ : http://php.net/manual/fr/functions.arguments.php#functions.variable-arg-list
- en PHP < 5.6 : http://php.net/manual/fr/function.func-num-args.php

Bonjour à tous,
J'aimerais comprendre comment est la structure d'une méthode telle que mysqli::bind_param().
La doc nous la décrit comme ça:
bool mysqli_stmt::bind_param ( string $types , mixed &$var1 [, mixed &$... ] )
Mais telle quelle elle est incapable de savoir combien de paramètres elle va recevoir. Hors, les var1, var2, var3, il faut bien qu'elles existent quelque part: comment recevoir un paramètre dans une variable qu'on a pas déclaré ?
Est-ce que sa structure réelle est du genre:
bind_param($types, &$var1=null, &$var2=null, &$var3=null, ...) à l'infini ?
Je sais pas si ma question est assez claire c'est pas évident à exprimer :oops: