PHP 5: const vs static

Was ist in PHP 5 der Unterschied zwischen constund static?

Wann ist jeder angemessen? Und welche Rolle spielt public, protectedund privatespielen - wenn überhaupt?

Im Kontext einer Klasse befinden sich statische Variablen im Bereich des Klassenbereichs (nicht des Objekts), aber im Gegensatz zu einer Konstante können ihre Werte geändert werden.

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.

Öffentlich, geschützt und privat sind in Bezug auf Konstanten (die immer öffentlich sind) irrelevant. Sie sind nur für Klassenvariablen nützlich, einschließlich statischer Variablen.

• Auf öffentliche statische Variablen kann überall über die Variable ClassName :: $ zugegriffen werden.
• Auf geschützte statische Variablen kann von der definierenden Klasse oder von erweiterten Klassen über die Variable ClassName :: $ zugegriffen werden.
• Auf private statische Variablen kann nur die definierende Klasse über die Variable ClassName :: $ zugreifen.

Bearbeiten: Es ist wichtig zu beachten, dass PHP 7.1.0 die Unterstützung für die Angabe der Sichtbarkeit von Klassenkonstanten eingeführt hat .

Ein letzter Punkt, der gemacht werden sollte, ist, dass eine Konstante immer statisch und öffentlich ist. Dies bedeutet, dass Sie innerhalb der Klasse wie folgt auf die Konstante zugreifen können:

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

Von außerhalb der Klasse würden Sie wie folgt darauf zugreifen:

echo MyClass::MYCONST;

Konstante ist nur eine Konstante, dh Sie können ihren Wert nach dem Deklarieren nicht ändern.

Auf statische Variablen kann zugegriffen werden, ohne eine Instanz einer Klasse zu erstellen, und daher von allen Instanzen einer Klasse gemeinsam genutzt werden.

Es kann auch eine statische lokale Variable in einer Funktion geben, die nur einmal deklariert wird (bei der ersten Ausführung einer Funktion) und deren Wert zwischen Funktionsaufrufen speichern kann. Beispiel:

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

Wenn Sie über Klassenvererbung sprechen, können Sie mithilfe von selfund staticSchlüsselwörtern zwischen Konstanten oder Variablen in verschiedenen Bereichen unterscheiden . Überprüfen Sie dieses Beispiel, das zeigt, wie Sie auf was zugreifen können:

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

Und dann mache:

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

oder:

Pirate::getType();

Ausgabe:

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

Mit anderen Worten self::bezieht sich auf die statische Eigenschaft und Konstante aus demselben Bereich, in dem sie aufgerufen wird (in diesem Fall die PersonOberklasse), während static::auf die Eigenschaft und Konstante aus dem Bereich zur Laufzeit zugegriffen wird (in diesem Fall also in der PirateUnterklasse).

Weitere Informationen zur späten statischen Bindung finden Sie hier auf php.net .
Überprüfen Sie auch die Antwort auf eine andere Frage hier und hier .

Wenn Sie eine Klassenmethode oder -eigenschaft als statisch deklarieren, können Sie auf sie zugreifen, ohne dass eine Instanziierung der Klasse erforderlich ist.

Eine Klassenkonstante ist wie eine normale Konstante und kann zur Laufzeit nicht geändert werden. Dies ist auch der einzige Grund, warum Sie const jemals verwenden werden.

Privat, öffentlich und geschützt sind Zugriffsmodifikatoren, die beschreiben, wer auf welchen Parameter / welche Methode zugreifen kann.

Öffentlich bedeutet, dass alle anderen Objekte Zugriff erhalten. Privat bedeutet, dass nur die instanziierte Klasse Zugriff erhält. Geschützt bedeutet, dass die instanziierte Klasse und die abgeleiteten Klassen Zugriff erhalten.

Hier sind die Dinge, die ich bisher über statische Elemente, konstante Variablen und Zugriffsmodifikatoren (privat, öffentlich und geschützt) gelernt habe. Konstante

Definition

Wie der Name schon sagt, können Werte einer konstanten Variablen nicht geändert werden. Konstanten unterscheiden sich von normalen Variablen darin, dass Sie das $ -Symbol nicht zum Deklarieren oder Verwenden verwenden.

Der Wert muss ein konstanter Ausdruck sein, nicht (zum Beispiel) eine Variable, eine Eigenschaft, ein Ergebnis einer mathematischen Operation oder ein Funktionsaufruf.

Hinweis: Der Wert der Variablen darf kein Schlüsselwort sein (z. B. self, parent und static).

Deklarieren einer Konstante in PHP

<?php
class constantExample{

   const CONSTANT = 'constant value'; //constant

 }
?>

Der Bereich von Constant ist global und kann über ein self-Schlüsselwort aufgerufen werden

<?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

?>

Statisch

Definition

Das statische Schlüsselwort kann zum Deklarieren einer Klasse, einer Elementfunktion oder einer Variablen verwendet werden. Auf statische Elemente in einer Klasse, die global ist, kann auch mit einem Selbstschlüsselwort zugegriffen werden. Wenn Sie Klasseneigenschaften oder -methoden als statisch deklarieren, können Sie auf sie zugreifen, ohne dass eine Instanziierung der Klasse erforderlich ist . Auf eine als statisch deklarierte Eigenschaft kann mit einem instanziierten Klassenobjekt nicht zugegriffen werden (obwohl dies mit einer statischen Methode möglich ist). Wenn keine Sichtbarkeitserklärung (öffentlich, privat, geschützt) verwendet wird, wird die Eigenschaft oder Methode so behandelt, als ob sie als öffentlich deklariert worden wäre. Statische Methoden können ohne eine Instanz des erstellten Objekts aufgerufen werden.

Hinweis: Die Pseudovariable $ this ist in der als statisch deklarierten Methode nicht verfügbar. Auf statische Eigenschaften kann mit dem Pfeiloperator -> nicht über das Objekt zugegriffen werden

Ab PHP 5.3.0 ist es möglich, die Klasse mithilfe einer Variablen zu referenzieren. Der Wert der> Variablen kann kein Schlüsselwort sein (z. B. self, parent und static).

Beispiel für statische Eigenschaften

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

?>

Beispiel für den Zugriff auf statische Eigenschaften und Funktionen

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

 ?>

Öffentlich, privat, geschützt (AKA-Zugriffsmodifikatoren)

Bevor Sie die folgende Definition lesen, lesen Sie diesen Artikel über Kapselung. Er wird Ihnen helfen, das Konzept besser zu verstehen

Link 1 Wikipedia

Tutorials zeigen Link zur Kapselung

Definition

Mit privaten, öffentlichen und geschützten Schlüsselwörtern können Sie den Zugriff auf die Mitglieder einer Klasse steuern. Als öffentlich deklarierte Klassenmitglieder können überall zugegriffen werden. Auf Mitglieder, die als geschützt deklariert wurden, kann nur innerhalb der Klasse selbst sowie von geerbten und übergeordneten Klassen zugegriffen werden. Als privat deklarierte Mitglieder dürfen nur von der Klasse aufgerufen werden, die das Mitglied definiert.

Beispiel

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

} 
 ?> 

Zugriff auf das Beispiel für öffentliche, private und geschützte Mitglieder

Auf öffentliche Variablen kann von außerhalb der Klasse oder innerhalb der Klasse zugegriffen und geändert werden. Sie können jedoch nur innerhalb der Klasse auf die privaten und geschützten Variablen und Funktionen zugreifen. Sie können den Wert von geschützten oder öffentlichen Mitgliedern außerhalb der Klasse nicht ändern.

  <?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)

  ?>

Weitere Informationen finden Sie in dieser PHP-Dokumentation zur Sichtbarkeit. Sichtbarkeit Php Doc

Referenzen: php.net

Ich hoffe du hast das Konzept verstanden. Danke fürs Lesen :) :) Hab einen guten

Um es auf @Matt noch einmal zusammenzufassen:

• Wenn die von Ihnen benötigte Eigenschaft nicht geändert werden soll, ist eine Konstante die richtige Wahl

• Wenn die von Ihnen benötigte Eigenschaft geändert werden darf, verwenden Sie stattdessen static

Beispiel:

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

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

Bearbeiten: Es ist wichtig zu beachten, dass PHP 7.1.0 die Unterstützung für die Angabe der Sichtbarkeit von Klassenkonstanten eingeführt hat .