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
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.
. Toute variable déclarée en dehors de toute fonction se trouve dans cette portée globale.
内的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.phpinclude代码的规则与适用于任何其他代码的规则相同：仅函数
<?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< /p>
$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.
répondre
0