Salut les gens,

Peut-être aurais-je pu directement aller dans "Contributions" mais ne sachant si cela peut interresser
grand monde ou... (pire) si ca n'a pas déja été proposé je préfère poser la question avant laissant,
ainsi libre, un modo déplacer cela dans la section sus-nommée. Merci pour vos avis.

Replongeant dans mes dossiers j'ai retrouvée cette class (bien utile) qui permet de hiérarchiser
objects et tableau, à vous de juger et me retourner vos avis: (que j'espère nombreux...)

<?php
  /**
   * LiveArray.php
   *
   * @class        : LiveArray
   * @author     : everal-dei (FuzzyLine)
   * @Licence   : next part
   * @Notice     : next part
   * @version    : 1.0.1
   * @Editor    : Edit.com (ms-dos)
   * @date        : 26/11/2008
   * @mise à jour : 15/08/2009
   *
   * NOTICE: 
   *
   * Cette class s'avert plus adaptée au tri fonctionnel que l'utilisation
   * de RecursiveIteratorIterator. Elle  permet  une  hiérarchie  globale,
   * autant  sur  les  tableaux  que sur les objets et  quelque  soit  les
   * dépendances. Ceci, biensur, sans  devoir  intégrer  l'interface (spl)
   * RecursiveIterator.
   *
   * 16/08/2009 : Conformité appels abstracts, régularisation de certains apects.
   *                   :  Mise en SB de la fonction __toString.
   *
   * LICENCE (Libre): 
   *
   * Cette class est libre d'utilisation, d'implentation et de modification.
   *
   * @Class parente    : none
   *
   * @Interface dédiée : iterator
   * @Interface dédiée : countable
   *
   * @function (accès public) : integer getLevel(void)
   * @function (accès public) : string getType(void)
   * @function (accès public) : string getNumberItem(void)
   * @function (accès public) : mixed getItem(void)
   * @function (accès public) : integer getMethod(void)
   *
   * @Usage : instance = LiveArray::init(mixed)
   *
   * everal-dei (FuzzyLine)
   */             
   class LiveArray implements iterator, countable
   {
     /**
      * @Constantes, déclartion interne
      */
      const AUTHOR  = "everal-dei (FuzzyLine)";
      const VERSION = "1.0";

     /**
      * @Const, déclartion des constantes de recherche
      */
      const TYPE_ARRAY = 0;
      const TYPE_KEY   = 1;
      const TYPE_VALUE = 2;

     /**
      * @Const, déclartion des constantes de type
      */
      const METHOD_OPEN    = 1;
      const METHOD_ELEMENT = 0;
      const METHOD_CLOSE   = -1;

     /**
      * @Const, déclartion de la constante d'incrémentation
      */
      const INC_INDEXAREA = 1;

     /**
      * @var, tableau de la liste des éléments
      */
      private $_list = array();

     /**
      * @var, éléments supplémentaires à connaitres
      */
      private $_attributes = array();

     /**
      * @var, position du pointeur
      */
      private $_iInternalPointeur = 0;

     /**
      * @function : string __toString()
      *
      * @param    : none
      * @return   : Nom du tableau/objet actuel
      *
      * @comment  : renvoie la liste des ‚l‚ments
      *                   : fonction mise en attente.
      */
      function __toString()
      {
         // return $this -> _list;
         //
         return "Not yet implemented.";
      }

     /**
      * @function : inst init(mixed)
      *
      * @param    : none
      * @return   : Instance
      *
      * @comment  : renvoie la référence de l'objet
      */
      public function init($obj)
      {
        /**
         * Si l'argument n'est pas de type attendu, on sort
         */
         if (!is_object($obj) && !is_array($obj))
         {
            echo "Argument invalide !";
            return false;
         }

        /**
         * Argument valide, on retourne l'instance
         */
         return new LiveArray($obj);
      }

     /**
      * @function : void __construct(object)
      *
      * @param    : object ou array
      * @return   : none
      *
      * @comment  : ajoute un élémént au tableau
      */
      private function __construct($obj)
      {
         $this -> _tree($obj);
      }

     /**
      * @function : private bool _isCompose(mixed)
      *
      * @param    : mixed
      * @return   : boolean
      *
      * @comment  : renvoie true si c'est un object ou un tableau
      */
      private function _isCompose($mixed)
      { 
         if (is_object($mixed)) return true;
         if (is_array($mixed)) return true;

         return false;
      }

     /**
      * @function : integer count(void)
      *
      * @param    : none
      * @return   : int
      *
      * @comment  : revoie le nombre d'éléments de this
      */
      function count()
      { 
         return count($this -> _list, COUNT_RECURSIVE);
      }

     /**
      * @function : private mixed _getElement(array, integer, integer)
      *
      * @param    : array, le tableau référence
      * @param    : int, index dans le tableau
      * @param    : int, type de valeur retournée
      * @return   : mixed
      *
      * @comment  : revoie une valeur suivant l'argument type
      */
      private function _getElement($array, $iIndex, $iType)
      {
        /**
         * @vérifie s'il s'agit bien d'un tableau ou d'un objet sinon sort
         */
         if (!is_array($array) & !is_object($array)) return false;

        /**
         * @var, compteur d'éléments
         */
         $iCount = 0;
         
        /**
         * @var, variable retournée, tableau ou lValue
         */
         $mixed = "";

        /**
         * @var, flag de réussite
         */
         $bfFound = false;

         foreach($array AS $key => $value)
         {  
            if ($iIndex == $iCount)
            {
               $bfFound = true;

              /**
               * Info: LiveArray:: équivaut à self::
               */
               switch($iType)
               {      
                  case LiveArray::TYPE_ARRAY:
                     $mixed[0] = $key;
                     $mixed[1] = $value;
                  break;

                  case LiveArray::TYPE_KEY:
                     $mixed = $key;
                  break;

                  case LiveArray::TYPE_VALUE:
                     $mixed = $value;
                  break;

                  default: return false;
               }
               break;
            }
            $iCount++;
         }
         return $bfFound ? $mixed : false;
      }

     /**
      * @function : private void _tree(object)
      *
      * @param    : none
      * @return   : none
      *
      * @comment  : enregiste tous les éléments de la hiérarchie
      */
      private function _tree($obj)
      {
        /**
         * @action, si le teste est faux revonvoie faux
         */
         if (!$this -> _isCompose($obj)) return false;

        /**
         * @var, compteur d'éléments
         */
         $iCount = 0;

        /**
         * @var, flag d'action
         */
         $bfWork = true;

        /**
         * @var, variable servant à établir la hiérarchie
         */
         $iLevel              = 0;
         $iIndex[$iLevel]     = 0;
         $actualItem[$iLevel] = $obj;

        /**
         * @action, boucle tant que l'opération se déclare vrai, élément de présent
         */
         while($bfWork)
         {  
           /**
            * @var, tableau de l'élémenet appelé
            */
            $array = $this -> _getElement($actualItem[$iLevel], $iIndex[$iLevel], LiveArray::TYPE_ARRAY);

           /**
            * @var, s'il y a encore des élément de disponibles pour cette branche
            */
            if ($array !== false)
            {
              /**
               * @action, incrémente un element
               */
               $iIndex[$iLevel]++;

              /**
               * @action, s'il ne s'agit que d'un élément
               */
               if ($this -> _isCompose($array[1]) === false)
               {
                 /**
                  * @action, enregistrement des données
                  */
                  $this -> _list[$iCount][$array[0]] = $array[1];
                  $this -> _list[$iCount]['level'] = $iLevel;
                  $this -> _list[$iCount]['item'] = $iItem=$iIndex[$iLevel];

                 /**
                  * @action, marque le fait qu'il s'agisse d'un élément
                  */
                  $this -> _attributes[$iCount]['type'] = false;
                  $this -> _attributes[$iCount]['method'] = LiveArray::METHOD_ELEMENT;
               }

              /**
               * @action, l'élément actuel est un objet, va dessus
               */
               else 
               {
                 /**
                  * @action, incrémente de un le numéro de la branche
                  */
                  $iLevel++;

                 /**
                  * @action, remise à zéro des éléments
                  */
                  $iIndex[$iLevel] = 0;

                 /**
                  * @action, enregistre l'objet actuel
                  */
                  $actualItem[$iLevel] = $array[1];

                  $typeName = is_array($actualItem[$iLevel]) ? "Array" : get_class($actualItem[$iLevel]);
                  $this -> _attributes[$iCount]['type'] = $typeName;
                  $this -> _attributes[$iCount]['object'] = $actualItem[$iLevel];
                  $this -> _attributes[$iCount]['method'] = LiveArray::METHOD_OPEN;

                 /**
                  * @patch:5/12/2008 valeur obligée même si null
                  */
                  $this -> _list[$iCount]['item'] = NULL;
               }
            }

           /**
            * @action, plus d'éléments disponibles pour cette branche
            */
            else
            {
              /**
               * @action, décrémente le niveau, revient à la branche mère
               */
               $iLevel--;
               $this -> _attributes[$iCount]['method'] = LiveArray::METHOD_CLOSE;

              /**
               * @patch:5/12/2008 valeur obligée même si null
               */
               $this -> _list[$iCount]['item'] = NULL;
               
              /**
               * @var, vérifie s'il s'agit d'un branche éxistante
               */
               if ($iLevel < 0) $bfWork = false;
            }

           /**
            * @action, incremente le nombre de lignes
            */
            $iCount++;
         }
      }

     /**
      * @function : integer getLevel(void)
      *
      * @param    : none
      * @return   : la profondeur de l'élément actuel
      *
      * @comment  : none
      */
      public function getLevel()
      {
         $iLevel = $this -> _list[$this -> _iInternalPointeur]['level'];
         return $iLevel;
      }

     /**
      * @function : string getType(void)
      *
      * @param    : none
      * @return   : le type de l'élément
      *
      * @comment  : Pose un probleme de redondance
      *           : s'insert au tableau de sortie
      */
      public function getType()
      {
         $type = $this -> _attributes[$this -> _iInternalPointeur]['type'];
         return $type;
      }

     /**
      * @function : integer getMethod(void)
      *
      * @param    : none
      * @return   : propriete de l'element
      *
      * @comment  : retourne une constante: Ouverture, élément ou fermeture
      */
      public function getMethod()
      {
         $method = $this -> _attributes[$this -> _iInternalPointeur]['method'];
         return $method;
      }

     /**
      * @function : integer getNumberItem(void)
      *
      * @param    : none
      * @return   : int, position de l'élément actuel
      *
      * @comment  : le nombre intègre les branches
      */
      function getNumberItem()
      {
         $iItem = $this -> _list[$this -> _iInternalPointeur]['item'];
         return $iItem;
      }

     /**
      * @function : mixed getItem(void)
      *
      * @param    : none
      * @return   : la branche actuel
      *
      * @comment  : peut-être un array ou un object, voir false 
      */
      function getItem()
      {
         $mixedItem = $this -> _attributes[$this -> _iInternalPointeur]['object'];
         return $mixedItem;
      }

     /**
      * @function : mixed current(void)
      *
      * @param    : none
      * @return   : l'élément actuel
      *
      * @comment  : si la fonction échoue renvoie false
      */
      function current()
      {
         $result = $this -> _getElement($this -> _list[$this -> _iInternalPointeur], 0, LiveArray::TYPE_VALUE);
         return $result;
      }

     /**
      * @function : mixed next(void)
      *
      * @param    : none
      * @return   : le prochain élément de la liste
      *
      * @comment  : si la fonction échoue renvoie false
      *           : est lancée apres valid 
      */
      function next()
      {  
         $this -> _iInternalPointeur+= LiveArray::INC_INDEXAREA;

         if (!$this -> valid()) return false;

         $result = $this -> _getElement($this -> _list[$this -> _iInternalPointeur], 0, LiveArray::TYPE_VALUE);
         return $result;
      }

     /**
      * @function : mixed key(void)
      *
      * @param    : none
      * @return   : la clef de l'élément actuel
      *
      * @comment  : si la fonction échoue renvoie false 
      */
      function key()
      {    
         $result = $this -> _getElement($this -> _list[$this -> _iInternalPointeur], 0, LiveArray::TYPE_KEY);
         return $result;
      }

     /**
      * @function : boolean valid(void)
      *
      * @param    : none
      * @return   : bool
      *
      * @comment  : none
      */
      function valid()
      {
         $iCounter = count($this -> _list);
         if ($this -> _iInternalPointeur+1 > $iCounter) return false;
         return true;
      }

     /**
      * @function : mixed rewind(void)
      *
      * @param    : none
      * @return   : l'élément à la position 0
      *
      * @comment  : remet le compteur d'élément à 0
      */
      function rewind()
      {
         $this -> _iInternalPointeur = 0;
         return reset($this -> _list);
      }
   }
?>

Si vous l'utiliser/la modifier, vous pouvez imaginer le temps que j'ai accorder à cette class,
alors merci de mentionner sa provenance ainsi que l'auteur (cad: everal-dei (FuZZyLine) )
dans vos scripts.

Il reste (j'imagine) des erreurs/fautes mais sachez que le charset de Edit.com (MS-DOS) est
un brin désuet et comme j'ai du faire les modifs avec mes petits doigts boudinnés...

Voici comment vous aurez à l'utiliser:

<?php

 // Include selon...
 //
 include "./xxx/Library/LiveArray.php";

 // Class bidon pour l'exemple
 //
 class personnal
 {
    public $stat  = 2;
    public $other = 1;

    function __construct()
    {
    }
 }

 // Instanciation de la class bidon
 // 
 $perso_1 = new personnal();

 // Tableaux bidons toujours pour l'exemple
 // 
 $perso_1 -> j = Array(1 => "Lun", 2 => "Mar", 3 => "Mer", 4 => "Jeu", 5 => "Ven", 6 => "Sam", 7 => "Dim");
 $perso_1 -> m = Array(1 => "Jan", 2 => "Fev", 3 => "Mar", 4 => "Avr");

 $perso_2 = new personnal();
 $perso_2 -> Autre = new personnal();

 $array = Array("objet_un" => $perso_1, "Tableau" => "essai", "objet_deux" => $perso_2);

 // Récupération de l'instance par l'envoie du tableau... OU de l'objet
 //
 $res = LiveArray::init($array);

 // Boucle sur les éléments
 // Les fonctions sont décrites dans la class...
 //
 foreach($res AS $key => $value)
 {
    if ($res -> getMethod() != -1)
    {
       if ($value != "")
       {
          $tab = str_repeat(">>>", $res -> getLevel());
          echo $tab." ";

          echo "Clef: ".$key." Valeur: ".$value."<br>";
       }
       else echo " <b>".$res -> getType()."</b><br>";
    }
 }
?>

Bonne lecture à tous, les repports seront "vraiment" appréciés, merci à vous.

@+;)

Hey ,
Je ne comprends pas à quoi ça sert. C'est juste un arbre c'est ça ?