web-dev-qa-db-fra.com

Mot-clé `static` dans la fonction?

Je cherchais la source de Drupal 7, et j'ai trouvé des choses que je n'avais pas vues auparavant. J'ai fait des recherches initiales dans le manuel php, mais cela n'expliquait pas ces exemples.

Que fait le mot clé static pour une variable dans une fonction?

function module_load_all($bootstrap = FALSE) {
    static $has_run = FALSE
phpfunctionstatickeyword
101
user151841

La fonction mémorise la valeur de la variable donnée ($has_run _ dans votre exemple) entre plusieurs appels.

Vous pouvez l'utiliser à différentes fins, par exemple:

function doStuff() {
  static $cache = null;

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

  // code using $cache
}

Dans cet exemple, le if ne serait exécuté qu'une fois. Même si plusieurs appels à doStuff se produiraient.

139
Yoshi

On dirait que personne n'a mentionné jusqu'à présent, que les variables statiques à l'intérieur de différentes instances de la même classe restent leur état. Soyez donc prudent lorsque vous écrivez du code OOP.

Considère ceci:

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 vous voulez qu'une variable statique se souvienne de son état uniquement pour l'instance de classe actuelle, vous devriez vous en tenir à une propriété de classe, comme ceci:

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
70
Yang

Étant donné l'exemple suivant:

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

Premier appel de

a(20);

affichera 10, puis $v être 20. La variable $v n'est pas une ordure collectée à la fin de la fonction, car il s'agit d'une variable statique (non dynamique). La variable restera dans sa portée jusqu'à la fin complète du script.

Par conséquent, l’appel suivant de

a(15);

affichera alors 20, puis définissez $v être 15.

13
mauris

La statique fonctionne de la même manière que dans une classe. La variable est partagée entre toutes les instances d'une fonction. Dans votre exemple particulier, une fois la fonction exécutée, $ has_run est défini sur TRUE. Toutes les futures exécutions de la fonction auront $ has_run = TRUE. Ceci est particulièrement utile dans les fonctions récursives (au lieu de passer le compte).

Une variable statique n'existe que dans l'étendue d'une fonction locale, mais elle ne perd pas sa valeur lorsque l'exécution du programme quitte cette étendue.

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

8
tofutim

variable statique dans une fonction signifie que peu importe le nombre de fois que vous appelez la fonction, il n'y a qu'une seule 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

?>
3
Pwnna

Pour développer la réponse de Yang

Si vous étendez une classe avec des variables statiques, les classes étendues individuelles conservent leur "propre" référence référencée partagée entre les instances.

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

les sorties:

un 1
deux : 1
un: 2
un: 3 <- x_repeat
un: 4
un: 5 <- x_repeat
deux : 2

http://ideone.com/W4W5Qv

2
Tschallacka

Dans une fonction, static signifie que la variable conservera sa valeur chaque fois que la fonction est appelée pendant la durée de vie du chargement de la page.

Par conséquent, dans l'exemple que vous avez donné, si vous appelez une fonction deux fois, si elle définit $has_run à true, la fonction pourra alors savoir qu'elle a déjà été appelée car $has_run serait toujours égal à true lorsque la fonction démarrera une deuxième fois.

L'utilisation du mot clé static dans ce contexte est expliquée dans le manuel PHP): http://php.net/manual/fr/language.variables .scope.php

1
Spudley