php - titulo - meta tags seo
`static` palabra clave dentro de la función? (7)
Estaba mirando 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é hace la palabra clave static a una variable dentro de una función?
function module_load_all($bootstrap = FALSE) {
static $has_run = FALSE
Dado el siguiente ejemplo:
function a($s){
static $v = 10;
echo $v;
$v = $s;
}
Primera llamada de
a(20);
dará salida a 10 , luego $v a ser 20 . La variable $v no es basura recolectada 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);
luego dará salida a 20 , y luego configure $v para que sea 15 .
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 ha dado, si llama a una función dos veces, si establece $has_run en true , entonces la función podría saber que se había llamado previamente porque $has_run seguiría siendo igual a true cuando 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í: php.net/manual/en/language.variables.scope.php
Hace que la función recuerde el valor de la variable dada ( $has_run en su ejemplo) entre varias llamadas.
Puede usar 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 solo se ejecutará una vez. Incluso si doStuff múltiples llamadas a doStuff .
Para ampliar la respuesta de Yang
Si amplía una clase con variables estáticas, las clases extendidas individuales mantendrán su propia estática de referencia compartida que se comparte entre las instancias.
<?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();
productos:
uno 1
dos : 1
uno: 2
uno : 3 <- x_repetición
uno: 4
uno : 5 <- x_repetición
dos : 2
Parece que nadie mencionó hasta ahora, que las variables estáticas dentro de diferentes instancias de la misma clase siguen siendo su estado. Así que tenga cuidado al escribir código OOP.
Considera esto:
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 que una variable estática recuerde su estado solo para la instancia de clase actual, será mejor que se quede con una propiedad de clase, como esta:
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
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).
Una variable estática existe solo en un alcance de función local, pero no pierde su valor cuando la ejecución del programa deja este ámbito.
variable estática en una función significa que no importa cuántas veces llame a la función, solo 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
?>