Les variables d'environnement (environnement) dans Windows contiennent diverses informations sur les paramètres système et l'environnement de l'utilisateur. Distinguer les variables d'environnement utilisateur, système et processus.

Le moyen le plus simple d'afficher le contenu des variables d'environnement sous Windows est d'ouvrir les propriétés système ( sysdm.cpl) -> Avancé -> Variables d'environnement. Comme vous pouvez le voir, dans la section ouverte il y a deux sections : la supérieure contient les variables d'environnement de l'utilisateur, la inférieure contient celles du système.

De plus, les variables d'environnement sont stockées dans le registre système. Les variables personnalisées sont stockées dans une section. Systémique - dans HKLM \ SYSTEM \ CurrentControlSet \ Control \ Session Manager \ Environment.

Vous pouvez afficher les valeurs de toutes les variables d'environnement dans la ligne de commande Windows. La commande est simple :

La commande listera les variables d'environnement et leurs valeurs.

Dans PowerShell, vous pouvez utiliser la commande pour afficher toutes les variables d'environnement :

Si vous souhaitez imprimer la valeur d'une seule variable, vous devez utiliser la commande echo et le nom de la variable doit être entouré de signes de pourcentage. Par exemple,

Écho% racine système%

set> c:\tmp\env_var.txt

Les variables d'environnement spécifiques au processus peuvent être obtenues à l'aide d'un Utilitaires Process Explorer(de Sysinternals). Il suffit d'ouvrir les propriétés du processus et d'aller dans l'onglet Environnement.

Variables PHP est une sorte de conteneur d'informations qui peut contenir différents types de données (texte, nombres, tableaux, etc.). En général, les variables vous permettent de créer, de stocker, de modifier et, à l'avenir, d'accéder rapidement aux informations qu'elles contiennent.

Comment créer une variable en PHP

Initialement, les variables contiennent le signe $ (dollar) - désignation de l'utilisation d'une variable, puis lettres alphabet latin(de a à z et petit et grand), à la fin peut contenir Nombres... En outre, le nom est autorisé à utiliser un trait de soulignement (pas à la fin).

Comment les variables peuvent être nommées :

$ var
variable $
$ année1945
$ _variable
Comment les variables ne peuvent pas être appelées :

$ 1 - se compose uniquement d'un chiffre
$ 1var - vous ne pouvez pas commencer un nom de variable avec un chiffre
$ / var - seuls les traits de soulignement sont autorisés pour les caractères supplémentaires _
$ variable - Cyrillique autorisé par la documentation php mais non recommandé
$ variable - les espaces ne peuvent pas être utilisés

Chaque variable se voit attribuer une valeur. Pour attribuer une valeur, utilisez le signe = (équivaut à). Pendant le traitement du script, la valeur de la variable peut changer à plusieurs reprises en fonction de différentes conditions.

$ ville = "Moscou" ; // la variable $ city a reçu une chaîne (entre guillemets) value Moscow
$ année = 1147 ; // et la variable $ année a reçu la valeur numérique 1147
?>

$ nom = "Alexandre" ;
$ Nom = "Alexey" ;
echo "$ nom, $ Nom" ; // affiche "Alexandre, Alexeï"
?>

Sortie des variables PHP

Séparément, vous devriez considérer comment afficher les variables en utilisant opérateurs de sortie, dont nous avons examiné le travail dans la dernière leçon, Création d'une page PHP. Opérateurs de sortie. ... Ci-dessous, je vais donner un certain nombre d'exemples illustratifs avec des commentaires.

// C'est ainsi que nous attribuons des valeurs aux variables
$ nom1 = "Alexey" ;
$ nom2 = "Alexandre" ;

// Affichage des variables
echo $ nom2; // Sortie : Alexandre
echo "nom1 est $ nom1" ; // name1 est Alexey

// Lors de l'utilisation de guillemets simples, la sortie est
// nom de la variable, pas la valeur
echo "nom1 est $ nom1" ; // affiche : nom1 est $ nom1

// vous pouvez simplement afficher les valeurs des variables
echo $ nom1; // Alexeï
echo $ nom1, $ nom2; // Alexeï Alexandre
echo $ nom1. "". $ nom2; // Alexeï Alexandre
echo "$ nom1, $ nom2" ; // Alexey, Alexandre

Écho<<Cela utilise la syntaxe "here document" pour afficher
plusieurs lignes avec substitution de variable $.
FINIR;

Opérations sur les variables PHP

Opérations arithmétiques en PHP
Dans le cas de valeurs numériques, vous pouvez effectuer des opérations arithmétiques : addition, soustraction, multiplication, etc.

- $ un(négation) Changer le signe de $ a.
$ a + $ b(addition) La somme de $ a et $ b.
$ a - $ b(soustraction) Différence entre $ a et $ b.
$ a * $ b(multiplication) Le produit de $ a et $ b.
$ a / $ b(division) Le quotient de $ a divisé par $ b.
$ a% $ b(division modulo) Le reste entier de $ a divisé par $ b.
Regardons des exemples

$a = 2 ; // attention, dans le cas des nombres, les guillemets ne sont pas utilisés
$b = 3 ; // attention, dans le cas des nombres, les guillemets ne sont pas utilisés

$ résultat = $ a + $ b ; // ajouter des variables
echo $ résultat ; // affichera 5

$ résultat = $ b - $ a ; // ajouter des variables
echo $ résultat ; // affichera 1

Opérations d'incrémentation et de décrémentation en PHP
Ces opérations seront utiles principalement lors de la construction de boucles, dont nous parlerons un peu plus tard.
Préfixe- opérateurs écrits AVANT la variable ( - $ un; ++ $ un). Renvoie la valeur de la variable avant la modification.
suffixe- opérateurs écrits après la variable ( $ un--; $ un--). Renvoie la valeur modifiée de la variable.
Incrément- augmenter la valeur.
Décrémenter- en diminuant la valeur.

++ $ un Incrément de préfixe. Incrémente $ a de un et renvoie la valeur de $ a.
$ un ++ Incrément de suffixe. Renvoie la valeur de $ a, puis incrémente $ a de un.
- $ un Décrément de préfixe. Diminue $ a de un et renvoie la valeur de $ a.
$ un-- Décrément de suffixe. Renvoie la valeur de $ a, puis décrémente $ a de un.
écho "

Incrément de suffixe

";
$a = 5 ;
echo "Devrait être 5:". $ un ++. "\n" ;

Écho "

Incrément de préfixe

";
$a = 5 ;
echo "Devrait être 6 :". ++ $ a. "\n" ;
echo "Devrait être 6 :". $ a. "\n" ;

Écho "

Décrément de suffixe

";
$a = 5 ;
echo "Devrait être 5:". $ un--. "\n" ;

Écho "

Décrément de préfixe

";
$a = 5 ;
echo "Devrait être 4:". - $ a. "\n" ;
echo "Devrait être 4:". $ a. "\n" ;
?>

Opérations d'affectation PHP
Opérateur de base ressemble à = ... À première vue, il peut sembler que cet opérateur est égal. En fait, ce n'est pas le cas. En effet, l'opérateur d'affectation signifie que l'opérande de gauche est défini sur la valeur de l'expression de droite (c'est-à-dire qu'il est défini sur la valeur résultante). Opérateurs combinés- ce sont des opérateurs qui vous permettent d'utiliser les valeurs précédentes des variables pour les opérations suivantes (ajouter à une variable de chaîne (avec texte) ou ajouter des valeurs numériques).

$ a = ($ b = 2) + 4 ; // résultat : $ a vaut 6, $ b vaut 2.

$a = 2 ;
$ a + = 3 ; // définit $ a à 5, similaire à l'écriture : $ a = $ a + 3;
$b = "Bonjour" ;
$ b. = "Paix!"; // définit $ b sur "Hello World!" comme le fait $ b = $ b. "Là!";

Il y a aussi opérations de comparaison et casse-tête, mais nous en parlerons dans les prochaines leçons. Je vais essayer de ne pas vous effrayer avec une grande quantité d'informations tout de suite !)

Vous avez sûrement une armoire ou une commode à la maison. Le principe de leur utilisation est simple : on y met des choses dont on n'a pas besoin pour l'instant, mais qui peuvent être nécessaires après un certain temps.

Les variables fonctionnent de la même manière. Vous pouvez y mettre de la valeur et les stocker jusqu'à ce que vous en ayez besoin.

Création de variables

Vous pouvez mettre une valeur dans une variable comme suit :

Dans le code ci-dessus, nous avons créé la variable $ name et y avons mis la valeur d'Ivan, puis nous avons créé la variable $ age et lui avons attribué la valeur 20.

Le nom "variable" signifie que sa valeur peut changer pendant l'exécution du script :

Dans certains langages, une variable doit d'abord être "déclarée" puis utilisée. Il n'y a pas de déclaration en PHP - une variable est créée au moment où vous y mettez une valeur.
Cependant, les programmeurs PHP disent souvent "déclarer une variable" au lieu de "créer une variable".

De plus, au lieu de "mettre une valeur dans une variable", ils disent souvent "attribuer une valeur".
La raison est simple - le symbole =, grâce auquel nous stockons une valeur dans une variable, est appelé "opérateur d'affectation". D'où le terme « approprié ».

Règles de nommage des variables

1. Le nom d'une variable commence par un symbole $.

2. Le deuxième caractère peut être une lettre ou un trait de soulignement _

Les noms de variables sont sensibles à la casse. $ name et $ Name sont des variables différentes.

Affichage de la valeur d'une variable à l'écran

Vous pouvez afficher la variable en utilisant la commande echo que nous connaissons déjà :

La commande echo vous permet d'imprimer plusieurs valeurs à l'écran à la fois :

Notez que nous avons passé 2 valeurs à echo, séparées par des virgules. De cette façon, nous pouvons transférer autant de valeurs que nous le souhaitons. Les deux exemples suivants produiront le même résultat :

Il existe également une syntaxe abrégée pour la sortie des variables en PHP. À la place de

Avant PHP 5.4, la syntaxe abrégée ne fonctionnait que lorsque la directive short_open_tag était activée dans les paramètres PHP, ce qui permet également l'utilisation de la balise d'ouverture abrégée

Vérifier la valeur d'une variable

La commande echo n'est pas toujours pratique pour vérifier la valeur actuelle d'une variable. Par exemple, si vous essayez d'afficher une chaîne vide, "" rien ne s'affichera à l'écran. Et la raison n'est pas claire - une variable vide ou un code qui ne fonctionne pas.

Par conséquent, la fonction var_dump() est utilisée pour vérifier la valeur d'une variable :

Le résultat de l'exécution du script :

Chaîne (5) "Vasya" chaîne (0) ""

Comme vous pouvez le voir, PHP affiche non seulement le contenu de la variable, mais aussi le nombre de caractères, et même le type de la variable (string). Nous examinerons de plus près les types de données dans les prochaines leçons.

Suppression de variables

Vous pouvez supprimer une variable existante à l'aide de la fonction unset () :

Il est maintenant temps de pratiquer un peu.

N'oubliez pas que presque toutes les tâches PHP peuvent avoir plusieurs solutions. Par conséquent, si vos décisions diffèrent de celles écrites sur ce site, cela ne signifie pas du tout que vous avez fait quelque chose de mal.

Écrivez un script qui :
1. Crée des variables avec des titres titre et contenu et quelques valeurs.
2. Affiche la valeur de la variable de titre à l'intérieur de la balise h1 et la valeur de la variable de contenu à l'intérieur de la balise div.

Afficher la solution

", $ titre,""; écho"

"; ?>

Je voudrais attirer votre attention sur le fait que cette décision n'est pas la seule correcte. Par exemple, le code suivant produira le même résultat :

Il y a 13 ans

Un petit piège à surveiller :

Si vous désactivez RegisterGlobals et associés, puis utilisez get_defined_vars (), vous pouvez voir quelque chose comme ce qui suit :

Déployer
[GLOBAUX] => Tableau
[GLOBAUX] => Tableau
*RÉCURSION*
[_POST] => Tableau ()
[_GET] => Tableau ()
[_COOKIE] => Tableau ()
[_FILES] => Tableau ()
)

[_POST] => Tableau ()
[_GET] => Tableau ()
[_COOKIE] => Tableau ()
[_FILES] => Tableau ()

)
?>

Notez que $ _SERVER n'est pas là. Il semble que php ne charge le superglobal $ _SERVER que s'il est utilisé quelque part. Vous pouvez faire ceci :

imprimer "

". htmlspecialchars (print_r (get_defined_vars (), true))."

" ;
imprimer "

". htmlspecialchars (print_r ($ _SERVER, true))."

" ;
?>

Et puis $ _SERVER apparaîtra dans les deux listes. Je suppose que ce "n'est pas vraiment un piège, car rien de mal n'arrivera de toute façon, mais c'est néanmoins une curiosité intéressante.

Il y a 6 ans

Étant donné que get_defined_vars () n'obtient les variables qu'au moment où vous appelez la fonction, il existe un moyen simple d'obtenir les variables définies dans la portée actuelle.

// Tout en haut de votre script php
$ vars = get_defined_vars ();

// Maintenant, fais tes affaires
$ foo = "foo";
$ barre = " barre " ;

// Récupère toutes les variables définies dans la portée courante
$ vars = array_diff (get_defined_vars (), $ vars);

écho "

"
;
print_r ($ vars); 
écho "

" ;
?>

il y a 15 ans

Voici une fonction qui génère un rapport de débogage pour affichage ou email
en utilisant get_defined_vars. Idéal pour obtenir un instantané détaillé sans
en s'appuyant sur l'entrée de l'utilisateur.

fonction generateDebugReport ($ method, $defined_vars, $ email = "undefined") (
// Fonction pour créer un rapport de débogage à afficher ou envoyer par e-mail.
// Utilisation : generateDebugReport (method, get_defined_vars (), email) ;
// Où la méthode est "navigateur" ou "email".

// Crée une liste d'ignorés pour les clés renvoyées par "get_defined_vars".
// Par exemple, HTTP_POST_VARS, HTTP_GET_VARS et autres sont
// redondant (identique à _POST, _GET)
// Incluez également les variables que vous souhaitez ignorer pour des raisons de sécurité - c'est-à-dire PHPSESSID.
$ ignorelist = tableau ("HTTP_POST_VARS", "HTTP_GET_VARS",
"HTTP_COOKIE_VARS", "HTTP_SERVER_VARS",
"HTTP_ENV_VARS", "HTTP_SESSION_VARS",
"_ENV", "PHPSESSID", "SESS_DBUSER",
"SESS_DBPASS", "HTTP_COOKIE");

$ timestamp = date ("m / j / y h: m: s");
$ message = "Rapport de débogage créé $ timestamp \ n" ;

// Récupère la dernière erreur SQL pour faire bonne mesure, où $ link est l'identifiant de la ressource
// pour mysql_connect. Commentez ou modifiez votre configuration de base de données ou d'abstraction.
lien $ global ;
$ sql_error = mysql_error (lien $);
if ($ sql_error) (
$ message. = "\ nMysql Messages : \ n". mysql_error (lien $);
}
// Fin de MySQL

// Pourrait utiliser une fonction récursive ici. Vous avez eu l'idée ;-)
foreach ($defined_vars as $ key => $ val) (
if (is_array ($ val) &&! in_array ($ key, $ ignorelist) && count ($ val)> 0) (
$ message. = "\ n $ key array (key = value): \ n";
foreach ($ val as $ subkey => $ subval) (
if (! in_array ($ subkey, $ ignorelist) &&! is_array ($ subval)) (
$ message. = $ sous-clé. "=". $ sous-val. "\n" ;
}
elseif (! in_array ($ subkey, $ ignorelist) && is_array ($ subval)) (
foreach ($ subval as $ subsubkey => $ subsubval) (
if (! in_array ($ sous-sous-clé, $ ignorelist)) (
$ message. = $ sous-sous-clé. "=". $ sous-valeur. "\n" ;
}
}
}
}
}
sinon (! is_array ($ val) &&! in_array ($ key, $ ignorelist) && $ val) (
$ message. = "\ nVariable". touche $. "=". val. $ "\n" ;
}
}

Si ($ méthode == "navigateur") (
echo nl2br ($message);
}
elseif ($ méthode == "email") (
if ($ email == "undefined") (
$ email = $ _SERVER ["SERVER_ADMIN"] ;
}

$ mresult = mail ($ email, "Rapport de débogage pour". $ _ENV ["HOSTNAME"]. "", $ message);
if ($ mresult == 1) (
écho "Rapport de débogage envoyé avec succès. \ N";
}
autre (
écho "Impossible d'envoyer le rapport de débogage. \ N";
}
}
}
?>

il y a 17 ans

Routine simple pour convertir un objet get_defined_vars en XML.

fonction obj2xml ($ v, $ indent = "") (
while (liste ($ key, $ val) = chaque ($ v)) (
if ($ key == "__attr") continuez ;
// Recherche de __attr
if (is_object ($ val -> __attr)) (
while (list ($ key2, $ val2) = each ($ val -> __attr)) (
$ attr. = "$ key2 = \" $ val2 \ "" ;
}
}
else $ attr = "" ;
if (is_array ($ val) || is_object ($ val)) (
print ("$ indent< $key$attr >\ n ");
obj2xml ($ val, $ indent. "");
print ("$ indent\ n ");
}
else print ("$ indent< $key$attr >valeur $\ n ");
}
}

// Exemple d'objet
$ x -> nom -> premier = "Jean" ;
$ x -> nom -> nom = "Smith" ;
$ x -> arr ["Fruit"] = "Bannane";
$ x -> arr ["Veg"] = "Carotte";
$ y -> client = $ x ;
$ y -> client -> __attr -> id = "176C4" ;

$ z = get_defined_vars ();
obj2xml ($ z ["y"]);
?>
affichera :


John
Forgeron


Banane
Carotte

il y a 11 ans

À noter, get_defined_vars () ne renvoie pas un ensemble de références de variables (comme je l'espérais). Par exemple:

// définir une variable
$ my_var = "toto" ;

// obtenir notre liste de variables définies
$defined_vars = get_defined_vars ();

// maintenant essayer de changer la valeur via le tableau renvoyé
$defined_vars ["my_var"] = "bar" ;

echo $ my_var, "\ n" ;

?>

affichera "foo" (la valeur d'origine). Ce serait bien si get_defined_vars () avait un argument facultatif pour en faire des références, mais j'imagine que c'est une requête plutôt spécialisée. Vous pouvez le faire vous-même (moins commodément) avec quelque chose comme :

$defined_vars = tableau ();
$ var_names = array_keys (get_defined_vars ());

foreach ($ var_names as $ var_name)
{
$defined_vars [$ var_name] = & $ $ var_name;
}

?>

il y a 1 an

J'ai déjà posté ici à propos de "cela" étant dans get_defined_vars.

Il s'avère qu'il "n'est pas toujours là mais dans certains cas, il apparaîtra inexplicablement.

Php -r "
Test de classe (
fonction publique a () (var_dump (array_keys (get_defined_vars ())); $ a = 123;)
fonction publique b () (var_dump (array_keys (get_defined_vars ())); $ this;)
}
$ t = nouveau test ();
$ t-> un ();
$ t -> b ();
"

Déployer ()
tableau ("ceci")

Cela n'arrive pas en PHP 7.2 mais arrivera en PHP 5.6.

il y a 1 an

Certains commentaires indiquent ici que cette fonction ne retournera pas de références. Il renvoie cependant des noms et les noms sont des "références".

Je ne recommanderais pas les suggestions ici qui le convertissent en références.

Fonction publique x ($ a, $ b, $ c) (
foreach (array_keys (get_defined_vars ()) en tant que clé $)
si (clé ! == "ceci")
$ this-> y (touche $ ($));
}

Fonction publique y (& $ input) (
$ entrée ++;
}

Au lieu de $ (), vous pouvez également utiliser $$.

J'ai fait des choses farfelues à mon époque pour créer du code extrêmement générique, mais je "n'ai jamais eu à faire quelque chose comme ce qui précède. Cela pourrait même ne pas fonctionner (mais devrait puisque ce" n'est pas différent de $ a [$ key]).

Vous pouvez également faire $$ key ++ mais je "n'ai jamais vu de code comme celui-ci qui n'était" pas horriblement mauvais (utiliser dynamic où dynamic n'est "pas bénéfique).

Si vous "faites quelque chose comme ça, donnez-lui un examen plus approfondi.

Cette leçon explore la portée des variables PHP. Explique la différence entre les portées locales et globales, montre comment accéder aux variables globales dans une fonction, comment travailler avec des superglobales et comment créer des variables statiques.

Lorsque vous commencez à apprendre PHP et commencez à travailler avec des fonctions et des objets, la portée des variables est un peu déroutante. Heureusement, les règles de PHP à cet égard sont très faciles à comprendre (par rapport à d'autres langages de programmation).

Qu'est-ce que la portée ?

La portée de la variable est le contexte dans lequel une variable a été définie et où elle est accessible. PHP a deux portées variables :

• Le Global- les variables sont accessibles n'importe où dans le script
• Local- les variables ne sont accessibles qu'à l'intérieur de la fonction dans laquelle elles ont été définies

La portée variable, et surtout la portée locale, facilite grandement la gestion de votre code. Si toutes les variables étaient globales, elles pourraient être modifiées n'importe où dans le script. Cela conduirait au chaos et à des scripts volumineux, car très souvent, différentes parties du script utilisent des variables du même nom. En délimitant le contexte local, vous définissez les limites du code pouvant accéder à la variable, ce qui rend le code plus robuste, modulaire et plus facile à déboguer.

Les variables à portée globale sont dites globales et les variables à portée locale sont dites locales.

Voici un exemple du fonctionnement des variables globales et locales.

";) sayHello (); echo" Valeur \ $ globalName : "$ globalName"
"; echo" Valeur \ $ localName : "$ localName"
"; ?>

Salut Harry! $ valeur GlobalName : "Zoe" $ valeur localName : ""

Dans ce script, nous avons créé deux variables :

• $ nomglobal- c'est un monde variable
• $ nomlocal- c'est local une variable qui est créée à l'intérieur de la fonction sayHello ().

Après avoir créé la variable et la fonction, le script appelle sayHello(), qui affiche "Hello Harry!" ... Le script essaie alors de faire écho aux valeurs des deux variables. Voici ce qui se passe :

• Parce que $ nomglobal a été créé en dehors de la fonction, il est disponible n'importe où dans le script, donc "Zoya" est affiché.
• $ nomlocal ne sera disponible que dans la fonction sayHello (). Comme l'expression echo est en dehors de la fonction, PHP n'autorise pas l'accès à la variable locale. Au lieu de cela, PHP suppose que le code créera une nouvelle variable nommée $ localName, qui recevra une valeur par défaut d'une chaîne vide. c'est pourquoi le deuxième appel à echo imprime la valeur "" pour la variable $ localName.

Accéder aux variables globales dans une fonction

Pour accéder à une variable globale hors fonctionécris juste son nom. Mais pour accéder à la variable globale fonction intérieure, vous devez d'abord déclarer la variable comme globale dans la fonction à l'aide du mot clé global :

Fonction myFunction() (global $ globalVariable ; // Accès à la variable globale $ globalVariable)

Si vous ne le faites pas, PHP suppose que vous créez ou utilisez une variable locale.

Voici un exemple de script qui utilise une variable globale dans une fonction :

"; global $ globalName; echo" Bonjour $ globalName !
";) sayBonjour ();?>

Une fois exécuté, le script affichera :

Salut Harry! Salut Zoya !

La fonction sayHello() utilise le mot clé global pour déclarer la variable $ globalName comme globale. Elle peut alors accéder à la variable et afficher sa valeur ("Zoya").

Que sont les superglobaux ?

PHP a un ensemble spécial de tableaux globaux prédéfinis qui contiennent diverses informations. De tels tableaux sont appelés superglobales, car ils sont accessibles de n'importe où dans le script, y compris l'espace de fonction interne, et n'ont pas besoin d'être définis à l'aide du mot-clé global.

Voici une liste des superglobales disponibles en PHP 5.3 :

• $ GLOBALS - liste de toutes les variables globales dans le script (à l'exception des superglobales)
• $ _GET - contient une liste de tous les champs de formulaire soumis par le navigateur à l'aide d'une requête GET
• $ _POST - contient une liste de tous les champs de formulaire soumis par le navigateur à l'aide d'une requête POST
• $ _COOKIE - contient une liste de tous les cookies envoyés par le navigateur
• $ _REQUEST - contient toutes les combinaisons clé/valeur contenues dans les tableaux $ _GET, $ _POST, $ _COOKIE
• $ _FILES - contient une liste de tous les fichiers chargés par le navigateur
• $ _SESSION - vous permet de stocker et d'utiliser des variables de session pour le navigateur actuel
• $ _SERVER - contient des informations sur le serveur, telles que le nom de fichier du script en cours d'exécution et l'adresse IP du navigateur.
• $ _ENV - Contient une liste de variables d'environnement passées à PHP, par exemple les variables CGI.

Par exemple, vous pouvez utiliser $ _GET pour obtenir les valeurs des variables incluses dans la chaîne d'URL de la requête de script, et les afficher sur la page :

Si vous exécutez le script ci-dessus avec la chaîne URL http://www.example.com/script.php?yourName=Fred, il affichera :

Salut Fred !

Un avertissement! Dans un script réel, vous ne devriez jamais utiliser un tel transfert de données en raison d'une sécurité faible. Vous devez toujours vérifier ou filtrer vos données.

Le superglobal $ GLOBALS est très pratique à utiliser car il permet d'organiser l'accès aux variables globales dans une fonction sans avoir besoin d'utiliser le mot clé global. Par exemple:

";) sayHello (); // Imprime" Hello, Zoe! "?>

Variables statiques : elles sont quelque part à proximité

Lorsque vous créez une variable locale dans une fonction, elle n'existe que pendant l'exécution de la fonction. Lorsque la fonction se termine, la variable locale disparaît. Lorsque la fonction est à nouveau appelée, une nouvelle variable locale est créée.

Cela fonctionne très bien dans la plupart des cas. De cette façon, les fonctions sont autonomes et fonctionnent toujours de la même manière à chaque fois qu'elles sont appelées.

Cependant, il existe des situations où il serait pratique de créer une variable locale qui "se souvient" de sa valeur entre les appels de fonction. Une telle variable est appelée statique.

Pour créer une variable statique dans une fonction, vous devez utiliser le mot-clé static devant le nom de la variable et assurez-vous de lui donner une valeur initiale. Par exemple:

Fonction maFonction () (statique $ maVariable = 0 ;)

Considérons une situation où il est commode d'utiliser une variable statique. Disons que vous créez une fonction qui, lorsqu'elle est appelée, crée un widget et affiche le nombre de widgets déjà créés. Vous pouvez essayer d'écrire du code comme celui-ci en utilisant une variable locale :

"; echo createWidget ()." que nous avons déjà créé.
"; echo createWidget ()." que nous avons déjà créé.>
"; ?>

Mais, puisque la variable $ numWidgets est créée à chaque fois que la fonction est appelée, nous obtiendrons le résultat suivant :

Nous créons des widgets... 1 que nous avons déjà créés. 1 que nous avons déjà créé. 1 que nous avons déjà créé.

Mais en utilisant une variable statique, nous pouvons stocker la valeur d'un appel de fonction au suivant :

"; echo createWidget ()." que nous avons déjà créé.
"; echo createWidget ()." que nous avons déjà créé.
"; echo createWidget ()."> nous avons déjà créé.
"; ?>

Le script va maintenant produire la sortie attendue :

Nous créons des widgets... 1 que nous avons déjà créés. 2 que nous avons déjà créé. 3 que nous avons déjà créé.

Bien qu'une variable statique conserve sa valeur entre les appels de fonction, elle n'est valide qu'au moment où le script est exécuté. Dès que le script termine son exécution, toutes les variables statiques sont détruites, ainsi que les variables locales et globales.

C'est tout! Consultez souvent la documentation PHP.