In PHP 5, qual è la differenza tra l'utilizzo di conste static?
Quando è appropriato? E che ruolo ha public, protectede privatese gioca?
In PHP 5, qual è la differenza tra l'utilizzo di conste static?
Quando è appropriato? E che ruolo ha public, protectede privatese gioca?
Risposte:
Nel contesto di una classe, le variabili statiche si trovano nell'ambito della classe (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, compresa la variabile statica.
Modifica: è importante notare che PHP 7.1.0 ha introdotto il supporto per specificare la visibilità delle costanti di classe .
$? static $my_var = 10;nella definizione
staticvariabili sono molto utili anche nei singoli e nelle funzioni ricorsive. Perché PUOI cambiare il valore ma la variabile verrà inizializzata una sola volta. Vedi stackoverflow.com/questions/203336/… per ulteriori spiegazioni su come creare un singleton. Per me quelle sono alcune situazioni in cui preferisco le variabili statiche.
Un ultimo punto da sottolineare è che una const è sempre statica e pubblica. Ciò significa che puoi accedere alla const dall'interno della classe in questo modo:
class MyClass
{
const MYCONST = true;
public function test()
{
echo self::MYCONST;
}
}Dall'esterno della classe accederesti in questo modo:
echo MyClass::MYCONST;Costante è solo una costante, ovvero non è possibile modificarne il valore dopo aver dichiarato.
La variabile statica è accessibile senza creare un'istanza di una classe e quindi condivisa tra tutte le istanze di una classe.
Inoltre, in una funzione può essere presente una variabile locale statica che viene dichiarata una sola volta (alla prima esecuzione di una funzione) e può memorizzare il suo valore tra chiamate di funzione, ad esempio:
function foo()
{
static $numOfCalls = 0;
$numOfCalls++;
print("this function has been executed " . $numOfCalls . " times");
}Quando si parla dell'ereditarietà delle classi, è possibile distinguere tra la costante o la variabile in ambiti diversi utilizzando selfe staticle parole chiave. Controlla questo esempio che illustra come accedere a 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 fai:
$pirate = new Pirate();
$pirate::getType();o:
Pirate::getType();Produzione:
string(6) "person"
string(6) "pirate"
string(6) "person"
string(6) "pirate"In altre parole, si self::riferisce alla proprietà statica e costante dallo stesso ambito in cui viene chiamata (in questo caso la Personsuperclasse), mentre static::accederà alla proprietà e alla costante dall'ambito in fase di esecuzione (quindi in questo caso nella Piratesottoclasse).
Maggiori informazioni sull'associazione statica tardiva qui su php.net .
Controlla anche la risposta su un'altra domanda qui e qui .
La dichiarazione di un metodo o di una proprietà di classe come statica li rende accessibili senza che sia necessaria un'istanza della classe.
Una costante di classe è proprio come una costante normale, non può essere modificata in fase di esecuzione. Questa è anche l'unica ragione per cui userai mai const.
Privato, pubblico e protetto sono modificatori di accesso che descrivono chi può accedere a quale parametro / metodo.
Pubblico significa che tutti gli altri oggetti hanno accesso. Privato significa che solo la classe istanziata ha accesso. Protetto significa che la classe istanziata e le classi derivate ottengono l'accesso.
Ecco le cose che ho imparato finora su membri statici, variabili costanti e modificatori di accesso (privati, pubblici e protetti). Costante
Definizione
Come dice il nome, i valori di una variabile costante non possono essere modificati. Le costanti differiscono dalle variabili normali in quanto non si utilizza il simbolo $ per dichiararle o usarle.
Il valore deve essere un'espressione costante, non (ad esempio) una variabile, una proprietà, il risultato di un'operazione matematica o una chiamata di funzione.
Nota: il valore della variabile non può essere una parola chiave (ad es. Self, parent e static).
Dichiarando una costante in php
<?php
class constantExample{
const CONSTANT = 'constant value'; //constant
}
?>L'ambito di Constant è globale e è possibile accedervi utilizzando una parola chiave 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
?>Statico
Definizione
La parola chiave statica può essere utilizzata per dichiarare una classe, una funzione membro o una variabile. È possibile accedere anche ai membri statici di una classe globale usando una parola chiave self. Dichiarare proprietà o metodi della classe come statici li rende accessibili senza bisogno di un'istanza della classe . Non è possibile accedere a una proprietà dichiarata come statica con un oggetto classe istanziato (anche se un metodo statico può). Se non viene utilizzata alcuna dichiarazione di visibilità (pubblica, privata, protetta), la proprietà o il metodo verranno trattati come se fossero stati dichiarati pubblici, poiché i metodi statici sono richiamabili senza un'istanza dell'oggetto creato.
Nota: la pseudo-variabile $ this non è disponibile all'interno del metodo dichiarato come static.Non è possibile accedere alle proprietà statiche tramite l'oggetto usando l'operatore freccia ->
A partire da PHP 5.3.0, è possibile fare riferimento alla classe usando una variabile. Il valore della variabile> non può essere una parola chiave (ad es. Self, parent e static).
Esempio di 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 ad esempio di proprietà statiche e funzioni
<?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 AKA)
Prima di leggere la definizione di seguito, leggi questo articolo sull'incapsulamento. Ti aiuterà a comprendere il concetto più profondamente
Link puntuale alle esercitazioni sull'incapsulamento
Definizione
Utilizzando parole chiave private, pubbliche e protette puoi controllare l'accesso ai membri di una classe. I membri della classe dichiarati pubblici sono accessibili ovunque. I membri dichiarati protetti sono accessibili solo all'interno della classe stessa e dalle classi ereditate e parent. I membri dichiarati come privati possono accedere solo alla 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 all'esempio di membri pubblici, privati e protetti
È possibile accedere e modificare le variabili pubbliche all'esterno della classe o all'interno della classe. Ma puoi accedere alle variabili e funzioni private e protette solo dall'interno della classe, non puoi 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 leggi questa documentazione php sulla visibilità Visibilità Php Doc
Riferimenti: php.net
Spero tu abbia capito il concetto. Grazie per la lettura :) :) Buona
Quindi, per ricapitolare su @Matt un'ottima risposta:
se la proprietà di cui hai bisogno non deve essere modificata, una costante è la scelta corretta
se è possibile modificare la proprietà richiesta, utilizzare invece static
Esempio:
class User{
private static $PASSWORD_SALT = "ASD!@~#asd1";
...
}
class Product{
const INTEREST = 0.10;
...
}Modifica: è importante notare che PHP 7.1.0 ha introdotto il supporto per specificare la visibilità delle costanti di classe .
self::$variableper le variabili statiche private e statiche protette poiché preferisco mantenere il nome della classe menzionato solo una volta dentro di sé, che è all'inizio della classe.