Quelle est la différence entre : : (double point) et -> (flèche) en PHP ?

Question

Il existe deux façons distinctes d'accéder aux méthodes en PHP, mais quelle est la différence ?

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

et

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

Je suppose que -> (tiret avec le signe plus grand que ou chevron) est utilisé pour les fonctions pour les variables, et :: (deux points) est utilisé pour les fonctions des classes. C'est bien cela ?

Est-ce que le => L'opérateur d'assignation est utilisé uniquement pour assigner des données dans un tableau ? Est-ce que cela contraste avec l'opérateur = l'opérateur d'affectation qui est utilisé pour instancier ou modifier une variable ?

Answer 1

Lorsque la partie gauche est une instance d'objet, vous utilisez -> . Sinon, vous utilisez :: .

Cela signifie que -> est principalement utilisé pour accéder aux membres d'instance (bien qu'il puisse également être utilisé pour accéder aux membres statiques, cette utilisation est déconseillée), alors que :: est généralement utilisé pour accéder aux membres statiques (bien que dans quelques cas particuliers, il soit utilisé pour accéder aux membres d'instance).

En général, :: est utilisé pour résolution du champ d'application et il peut avoir un nom de classe, parent , self ou (en PHP 5.3) static à sa gauche. parent fait référence à l'étendue de la superclasse de la classe où il est utilisé ; self fait référence à la portée de la classe dans laquelle il est utilisé ; static fait référence à la "portée appelée" (voir liaisons statiques tardives ).

La règle est qu'un appel avec :: est un appel d'instance si et seulement si :

• la méthode cible n'est pas déclarée comme statique et
• il existe un contexte d'objet compatible au moment de l'appel, ce qui signifie que ces éléments doivent être vrais :
  1. l'appel est effectué à partir d'un contexte où $this existe et
  2. la classe de $this est soit la classe de la méthode appelée, soit une sous-classe de celle-ci.

Exemple :

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";

Sortie :

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

:: est utilisé dans statique c'est-à-dire lorsqu'une méthode ou une propriété est déclarée comme statique :

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

$result = Math::sin(123);

En outre, le :: (l'opérateur de résolution de la portée, alias Paamayim Nekudotayim ) est utilisé dans un contexte dynamique lorsque vous invoquez une méthode/propriété d'une classe parente :

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);
    }
}

-> est utilisé dans dynamique le contexte, c'est-à-dire lorsque vous avez affaire à une instance d'une classe :

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

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

Au fait : Je ne pense pas qu'utiliser Symfony soit une bonne idée quand on n'a pas d'expérience en matière de POO.

Answer 3

En fait, grâce à ce symbole, nous pouvons appeler une méthode de classe qui est statique et ne pas dépendre d'une autre initialisation...

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;
    }
}

Ici, le doWrite() ne dépend d'aucune autre méthode ou variable, et c'est une méthode statique. C'est pourquoi nous pouvons appeler cette méthode par cet opérateur sans initialiser l'objet de cette classe.

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

Mais si vous voulez appeler le write de cette manière, il générera une erreur car il dépend de l'initialisation.

Answer 4

Le site => est utilisé pour assigner des paires clé-valeur dans un tableau associatif. Par exemple :

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

Sa signification est similaire dans le foreach déclaration :

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

Answer 5

La différence entre les méthodes et les propriétés statiques et instanciées semble être l'un des plus grands obstacles pour ceux qui débutent avec la POO en PHP 5.

L'opérateur double deux-points (appelé Paamayim Nekudotayim en hébreu - futilité) est utilisé pour appeler un objet ou une propriété à partir d'un fichier de type statique le contexte. Cela signifie qu'une instance de l'objet n'a pas encore été créée.

L'opérateur flèche, à l'inverse, appelle des méthodes ou des propriétés à partir d'une référence d'une instance de l'objet.

Les méthodes statiques peuvent être particulièrement utiles dans les modèles d'objets qui sont liés à une base de données pour les méthodes de création et de suppression, puisque vous pouvez définir la valeur de retour sur l'identifiant de la table insérée et ensuite utiliser le constructeur pour instancier l'objet par l'identifiant de la ligne.