PHP 5: const vs static

En PHP 5, ¿cuál es la diferencia entre usar consty static?

¿Cuándo es apropiado cada uno? Y qué papel public, protectedy el privatejuego - en su caso?

En el contexto de una clase, las variables estáticas están en el alcance de la clase (no en el objeto), pero a diferencia de una constante, 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 concursos (que siempre son públicos); solo son útiles para las variables de clase, incluida la variable estática.

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

Editar: Es importante tener en cuenta que PHP 7.1.0 introdujo soporte para especificar la visibilidad de las constantes de clase .

Un último punto que debe hacerse es que una constante siempre es estática y pública. Esto significa que puede acceder al const desde dentro de la clase de la siguiente manera:

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

Desde fuera de la clase accederías así:

echo MyClass::MYCONST;

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

Se puede acceder a la variable estática sin hacer una instancia de una clase y, por lo tanto, se comparte entre todas las instancias de una clase.

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

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

Al hablar sobre la herencia de clases, puede diferenciar entre la constante o la variable en diferentes ámbitos utilizando palabras clave selfy static. Verifique este ejemplo que ilustra cómo acceder a qué:

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"

En otras palabras, se self::refiere a la propiedad estática y constante desde el mismo ámbito donde se llama (en este caso, la Personsuperclase), mientras que static::accederá a la propiedad y constante desde el ámbito en tiempo de ejecución (en este caso, en la Piratesubclase).

Lea más sobre el enlace estático tardío aquí en php.net .
También verifique la respuesta en otra pregunta aquí y aquí .

Declarar un método de clase o propiedad como estática los hace accesibles sin necesidad de una instanciación 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.

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 tiene acceso. Protegido significa que la clase instanciada y las clases derivadas obtienen acceso.

Estas son las cosas que aprendí hasta ahora sobre miembros estáticos, variables constantes y modificadores de acceso (privados, públicos y protegidos). Constante

Definición

Como el nombre dice, los valores de una variable constante no se pueden cambiar. Las constantes difieren de las variables normales en que no se usa el símbolo $ para declararlas o usarlas.

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

Declarando una constante en php

<?php
class constantExample{

   const CONSTANT = 'constant value'; //constant

 }
?>

El alcance de Constant es global y se puede acceder mediante una palabra clave propia

<?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, una función miembro o una variable. También se puede acceder a los miembros estáticos en una clase global utilizando una palabra clave propia. . No se puede acceder a una propiedad declarada como estática con un objeto de clase instanciado (aunque sí 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 declarara pública. Debido a que los métodos estáticos son invocables sin una instancia del objeto creado.

Nota: la pseudo-variable $ this no está disponible dentro del método declarado como static. No se puede acceder a las propiedades estáticas a través del objeto utilizando 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 de 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
    }
}

?>

Acceso a propiedades estáticas y ejemplo de funciones

 <?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úblico, privado, protegido (modificadores de acceso AKA)

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

Enlace 1 wikipedia

Tutoriales punto enlace sobre encapsulación

Definición

Con palabras clave privadas, públicas y protegidas, puede controlar el acceso a los miembros de una clase. Se puede acceder a los miembros de la clase declarados públicos desde cualquier lugar. Solo se puede acceder a los miembros declarados protegidos dentro de la propia clase y mediante clases heredadas y primarias. Los miembros declarados como privados solo pueden ser accedidos por 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
   }

} 
 ?> 

Accediendo al ejemplo de miembros públicos, privados y protegidos

Se puede acceder a las variables públicas y modificarlas desde fuera de la clase o desde dentro de la clase. 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 obtener más información, lea esta documentación de php sobre visibilidad Visibilidad Php Doc

Referencias: php.net

Espero que hayas entendido el concepto. Gracias por leer :) :) Que tengas una buena

Así que para recapitular en @Matt gran respuesta:

• Si la propiedad que necesita no debe cambiarse, entonces una constante es la elección correcta

• si se permite cambiar la propiedad que necesita, use static en su lugar

Ejemplo:

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

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

Editar: Es importante tener en cuenta que PHP 7.1.0 introdujo soporte para especificar la visibilidad de las constantes de clase .