php - remove - strip_tags wordpress

¿Cómo anular la función de rasgo y llamarla desde la función anulada?

Question

Guión:

trait A {
    function calc($v) {
        return $v+1;
    }
}

class MyClass {
    use A;

    function calc($v) {
        $v++;
        return A::calc($v);
    }
}

print (new MyClass())->calc(2); // should print 4

Este código no funciona, y no puedo encontrar una manera de llamar a una función de rasgo como si fuera heredada. Intenté llamar self::calc($v) , static::calc($v) , parent::calc($v) , A::calc($v) y lo siguiente:

trait A {
    function calc($v) {
        return $v+1;
    }
}

class MyClass {
    use A {
        calc as traitcalc;
    }

    function calc($v) {
        $v++;
        return traitcalc($v);
    }
}

Nada funciona.

¿Hay alguna forma de hacerlo funcionar o debo anular completamente la función de rasgo que es mucho más compleja que esta :)

Answer 1

Si la clase implementa el método directamente, no utilizará la versión de rasgos. Quizás en lo que estás pensando es:

trait A {
    function calc($v) {
        return $v+1;
    }
}

class MyClass {
    function calc($v) {
        return $v+2;
    }
}

class MyChildClass extends MyClass{
}

class MyTraitChildClass extends MyClass{
    use A;
}

print (new MyChildClass())->calc(2); // will print 4

print (new MyTraitChildClass())->calc(2); // will print 3

Debido a que las clases secundarias no implementan el método directamente, primero usarán el del rasgo si, de lo contrario, usarán el de la clase principal.

Si lo desea, el rasgo puede usar el método en la clase principal (suponiendo que sepa que el método estaría allí) por ejemplo

trait A {
    function calc($v) {
        return parent::calc($v*3);
    }
}
// .... other code from above
print (new MyTraitChildClass())->calc(2); // will print 8 (2*3 + 2)

También puede proporcionar maneras de anular, pero aún así acceder al método de rasgo de la siguiente manera:

trait A {
    function trait_calc($v) {
        return $v*3;
    }
}

class MyClass {
    function calc($v) {
        return $v+2;
    }
}


class MyTraitChildClass extends MyClass{
    use A {
      A::trait_calc as calc;
    }
}


class MySecondTraitChildClass extends MyClass{
    use A {
      A::trait_calc as calc;
    }

    public function calc($v) {
      return $this->trait_calc($v)+.5;
    }
}


print (new MyTraitChildClass())->calc(2); // will print 6
echo "/n";
print (new MySecondTraitChildClass())->calc(2); // will print 6.5

Puede verlo funcionar en http://sandbox.onlinephpfunctions.com/code/e53f6e8f9834aea5e038aec4766ac7e1c19cc2b5

Answer 2

Tu último estaba casi allí:

trait A {
    function calc($v) {
        return $v+1;
    }
}

class MyClass {
    use A {
        calc as protected traitcalc;
    }

    function calc($v) {
        $v++;
        return $this->traitcalc($v);
    }
}

El rasgo no es una clase. No puedes acceder a sus miembros directamente. Básicamente es simplemente copiar y pegar automáticamente ...

Answer 3

Un enfoque alternativo si está interesado: con una clase intermedia adicional para utilizar la forma normal de OOO. Esto simplifica el uso con parent :: methodname

trait A {
    function calc($v) {
        return $v+1;
    }
}

// an intermediate class that just uses the trait
class IntClass {
    use A;
}

// an extended class from IntClass
class MyClass extends IntClass {
    function calc($v) {
        $v++;
        return parent::calc($v);
    }
}

Answer 4

Usando otro rasgo:

trait ATrait {
    function calc($v) {
        return $v+1;
    }
}

class A {
    use ATrait;
}

trait BTrait {
    function calc($v) {
        $v++;
        return parent::calc($v);
    }
}

class B extends A {
    use BTrait;
}

print (new B())->calc(2); // should print 4