que - ¿Cuál es la diferencia entre::(dos puntos) y->(flecha) en PHP?

-> en php

Question

Hay dos formas distintas de acceder a los métodos en PHP, pero ¿cuál es la diferencia?

$response->setParameter(''foo'', ''bar'');

y

sfConfig::set(''foo'', ''bar'');

Supongo que -> (guión con mayor que signo o chevron) se usa para funciones para variables, y :: (dobles puntos) se usa para funciones para clases. ¿Correcto?

¿El operador de asignación => solo se usa para asignar datos dentro de una matriz? ¿Está esto en contraste con el operador = asignación que se usa para crear instancias o modificar una variable?

Answer 1

Cuando la parte izquierda es una instancia de objeto, usa -> . De lo contrario, usas :: .

Esto significa que -> se usa principalmente para acceder a miembros de instancias (aunque también se puede usar para acceder a miembros estáticos, se desaconseja su uso), mientras que :: se usa generalmente para acceder a miembros estáticos (aunque en algunos casos especiales, se usa para acceder a los miembros de la instancia).

En general, :: se utiliza para la resolución del alcance , y puede tener un nombre de clase, parent , self o (en PHP 5.3) static a su izquierda. parent refiere al alcance de la superclase de la clase donde se usa; self refiere al alcance de la clase donde se usa; static refiere al "alcance llamado" (ver enlaces estáticos finales ).

La regla es que una llamada con :: es una llamada de instancia si y solo si:

• el método de destino no está declarado como estático y
• hay un contexto de objeto compatible en el momento de la llamada, lo que significa que debe ser cierto:
  1. la llamada se hace desde un contexto donde $this existe y
  2. la clase de $this es la clase del método que se llama o una subclase de la misma.

Ejemplo:

class A {
    public function func_instance() {
        echo "in ", __METHOD__, "/n";
    }
    public function callDynamic() {
        echo "in ", __METHOD__, "/n";
        B::dyn();
    }

}

class B extends A {
    public static $prop_static = ''B::$prop_static value'';
    public $prop_instance = ''B::$prop_instance value'';

    public function func_instance() {
        echo "in ", __METHOD__, "/n";
        /* this is one exception where :: is required to access an
         * instance member.
         * The super implementation of func_instance is being
         * accessed here */
        parent::func_instance();
        A::func_instance(); //same as the statement above
    }

    public static function func_static() {
        echo "in ", __METHOD__, "/n";
    }

    public function __call($name, $arguments) {
        echo "in dynamic $name (__call)", "/n";
    }

    public static function __callStatic($name, $arguments) {
        echo "in dynamic $name (__callStatic)", "/n";
    }

}

echo ''B::$prop_static: '', B::$prop_static, "/n";
echo ''B::func_static(): '', B::func_static(), "/n";
$a = new A;
$b = new B;
echo ''$b->prop_instance: '', $b->prop_instance, "/n";
//not recommended (static method called as instance method):
echo ''$b->func_static(): '', $b->func_static(), "/n";

echo ''$b->func_instance():'', "/n", $b->func_instance(), "/n";

/* This is more tricky
 * in the first case, a static call is made because $this is an
 * instance of A, so B::dyn() is a method of an incompatible class
 */
echo ''$a->dyn():'', "/n", $a->callDynamic(), "/n";
/* in this case, an instance call is made because $this is an
 * instance of B (despite the fact we are in a method of A), so
 * B::dyn() is a method of a compatible class (namely, it''s the
 * same class as the object''s)
 */
echo ''$b->dyn():'', "/n", $b->callDynamic(), "/n";

Salida:

B::$prop_static: B::$prop_static value B::func_static(): in B::func_static $b->prop_instance: B::$prop_instance value $b->func_static(): in B::func_static $b->func_instance(): in B::func_instance in A::func_instance in A::func_instance $a->dyn(): in A::callDynamic in dynamic dyn (__callStatic) $b->dyn(): in A::callDynamic in dynamic dyn (__call)

Answer 2

El operador => se usa para asignar pares clave-valor en una matriz asociativa. Por ejemplo:

$fruits = array(
  ''Apple''  => ''Red'',
  ''Banana'' => ''Yellow''
);

Su significado es similar en la declaración foreach :

foreach ($fruits as $fruit => $color)
  echo "$fruit is $color in color.";

Answer 3

En realidad, mediante este símbolo podemos llamar a un método de clase que es estático y no depende de otra inicialización ...

class Test {

    public $name;

    public function __construct() {
        $this->name = ''Mrinmoy Ghoshal'';
    }

    public static function doWrite($name) {
        print ''Hello ''.$name;
    }

    public function write() {
        print $this->name;
    }
}

Aquí la función doWrite () no depende de ningún otro método o variable, y es un método estático. Es por eso que podemos llamar a este método por este operador sin inicializar el objeto de esta clase.

Test::doWrite(''Mrinmoy''); // Output: Hello Mrinmoy.

Pero si desea llamar al método de write de esta manera, generará un error porque depende de la inicialización.

Answer 4

La diferencia entre los métodos y propiedades estáticos e instanciados parece ser uno de los mayores obstáculos para aquellos que recién comienzan con OOP PHP en PHP 5.

El operador de dos puntos (que se llama Paamayim Nekudotayim en hebreo - trivia) se usa cuando se llama a un objeto o propiedad desde un contexto estático . Esto significa que todavía no se ha creado una instancia del objeto.

El operador de flecha, a la inversa, llama a métodos o propiedades que provienen de una referencia de una instancia del objeto.

Los métodos estáticos pueden ser especialmente útiles en los modelos de objetos que están vinculados a una base de datos para crear y eliminar métodos, ya que puede establecer el valor de retorno para la identificación de la tabla insertada y luego usar el constructor para crear una instancia del objeto por la identificación de la fila.

Answer 5

Sí, acabo de golpear mi primer ''PHP Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM'' . Mi mal, tuve un $instance::method() que debería haber sido $instance->method() . Tonto de mí.

Lo curioso es que esto todavía funciona bien en mi máquina local (ejecutando PHP 5.3.8) - nada, ni siquiera una advertencia con error_reporting = E_ALL - pero no en absoluto en el servidor de prueba, allí explota con un error de sintaxis y una pantalla blanca en el navegador. Como el registro de PHP estaba desactivado en la máquina de prueba y la empresa de alojamiento estaba demasiado ocupada para encenderlo, no era demasiado obvio.

Entonces, una palabra de advertencia: aparentemente, algunas instalaciones de PHP le permitirán usar $ instance :: method (), mientras que otras no.

Si alguien puede ampliar sobre por qué es eso, por favor hazlo.

Answer 6

:: se usa en contexto estático , es decir. cuando algún método o propiedad se declara como estático:

class Math {
    public static function sin($angle) {
        return ...;
    }
}

$result = Math::sin(123);

Además, el operador :: (el operador de resolución de alcance, también conocido como Paamayim Nekudotayim ) se utiliza en contexto dinámico cuando se invoca un método / propiedad de una clase principal:

class Rectangle {
     protected $x, $y;

     public function __construct($x, $y) {
         $this->x = $x;
         $this->y = $y;
     }
}

class Square extends Rectangle {
    public function __construct($x) {
        parent::__construct($x, $x);
    }
}

-> se usa en contexto dinámico , es decir. cuando tratas con alguna instancia de alguna clase:

class Hello {
    public function say() {
       echo ''hello!'';
    }
}

$h = new Hello();
$h->say();

Por cierto: no creo que usar Symfony sea una buena idea cuando no tienes ninguna experiencia OOP.