2010-03-07 21 views
13

EN PHP5 puedo declarar un valor const a una clase:const vs estática en PHP

class config 
{ 
    const mailserver = 'mx.google.com'; 
} 

pero también puedo declarar public static:

class config 
{ 
    public static $mailserver = 'mx.google.com'; 
} 

En caso de un archivo de configuración que me más adelante, como:

imap_connect(config::$mailserver ... 
imap_connect(config::mailserver ... 

¿Cuál de las opciones cree que es mejor usar? (más rápido, menos carga de memoria, etc.)

Gracias.

Respuesta

43

La variable estática se puede cambiar, la const uno no puede. La principal consideración debería ser si las variables de configuración deberían poder modificarse en tiempo de ejecución, no cuál es más rápido. La diferencia de velocidad entre los dos (si hay alguna) es tan mínima que no vale la pena pensar en ella.

1

También tenga en cuenta que debido a lo que Yacoby dijo anteriormente, hay ciertas cosas que puede hacer con una variable estática que no puede hacer con una CONST, por ejemplo, asignar el resultado de una llamada de método de ejecución a la variable.

8

uso función de retorno mundial

0,0096, 0,0053, 0,0056, 0,0054, 0,0072, 0,0063, 0,006, 0,0054, 0,0054, 0,0055, 0,005, 0,0057, 0,0053, 0,0049, 0,0064, 0,0054, 0,0053, 0,0053, 0,0061, 0,0059, 0,0076, config1

utilización llegar instancia de clase normal de

0,0101, 0,0089, 0,0105, 0,0088, 0,0107, 0,0083, 0,0094, 0,0081, 0,0106, 0,0093, 0,0098, 0,0092, 0,009, 0,0087, 0,0087, 0,0093, 0.0095, 0.0101, 0.0086, 0.0088, 0.0082, config2

use var estático

0.0029, 0.003, 0.003, 0.0029, 0.0029, 0.0029, 0.003, 0.0029, 0.003, 0.0031, 0.0032, 0.0031, 0.0029, 0.0029, 0.0029, 0.0029, 0.0031, 0.0029, 0.0029, 0.0029, 0.0029, config3

uso const var 0.0033, 0.0031, 0.0031, 0.0031, 0.0031, 0.0031, 0.0032, 0.0031, 0.0031, 0.0031, 0.0031, 0.0034, 0.0031, 0.0031, 0.0033, 0.0031, 0.0037, 0.0031, 0.0031, 0.0032, 0.0031 , config4

function getTime() { 
    $timer = explode(' ', microtime()); 
    $timer = $timer[1] + $timer[0]; 
    return $timer; 
} 

$config["time"] = "time"; 

class testconfig2 
{ 
    public $time = "time"; 
    static $instance; 
    static function getInstance() 
    { 
     if(!isset(self::$instance)) 
      self::$instance = new testconfig2(); 
     return self::$instance; 
    } 
} 

class testconfig3 
{ 
    static $time = "time"; 
} 

class testconfig4 
{ 
    const time = "time"; 
} 

function getConfig1() 
{ 
    global $config; 
    return $config; 
} 

$burncount = 2000; 
$bcount = 22; 

for($lcnt =1;$lcnt < $bcount;$lcnt++){ 
$start = getTime(); 
for($i=1;$i< $burncount;$i++) 
{ 
    $gs=getConfig1(); 
    $t = $gs["time"]; 
} 
$end = getTime(); 
echo round($end - $start,4).', '; 
} 
echo ' config1<br/>'; 



for($lcnt =1;$lcnt < $bcount;$lcnt++){ 
$start = getTime(); 
for($i=1;$i< $burncount;$i++) 
{ 
    $gs=testconfig2::getInstance(); 
    $t = $gs->time; 
} 
$end = getTime(); 
echo round($end - $start,4).', '; 
} 
echo ' config2<br/>'; 



for($lcnt =1;$lcnt < $bcount;$lcnt++){ 
$start = getTime(); 
for($i=1;$i< $burncount;$i++) 
{ 
    $gs=testconfig3::$time; 
    $t = $gs; 
} 
$end = getTime(); 
echo round($end - $start,4).', '; 
} 
echo ' config3<br/>'; 



for($lcnt =1;$lcnt < $bcount;$lcnt++){ 
$start = getTime(); 
for($i=1;$i< $burncount;$i++) 
{ 
    $gs=testconfig4::time; 
    $t = $gs; 
} 
$end = getTime(); 
echo round($end - $start,4).', '; 
} 
echo ' config4<br/>'; 
?> 

3

Otra diferencia entre const y estático es que algunas variables de li ke matrices no están permitidos en constantes de clase, por lo

class mytest 
{ 
    public static $c = array(1=> 'hello', 2=>'world'); 
} 

obras, sino

class mytest 
{ 
    const c = array(1=> 'hello', 2=>'world'); 
} 

no.

+3

Ya no es cierto desde PHP5.6 – Raffaello

4

Puede usar constantes para valores de argumento de función predeterminados, donde las variables estáticas no están permitidas.

+0

Aunque es un punto válido, esto no aborda la pregunta "¿cuál es mejor usar?". Tal vez, si la pregunta era "cuál es mejor usar * en este escenario *", sí, pero en general, no. – newfurniturey

+1

@newfurniturey, no estoy de acuerdo con su comentario. Señalar una limitación de uno u otro necesariamente muestra cómo el otro puede ser mejor. Y parece que, dado que este es precisamente el argumento de la respuesta más popular y aceptada, no creo estar solo en esto. – mkoistinen

-2

¡Tanto 'const' como 'public static' son malos!

Como observó Keith Humm: una const no puede ser el resultado de un método de tiempo de ejecución.Y, aunque al principio pensé que estaba en lo cierto al decir que puede "asignar el resultado de una llamada al método de tiempo de ejecución a una variable (estática)", mi prueba muestra que debe pasar por algunos aros para hacerlo.

Esto puede parecer un punto menor, pero podría ser la semilla de un futuro desastre. Supongamos que estoy obligado a cambiar a un método de inicialización por alguna razón imprevista en el futuro. No tengo problemas si esto significa que tengo que hacer algunos cambios en los archivos bajo mi control. Pero, ¿qué sucede si cambio una biblioteca que he enviado por todas partes a otros desarrolladores?

Iba a escribir que, al menos, tendré que decirle a todos los demás (y 'Future Me') que hagan cambios a SUS archivos si quieren actualizar a mi nueva versión. En el caso de 'const', tendrán que agregar un '$' donde lo usen. En otros escenarios, mis pruebas de hoy indican que quizás tengan que hacer menos cambios, pero algunos.

Asumiendo el código orientado a objetos, sigo los consejos generales que he visto para muchos idiomas, y necesita un énfasis adicional para PHP - EVITE PROPIEDADES VISIBLES de cualquier tipo ya sea const, estático o cualquier otra cosa. ¡Usa métodos getter!

Esto puede parecer un golpe de rendimiento ridículo y un estilo de código feo, pero a menos que pueda predecir el futuro, es el único camino a seguir.

Ver: respuesta de Tjeerd Visser a How to initialize static variables y darle un golpe. Ignore a sus detractores: si le preocupa el rendimiento, los posibles errores y otros desastres, cambie a otro idioma.