PHP5: const vs static

Question

In PHP5, qual è la differenza tra l'utilizzo di const e static? Quando è appropriato? E quale ruolo svolge public, protected e private - se presente.

Answer 1

Nel contesto di una classe, le variabili statiche si trovano nell'ambito della classe scope (non dell'oggetto), ma a differenza di una const, i loro valori possono essere modificati.

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. 

Pubblico, protetto e privato sono irrilevanti in termini di costi (che sono sempre pubblici); sono utili solo per le variabili di classe, inclusa la variabile statica.

• Le variabili statiche pubbliche sono accessibili ovunque tramite ClassName :: $ variabile.
• È possibile accedere alle variabili statiche protette mediante la classe di definizione o le classi di estensione tramite la variabile ClassName :: $.
• Le variabili statiche private sono accessibili solo dalla classe di definizione tramite la variabile ClassName :: $.

---

Edit: E 'importante notare che PHP 7.1.0 introduced support for specifying the visibility of class constants.

Answer 2

Dichiarare un metodo di classe o una proprietà come statici li rende accessibili senza richiedere un'istanza della classe.

Una costante di classe è proprio come una costante normale, non può essere modificata in fase di esecuzione. Questo è anche l'unico motivo per cui userai mai const per.

Privati, pubblici e protetti sono modificatori di accesso che descrivono chi può accedere a quale parametro/metodo.

Pubblico significa che tutti gli altri oggetti possono accedere. Privato significa che solo la classe istanziata ottiene l'accesso. Protetto significa che la classe istanziata e le classi derivate ottengono l'accesso.

Answer 3

Costante è solo una costante, ovvero non è possibile modificarne il valore dopo la dichiarazione.

La variabile statica è accessibile senza creare un'istanza di una classe e quindi condivisa tra tutte le istanze di una classe.

Inoltre, ci può essere una statica variabile locale in funzione dichiarata solo una volta (la prima esecuzione di una funzione) e può memorizzare il suo valore tra chiamate di funzione, esempio:

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

Answer 4

Un ultimo punto che dovrebbe essere fatto è che un const è sempre statico e pubblico.Ciò significa che è possibile accedere al const dall'interno della classe in questo modo:

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

Da fuori la classe che si sarebbe accedere in questo modo:

echo MyClass::MYCONST; 

Answer 5

Quindi, per ricapitolare su @ Matt grande risposta:

• nella maggior parte delle situazioni è necessaria una proprietà statica privata/protetta in modo che le costanti non siano un'opzione.

• se la proprietà di cui hai bisogno è destinata a essere disponibile al pubblico ma non modificata, la costante è la scelta giusta.

Esempio:

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

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

Answer 6

Quando si parla di ereditarietà di classe è possibile distinguere tra la costante o variabile in ambiti diversi, utilizzando self e static parole chiave. Controllare questo esempio che illustra come accedere cosa:

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

E poi fare:

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

o:

Pirate::getType(); 

uscita:

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

Answer 7

Ecco le cose che ho imparato così tanto sui membri statici, variabili costanti e modificatori di accesso (privati, pubblici e protetti). costante

Definizione

Come il nome dice valori di una variabile costante non possono essere changed.Constants differiscono dalle variabili normali che non si utilizza il simbolo $ per dichiarare o usarli .

Il valore deve essere un'espressione costante, non (ad esempio) una variabile, una proprietà, un risultato di un'operazione matematica o una chiamata di funzione.

Nota: il valore della variabile non può essere una parola chiave (ad es. Auto, genitore e statico).

Dichiarazione di una costante in php

<?php 
class constantExample{ 

    const CONSTANT = 'constant value'; //constant 

} 
?> 

portata di Constant è globale ed è possibile accedervi utilizzando una parola chiave auto

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

?> 

Statico

Definizione

La parola chiave statica può essere utilizzata per dichiarare una classe, una funzione membro o una variabile. È possibile accedere a membri statici di una classe utilizzando anche una parola chiave self. Dichiarare proprietà o metodi di classe come statici rendendoli accessibili senza richiedere un'istanza della classe. Non è possibile accedere a una proprietà dichiarata come statica con un oggetto classe istanziato (sebbene un metodo statico possa). Se non viene utilizzata alcuna dichiarazione di visibilità (pubblica, privata, protetta), la proprietà o il metodo verrà trattato come se fosse dichiarato pubblico. Perché i metodi statici sono richiamabili senza un'istanza dell'oggetto creato.

Nota: la pseudo-variabile $ questo non è disponibile all'interno del metodo dichiarata come proprietà static.Static non è possibile accedere attraverso l'oggetto utilizzando l'operatore freccia ->

Dal PHP 5.3.0 , è possibile fare riferimento alla classe usando una variabile. Il valore della variabile> non può essere una parola chiave (ad esempio self, parent e static).

esempio Proprietà statica

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

?> 

Accesso alle proprietà statiche e le funzioni di esempio

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

?> 

pubblico, privato, protetto (modificatori di accesso A.K.A)

Prima di leggere la definizione di seguito, leggere questo articolo su Encapsulation .E vi aiuterà a capire il concetto più profondamente

Link 1 wikipedia

Tutorials point link about encapsulation

Definizione

Utilizzando privata, pubblica, parole chiave protette è possibile controllare l'accesso ai membri in una classe. I membri della classe dichiarati pubblici sono accessibili ovunque. I membri dichiarati protetti sono accessibili solo all'interno della classe stessa e per classi ereditate e padre. I membri dichiarati come privati ​​possono essere raggiunti solo dalla classe che definisce il membro.

Esempio

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

} 
?> 

Accesso al pubblico, privato e protetto i membri esempio

del possono essere consultati e modificati dall'esterno della classe o all'interno della classe variabile pubblica. Ma è possibile accedere alle variabili e alle funzioni private e protette solo dall'interno della classe, Non è possibile modificare il valore dei membri protetti o pubblici al di fuori della 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) 

    ?> 

Per maggiori informazioni leggere questa documentazione di PHP sulla visibilità Visibility Php Doc

Riferimenti: php.net

Spero che hai capito il concetto. Grazie per la lettura :) :) Buona lettura