PHP 5: const vs static
Dans PHP 5, quelle est la différence entre utiliser const et static?
Quand est-ce approprié? Et quel rôle jouent public, protected et private - le cas échéant?
Dans le contexte d'une classe, les variables statiques sont dans l'étendue 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 const (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 à la classe de définition ou aux classes d'extension 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 de la manière suivante:
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;
Constant n’est qu’une constante, c’est-à-dire que vous ne pouvez pas changer sa valeur après la déclaration.
La variable statique est accessible sans créer une instance d'une classe et est donc partagée entre toutes les instances d'une classe.
En outre, il peut exister une variable locale statique dans une fonction déclarée une seule fois (lors de la première exécution d'une fonction) et pouvant stocker sa valeur entre les appels de fonction, par 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 les mots-clés self et 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 ensuite faire:
$pirate = new Pirate();
$pirate::getType();
ou:
Pirate::getType();
Sortie:
string(6) "person"
string(6) "pirate"
string(6) "person"
string(6) "pirate"
En d'autres termes self:: fait référence à la propriété static et à la constante de la même portée où elle est appelée (dans ce cas, la superclasse Person,), tandis que static:: accédera à la propriété et à la constante à partir de la portée au moment de l'exécution (donc dans ce cas dans la sous-classe Pirate).
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 recourir à une instanciation de la classe.
Une constante de classe est comme une constante normale, elle ne peut pas être modifiée au moment de 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/quelle méthode.
Public signifie que tous les autres objets ont accès. Privé signifie que seule la classe instanciée obtient l'accès. Protected signifie que la classe instanciée et les classes dérivées ont accès.
Donc, pour récapituler sur @Matt, la réponse est excellente:
si la propriété dont vous avez besoin ne doit pas être modifiée, 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 .
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). Constante
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 sens 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 Constant 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
Un 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. . Une propriété déclarée comme statique est inaccessible avec un objet de classe instancié (bien qu'une méthode statique le puisse). Si aucune déclaration de visibilité (public, privé, protégé) n'est utilisée, la propriété ou la méthode sera traitée comme si elle avait été déclarée comme publique. Les méthodes statiques sont appelables sans qu'une instance de l'objet ne soit créée.
Remarque: la pseudo-variable $ this n'est pas disponible dans la méthode déclarée statique.Les propriétés statiques ne sont pas accessibles via l'objet à l'aide de l'opérateur de flèche ->
A partir de PHP 5.3.0, il est possible de référencer la classe à l'aide d'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 A.K.A)
Avant de lire la définition ci-dessous, lisez cet article sur l’encapsulation. Il vous aidera à comprendre le concept plus en profondeur.
Lien vers les tutoriels sur l'encapsulation
Définition
À l'aide de 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 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 peuvent être consultés 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 consulté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 protected ou Public 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é Visibility Php Doc
Références: php.net
J'espère que vous avez compris le concept. Merci d'avoir lu :) :) Bonne journée