PHP está manejando incorrectamente mi llamada estática

class methods

Question

Tengo un problema en PHP 5.3. Necesito llamar a un método usando __callStatic , pero si lo uso en un objeto instancied, PHP llama a __call en __call lugar.

Por encima de un ejemplo de la vida real:

<?php
class A {
function __call($method, $args){
// Note: $this is defined!
echo "Ops! Don''t works. {$this->c}";
}
static function __callStatic($method, $args){
echo ''Fine!'';
}
}
class B extends A {
public $c = ''Real Ops!'';
function useCallStatic(){
static::foo();
// === A::foo();
// === B::foo();
}
}
$foo = new B();
$foo->useCallStatic();
// This works:
// B::foo();
?>

Grabados : ¡Ops! No funciona Real Ops!

Tenga en cuenta que llamo useCallStatic desde un new B() . Si llamo directamente funciona bien como B::foo() .

¿Qué puedo hacer para que funcione bien?

Answer 1

Esto es probablemente debido a la notación estándar de llamar a los métodos principales, independientemente del estado. Usted podría verificar si $this palabra clave está establecida en el método __call y si no, haga una llamada a __callStatic ?

EDITAR: Esto no es un error per se, la llamada estática se realiza desde un contexto de objeto. Eche un vistazo a este hilo de error en php .

Answer 2

La herencia de métodos estáticos es un poco raro en PHP. Sospecho que debes redefinir __callStatic en B

Answer 3

Después de pensarlo, no es realmente un error. Pero definitivamente no es intuitivo.

<?php
class A
{
public function foo()
{
static::bar();
}
public function bar()
{
echo "bar()/n";
}
}
$a = new A();
$a->foo();

Esto es válido y llama a bar (). No significa barra de llamada estáticamente. Significa buscar el nombre de clase actual y la bar función de llamada bar si existe, ya sea que se trate de una función estática o no.

Para aclarar un poco más: ¿crees que parent::bar() significa llamar a una función estática llamada bar() ? No, significa que llamar a cualquier función se llama bar() .

Considerar:

<?php
class A
{
function __call($name, $args)
{
echo "__call()/n";
}
static function __callStatic($name, $ags)
{
echo "__callStatic()/n";
}
function regularMethod()
{
echo "regularMethod()/n";
}
static function staticMethod()
{
echo "staticMethod()/n";
}
}
class B extends A
{
function foo()
{
parent::nonExistant();
static::nonExistant();
parent::regularMethod();
parent::staticMethod();
}
}
$b = new B();
$b->foo();

El método parent::nonExistant() invoca A::__call() , al igual que static::nonExistant() . Invocar A::__callStatic() para cualquiera de las llamadas sería igual de válido. No hay forma de que PHP sepa a cuál te quieres llamar. Sin embargo, por diseño, PHP le da a __call la prioridad cuando se invoca desde este tipo de contexto.

parent::regularMethod() invoca la función no estática regularMethod() . (De nuevo, el operador :: no significa "llamar a esta función estática"). Asimismo, parent::staticMethod() invoca A::staticMethod() como uno podría esperar.

Para resolver su problema:

Puede llamar manualmente a self::__callStatic(''foo'') en la clase heredada.

O dentro del método __call del filtro clase A contra una lista conocida y llame a self::__callStatic .

function __call($f, $a)
{
if ($f == ''foo'')
return self::__callStatic($f, $a);
else
{
}
}

Es feo, pero al menos las personas que extienden la clase no necesitarán hacer nada especial.

Answer 4

Primero, asegúrese de estar usando PHP 5.3.0 o posterior, ya que es cuando se implementó __callStatic. Todo parece funcionar como se esperaba, ver este ejemplo:

<?php
class A {
public function __call($method, $args) {
echo ''A::__call, '' .
var_export(array($method, $args), true), PHP_EOL;
}
/** As of PHP 5.3.0 */
public static function __callStatic($method, $args) {
echo ''A::__callStatic, '' .
var_export(array($method, $args), true), PHP_EOL;
}
}
$a = new A;
$a->foo(''abc'');
A::bar(''123'');
class B extends A {
function invokeStatic($args) {
echo ''B::invokeStatic'', PHP_EOL;
self::someStatic($args);
}
}
$b = new B;
$b->invokeStatic(''456'');
?>

La salida debe ser (o al menos, es para mí):

A::__call, array (
0 => ''foo'',
1 =>
array (
0 => ''abc'',
),
)
A::__callStatic, array (
0 => ''bar'',
1 =>
array (
0 => ''123'',
),
)
B::invokeStatic
A::__callStatic, array (
0 => ''someStatic'',
1 =>
array (
0 => ''456'',
),
)

Cuando ejecuto su ejemplo anterior, me sale "¡Bien!" como el único resultado, que es exactamente lo que habría esperado.

¿Exactamente qué versión de PHP estás ejecutando? Puedes verificar con esto:

$ php -r ''echo phpversion(), PHP_EOL;''
5.3.3-7+squeeze1

Answer 5

Buenas noticias

Hago un gran trabajo alrededor, pero funciona bastante bien. Este es el código:

class NoContext {
public static function call($callback, $args = null){
return call_user_func_array($callback, $args ?: array());
}
}

NoContext::call llamar a NoContext::call (estáticamente) como si llamara call_user_func o similar. Eliminará el $this contexto. Todavía creo que es un error de PHP, pero ...

Para resolver mi problema, lo hago:

class B extends A {
function useCallStatic(){
NoContext::call(''A::foo'');
}
}

Y se imprimirá: Fine! .

Gracias a todos los que me ayudan. Realmente aprendo demasiado con tus respuestas y espero que mis consejos sean útiles para ti alguna vez.