PHP5: const vs static

Question

En PHP5, ¿cuál es la diferencia entre usar const y static? ¿Cuándo es apropiado cada uno? Y qué papel juegan public, protected y private, si corresponde.

Answer 1

En el contexto de una clase, las variables estáticas están en el alcance del alcance de clase (no del objeto), pero a diferencia de const, sus valores se pueden cambiar.

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. 

Público, protegido y privado son irrelevantes en términos de ventajas (que son siempre públicas); solo son útiles para las variables de clase, incluida la variable estática.

• variables estáticas públicas se puede acceder en cualquier lugar a través de ClassName :: $ variable.
• variables estáticas protegidas se puede acceder por la clase de definición o extender clases a través de ClassName :: $ variable.
• variables estáticas privadas se puede acceder solo por la clase de definición a través de ClassName :: $ variable.

---

Editar: Es importante tener en cuenta que PHP 7.1.0 introduced support for specifying the visibility of class constants.

Answer 2

Declarar un método o propiedad de clase como estático los hace accesibles sin necesidad de crear una instancia de la clase.

Una constante de clase es como una constante normal, no se puede cambiar en tiempo de ejecución. Esta es también la única razón por la que usará const for.

Privado, público y protegido son modificadores de acceso que describen quién puede acceder a qué parámetro/método.

Público significa que todos los demás objetos tienen acceso. Privado significa que solo la clase instanciada obtiene acceso. Protegido significa que la clase instanciada y las clases derivadas obtienen acceso.

Answer 3

Constante es solo una constante, es decir, no puede cambiar su valor después de declarar.

Static variable es accesible sin hacer una instancia de una clase y por lo tanto compartida entre todas las instancias de una clase.

Además, puede haber una estática variable local en una función que se declara sólo una vez (en la primera ejecución de una función) y puede almacenar su valor entre llamadas a funciones, ejemplo:

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

Answer 4

Un último punto que debe hacerse es que un const siempre es estático y público.Esto significa que se puede acceder a la const desde dentro de la clase, así:

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

Desde fuera de la clase en la que poder acceder a ella de esta manera:

echo MyClass::MYCONST; 

Answer 5

Así que para recapitular sobre @ Matt gran respuesta:

• en la mayoría de las situaciones, necesitará una propiedad estática privada/protegida, por lo que las constantes no son una opción.

• Si la propiedad que necesita está destinada a ser públicamente disponible pero no cambiada, la constante es la opción correcta.

Ejemplo:

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

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

Answer 6

Cuando se habla de la herencia de clases se puede diferenciar entre la constante o variable en distintos ámbitos mediante el uso de self y static palabras clave. Compruebe este ejemplo que ilustra cómo acceder a lo que:

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

y luego hacer:

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

o:

Pirate::getType(); 

Salida:

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

Answer 7

He aquí las cosas i aprendido hasta ahora sobre miembros estáticos, variables constantes y modificadores de acceso (privado, público y protegido). constante

Definición

Como el nombre lo dice valores de una variable constante no pueden ser changed.Constants difieren de las variables normales en que no se utiliza el símbolo $ para declarar o utilizarlos .

El valor debe ser una expresión constante, no (por ejemplo) una variable, una propiedad, un resultado de una operación matemática o una llamada a una función.

Nota: El valor de la variable no puede ser una palabra clave (por ejemplo, self, parent y static).

declarar una constante en php

<?php 
class constantExample{ 

    const CONSTANT = 'constant value'; //constant 

} 
?> 

alcance de Constant es global y se puede acceder utilizando una palabra clave 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 

?> 

estático

Definición

La palabra clave estática se puede utilizar para declarar una clase, función de miembro o una variable. También se puede acceder a los miembros estáticos de una clase global utilizando una palabra clave self.Declarar las propiedades de clase o métodos como estáticos los hace accesibles sin necesidad de instanciación de la clase. No se puede acceder a una propiedad declarada como estática con un objeto de clase instanciado (aunque puede hacerlo un método estático). Si no se utiliza ninguna declaración de visibilidad (pública, privada, protegida), la propiedad o el método se tratarán como si se hubiera declarado público. Debido a que los métodos estáticos se pueden llamar sin una instancia del objeto creado.

Nota: la pseudo-variable $ esto no está disponible dentro del método declarada como propiedades static.Static no se puede acceder a través del objeto usando el operador de flecha ->

A partir de PHP 5.3.0 , es posible hacer referencia a la clase utilizando una variable. El valor de la variable> no puede ser una palabra clave (por ejemplo, self, parent y static).

ejemplo Propiedad estática

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

?> 

acceder a las propiedades estáticas y funciones ejemplo

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

?> 

Públicas,, protegido (modificadores de acceso A.K.A) privadas

Antes de leer la definición a continuación, lea este artículo sobre la encapsulación .Se le ayudará a entender el concepto más profundamente

Link 1 wikipedia

Tutorials point link about encapsulation

Definición

El uso privado, público, palabras clave protegidas, puede controlar el acceso a los miembros en una clase. Los miembros de la clase declarados públicos se pueden acceder a todas partes. Se puede acceder a los miembros declarados protegidos solo dentro de la clase en sí y por las clases heredadas y principales. Los miembros declarados como privados solo pueden acceder a la clase que define al miembro.

Ejemplo

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

} 
?> 

Acceso al público, privado y miembros protegida ejemplo

de puede ser accedido y modificado desde fuera de la clase o dentro de la clase variable pública. Pero puede acceder a las variables y funciones privadas y protegidas solo desde dentro de la clase. No puede modificar el valor de los miembros protegidos o públicos fuera de la clase.

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

    ?> 

Para más información leer esta documentación acerca de la visibilidad php Visibility Php Doc

Referencias: php.net

espero que usted entiende el concepto. Gracias por leer :) :) Tener uno bueno