[i]BeRoots, tire son chapeau[/i] =D>
Bas merci tout bien :)

Les tableaux en PHP sont des [url=https://fr.wikipedia.org/wiki/Hashmap][i]hashmaps[/i][/url]. Les objets sont des instances de classes. Une classe est une zone mémoire à laquelle sont rattachés des méthodes qui travaillent sur des données qui appartiennent elles-mêmes à différentes zones mémoires (statique ou dynamique).

Si tu connais un peu le C, une classe est strictement équivalente à une structure. Un bête [i]record[/i] qui permet d'associer des données à des symboles (noms). En PHP, on a la classe [i]StdClass[/i] qui permettrait d'en faire autant, mais l'habitude est plutôt d'utiliser les tableaux pour ça. L'impact mémoire est différent, tout comme la vitesse d'exécution. Il faut prendre ça en considération lorsque l'on manipule des millions de données, car c'est uniquement dans ce cas que l'on verra une différence (faire $array['foo'] ou $object->foo est différent, car 'foo' est une chaîne qui va être transformée en hash pour trouver la valeur associée — notons que les chaînes sont représentées par des [i]buffers[/i] en C —, alors que foo dans $object->foo est un symbole, donc il faut parcourir la table des symboles). Mais (!), PHP n'est pas conçu pour traiter des millions de données, son exécution est linéaire (contrairement à d'autres machines virtuelles qui utilisent des astuces, comme [url=https://fr.wikipedia.org/wiki/Compilation_%C3%A0_la_vol%C3%A9e]JIT[/url], pour accélérer les codes exécutés plusieurs fois).
[b]Bref[/b], utilises les tableaux, c'est franchement plus simple dans ton cas et [i]StdClass[/i] n'apportera rien de plus.

Cette [i]StdClass[/i] a été créée comme [i]fallback[/i] pour plusieurs fonctions PHP. Par exemple une lecture de base de données pour produire un tableau ou un objet. Les propriétés ne sont pas les mêmes : un tableau est très souvent copié lors d'un passage en argument d'une fonction, alors que pour un objet, c'est toujours sa référence qui est passée, donc on ne copie pas l'objet mais sa référence. Ça peut-être intéressant.

Tu parles aussi de [i]ArrayObject[/i]. C'est une classe proposée par la [url=http://php.net/spl]SPL[/url]. C'est une classe qui se comporte comme un tableau grâce aux interfaces [i]ArrayAccess[/i], [i]Countable[/i] etc. Sauf que l'objectif n'est pas de stocker de bêtes chaînes ou entiers mais des tableaux, et en grande quantité. (Note : si on veut un itérateur sur un tableau, il est préférable d'utiliser [i]ArrayIterator[/i] plutôt que [i]ArrayObject[/i]).

Donc, pour reprendre mon bref : utilise les tableaux et ça ira tout bien. Réfléchis juste à ce que tu vas mettre dedans et comment tu vas l'agencer, ça fera tout le boulot niveau optimisation.

Ah oui, tu parlais de transformer les clés, d'échapper les guillemets simples, les espaces etc. Sache que tu peux écrires : $object->{"abc'def ghi"}, et ça fonctionnera tout bien.

Aucune en faite je recherche dejà a voir comment faire pour standardiser mon code à ce niveau :p
Je viens de faire le tour de la question et de comprend qu'il faut voir simplement si besoin en recusivité ou non... En fin de compte c'est toujours mieux en array (voir syntaxe encore plus light qu'un array en php niveau perf) que recurcivement je pense. Mais si tu doit compilé du php par exemple. Le travail sur chaine classique d'utilisation de propriété "tableau" dans tes classes demandera un echappement massif des ' de chaque index de tableau qui peut être contourner par les syntaxes objet.

On doit sans doute aussi garder l'oeil sur un rapport factorisation de code / performance je suppose...

Enfin c'est mon avis sur le pourquoi utilise t'on des stdClass et autre ArrayObject mais est ce que j'ai bien tout compris??? :p
Si quelqu'un ce sent pour une théorie sur le sujet :D

En gros est il plus performant de faire, au sein d'une classe, l'instanciation d'une classe de definition de variable, ou, par la création/definition d'une propriété etant un array ?

Ton [i]helper[/i] te présente les données sous quelle forme actuellement ?

en fait je suis pris d'un doute depuis la lecture de ceci: http://www.mcherifi.org/developpement-web/php/php-convertir-un-tableau-en-objet-stdclass.html
Cf le commentaire de daminux: "désormais récursif"

Je ne comprend pas ce qu'il entand par là mais je sous entend de ce fait qu'il existe peut être maintenant une autre methode pour arrivé à ce genre de résultat...

Si quelqu'un à une idée sur le sujet ;)
Merci d'avance...

echo $this->helper()->returnmyobjectstdClass()->index1->var1;
echo $this->helper()->returnmyobjectstdClass()->index1->var2;
echo $this->helper()->returnmyobjectstdClass()->index1->var3->var1;
// ...

echo $this->helper()->myobjectstdClass->var;
echo $this->helper()->myobjectstdClass->index1->var2;
echo $this->helper()->myobjectstdClass->index1->var3->var1;
// ...

En fait moi je suis sous zf2 pour le moment et j'aimerai qu'un helper me sorte à la fois des methode et aussi des vars accessible comme un objet et ces vars sont en fait le retour d'un objet stdClass...

un genre d'utilisation:
[php]echo $this->helper()->returnmyobjectstdClass()->index1->var1;
echo $this->helper()->returnmyobjectstdClass()->index1->var2;
echo $this->helper()->returnmyobjectstdClass()->index1->var3->var1;
// ...[/php]

Voir même si possible avec les propriété public:
[php]echo $this->helper()->myobjectstdClass->var;
echo $this->helper()->myobjectstdClass->index1->var2;
echo $this->helper()->myobjectstdClass->index1->var3->var1;
// ...[/php]

Je ne sait pas si l'on peut faire mieux que l'objet stdClass pour avoir ce genre d'architecture de variable sur plusieurs niveaux ?
Doit t'on etendre stdClass... Doit on definir une fonction convertArrayToObject() comme tu l'a fait...

Euh ça dépend des projets. Parfois il est plus utile de manipuler un tableau, parfois un objet, tout dépend du contexte. Peux-tu préciser un peu ta question ?

Salut Hywan :)
Utilise tu toujours cette methode depuis le temps ?

class MyClass {

    /**
     * convertArrayToObject
     * Convert an array to an StdClass object.
     *
     * @access  public
     * @param   array         array     Array.
     * @param   previousNode  object    Previous node. Do not be set by user.
     * @return  object
     */
    public static function convertArrayToObject ( Array $array, $previousNode = null ) {

        if(null === $previousNode)
            $previousNode = new StdClass;

        foreach($array as $variable => $value) {

            $currentNode = $previousNode;

            if(is_array($value)) {

                $currentNode->$variable = new StdClass;
                self::convertArrayToObject($value, $currentNode->$variable);
            }
            else
                $currentNode->$variable = $value;
        }

        return $currentNode;
    }
}

$array = array(
    'database' => array(
        'table' => array(
            'name' => 'testing'
        ),
        'host' => '127.0.0.1'
    ),
    'other' => 'truc'
);

$out = MyClass::convertArrayToObject($array);
print_r($out);

echo $out->database->table->name . "\n" .
     $out->other . "\n";

Bien.
J'ai terminé ce que je voulais faire :P
Pour ceux que ça intéresse, voici comment convertir un tableau vers un arbre à objet StdClass.
[php]class MyClass {

/**
* convertArrayToObject
* Convert an array to an StdClass object.
*
* @access public
* @param array array Array.
* @param previousNode object Previous node. Do not be set by user.
* @return object
*/
public static function convertArrayToObject ( Array $array, $previousNode = null ) {

if(null === $previousNode)
$previousNode = new StdClass;

foreach($array as $variable => $value) {

$currentNode = $previousNode;

if(is_array($value)) {

$currentNode->$variable = new StdClass;
self::convertArrayToObject($value, $currentNode->$variable);
}
else
$currentNode->$variable = $value;
}

return $currentNode;
}
}[/php]
Voici les tests :
[php]$array = array(
'database' => array(
'table' => array(
'name' => 'testing'
),
'host' => '127.0.0.1'
),
'other' => 'truc'
);

$out = MyClass::convertArrayToObject($array);
print_r($out);

echo $out->database->table->name . "\n" .
$out->other . "\n";[/php]

Affichera :
[code]stdClass Object
(
[database] => stdClass Object
(
[table] => stdClass Object
(
[name] => testing
)

[host] => 127.0.0.1
)

[other] => truc
)
testing
truc[/code]

Voilà, bon c'est vraiment tout bête, mais c'était histoire de conclure le sujet ;-)
J'ai utilisé ce système pour utiliser les configurations en .ini.

Par exemple :
[code]database.table.name = testing
database.host = 127.0.0.1
other = truc[/code]
Me donnerait le tableau ci-dessus. C'est un peu plus compliqué pour construire le tableau. Je ne vais pas poluer le sujet.

Voilà :) Je n'ai pas mis dans « Vos Contributions », car ce n'est pas suffisament compliqué pour être une réelle contribution, c'est juste une idée comme ça :) Libre aux modos de déplacer s'ils en jugent nécessaire ;-)

Ah oui, pour terminer, on peut ajouter un test sur le nom des variables (regex) pour vérifier qu'on aura pas d'erreurs. Je ne l'ai pas mis ici, mais c'est également tout bête car l'expression régulière se trouve dans la documentation :P

Voilà :)

$a = new stdClass;
$a->b->c = 'hop';
$a->b->e = 'toc';
$a->d = 'la';

echo $a->b->c . ' ' . $a->d . ' ' . $a->b->e . "\n";
print_r($a->b);

foreach($a->b as $key => $value)
    $a->b->$value = $key;

print_r($a->b);

Quand je disais que je voulais utiliser cette classe, c'était m'en servir, et non pas utiliser le nom lol. Je me suis mal exprimé.

Je ne suis pas encore suffisament bête au point de me borner à un nom de classe ;-) Je peux utiliser un préfixe par exemple (vous voyez, j'ai de l'imagination ;-)).

Donc il n'y a pas de soucis à utiliser cette classe ? On peut l'utiliser dans tous les cas, sans que ça pose un problème quelconque à PHP. Car la doc spécifie que la classe est utilisée en interne par PHP, alors je voulais savoir si ça ne posait pas de problèmes.

Hubert me dit que toutes les classes sont une extension de StdClass. Bien. Seulement, StdClass a des propriétés intéressantes, qu'on ne retrouve pas dans une classe normale. Par exemple :
[php]$a = new stdClass;
$a->b->c = 'hop';
$a->b->e = 'toc';
$a->d = 'la';

echo $a->b->c . ' ' . $a->d . ' ' . $a->b->e . "\n";
print_r($a->b);

foreach($a->b as $key => $value)
$a->b->$value = $key;

print_r($a->b);[/php]
Affiche :
[code]hop la toc
stdClass Object
(
[c] => hop
[e] => toc
)
stdClass Object
(
[c] => hop
[e] => toc
[hop] => c
[toc] => e
)[/code]
On ne peut pas avoir un tableau sur $a->b avec une classe normale. Me trompe-je ?

Et si c'est une extension de chaque classe, on ne pourrait plus étendre de classe, car on a le droit qu'à une seule extension (et c'est parfois dommage). Ou alors, c'est fait dans d'autres couches de PHP, sûrement.

Et j'aimerais savoir où on pourrait avoir un peu plus de documentations. Car je compte me servir de cette classe pour un package, et j'aimerais utiliser la stdClass à fond. On peut sûrement faire autre chose que d'assigner des variables :P ?

Merci de m'avoir pris pour un idiot haha :mrgreen:. <- edit : je plaisantais aye :oops: :)

Bah elle est utilisée malgré tout...
si tu fais $obj = (object) $_GET;
$obj devient une stdClass

et dans l'autre sens ca marche aussi.
$tab = (array)$obj; $tab redevient un tableau.

Si tu fais des echanges en json, tu es souvent confronté a la stdClass.

class a {}

class a extends stdClass {}

function passez_moi_un_objet(stdClass $obj) {}

Je ne connais pas les détails techniques de stdClass, mais je sais que toutes les classes sont des extensions de stdClass par défaut. Quand on utilise
[php]class a {}[/php]
...c'est comme si on faisait
[php]class a extends stdClass {}[/php]

Ça peut être utile dans la signature d'une fonction
[php]function passez_moi_un_objet(stdClass $obj) {}[/php]

Pour le reste... à mon avis t'es pas près de te débarrasser de stdClass donc va falloir songer à un nouveau nom pour ton truc :lol:

C'est un peu ce que je me suis dit aussi ... ;)

si tu veux tant que ça une classe standard, utilise [i]standardClass[/i] ou [i]stdClasse[/i] :?

N'empèche HyWaN, ya un seul nom de classe que php interdit, et faut absolument que tu veuilles nommer une classe avec ce nom là précisément... :p

Std = standard.

Lorsque tu fais dans un code
[code]$foo->bar = 'toto';[/code]
ça te créé un objet $foo de type StdClass. En gros c'est la classe passe partout de PHP ;)