`static` palabra clave dentro de la función?

Question

Estaba buscando la fuente de Drupal 7, y encontré algunas cosas que no había visto antes. Hice algunas búsquedas iniciales en el manual php, pero no explicó estos ejemplos.

¿Qué significa la palabra clave static para una variable dentro de una función?

function module_load_all($bootstrap = FALSE) { 
    static $has_run = FALSE 

Answer 1

Esto hace que la función de recordar el valor de la variable dada ($has_run en su ejemplo) entre varias llamadas.

Usted podría utilizar esto para diferentes propósitos, por ejemplo:

function doStuff() { 
    static $cache = null; 

    if ($cache === null) { 
    $cache = '%heavy database stuff or something%'; 
    } 

    // code using $cache 
} 

En este ejemplo, el if solamente serían ejecutados una vez. Incluso si ocurrieran llamadas múltiples al doStuff.

Answer 2

Dentro de una función, static significa que la variable retendrá su valor cada vez que se llame a la función durante la vida de la carga de la página.

Por lo tanto, en el ejemplo que hemos dado, si se llama a una función doble, si se establece $has_run a true, a continuación, la función sería capaz de saber que había sido llamado por $has_run seguiría siendo igual a cuando true la función comienza la segunda vez.

El uso de la palabra clave static en este contexto se explica en el manual de PHP aquí: http://php.net/manual/en/language.variables.scope.php

Answer 3

Dado el siguiente ejemplo:

function a($s){ 
    static $v = 10; 
    echo $v; 
    $v = $s; 
} 

Primera llamada de la producción

a(20); 

voluntad 10, luego $v para ser 20. La variable $v no se recoge basura después de que la función finaliza, ya que es una variable estática (no dinámica). La variable permanecerá dentro de su alcance hasta que la secuencia de comandos termine totalmente.

Por lo tanto, la siguiente llamada de

a(15); 

hará entonces la salida 20, y a continuación, establezca $v ser 15.

Answer 4

Static funciona de la misma manera que en una clase. La variable se comparte en todas las instancias de una función. En su ejemplo particular, una vez que se ejecuta la función, $ has_run se establece en TRUE. Todas las ejecuciones futuras de la función tendrán $ has_run = TRUE. Esto es particularmente útil en funciones recursivas (como una alternativa para pasar el conteo).

Existe una variable estática sólo en un ámbito local de la función , pero no pierden su valor cuando la ejecución del programa abandona este ámbito.

Ver http://php.net/manual/en/language.variables.scope.php

Answer 5

variable estática en una función significa que no importa cuántas veces se llama a la función, sólo hay 1 variable.

<?php 

class Foo{ 
    protected static $test = 'Foo'; 
    function yourstatic(){ 
     static $test = 0; 
     $test++; 
     echo $test . "\n"; 
    } 

    function bar(){ 
     $test = 0; 
     $test++; 
     echo $test . "\n"; 
    } 
} 

$f = new Foo(); 
$f->yourstatic(); // 1 
$f->yourstatic(); // 2 
$f->yourstatic(); // 3 
$f->bar(); // 1 
$f->bar(); // 1 
$f->bar(); // 1 

?> 

Answer 6

Parece que nadie mencionó hasta ahora, que las variables estáticas dentro de instancias diferentes de la misma clase permanecen en su estado. Así que tenga cuidado al escribir código OOP.

Considera:

class Foo 
{ 
    public function call() 
    { 
     static $test = 0; 

     $test++; 
     echo $test . PHP_EOL; 
    } 
} 

$a = new Foo(); 
$a->call(); // 1 
$a->call(); // 2 
$a->call(); // 3 


$b = new Foo(); 
$b->call(); // 4 
$b->call(); // 5 

Si desea una variable estática para recordar su estado solamente, por ejemplo, la clase actual, es mejor que se adhieren a una propiedad de clase, así:

class Bar 
{ 
    private $test = 0; 

    public function call() 
    { 
     $this->test++; 
     echo $this->test . PHP_EOL; 
    } 
} 


$a = new Bar(); 
$a->call(); // 1 
$a->call(); // 2 
$a->call(); // 3 


$b = new Bar(); 
$b->call(); // 1 
$b->call(); // 2 

Answer 7

Para ampliar en the answer of Yang

Si amplía una clase con variables estáticas, las clases ampliadas individuales contendrán su "propia" estática de referencia que se comparte entre ins tances.

<?php 
class base { 
    function calc() { 
     static $foo = 0; 
     $foo++; 
     return $foo; 
    } 
} 

class one extends base { 
    function e() { 
     echo "one:".$this->calc().PHP_EOL; 
    } 
} 
class two extends base { 
    function p() { 
     echo "two:".$this->calc().PHP_EOL; 
    } 
} 
$x = new one(); 
$y = new two(); 
$x_repeat = new one(); 

$x->e(); 
$y->p(); 
$x->e(); 
$x_repeat->e(); 
$x->e(); 
$x_repeat->e(); 
$y->p(); 

salidas:

uno: 1
dos: 1
uno: 2
uno: 3 < - x_repeat
uno: 4
uno: 5 < - x_ repetir
dos: 2

http://ideone.com/W4W5Qv