PHP 5: const vs statique

En PHP 5, quelle est la différence entre utiliser constet static?

Quand est-ce que chacun est approprié? Et quel rôle public, protectedet le privatejeu - le cas échéant?

Dans le contexte d'une classe, les variables statiques sont sur la portée de la classe (pas l'objet), mais contrairement à un const, leurs valeurs peuvent être modifiées.

class ClassName {
    static $my_var = 10;  /* defaults to public unless otherwise specified */
    const MY_CONST = 5;
}
echo ClassName::$my_var;   // returns 10
echo ClassName::MY_CONST;  // returns 5
ClassName::$my_var = 20;   // now equals 20
ClassName::MY_CONST = 20;  // error! won't work.

Public, protected et private ne sont pas pertinents en termes de consts (qui sont toujours publics); ils ne sont utiles que pour les variables de classe, y compris les variables statiques.

• les variables statiques publiques sont accessibles n'importe où via ClassName :: $ variable.
• les variables statiques protégées sont accessibles par la classe de définition ou par l'extension des classes via ClassName :: $ variable.
• les variables statiques privées ne sont accessibles que par la classe de définition via ClassName :: $ variable.

Edit: Il est important de noter que PHP 7.1.0 a introduit le support pour spécifier la visibilité des constantes de classe .

Un dernier point à souligner est qu'un const est toujours statique et public. Cela signifie que vous pouvez accéder au const depuis la classe comme suit:

class MyClass
{
     const MYCONST = true;
     public function test()
     {
          echo self::MYCONST;
     }
}

De l'extérieur de la classe, vous y accéderiez comme ceci:

echo MyClass::MYCONST;

La constante est juste une constante, c'est-à-dire que vous ne pouvez pas changer sa valeur après la déclaration.

La variable statique est accessible sans faire d'instance de classe et donc partagée entre toutes les instances d'une classe.

De plus, il peut y avoir une variable locale statique dans une fonction qui n'est déclarée qu'une seule fois (lors de la première exécution d'une fonction) et peut stocker sa valeur entre les appels de fonction, exemple:

function foo()
{
   static $numOfCalls = 0;
   $numOfCalls++;
   print("this function has been executed " . $numOfCalls . " times");
}

Lorsque vous parlez d'héritage de classe, vous pouvez différencier la constante ou la variable dans différentes portées en utilisant des mots clés selfet static. Consultez cet exemple qui illustre comment accéder à quoi:

class Person
{
    static $type = 'person';

    const TYPE = 'person';

    static public function getType(){
        var_dump(self::TYPE);
        var_dump(static::TYPE);

        var_dump(self::$type);
        var_dump(static::$type);
    }
}

class Pirate extends Person
{
    static $type = 'pirate';

    const TYPE = 'pirate';
}

Et puis faites:

$pirate = new Pirate();
$pirate::getType();

ou:

Pirate::getType();

Production:

string(6) "person" 
string(6) "pirate" 
string(6) "person" 
string(6) "pirate"

En d'autres termes, self::fait référence à la propriété statique et à la constante de la même portée où elle est appelée (dans ce cas, la Personsuperclasse), alors static::qu'elle accédera à la propriété et à la constante depuis la portée au moment de l'exécution (donc dans ce cas dans la Piratesous - classe).

En savoir plus sur la liaison statique tardive ici sur php.net .
Vérifiez également la réponse à une autre question ici et ici .

Déclarer une méthode ou une propriété de classe comme statique les rend accessibles sans avoir besoin d'une instanciation de la classe.

Une constante de classe est comme une constante normale, elle ne peut pas être modifiée à l'exécution. C'est aussi la seule raison pour laquelle vous utiliserez jamais const.

Privé, public et protégé sont des modificateurs d'accès qui décrivent qui peut accéder à quel paramètre / méthode.

Public signifie que tous les autres objets ont accès. Private signifie que seule la classe instanciée a accès. Protected signifie que la classe instanciée et les classes dérivées ont accès.

Voici ce que j'ai appris jusqu'à présent sur les membres statiques, les variables constantes et les modificateurs d'accès (privés, publics et protégés). Constant

Définition

Comme son nom l'indique, les valeurs d'une variable constante ne peuvent pas être modifiées. Les constantes diffèrent des variables normales en ce que vous n'utilisez pas le symbole $ pour les déclarer ou les utiliser.

La valeur doit être une expression constante et non (par exemple) une variable, une propriété, le résultat d'une opération mathématique ou un appel de fonction.

Remarque: la valeur de la variable ne peut pas être un mot-clé (par exemple self, parent et static).

Déclarer une constante en php

<?php
class constantExample{

   const CONSTANT = 'constant value'; //constant

 }
?>

La portée de la constante est globale et est accessible à l'aide d'un mot-clé self

<?php
class MyClass
{
    const CONSTANT = 'constant value';

    function showConstant() {
        echo  self::CONSTANT . "\n";
    }
}

echo MyClass::CONSTANT . "\n";

$classname = "MyClass";
echo $classname::CONSTANT . "\n"; // As of PHP 5.3.0

$class = new MyClass();
$class->showConstant();

echo $class::CONSTANT."\n"; // As of PHP 5.3.0

?>

Statique

Définition

Le mot-clé statique peut être utilisé pour déclarer une classe, une fonction membre ou une variable.Les membres statiques d'une classe sont globaux sont également accessibles à l'aide d'un mot-clé self.Déclarer des propriétés de classe ou des méthodes comme statiques les rend accessibles sans avoir besoin d'une instanciation de la classe . Une propriété déclarée comme statique n'est pas accessible avec un objet de classe instancié (bien qu'une méthode statique le puisse). Si aucune déclaration de visibilité (publique, privée, protégée) n'est utilisée, la propriété ou la méthode sera traitée comme si elle avait été déclarée comme publique, car les méthodes statiques sont appelables sans qu'une instance de l'objet créé.

Remarque: la pseudo-variable $ this n'est pas disponible dans la méthode déclarée comme statique.Les propriétés statiques ne sont pas accessibles via l'objet à l'aide de l'opérateur de flèche ->

Depuis PHP 5.3.0, il est possible de référencer la classe en utilisant une variable. La valeur de la variable> ne peut pas être un mot-clé (par exemple self, parent et static).

Exemple de propriété statique

<?php
class Foo
{
    public static $my_static = 'foo'; //static variable 

    public static function staticValue() { //static function example
        return self::$my_static;  //return the static variable declared globally
    }
}

?>

Exemple d'accès aux propriétés et fonctions statiques

 <?php
     print Foo::$my_static . "\n";

    $foo = new Foo();
    print $foo->staticValue() . "\n";
    print $foo->my_static . "\n";      // Undefined "Property" my_static 

    print $foo::$my_static . "\n";
    $classname = 'Foo';
    print $classname::$my_static . "\n"; // As of PHP 5.3.0

    print Bar::$my_static . "\n";
    $bar = new Bar();
    print $bar->fooStatic() . "\n";

 ?>

Public, privé, protégé (modificateurs d'accès AKA)

Avant de lire la définition ci-dessous, lisez cet article sur l'encapsulation. Il vous aidera à comprendre le concept plus en profondeur

Lien 1 wikipedia

Tutoriels pointent le lien sur l'encapsulation

Définition

En utilisant des mots-clés privés, publics et protégés, vous pouvez contrôler l'accès aux membres d'une classe. Les membres de la classe déclarés publics sont accessibles partout. Les membres déclarés protégés ne sont accessibles que dans la classe elle-même et par les classes héritées et parentes. Les membres déclarés comme privés ne sont accessibles que par la classe qui définit le membre.

Exemple

 <?php 
class Example{
 public $variable = 'value'; // variable declared as public 
 protected $variable = 'value' //variable declared as protected
 private $variable = 'value'  //variable declared as private

 public function functionName() {  //public function
 //statements
 }

 protected function functionName() {  //protected function
 //statements
 }
  private function functionName() {  //private function
   //statements
   }

} 
 ?> 

Accès à l'exemple des membres publics, privés et protégés

Les variables publiques peuvent être accédées et modifiées depuis l'extérieur de la classe ou à l'intérieur de la classe. Mais vous ne pouvez accéder aux variables et fonctions privées et protégées qu'à partir de l'intérieur de la classe. Vous ne pouvez pas modifier la valeur des membres protégés ou publics en dehors de la classe.

  <?php 
  class Example{
    public $pbVariable = 'value'; 
    protected $protVariable = 'value'; 
    private $privVariable = 'value';
    public function publicFun(){

     echo $this->$pbVariable;  //public variable 
     echo $this->$protVariable;  //protected variable
     echo $this->privVariable; //private variable
    }

   private function PrivateFun(){

 //some statements
  }
  protected function ProtectedFun(){

 //some statements
  }

  }


 $inst = new Example();
 $inst->pbVariable = 'AnotherVariable'; //public variable modifed from outside
 echo $inst->pbVariable;   //print the value of the public variable

 $inst->protVariable = 'var'; //you can't do this with protected variable
 echo $inst->privVariable; // This statement won't work , because variable is limited to private

 $inst->publicFun(); // this will print the values inside the function, Because the function is declared as a public function

 $inst->PrivateFun();   //this one won't work (private)
 $inst->ProtectedFun();  //this one won't work as well (protected)

  ?>

Pour plus d'informations, lisez cette documentation php sur la visibilité Visibilité Php Doc

Références: php.net

J'espère que vous avez compris le concept. Merci d'avoir lu :) :) Bonne lecture

Alors pour récapituler sur @Matt grande réponse:

• si la propriété dont vous avez besoin ne doit pas être modifiée, alors une constante est le bon choix

• si la propriété dont vous avez besoin est autorisée à être modifiée, utilisez plutôt statique

Exemple:

class User{
    private static $PASSWORD_SALT = "ASD!@~#asd1";
    ...
}

class Product{
    const INTEREST = 0.10;
    ...
}

Edit: Il est important de noter que PHP 7.1.0 a introduit le support pour spécifier la visibilité des constantes de classe .