significa - self php

padre:: padre en PHP

Question

Busco una forma de acceder a la función principal, parental de una clase sin llamar al padre ... Hmmm, esa explicación suena un poco extraña así que daré un ejemplo:

class myclass
{
  public function test() { return ''level 1''; }
}
class myclass2 extends myclass
{
  public function test() { return parent::test() . ''-level 2''; }
}
class myclass3 extends myclass2
{
  public function test() { return parent::test() . ''-level 3''; }
}
$example = new myclass3();
echo $example->test(); // should display "level 1-level 2-level 3"

Me gustaría mostrar "nivel 1-nivel 3" y luego hacer algo como eso:

class myclass3 extends myclass2
{
  public function test() { return parent::parent::test() . ''-level 3''; }
}

¿Tienes una idea de cómo puedo hacer esto? (No me permiten editar myclass y myclass2, son parte de un marco ...)

Answer 1

En algunas situaciones, probablemente puede anular por completo el método de la raíz. Quiero decir, en lugar de llamar al padre de uno de los padres, puedes copiar el código de método del padre de los padres y agregar el tuyo.

Answer 2

No hay operador para obtener el objeto raíz. Haría algo como esto:

class myclass
{
  public function getRoot() { return __CLASS__; }
  public function test() { return ''level 1''; }
}
class myclass2 extends myclass
{
  public function getRoot() { return parent::getRoot(); }
}
class myclass3 extends myclass2
{
  public function getRoot() { return parent::getRoot(); }
  public function test() {
    $grandparent = self::getRoot();
    return $grandparent::test() . ''-level 3'';
  }
}
$example = new myclass3();
echo $example->test(); // should display "level 1-level 2-level 3"

Answer 3

No puede encadenar a los padres, en su lugar crea algún tipo de método GetParent () en sus clases principales que simplemente devuelve $ this;

Answer 4

No, esto no es posible Lamentablemente, no hay posibilidad de referirse directamente a la clase original, solo a sí self o a sus parent .

Answer 5

Puedes hacerlo usando get_parent_class

function get_grandparent_class($thing) {
    if (is_object($thing)) {
        $thing = get_class($thing);
    }
    return get_parent_class(get_parent_class($thing));
}

class myclass3 extends myclass2 {
    public function test() {
      $grandparent = get_grandparent_class($this);
      return $grandparent::test() . ''-level 3''; 
    }
}

O podrías usar la reflection :

function get_grandparent_class($thing) {
    if (is_object($thing)) {
        $thing = get_class($thing);
    }
    $class = new ReflectionClass($thing);
    return $class->getParentClass()->getParentClass()->getName();
}

Sin embargo, puede que no sea una buena idea, dependiendo de lo que intentes lograr.

Answer 6

Solución simple. Usa el objeto raíz myclass directamente:

class myclass3 extends myclass2
{
  public function test() { return myclass::test() . ''-level 3''; }
}

Si necesita un enfoque más general, eche un vistazo a la respuesta externa .

Answer 7

Tal vez solo puede agregar myclass2 como un objeto miembro en myclass3 e intentar codificar como:

class myclass3{
myclass2 obj2;
public function test() { return $obj2->callParentTest() . ''-level3'';}
}

Answer 8

mi enfoque: si tienes el código:

class A {
    protected function method () {
        var_dump(''A -> method'');
    }
}

class B extends A {
    protected function method () {
        var_dump(''B -> method'');
    }
}

class C extends B {
    protected function method () {
        var_dump(''C -> method'');
    }
}

y quiere que en el método de llamada de la class C de la class A (pero no de la class B ) lo refactorice al código:

<?php

class A {
    protected function method () {
        $this->methodA();
    }

    protected function methodA () {
        var_dump(''A -> method'');
    }
}

class B extends A {
    protected function method () {
        var_dump(''B -> method'');
    }
}

class C extends B {
    protected function method () {
        $this->methodA();
    }
}

Answer 9

si quieres usar la función de prueba directamente en class1, debes extender desde class1. Por favor busca sobre polimorfismo.

¿intentarás " parent::parent::parent::parent " cuando tienes clase5?

Creo que puedes agregar un parámetro de level al método de prueba. y verificarlo primero.

<?php
    class myclass
    {
        public function test($level) 
        { 
            return ''level 1''; 
        }
    }
    class myclass2 extends myclass
    {
        public function test($level) 
        { 

            return $level >= 2 ? parent::test($level) . ''-level 2'' : parent::test($level); 
        }
    }
    class myclass3 extends myclass2
    {
        public function test() 
        { 
            return parent::test(1) . ''-level 3'';
        }
    }
    $example = new myclass3();
    echo $example->test(); // should display "level 1-level 3"