PHP 5: stała vs statyczna

Jaka jest różnica między używaniem consti static?

Kiedy każdy jest odpowiedni? I jaką rolę public, protecteda privateplay - jeśli w ogóle?

W kontekście klasy zmienne statyczne znajdują się w zakresie klasy (nie obiektu), ale w przeciwieństwie do stałej, ich wartości można zmieniać.

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.

Publiczne, chronione i prywatne nie mają znaczenia w kategoriach stałych (które są zawsze publiczne); są użyteczne tylko dla zmiennych klas, w tym zmiennych statycznych.

• publiczne zmienne statyczne są dostępne w dowolnym miejscu poprzez ClassName :: $ variable.
• Dostęp do chronionych zmiennych statycznych można uzyskać za pomocą klasy definiującej lub klas rozszerzających za pośrednictwem zmiennej ClassName :: $.
• Dostęp do prywatnych zmiennych statycznych można uzyskać tylko przez klasę definiującą za pośrednictwem ClassName :: $ variable.

Edycja: Należy zauważyć, że PHP 7.1.0 wprowadziło obsługę określania widoczności stałych klas .

Ostatnim punktem, na który należy zwrócić uwagę, jest to, że stała jest zawsze statyczna i publiczna. Oznacza to, że możesz uzyskać dostęp do stałej z poziomu klasy w następujący sposób:

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

Spoza klasy można uzyskać do niej dostęp w następujący sposób:

echo MyClass::MYCONST;

Stała jest po prostu stałą, tzn. Nie można zmienić jej wartości po zadeklarowaniu.

Zmienna statyczna jest dostępna bez tworzenia instancji klasy i dlatego jest współdzielona między wszystkimi instancjami klasy.

Ponadto w funkcji może istnieć statyczna zmienna lokalna, która jest zadeklarowana tylko raz (przy pierwszym wykonaniu funkcji) i może przechowywać jej wartość między wywołaniami funkcji, na przykład:

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

Mówiąc o dziedziczeniu klas, możesz rozróżnić stałą lub zmienną w różnych zakresach za pomocą słów kluczowych selfi static. Sprawdź ten przykład, który ilustruje, jak uzyskać dostęp do:

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

A następnie wykonaj:

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

lub:

Pirate::getType();

Wynik:

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

Innymi słowy, self::odnosi się do właściwości statycznej i stałej z tego samego zakresu, w którym jest wywoływana (w tym przypadku do Personsuperklasy), podczas gdy w czasie wykonywania static::uzyskuje dostęp do właściwości i stałej z zakresu (czyli w tym przypadku wPirate podklasie).

Przeczytaj więcej o późnym wiązaniu statycznym tutaj na php.net .
Sprawdź również odpowiedź na inne pytanie tutaj i tutaj .

Zadeklarowanie metody lub właściwości klasy jako statycznej powoduje, że są one dostępne bez konieczności tworzenia wystąpienia klasy.

Stała klasy jest jak normalna stała, nie można jej zmienić w czasie wykonywania. Jest to również jedyny powód, dla którego kiedykolwiek będziesz używać const.

Prywatne, publiczne i chronione to modyfikatory dostępu, które opisują, kto może uzyskać dostęp do danego parametru / metody.

Publiczny oznacza, że ​​wszystkie inne obiekty mają dostęp. Prywatny oznacza, że ​​tylko klasa, której dotyczy instancja, ma dostęp. Chroniony oznacza, że ​​klasa, dla której utworzono wystąpienie, i klasy pochodne uzyskują dostęp.

Oto rzeczy, których nauczyłem się do tej pory o statycznych elementach członkowskich, stałych zmiennych i modyfikatorach dostępu (prywatnych, publicznych i chronionych). Stały

Definicja

Tak jak nazwa mówi, wartości stałej zmiennej nie można zmienić. Stałe różnią się od zwykłych zmiennych tym, że nie używa się symbolu $ do ich deklarowania lub używania.

Wartość musi być wyrażeniem stałym, a nie (na przykład) zmienną, właściwością, wynikiem operacji matematycznej lub wywołaniem funkcji.

Uwaga: Wartość zmiennej nie może być słowem kluczowym (np. Self, parent i static).

Deklarowanie stałej w php

<?php
class constantExample{

   const CONSTANT = 'constant value'; //constant

 }
?>

Zakres stałej jest globalny i można uzyskać do niego dostęp za pomocą słowa kluczowego 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

?>

Statyczny

Definicja

Static słowo kluczowe może być użyte do zadeklarowania klasy, funkcji składowej lub zmiennej Statyczne składowe w klasie są globalne mogą być również dostępne za pomocą słowa kluczowego self Deklarowanie właściwości lub metod klasy jako statyczne czyni je dostępnymi bez potrzeby tworzenia instancji klasy . Do właściwości zadeklarowanej jako statyczna nie można uzyskać dostępu za pomocą utworzonego obiektu klasy (chociaż metoda statyczna może). Jeśli nie zostanie użyta żadna deklaracja widoczności (publiczna, prywatna, chroniona), wówczas właściwość lub metoda będzie traktowana tak, jakby była zadeklarowana jako publiczna, ponieważ metody statyczne można wywołać bez instancji utworzonego obiektu.

Uwaga: pseudozmienna $ this nie jest dostępna wewnątrz metody zadeklarowanej jako statyczna, a do właściwości statycznych nie można uzyskać dostępu przez obiekt za pomocą operatora strzałki ->

Od PHP 5.3.0 możliwe jest odwoływanie się do klasy przy użyciu zmiennej. Wartość zmiennej> nie może być słowem kluczowym (np. Self, parent i static).

Przykład właściwości statycznej

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

?>

Przykład dostępu do statycznych właściwości i funkcji

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

 ?>

Publiczny, prywatny, chroniony (modyfikatory dostępu AKA)

Przed przeczytaniem poniższej definicji przeczytaj ten artykuł o hermetyzacji, który pomoże ci głębiej zrozumieć koncepcję

Link 1 wikipedia

Samouczki wskazują łącze dotyczące hermetyzacji

Definicja

Używając prywatnych, publicznych, chronionych słów kluczowych, możesz kontrolować dostęp do członków w klasie. Członkowie klasy zadeklarowani jako publiczni są dostępni wszędzie. Elementy członkowskie zadeklarowane jako chronione są dostępne tylko w ramach samej klasy oraz przez klasy dziedziczone i nadrzędne. Elementy członkowskie zadeklarowane jako prywatne mogą być dostępne tylko dla klasy, która definiuje element członkowski.

Przykład

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

} 
 ?> 

Dostęp do przykładu członków publicznych, prywatnych i chronionych

Dostęp do zmiennych publicznych i modyfikowanie ich można uzyskać spoza klasy lub wewnątrz klasy. Ale możesz uzyskać dostęp do prywatnych i chronionych zmiennych i funkcji tylko z wnętrza klasy. Nie możesz modyfikować wartości chronionych lub publicznych członków poza klasą.

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

  ?>

Aby uzyskać więcej informacji, przeczytaj dokumentację php o widoczności. Widoczność Php Doc

Źródła : php.net

Mam nadzieję, że zrozumiałeś koncepcję. Dzięki za przeczytanie :) :) Życzę miłego

Podsumowując @Matt, świetna odpowiedź:

• jeśli właściwość, której potrzebujesz, nie powinna zostać zmieniona, właściwym wyborem jest stała

• jeśli właściwość, której potrzebujesz, może zostać zmieniona, użyj zamiast tego static

Przykład:

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

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

Edycja: Należy zauważyć, że PHP 7.1.0 wprowadziło obsługę określania widoczności stałych klas .