Bonjour,
Est-il possible de connaître le nom de l'instance d'une classe depuis celle-ci ?

Un exemple basique : Je cherche à avoir une fonction (ou une méthode à définir dans la classe) à utiliser dans la classe A du genre get_instance_name($this) qui me renverrait 'truc' dans l'exemple ci-dessus.

Salut,

Bonjour,
Est-il possible de connaître le nom de l'instance d'une classe depuis celle-ci ?
Un exemple basique :

Code : Tout sélectionner

class A{ } $truc=new A();

Je cherche à avoir une fonction (ou une méthode à définir dans la classe) à utiliser dans la classe A du genre get_instance_name($this) qui me renverrait 'truc' dans l'exemple ci-dessus.

Comme ca tu veux dire?

$className = get_class($instance);

@+

Non : get_class va me donner le nom de la classe ("A"), pas de l'instance que j'ai créée.

Non : get_class va me donner le nom de la classe ("A"), pas de l'instance que j'ai créée.

Merde, j'ai lu en biais, désolé

EDIT: As-tu pensé au pattern Singleton?

EDIT: As-tu pensé au pattern Singleton?

Non, je ne sais même pas ce que c'est. :/

EDIT: As-tu pensé au pattern Singleton?

Non, je ne sais même pas ce que c'est. :/

Le Singleton permet d'avoir une instance unique:

<?php
class Toto
{
  /**
   * Variable de class pour l'instance
   *
   * @var, instance
   */
   private static $_instance = NULL;

  /**
   * Constructeur privé, empèche une instanciation externe
   *
   * @value : none
   * @return : none
   */
   private function  __construct()
   {
   }

  /**
   * Empêche le clonage
   *
   * @value : none
   * @return : none
   */
   private function  __clone()
   {
   }

  /**
   * Récupère l'instance de class 
   * Si elle n'éxsiste pas on la créé
   *
   * @value : none 
   * @return : none
   */
   public static function getInstance()
   {
      if (!isset(self::$_instance)) self::$_instance = new self();
     return self::$_instance;
   }
}
?>

Si tu as besoin de plusieurs Instances de même class c'est un peu différent mais très faisable
avec un pool de class.

@+

Ouh là, ça se complique. :/

Je manipule plusieurs classes, en fait. En simplifiant le plus possible, j'ai quelque chose dans ce goût-là : Dans ma première classe, j'utilise une fonction qui va récupérer des infos dans une base de données selon différents critères (pour simplifier, on va dire qu'elles sont récupérées sous forme d'un tableau) et je crée plusieurs instances d'une seconde classe (photo) pour gérer mes diverses photos.
Dans la classe photo, je voudrais pouvoir récupérer le nom de l'instance pour l'utiliser dans la méthode magique __toString afin de créer un champ de formulaire.
Le but est d'obtenir, après validation du formulaire, les variables $_POST avec les bons noms (dans cet exemple $_POST['photo_avant'] et $_POST['photo_apres']) pour pouvoir automatiser leur traitement à coup de Je ne comprends pas bien à quoi sert le "singleton" et je ne crois pas qu'il puisse m'aider pour générer mes champs de formulaire.

Ouh là, ça se complique. :/

Je manipule plusieurs classes, en fait. En simplifiant le plus possible, j'ai quelque chose dans ce goût-là :
[...]
Dans ma première classe, j'utilise une fonction qui va récupérer des infos dans une base de données selon différents critères (pour simplifier, on va dire qu'elles sont récupérées sous forme d'un tableau) et je crée plusieurs instances d'une seconde classe (photo) pour gérer mes diverses photos.
Dans la classe photo, je voudrais pouvoir récupérer le nom de l'instance pour l'utiliser dans la méthode magique __toString afin de créer un champ de formulaire.
Le but est d'obtenir, après validation du formulaire, les variables $_POST avec les bons noms (dans cet exemple $_POST['photo_avant'] et $_POST['photo_apres']) pour pouvoir automatiser leur traitement à coup de

Code : Tout sélectionner

foreach($_POST as $key => $value) $monprojet->$key=$value;

Je ne comprends pas bien à quoi sert le "singleton" et je ne crois pas qu'il puisse m'aider pour générer mes champs de formulaire.

Ca permet d'avoir qu'une Instance... L'intéret est multiple. Le plus classique est l'accès aux DB.

Je parlais pool dans le précédent post, je pense que tu peux tenter de t'orienter par la. Petit exemple:
L'enregistrement se fait sur toutes instances.

abstract class Toto
{
   // Tableau des instances
   //
   private static $arrayPool = Array();

   // Même principe que le Singleton: Ni New & ni Clone
   //
   private function __construct()
   {
   }
   private function __clone()
   {
   }

   // Initialisation
   //
   function static register($name, $mixed)
   {
      if (!is_string($name)) die ("Argument attendu de type chaine !");
      if (isset(self::$arrayPool[$name])) die ("Argument invalide, ID déja référencé !");
      if (!is_object($mixed) && !is_string($mixed)) die("Argument attendu string ou instance !");
      if (is_string($mixed) && !class_exists($mixed)) die("La class est introuvable !");

      self::$arrayPool[$name] = is_object($mixed) ?  new $mixed() : $mixed;
      return self::$arrayPool[$name];
   }

   // Récupère l'instance
   //
   function static getInstance($name)
   {
      if (!is_string($name)) die("Argument attendu de type chaine !");
      if (isset(self::$arrayPool[$name])) die ("Clef inconnue, instance introuvable !");
      return self::$arrayPool[$name];
   }
   .
   .
   .
}

Voila, une class de pool d'instances (ce pattern porte un nom mais j'ai un trou. L'appel se fait par

(instance)Toto::register("clef", "nom de class");
(instance)Toto::register("clef", Instance);

(instance)Toto::getInstance("clef");

Le retour est biensur l'instance de l'objet venant d'être enregistré. A toi de modifier/adapter...

J'oubliais tu as aussi la variante qui est: Utiliser comme instance le parent de la class utilisée
pour le pool.

Exemple rapide:

// La class qui sera enregistrée 
//
class ParentToto
{
   // En admétant qu'on ne veuille l'instancier
   //
   protected function __construct()
   {
   }

   private function __clone()
   {
   }
   .
   .
   .
}

abstract class Toto
{
   // Tableau des instances
   //
   private static $arrayPool = Array();

   // Initialisation
   //
   function static register($name)
   {
      if (!is_string($name)) die ("Argument attendu de type chaine !");
      if (isset(self::$arrayPool[$name])) die ("Argument invalide, ID déja référencé !");

      self::$arrayPool[$name] = new parent();
      return self::$arrayPool[$name];
   }

   // Récupère l'instance
   //
   function static getInstance($name)
   {
      if (!is_string($name)) die("Argument attendu de type chaine !");
      if (isset(self::$arrayPool[$name])) die ("Clef inconnue, instance introuvable !");
      return self::$arrayPool[$name];
   }
   .
   .
   .
}

Voila, je pense que tu as un peu plus de matos pour réaliser ce que tu veux.

@+ bon code

PS: Après relecture de ton post, mon exemple 1 semble correspondre à ce que tu cherches.

EDIT:
1) Désolé j'ai fais avec moins de commentaires mais bon...
2) Possible qu'il y ait 1 ou 2 coquilles mais à vu de nez le script est bon

Je crois qu'il va me falloir de la doc détaillée, parce que là, je ne comprends rien ("pattern", "pool", des classes "abstraites", la syntaxe avec ::, les propriétés et les méthodes "statiques", etc.).

Je crois qu'il va me falloir de la doc détaillée, parce que là, je ne comprends rien ("pattern", "pool", des classes "abstraites", la syntaxe avec ::, etc.).

Tsss... tsss... Je vois ton oeuil plein de curiosité

Plus sèrieux, même si ce sont des termes "barbares" c'est assez simple. Donc t'en fais pas, tout
viendra au moment ou ca viendra. Essaie d'apréhender la logique Objet après ce sera du
gateau.

Bon, pas tout ca mais je dois y aller, @+

PS: Hesite pas si tu as des questions.

tiré de la doc de PHP :

 the_good_technician [a.t.] y-a-h-o-o.
07-Aug-2009 04:32
Sometimes it's necessary to retrieve the value of $this from within an object.
This solution dedicates a public var $ID to store a unique identifier for the object:

<?php
class Someclass {
    public $ID;
   
    public function what_is_this() {
        return '$this is: ' . $this->get_varname();
    }
    private function get_varname() {
        $this->ID = uniqid();
        foreach($GLOBALS as $key => $val) {
            if (is_a($val,'Someclass')) {
                if ($val->ID === $this->ID) {
                    return $key;
                    break;
                }
            }
        }
    }
}

// example:
$my_var_instance = new Someclass;
echo $my_var_instance->what_is_this();   // returns '$this is: my_var_instance'
?>

Bye Hawk

Plus sèrieux, même si ce sont des termes "barbares" c'est assez simple. Donc t'en fais pas, tout
viendra au moment ou ca viendra. Essaie d'apréhender la logique Objet après ce sera du
gateau.

Justement : comment appréhender la logique objet en question et la syntaxe qui va avec ? Est-ce que tu aurais des tutoriels du genre "la programmation objet en PHP pour les nuls mais complète quand même" ?

Parce que autant j'ai envie de dire "merci pour les exemples de code", autant je ne sais pas du tout comment les employer, les adapter, les appréhender. C'est un peu comme si je parlais anglais depuis 3 semaines et qu'on me donne une pièce de Shakespeare à traduire.

tiré de la doc de PHP

Ah merci, je vais regarder ça en détail.
EDIT : mouais, je suis pas vraiment convaincu par cette solution : mon système fonctionne de telle façon que ça ne m'arrange pas du tout de rajouter une propriété (ID) à mes classes. Comme leurs propriétés correspondent aux colonnes des tables que je manipule, je ne peux rien garantir : si je manipule une table qui a une colonne "ID", ça fout tout en l'air.

Rah... Pas le temps...

Ok quelques info/doc pour php

http://www.phpfrance.com/ (yep, je sais...)
http://www.php.net
http://www.developpez.net

y en a d'autres (bcp d'autres) mais vraiment pas le temps ce soir.
Je t'en refiles demain.

j'y go @+

EDIT:

http://hachesse.developpez.com/objetphp/
http://www.siteduzero.com/tutoriel-3-14 ... n-php.html
http://www.apprendre-php.com/tutoriels/ ... t-poo.html
http://php.developpez.com/cours/?page=langage

Ce n'est pas une liste exaustive mais bon...

Voila, tout ce que je peux dire c'est bonne lecture et de te confirmer le fait que c'est
très simple même si l'aspect le laisse peu supposer.

D'autre part (sans rapport, vraiment, direct avec la POO) les auteurs qui m'ont aidés
à apréhender les objets et la logique de prog: Michael Tisher & Claude Delanoy.
Je dois dire que ca m'a pas mal aidé quand je me suis tourné vers les objets.
L'un est plus Système, l'autre plus C... A toi de voir l'intérêt et peut-être de les lire.

Bon, j'y re-go, @+

Merci, je vais regarder tout ça.