Référence : Qu'est-ce que la portée des variables, quelles variables sont accessibles à partir d'où et qu'est-ce qu'une erreur de « variable non définie » ?

Question

Remarque : Il s'agit d'une question de référence traitant de la portée des variables en PHP. Veuillez fermer l'une des nombreuses questions qui correspondent à ce modèle en tant que doublon de cette question.

Qu'est-ce que la « portée variable » en PHP ? Les variables d'un fichier .php sont-elles accessibles dans un autre fichier .php ? Pourquoi est-ce que j'obtiens parfois des erreurs "variable non définie"  ?

Answer 1

Bien que les variables définies dans la portée d'une fonction ne soient pas accessibles de l'extérieur, cela ne signifie pas que vous ne pouvez pas utiliser leurs valeurs une fois la fonction terminée. PHP possède un static 关键字，在面向对象的 PHP 中广泛用于定义静态方法和属性，但应该记住 static bien connu qui peut également être utilisé pour définir des variables statiques à l'intérieur de fonctions.

Qu'est-ce qu'une « variable statique » ?

Les variables statiques sont différentes des variables ordinaires définies dans la portée de la fonction. Les variables statiques ne perdront pas leur valeur lorsque l'exécution du programme quitte la portée. Considérons l'exemple suivant utilisant des variables statiques :

function countSheep($num) {
 static $counter = 0;
 $counter += $num;
 echo "$counter sheep jumped over fence";
}

countSheep(1);
countSheep(2);
countSheep(3);

Résultat :

1 sheep jumped over fence
3 sheep jumped over fence
6 sheep jumped over fence

Si nous définissons $counter 没有 static 那么每次回显的值将与传递给函数的 $num 参数相同。使用 static, nous pouvons construire ce compteur simple sans solutions de contournement supplémentaires.

Cas d'utilisation des variables statiques

1. Stockez la valeur entre les appels suivants à la fonction.
2. Stocker les valeurs entre les appels récursifs lorsqu'il n'y a aucun moyen (ou aucun moyen) Objectif) en les passant comme paramètres.
3. Le cache est généralement préférable pour récupérer les valeurs une fois. pour Par exemple, le résultat de la lecture d'un fichier immuable sur le serveur.

Conseils

Les variables statiques n'existent que dans la portée de la fonction locale. ça ne peut pas être Accessible en dehors de la fonction dans laquelle il est défini. afin que vous puissiez Assurez-vous qu'il conservera sa valeur jusqu'au prochain appel Cette fonction.

Les variables statiques ne peuvent être définies que comme scalaires ou scalaires Expressions (depuis PHP 5.6). lui attribuer forcément d'autres valeurs Ce qui aboutit à un échec, du moins au moment d’écrire ces lignes. Cependant, vous pouvez le faire sur la ligne de code suivante :

function countSheep($num) {
  static $counter = 0;
  $counter += sqrt($num);//imagine we need to take root of our sheep each time
  echo "$counter sheep jumped over fence";
}

Résultat :

2 sheep jumped over fence
5 sheep jumped over fence
9 sheep jumped over fence

Les fonctions statiques sont quelque peu "partagées" entre les méthodes de l'objet Camarades de classe. C’est facile à comprendre en regardant l’exemple ci-dessous :

class SomeClass {
  public function foo() {
    static $x = 0;
    echo ++$x;
  }
}

$object1 = new SomeClass;
$object2 = new SomeClass;

$object1->foo(); // 1
$object2->foo(); // 2 oops, $object2 uses the same static $x as $object1
$object1->foo(); // 3 now $object1 increments $x
$object2->foo(); // 4 and now his twin brother

Cela ne fonctionne que pour les objets de la même classe. Les variables statiques se comporteront comme prévu si les objets appartiennent à des classes différentes (ou même s'étendent les uns les autres).

Les variables statiques sont-elles le seul moyen de conserver les valeurs entre les appels de fonction ?

Une autre façon de préserver les valeurs entre les appels de fonction consiste à utiliser des fermetures. Les fermetures ont été introduites dans PHP 5.3. En bref, ils vous permettent de restreindre l'accès à un certain ensemble de variables dans le cadre d'une fonction à une autre fonction anonyme, qui sera le seul moyen d'y accéder. Être à l'intérieur d'une variable de fermeture peut émuler (plus ou moins avec succès) des concepts POO tels que les "constantes de classe" (si elles sont transmises par valeur dans la fermeture) ou les "propriétés privées" (si transmises par référence) dans la programmation structurée.

Ce dernier permet en fait d'utiliser des fermetures au lieu de variables statiques. C'est toujours au développeur de décider quoi utiliser, mais il convient de mentionner que les variables statiques sont certainement utiles lors de l'utilisation de la récursivité et méritent l'attention du développeur.

Answer 2

Qu'est-ce que la « portée variable » ?

Les variables sont limitées dans leur « portée » ou « où elles sont accessibles ». Ce n'est pas parce que vous avez écrit $foo = 'bar'; une fois quelque part dans votre application que vous pouvez référencer $foo depuis $foo = 'bar'; 一次，并不意味着您可以从引用 $foo >应用程序内的其他地方。变量 $foo >Ailleurs dans l'application

. La variable $foo a une certaine portée dans laquelle elle est valide, et seul le code dans la même portée peut accéder à la variable.

Comment définir la portée en PHP ?

C'est très simple : PHP a des étendues de fonctions. C'est le seul délimiteur de plage présent en PHP. Les variables à l'intérieur d'une fonction ne sont disponibles qu'à l'intérieur de cette fonction. Les variables en dehors d'une fonction peuvent être utilisées n'importe où en dehors de la fonction, mais ne peuvent pas être utilisées dans une fonction. Cela signifie qu'il existe une portée spéciale en PHP : la portée globale

. Toute variable déclarée en dehors de toute fonction se trouve dans cette portée globale.

Exemple :

<?php

$foo = 'bar';

function myFunc() {
    $baz = 42;
}

$foo 位于 global 范围内，$baz 位于 内的local 范围内myFunc。只有 myFunc 中的代码才能访问 $baz。只有myFunc外部的代码可以访问$foo$foo est dans la portée global

et $baz est dans la portée

local

de myFunc dans . Seul le code dans myFunc peut accéder à $baz. Seul le code en dehors de myFunc peut accéder à $foo. Aucune des parties ne peut accéder à l'autre :

<?php

$foo = 'bar';

function myFunc() {
    $baz = 42;

    echo $foo;  // doesn't work
    echo $baz;  // works
}

echo $foo;  // works
echo $baz;  // doesn't work

Portée et fichiers inclus Les limites des fichiers

ne se séparent pas

Plage :

a.php

include代码的规则与适用于任何其他代码的规则相同：仅函数

<?php

$foo = 'bar';

b.php

<?php

include 'a.php';

echo $foo;  // works!

S'applique à une portée distincte pour

. À des fins de portée, vous pouvez envisager d'inclure des fichiers tels que copier et coller du code : a.php 包含在 myFunc 中，a.php 中的任何变量仅具有本地函数作用域。仅仅因为它们似乎位于a.php

c.php

<?php

function myFunc() {
    include 'a.php';

    echo $foo;  // works
}

myFunc();

echo $foo;  // doesn't work!

functionDans l'exemple ci-dessus, a.php est contenu dans myFunc, et toutes les variables de a.php n'ont qu'une portée de fonction locale. Ce n'est pas parce qu'ils semblent

avoir une portée globale dans a.php qu'ils le sont, cela dépend vraiment du contexte dans lequel le code est contenu/exécuté.

Qu'en est-il des fonctions et fonctions au sein des classes ?

Chaque nouvelle

déclaration introduit un nouveau champ d'application, c'est aussi simple que cela.

Fonction au sein d'une fonction (anonyme)

function foo() {
    $foo = 'bar';

    $bar = function () {
        // no access to $foo
        $baz = 'baz';
    };

    // no access to $baz
}

$nameCours

$foo = 'foo';

class Bar {

    public function baz() {
        // no access to $foo
        $baz = 'baz';
    }

}

// no access to $baz

À quoi sert la portée ?

🎜Gérer les problèmes de portée peut sembler ennuyeux, mais 🎜la portée limitée des variables est cruciale pour écrire des applications complexes ! 🎜 Si chaque variable que vous déclarez est disponible n'importe où ailleurs dans votre application, vous effectuerez toutes les opérations sur vos variables sans aucun moyen réel de suivre ce qui a changé quoi. Vous êtes limité dans les noms sensés que vous pouvez donner à vos variables, et vous souhaiterez peut-être utiliser la variable "🎜" à plusieurs endroits. Si vous ne pouvez utiliser ce nom de variable unique qu'une seule fois dans votre application, vous devez utiliser un schéma de dénomination très complexe pour garantir que vos variables sont uniques et que vous ne modifiez pas la mauvaise variable à partir du mauvais morceau de code. 🎜 🎜Observations : 🎜

function foo() {
    echo $bar;
}

Que fait la fonction ci-dessus s'il n'y a pas de portée ? $barD'où vient-il ? Quel statut a-t-il ? Est-il même initialisé ? Dois-je le vérifier à chaque fois ? Ce n'est pas maintenable. Ce qui nous amène à...

Franchir les limites de la gamme

La bonne façon : transmettre des variables d'entrée et de sortie

function foo($bar) {
    echo $bar;
    return 42;
}

Variables$barentrent explicitement cette portée en tant que paramètres de fonction. Rien qu'en regardant cette fonction, il est clair d'où viennent les valeurs qu'elle utilise. Ensuite, il renvoie explicitement une valeur. L'appelant sait en toute confiance quelles variables la fonction utilisera et d'où proviendra sa valeur de retour :

$baz   = 'baz';
$blarg = foo($baz);

Étendre la portée des variables aux fonctions anonymes

$foo = 'bar';

$baz = function () use ($foo) {
    echo $foo;
};

$baz();

Les fonctions anonymes incluent explicitement $foo dans leur portée environnante. Notez que ce n'est pas la même chose que le périmètre mondial.

Mauvais chemin :全局

Comme mentionné précédemment, la portée globale est quelque peu spéciale et les fonctions peuvent explicitement en importer des variables :

$foo = 'bar';

function baz() {
    global $foo;
    echo $foo;
    $foo = 'baz';
}

Cette fonction utilise et modifie les variables globales$foo. Ne fais pas ça ! _{(À moins que tu saches vraiment vraiment ce que tu fais, et encore : ne le fais pas !)}

Ce que voit l'appelant de cette fonction est ceci :

baz(); // outputs "bar"
unset($foo);
baz(); // no output, WTF?!
baz(); // outputs "baz", WTF?!?!!

Rien n’indique que cette fonction ait des effets secondaires, mais c’est le cas. Cela peut facilement prêter à confusion car certaines fonctions se modifient constamment et nécessitent un état global. Vous voulez que les fonctions soient sans état, agissant uniquement sur leurs entrées et renvoyant des sorties définies, peu importe le nombre de fois que vous les appelez.

Vous devez éviter d'utiliser la portée globale de quelque manière que ce soit si possible ; très certainement, vous ne devez pas "extraire" les variables de la portée globale vers la portée locale.