[POO] Comportement statique d'un objet [Résolu]

[Benjamin Delespierre]

Bonsoir à tous.

Ça fait un moment que je fraye dans les eaux nébuleuses des bizarreries de l'implémentation de l'OOP en PHP 5.3.x mais je suis tombé à la renverse récemment en voyant ça:

Code :

1
2
3
 
class a { public function sayHello () { echo "hello"; } }
a::sayHello(); // Affiche hello

Je n'étais jamais tombé dessus par avant (et pour cause, je pensait ça tout bonnement impossible.) A moins que je ne me trompe, un tel méfait est inconcevable en Java ou d'autres langages objet (quelqu'un peut-il confirmer ?)

Du coup mon idée d'utiliser le __callStatic pour résoudre

Code :

MonSingleton::maMethodeObjet();

en

Code :

MonSingleton::instance()->maMethodeObjet()

tombe à l'eau. C'est dommage, ça aurait été bien pratique...

Vous avez des idées sur ce point ?

[stealth35]

y'a rien de choquant mais t'as un belle erreur :

Strict Standards: Non-static method a::sayHello() should not be called statically

y'aura aussi des soucis pour $this/self

[Benjamin Delespierre]

J'ai remarqué oui. C'est assez impressionnant ce manque de sécurité dans le langage.
Je me demande si c'est possible également en 5.1 ou si c'est un side effect de l'implémentation du late static binding...

[rawsrc]

Bonjour,

Autre bizzarerie du PHP 5.3.x : la résolution de constantes à la volée, oui oui et pas de fonctions statiques :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php 
 
class mere {
   static function uidcp() {
      return static::UIDCP;
   }
}
 
class fille extends mere {
   const UIDCP = 'fille123';
}
 
$a = fille::uidcp(); //$a = 'fille123'
 
?>

[stealth35]

y'a rien de choquant non plus c'est le late static binding ca

[rawsrc]

Oui je suis bien d'accord, juste que la doc de PHP n'en fait pas mention du LSB sur les constantes.

[Benjamin Delespierre]

Oui je suis bien d'accord, juste que la doc de PHP n'en fait pas mention du LSB sur les constantes.

Je sais pas, moi ça m'a paru évident.

Un autre truc qui est bien illogique:

Code :

1
2
3
4
5
 
abstract class MaClasse
{
     abstract protected static function maMethode ();
}

(j'entends d'ici un grand "c'est normal" de la part de stealth35 )

Je me pose donc la question suivante, est-ce qu'en PHP tout est par défaut publc static (un peu comme en C#) ?

[Helfima]

je vois pas le problème, si on commence à comparer les interpréteurs de chaque langage et leur syntaxe pas fini de discuter

sinon si c'est un singleton que tu voulais faire ca fonctionne très bien

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<?php
/**
* @filesource Singleton.php
* @author helfima
* @version 1.0
* Date 21 janv. 2011
*/
 
class Singleton {
	private static $_instance = null;
	private $_var = null;
 
	/**
	 * non instanciable
	 */
	private function __construct(){
		$this->_var = 'hello!';
	}
 
	/**
	 * Retourne l'instance
	 * @return Singleton
	 */
	public static function getInstance(){
		if(is_null(self::$_instance)){
			self::$_instance = new Singleton();
		}
		return self::$_instance;
	}
 
	/**
	 * affiche la var
	 */
	public function maVariable(){
		echo $this->_var;
	}
}
Singleton::getInstance()->maVariable();// affiche bien la variable

tu as juste à écrire comme en java pour être strict, faut juste faire attention au $this(normal) / self (static)

[Benjamin Delespierre]

Ouais enfin, le but c'était de proposer un accès direct aux méthodes de l'objet interne sans avoir à tout redéclarer / redéfinir dans le singleton.

A la base, je voulais détourner l'usage de __callStatic pour ça... mais visiblement c'est impossible sans une méthode invoke() (pas __invoke) ce qui est absurde puisqu'on a instance().

Tien au passage, voila mon singleton:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
/**
 * Singleton abstract class
 *
 * @author Delespierre
 * @version 1.0.0
 * @package cobalt\utilities
 */
abstract class Singleton extends Object implements Identifiable
{
    /**
     * Inner instance of singleton
     * @var Singleton
     */
    protected static $_instance;
 
    /**
     * Constructor visibility MUST be protected
     */
    protected function __construct () {}
 
    /**
     * Protected method intended to initialize the object
     */
    protected function _init() {}
 
    /**
     * Instance method
     *
     * Will create the instance if wasn't previously in use.
     * Returns the inner and unique instance.
     * May take as parameters the equivalent of the current
     * child class constructor parameters.
     *
     * @throws Exception
     * @return Singleton
     */
    public static function instance ()
    {
        if (!isset(self::$_instance))
        {
            $c = static::whoami();
            try { self::$_instance = new $c(); }
            catch (Exception $e) { throw $e; }
 
            // Initialize
            if ($args = func_get_args())
            {
                switch (count($args))
                {
                    case 0:
                        static::_init(); break;
                    case 1:
                        static::_init($args[0]); break;
                    case 2:
                        static::_init($args[0], $args[1]); break;
                    case 3:
                        static::_init($args[0], $args[1], $args[2]); break;
                    case 4:
                        static::_init($args[0], $args[1], $args[2], $args[3]); break;
                    case 5:
                        static::_init($args[0], $args[1], $args[2], $args[3], $args[4]); break;
                    default:
                        call_user_func_array(array(self::$_instance, "_init"), func_get_args()); break;
                }
            }
        }
        return self::$_instance;
    }
 
    /**
     * Shorthand to access object methods from static context
     *
     * E.G.
     * > SomeSingletonClass::someObjectMethod($a,$b,$c);
     * Will be equivalent as
     * > SomeSingletonClass::instance()->someObjectMethod($a,$b,$c)
     *
     * Will have the behavior of the called method or will
     * throw a bad method call exception if the methods isn't callable.
     *
     * @param string $name
     * @param array $args
     * @throws BadMethodCallException
     * @return mixed
     */
    public static function __callStatic ($name, $args)
    {
        if (is_callable(array(self::instance(), $name)))
        {
            return call_user_func_array(array(self::instance(), $name), $args);
        }
        throw new BadMethodCallException("$name is innacessible for " . static::whoami());
    }
}

Je vais être obligé d'enlever le __callStatic puisque, et c'est le sujet du topic, il n'est jamais appellé.

[Helfima]

ah ben d'après la doc php il faut que ton serveur php soit au moins en version 5.3.0 pour utiliser

Code :

public static function __callStatic ($name, $args)

[grunk]

Je dis peut être une connerie mais le principe du singleton n'est il pas d’empêcher plusieurs instances d'une classe ?

Si ta classe est en abstract , elle ne peux pas être instanciée, du coup le singleton n'a pas lieu d'être si ?

[stealth35]

Envoyé par grunk

Je dis peut être une connerie mais le principe du singleton n'est il pas d’empêcher plusieurs instances d'une classe ?

Si ta classe est en abstract , elle ne peux pas être instanciée, du coup le singleton n'a pas lieu d'être si ?

elle non mais les classes fille oui, sinon oui le singleton garde qu'une seule instance

[Benjamin Delespierre]

ah ben d'après la doc php il faut que ton serveur php soit au moins en version 5.3.0 pour utiliser

Non, ce n'est pas pour cette raison que j'ai dit que j'allais l'enlever. Bien sûr je travaillle en 5.3.2. Considère le code suivant:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
abstract class Singleton
{
	protected static $_instance;
 
	protected function __construct () { }
 
	abstract public static function whoami ();
 
	public static function instance ()
	{
		if (!isset(self::$_instance))
		{
			$c = static::whoami();
			self::$_instance = new $c(); // on va simplifier avec un constructeur sans paramètre pour l'exemple
		}
		return self::$_instance;
	}
 
	public static function __callStatic ($method, $args)
	{
		echo __METHOD__ . " called!";
		if (is_callable(array(self::$_instance, $method)))
		{
			return call_user_func_array(array(self::$_instance, $method), $args);
		}
		throw new BadMethodCallException("$method not found");
	}
}
 
class MySingleton extends Singleton
{
	public static function whoami() { return __CLASS__; }
 
	protected function __construct () { echo __METHOD__ . " called!"; }
 
	public function testA () { echo __METHOD__ . " called!"; }
 
	public function testB () { echo __METHOD__ . " called!"; }
}
 
MySingleton::instance();
 
MySingleton::testA();
MySingleton::testB();

On s'attends à avoir

Code :

1
2
3
4
5
6
 
MySingleton::__construct called!
MySingleton::__callStatic called!
MySingleton::testA called!
MySingleton::__callStatic called!
MySingleton::testB called!

mais on a

Code :

1
2
3
4
 
MySingleton::__construct called!
MySingleton::testA called!
MySingleton::testB called!

Ce qui signifie que __callStatic n'est pas appellé. Donc si on utilise $this dans testA ou testB, on part en fatal error.

ça signifie qu'il est possible en PHP d'appeller des méthodes d'instance comme des méthodes statiques! Personnellement ça me choque, mais c'est un point de vue que ne partage pas stealth35

C'est domage car ça m'aurait évité de devoir faire systématiquement:

Code :

1
2
3
 
MySingleton::instance()->testA();
MySingleton::instance()->testB();

[stealth35]

c'est pas self qui faut utilise mais static a la place

et la t'as :

Code :

1
2
3
4
5
6
Strict Standards: Static function Singleton::whoami() should not be abstract
MySingleton::__construct called!
Strict Standards: Non-static method MySingleton::testA() should not be called statically
MySingleton::testA called!
Strict Standards: Non-static method MySingleton::testB() should not be called statically
MySingleton::testB called!

faut savoir que call est appelle uniquement si la methode n'existe pas, or la testA et testB existe
si tu veux le callStatic il faut faire : MySingleton::testC();

Envoyé par Benjamin Delespierre

ça signifie qu'il est possible en PHP d'appeller des méthodes d'instance comme des méthodes statiques! Personnellement ça me choque, mais c'est un point de vue que ne partage pas stealth35

tu peux le faire, mais t'as une erreur

[Benjamin Delespierre]

Code :

Strict Standards: Static function Singleton::whoami() should not be abstract

Celui-là je dois dire que je m'y attendait pas... Une idée Stealth ?

C'est louche, je n'ai pas cette erreur:

Code :

1
2
3
4
5
6
7
 
// produit chez moi avec ini_set('error_reporting', E_STRICT);
MySingleton::__construct called!
Strict Standards: Non-static method MySingleton::testA() should not be called statically in C:\wamp2\www\index.php(216) : eval()'d code on line 45
MySingleton::testA called!
Strict Standards: Non-static method MySingleton::testB() should not be called statically in C:\wamp2\www\index.php(216) : eval()'d code on line 46
MySingleton::testB called!

Et pis:

tu peux le faire, mais t'as une erreur

Justement, je veux pas le faire, je veux forcer l'appel de __callStatic, mais c'est visiblement impossible. Alors tant pis, l'API sera moins belle c'est tout.

[stealth35]

tu peux pas le forcer __callStatic est appelle uniquement si la methode n'existe pas, la elle existe ton il passera pas par __callStatic, dans ce qu'a la utilise du Delegate, sinon pour ton niveau d'erreur c'est pas E_STRICT mais E_ALL | E_STRICT, si y'a pas le E_ALL ca marche pas

Envoyé par Benjamin Delespierre

Code :

Strict Standards: Static function Singleton::whoami() should not be abstract

Celui-là je dois dire que je m'y attendait pas... Une idée Stealth ?

tu ne peux pas faire de l'abstract sur du static

[stealth35]

si vous voulez un truc plus marrant y'a ca :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class A
{
    public $test = 'test';
 
    public function __construct()
    {
        B::testB();
    }
}
 
class B
{
    public function testB()
    {
        echo $this->test;
    }
}
 
new A();

[Benjamin Delespierre]

Ahaha, en effet, c'est n'importe quoi!

Mais comment ils ont implémenté la POO les gars de chez Zend ? C'est à se demander.

[Benjamin Delespierre]

tu ne peux pas faire de l'abstract sur du static

Ok, voyons ce qu'il en est dans une interface:

Code :

1
2
3
4
5
6
7
 
ini_set('error_reporting', E_ALL & E_STRICT);
interface A { public static function test (); }
abstract class B implements A { public static function launchTest() { static::test(); } }
class C extends B { public static function test () { echo "test"; } }
 
C::launchTest();

Produit "test" sans erreur

[stealth35]

Envoyé par Benjamin Delespierre

Ok, voyons ce qu'il en est dans une interface:

Code :

Produit "test" sans erreur

yep c'est la bonne méthode