Php visi mainīgie. Mainīgie PHP

Php mainīgie ir sava veida informācijas konteiners, kas var saturēt dažāda veida datus (tekstu, ciparus, masīvus utt.). Parasti mainīgie ļauj izveidot, saglabāt, modificēt un nākotnē ātri piekļūt tajos norādītajai informācijai.

Kā izveidot mainīgo PHP

Sākotnēji mainīgie satur zīmi $ (dolārs) - mainīgā lietošanas apzīmējums, pēc tam burti Latīņu alfabēts(no a līdz z un maziem un lieliem), beigās var saturēt numurus... Turklāt nosaukumam ir atļauts izmantot pasvītrojumu (nevis beigās).

Kā nosaukt mainīgos:

$ var
$ mainīgais
1945 ASV dolāri
$ _variable
Kā nevar izsaukt mainīgos:

1 USD - sastāv tikai no cipara
$ 1var - jūs nevarat sākt mainīgā nosaukumu ar ciparu
$ / var - papildu rakstzīmes ir atļautas tikai pasvītras _
$ mainīgais - kirilicu atļauj php dokumentācija, bet nav ieteicams
$ var iable - atstarpes nevar izmantot

Katram mainīgajam tiek piešķirta vērtība. Lai piešķirtu vērtību, izmantojiet zīmi = (vienāds). Skripta apstrādes laikā mainīgā vērtība var mainīties atkārtoti atkarībā no dažādiem apstākļiem.

$ city = "Maskava"; // mainīgajam $ city tika piešķirta virkne (pēdiņās) vērtība Maskava
$ gads = 1147; // un $ year mainīgajam tika piešķirta skaitliskā vērtība 1147
?>

$ name = "Aleksandrs";
$ Name = "Aleksejs";
echo "$ name, $ Name"; // parāda "Aleksandrs, Aleksejs"
?>

Mainīga PHP izvade

Atsevišķi jums jāapsver, kā parādīt mainīgos, izmantojot izvades operatori, par kuru darbu mēs runājām pēdējā nodarbībā PHP lapas izveide. Izvades operatori. ... Tālāk es sniegšu vairākus ilustratīvus piemērus ar komentāriem.

// Šādi mēs piešķiram vērtības mainīgajiem
$ name1 = "Aleksejs";
$ name2 = "Aleksandrs";

// Parādīt mainīgos
echo $ name2; // Izeja: Aleksandrs
echo "name1 ir $ name1"; // vārds1 ir Aleksejs

// Izmantojot atsevišķas pēdiņas, iznākums ir
// mainīgā nosaukums, nevis vērtība
echo "name1 ir $ name1"; // izdrukas: nosaukums1 ir $ name1

// jūs varat vienkārši parādīt mainīgo vērtības
echo $ name1; // Aleksejs
echo $ name1, $ name2; // Aleksejs Aleksandrs
echo $ name1. "". $ name2; // Aleksejs Aleksandrs
atbalss "$ name1, $ name2"; // Aleksejs, Aleksandrs

Atbalss<<Izvadīšanai tiek izmantota sinhronizācija "šeit dokuments"
vairākas rindas ar $ mainīgu aizvietošanu.
END;

Mainīgas PHP darbības

Aritmētiskās operācijas PHP
Skaitlisko vērtību gadījumā varat veikt aritmētiskas darbības: saskaitīšanu, atņemšanu, reizināšanu utt.

- $ a(noliegums) Mainiet $ a zīmi.
$ a + $ b(papildinājums) $ a un $ b summa.
$ a - $ b(atņemšana) Atšķirība starp $ a un $ b.
$ a * $ b(reizināšana) $ a un $ b reizinājums.
$ a / $ b(dalījums) $ a koeficients dalīts ar $ b.
$ a% $ b(modulo) $ a vesels skaitlis, dalīts ar $ b.
Apskatīsim piemērus

$ a = 2; // piezīme, skaitļu gadījumā pēdiņas netiek izmantotas
$ b = 3; // piezīme, skaitļu gadījumā pēdiņas netiek izmantotas

$ rezultāts = $ a + $ b; // pievienot mainīgos
echo $ rezultāts; // drukās 5

$ rezultāts = $ b - $ a; // pievienot mainīgos
echo $ rezultāts; // tiks izvadīts 1

Palielināšanas un samazināšanas operācijas PHP
Šīs darbības būs noderīgas galvenokārt, veidojot cilpas, par kurām mēs runāsim nedaudz vēlāk.
Priedēklis- operatori, kas rakstīti PIRMS mainīgā ( - $ a; ++ $ a). Atgriež mainīgā vērtību pirms izmaiņām.
Postfix- operatori, kas rakstīti aiz mainīgā ( $ a--; $ a--). Atgriež mainīgā mainīto vērtību.
Palielinājums- vērtības palielināšana.
Samazinājums- vērtības samazināšana.

++ $ a Prefiksa palielinājums. Palielina $ a par vienu un atgriež $ a.
$ a ++ Postfix palielinājums. Atgriež USD a vērtību un pēc tam palielina USD a par vienu.
- $ a Prefiksa samazināšana. Samazina $ a par vienu un atgriež vērtību $ a.
$ a-- Postfix samazinājums. Atgriež USD a vērtību un pēc tam samazina USD a par vienu.
atbalss "

Postfix palielinājums

";
$ a = 5;
atbalss "Vajadzētu būt 5:". $ a ++. "\ n";

Atbalss "

Prefiksa pieaugums

";
$ a = 5;
atbalss "Jābūt 6:". ++ $ a. "\ n";
atbalss "Jābūt 6:". $ a. "\ n";

Atbalss "

Postfix samazinājums

";
$ a = 5;
atbalss "Vajadzētu būt 5:". $ a--. "\ n";

Atbalss "

Prefiksa samazināšana

";
$ a = 5;
atbalss "Vajadzētu būt 4:". - $ a. "\ n";
atbalss "Vajadzētu būt 4:". $ a. "\ n";
?>

PHP piešķiršanas operācijas
Pamata operators izskatās kā = ... No pirmā acu uzmetiena varētu šķist, ka šis operators ir līdzvērtīgs. Patiesībā tas tā nav. Faktiski piešķiršanas operators nozīmē, ka kreisajam operandam ir iestatīta labās izteiksmes vērtība (tas ir, to nosaka iegūtā vērtība). Kombinētie operatori- tie ir operatori, kas ļauj izmantot iepriekšējās mainīgo vērtības turpmākajām darbībām (pievienot virknes mainīgajam (ar tekstu) vai pievienot skaitliskas vērtības).

$ a = ($ b = 2) + 4; // rezultāts: $ a ir iestatīts uz 6, $ b ir iestatīts uz 2.

$ a = 2;
$ a + = 3; // nosaka $ a līdz 5, līdzīgi kā rakstot: $ a = $ a + 3;
$ b = "Labdien";
$ b. = "Pasaule!"; // nosaka $ b uz "Hello World!", tāpat kā $ b = $ b. "Tur!";

Tur ir arī salīdzināšanas operācijas un prāta mežģis, bet par tiem mēs runāsim nākamajās nodarbībās. Es centīšos jūs uzreiz nebiedēt ar lielu informācijas daudzumu!)

Šajā nodarbībā tiek pētīts PHP mainīgo apjoms. Izskaidro atšķirību starp vietējo un globālo darbības jomu, parāda, kā funkcijā piekļūt globālajiem mainīgajiem, kā strādāt ar superglobaliem un kā izveidot statiskus mainīgos.

Kad sākat mācīties PHP un sākat strādāt ar funkcijām un objektiem, mainīgo apjoms ir nedaudz mulsinošs. Par laimi, PHP noteikumi šajā sakarā ir ļoti viegli saprotami (salīdzinot ar citām programmēšanas valodām).

Kas ir tvērums?

Mainīgā darbības joma ir konteksts, kurā mainīgais tika definēts un kur tam var piekļūt. PHP ir divas mainīgas darbības jomas:

  • Globālā- mainīgajiem var piekļūt jebkurā skripta vietā
  • Vietējais- mainīgajiem var piekļūt tikai tajā funkcijā, kurā tie tika definēti

Mainīgā darbības joma, un jo īpaši vietējā darbības joma, ievērojami atvieglo koda pārvaldību. Ja visi mainīgie būtu globāli, tos varētu mainīt jebkurā skripta vietā. Tas radītu haosu un lielus skriptus, jo ļoti bieži dažādās skripta daļās tiek izmantoti mainīgie ar tādu pašu nosaukumu. Izmantojot lokālo kontekstu, jūs definējat koda robežas, kas var piekļūt mainīgajam, padarot kodu izturīgāku, modulārāku un vieglāk atkļūdojamu.

Mainīgos, kuru darbības joma ir globāla, sauc par globāliem, un tos, kas ir lokāli, sauc par vietējiem.

Šeit ir piemērs tam, kā darbojas globālie un vietējie mainīgie.

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

Sveiks Harij! $ GlobalName vērtība: "Zoe" $ localName vērtība: ""

Šajā skriptā mēs esam izveidojuši divus mainīgos:

  • $ globalName- tas ir globāls mainīgais
  • $ localName- tas ir vietējais mainīgais, kas tiek izveidots funkcijā sayHello ().

Pēc mainīgā un funkcijas izveides skripts izsauc sayHello (), kas izvada "Hello Harry!" ... Pēc tam skripts mēģina atkārtot abu mainīgo vērtības. Lūk, kas notiek:

  • Jo $ globalName tika izveidots ārpus funkcijas, tas ir pieejams jebkurā skripta vietā, tāpēc tiek parādīts "Zoya".
  • $ localName būs pieejams tikai funkcijā sayHello (). Tā kā atbalss izteiksme ir ārpus funkcijas, PHP neļauj piekļūt vietējam mainīgajam. Tā vietā PHP pieņem, ka kods izveidos jaunu mainīgo ar nosaukumu $ localName, kas saņems tukšas virknes noklusējuma vērtību. tāpēc otrais zvans atbalss izdrukā mainīgā $ localName vērtību "".

Piekļuve globālajiem mainīgajiem funkcijas ietvaros

Lai piekļūtu globālajam mainīgajam nedarbojas vienkārši uzraksti viņas vārdu. Bet, lai piekļūtu globālajam mainīgajam iekšējā funkcija, vispirms mainiet mainīgo kā globālu funkcijā, izmantojot globālo atslēgvārdu:

Funkcija myFunction () (global $ globalVariable; // Piekļuve globālajam mainīgajam $ globalVariable)

Ja to nedarāt, PHP pieņem, ka veidojat vai izmantojat vietējo mainīgo.

Šeit ir skripta piemērs, kas funkcijā izmanto globālu mainīgo:

"; global $ globalName; echo" Labdien $ globalName!
";) sakiet sveiki ();?>

Izpildot, skripts izdos:

Sveiks Harij! Sveika Zoja!

Funkcija sayHello () izmanto globālo atslēgvārdu, lai mainītu $ globalName mainīgo kā globālu. Tad viņa var piekļūt mainīgajam un parādīt tā vērtību ("Zoya").

Kas ir superglobāli?

PHP ir īpašs iepriekš definētu globālo masīvu komplekts, kas satur dažādu informāciju. Šādus masīvus sauc superglobāli, jo tie ir pieejami no jebkuras vietas skriptā, ieskaitot iekšējo funkciju telpu, un tie nav jādefinē, izmantojot globālo atslēgvārdu.

Šeit ir saraksts ar superglobaliem, kas pieejami PHP 5.3:

  • $ GLOBALS - visu skripta globālo mainīgo saraksts (izņemot superglobalus)
  • $ _GET - satur sarakstu ar visiem veidlapu laukiem, kurus pārlūks ir iesniedzis, izmantojot GET pieprasījumu
  • $ _POST - satur sarakstu ar visiem veidlapu laukiem, kurus pārlūks ir iesniedzis, izmantojot POST pieprasījumu
  • $ _COOKIE - satur visu pārlūkprogrammas nosūtīto sīkfailu sarakstu
  • $ _REQUEST - satur visas atslēgu / vērtību kombinācijas, kas atrodas masīvos $ _GET, $ _POST, $ _COOKIE
  • $ _FILES - satur visu pārlūka ielādēto failu sarakstu
  • $ _SESSION - ļauj saglabāt un izmantot sesijas mainīgos pašreizējam pārlūkam
  • $ _SERVER - satur informāciju par serveri, piemēram, izpildāmā skripta faila nosaukumu un pārlūkprogrammas IP adresi.
  • $ _ENV - satur PHP nodoto vides mainīgo sarakstu, piemēram, CGI mainīgos.
Piemēram, varat izmantot $ _GET, lai iegūtu skripta pieprasījuma URL virknē iekļauto mainīgo vērtības un parādītu tās lapā:

Ja izpildīsit iepriekš minēto skriptu ar URL virkni http://www.example.com/script.php?yourName=Fred, tas izvadīs:

Sveiks Fred!

Brīdinājums!Īstā skriptā vāja drošības dēļ nekad nevajadzētu izmantot šādu datu pārsūtīšanu. Jums vienmēr jāpārbauda vai jāfiltrē savi dati.

$ GLOBALS superglobal ir ļoti ērti lietojams, jo tas ļauj organizēt piekļuvi globālajiem mainīgajiem kādā funkcijā, neizmantojot globālo atslēgvārdu. Piemēram:

";) sayHello (); // Izdrukā" Sveika, Zoja! "?>

Statiskie mainīgie: tie atrodas kaut kur tuvumā

Kad funkcijā izveidojat lokālu mainīgo, tas pastāv tikai funkcijas darbības laikā. Kad funkcija beidzas, vietējais mainīgais pazūd. Kad funkcija tiek izsaukta vēlreiz, tiek izveidots jauns lokālais mainīgais.

Tas vairumā gadījumu darbojas lieliski. Tādā veidā funkcijas ir patstāvīgas un vienmēr darbojas vienādi katru reizi, kad tās tiek izsauktas.

Tomēr ir situācijas, kad starp funkciju izsaukumiem būtu ērti izveidot vietējo mainīgo, kas "atceras" tā vērtību. Šādu mainīgo sauc par statisku.

Lai funkcijā izveidotu statisku mainīgo, mainīgā nosaukuma priekšā jāizmanto statiskais atslēgvārds un noteikti jānorāda tam sākotnējā vērtība. Piemēram:

Funkcija myFunction () (statisks $ myVariable = 0;)

Aplūkosim situāciju, kad ir ērti izmantot statisku mainīgo. Pieņemsim, ka izveidojat funkciju, kas pēc izsaukšanas izveido logrīku un parāda jau izveidoto logrīku skaitu. Varat mēģināt rakstīt kodu šādi, izmantojot vietējo mainīgo:


"; echo createWidget ()." mēs jau esam izveidojuši.
"; echo createWidget ()." mēs jau esam izveidojuši.>
"; ?>

Bet, tā kā mainīgais $ numWidgets tiek izveidots katru reizi, kad tiek izsaukta funkcija, mēs iegūsim šādu rezultātu:

Mēs izveidojam dažus logrīkus ... 1 mēs jau esam izveidojuši. 1 mēs jau esam izveidojuši. 1 mēs jau esam izveidojuši.

Bet, izmantojot statisku mainīgo, mēs varam saglabāt vērtību no viena funkcijas izsaukuma uz nākamo:

"; echo createWidget ()." mēs jau esam izveidojuši.
"; echo createWidget ()." mēs jau esam izveidojuši.
"; echo createWidget ()."> mēs jau esam izveidojuši.
"; ?>

Skripts tagad radīs gaidīto rezultātu:

Mēs izveidojam dažus logrīkus ... 1 mēs jau esam izveidojuši. 2 mēs jau esam izveidojuši. 3 mēs jau esam izveidojuši.

Lai gan statiskais mainīgais saglabā vērtību starp funkciju izsaukumiem, tas ir derīgs tikai skripta izpildes laikā. Tiklīdz skripts pabeidz izpildi, tiek iznīcināti visi statiskie mainīgie, kā arī vietējie un globālie mainīgie.

Tas ir viss! Bieži pārbaudiet PHP dokumentāciju.

Vides mainīgie (vide) sistēmā Windows satur dažādu informāciju par sistēmas iestatījumiem un lietotāja vidi. Atšķirt lietotāja, sistēmas un procesa vides mainīgos.

Vienkāršākais veids, kā apskatīt vides mainīgo saturu sistēmā Windows, ir atvērt sistēmas rekvizītus ( sysdm.cpl) -> Papildu -> Vides mainīgie. Kā redzat, atvērtajā sadaļā ir divas sadaļas: augšējā ir lietotāja vides mainīgie, bet apakšējā - sistēmas.

Turklāt vides mainīgie tiek saglabāti sistēmas reģistrā. Pielāgotie mainīgie tiek saglabāti sadaļā. Sistēma - iekšā HKLM \ SYSTEM \ CurrentControlSet \ Control \ Session Manager \ Environment.

Windows komandrindā varat parādīt visu vides mainīgo vērtības. Komanda ir vienkārša:

Komanda uzskaitīs vides mainīgos un to vērtības.

Programmā PowerShell varat izmantot komandu, lai parādītu visus vides mainīgos:

Ja vēlaties parādīt tikai viena mainīgā vērtību, jums jāizmanto komanda echo, un mainīgā nosaukums jāiekļauj procentu zīmēs. Piemēram,

Echo% systemroot%

iestatiet> c: \ tmp \ env_var.txt

Konkrēta procesa vides mainīgos var iegūt, izmantojot bezmaksas Process Explorer utilītas(no Sysinternals). Pietiek, lai atvērtu procesa rekvizītus un dotos uz cilni Vide.

Pirms 13 gadiem

Nedaudz jāpievērš uzmanība:

Ja izslēdzat RegisterGlobals un saistīto, tad izmantojiet get_defined_vars (), iespējams, redzēsit kaut ko līdzīgu:

Masīvs
[GLOBALS] => Masīvs
[GLOBALS] => Masīvs
* KĀRTĪBA *
[_POST] => Masīvs ()
[_GET] => Masīvs ()
[_COOKIE] => Masīvs ()
[_FILES] => Masīvs ()
)

[_POST] => Masīvs ()
[_GET] => Masīvs ()
[_COOKIE] => Masīvs ()
[_FILES] => Masīvs ()

)
?>

Ņemiet vērā, ka $ _SERVER tur nav. Šķiet, ka php tikai ielādē superglobālo $ _SERVER, ja tas tiek izmantots kaut kur. Jūs varētu to izdarīt:

drukāt " 

". htmlspecialchars (print_r (get_defined_vars (), true))."
" ;
drukāt " 
". htmlspecialchars (print_r ($ _SERVER, true))."
" ;
?>

Un tad abos sarakstos parādīsies $ _SERVER. Es domāju, ka tā īsti nav nekāda aizķeršanās, jo nekas slikts nenotiks jebkurā gadījumā, bet tomēr interesanta ziņkārība.

Pirms 6 gadiem

Tā kā get_defined_vars () iegūst mainīgos tikai tajā brīdī, kad izsaucat funkciju, ir vienkāršs veids, kā iegūt mainīgos, kas definēti pašreizējā darbības jomā.

// PHP skripta augšdaļa
$ vars = get_defined_vars ();

// Tagad dari savas lietas
$ foo = "foo";
$ bar = "bārs";

// Iegūstiet visus mainīgos, kas definēti pašreizējā tvērumā
$ vars = masīva_difs (get_defined_vars (), $ vars);

atbalss " 

"
;
print_r ($ vars); 
atbalss "
" ;
?>

Pirms 15 gadiem

Šeit ir funkcija, kas ģenerē atkļūdošanas ziņojumu attēlošanai vai e -pastam
izmantojot get_defined_vars. Lieliski piemērots detalizēta momentuzņēmuma iegūšanai bez tā
paļaujoties uz lietotāja ievadi.

funkcija generatedDebugReport ($ metode, $ define_vars, $ email = "undefined") (
// Funkcija, lai izveidotu atkļūdošanas pārskatu, ko parādīt vai nosūtīt pa e -pastu.
// Lietošana :geneDebugReport (metode, get_defined_vars (), e -pasts);
// Kur metode ir "pārlūks" vai "e -pasts".

// Izveidojiet ignorēšanas sarakstu atslēgām, kuras atgriež "get_defined_vars".
// Piemēram, HTTP_POST_VARS, HTTP_GET_VARS un citi
// lieki (tādi paši kā _POST, _GET)
// Iekļaujiet arī versijas, kuras drošības apsvērumu dēļ vēlaties ignorēt - t.i. PHPSESSID.
$ ignorelist = array ("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 = datums ("m / d / g h: m: s");
$ message = "Atkļūdošanas pārskats izveidoja $ timestamp \ n";

// Iegūstiet pēdējo SQL kļūdu, lai novērtētu, kur $ saite ir resursa identifikators
// par mysql_connect. Komentējiet vai pārveidojiet savu datu bāzi vai abstrakcijas iestatījumus.
globālā $ saite;
$ sql_error = mysql_error ($ saite);
ja ($ sql_error) (
$ message. = "\ nMysql ziņojumi: \ n". mysql_error ($ saite);
}
// Beigt MySQL

// Šeit varētu izmantot rekursīvu funkciju. Jūs sapratāt ideju ;-)
foreach ($ define_vars kā $ key => $ val) (
ja (is_array ($ val) &&! in_array ($ key, $ ignorelist) && count ($ val)> 0) (
$ message. = "\ n $ atslēgu masīvs (atslēga = vērtība): \ n";
foreach ($ val kā $ apakšatslēga => $ apakšvaloda) (
ja (! in_array ($ apakšatslēga, $ ignorelist) &&! is_array ($ subval)) {
$ message. = $ apakšatslēga. "=". $ apakšvaloda. "\ n";
}
elseif (! in_array ($ apakšatslēga, $ ignorelist) && is_array ($ subval)) {
foreach ($ subval kā $ subsubkey => $ subsubval) (
ja (! in_array ($ apakšatslēga, $ ignorelist)) (
$ message. = $ apakšatslēga. "=". $ apakšpakalpojums. "\ n" ;
}
}
}
}
}
cits (! is_array ($ val) &&! in_array ($ atslēga, $ ignorēšanas saraksts) && $ val) (
$ message. = "\ nMainīgs". $ atslēga. "=". $ val. "\ n";
}
}

Ja ($ method == "pārlūks") (
echo nl2br ($ ziņa);
}
elseif ($ method == "e -pasts") (
ja ($ email == "undefined") (
$ e -pasts = $ _SERVER ["SERVER_ADMIN"];
}

$ mresult = mail ($ email, "Atkļūdošanas ziņojums par". $ _ENV ["HOSTNAME"]. "", $ message);
ja ($ mresult == 1) (
atbalss "Atkļūdošanas ziņojums ir veiksmīgi nosūtīts. \ N";
}
cits (
atbalss "Neizdevās nosūtīt atkļūdošanas pārskatu. \ N";
}
}
}
?>

Pirms 17 gadiem

Vienkārša rutīna get_defined_vars objekta pārvēršanai XML.

funkcija obj2xml ($ v, $ indent = "") (
while (saraksts ($ atslēga, $ val) = katrs ($ v)) (
ja ($ key == "__attr") turpināt;
// Pārbaudiet, vai nav __attr
ja (ir_objekts ($ val -> __attr)) {
while (saraksts ($ key2, $ val2) = katrs ($ val -> __attr)) (
$ attr. = "$ key2 = \" $ val2 \ "";
}
}
cits $ attr = "";
if (is_array ($ val) || is_object ($ val)) (
print ("$ ievilkums< $key$attr >\ n ");
obj2xml ($ val, $ ievilkums. "");
print ("$ ievilkums\ n ");
}
else print ("$ ievilkums< $key$attr >$ val\ n ");
}
}

// Objekta piemērs
$ x -> vārds -> pirmais = "Jānis";
$ x -> vārds -> pēdējais = "Smits";
$ x -> arr ["Augļi"] = "Bannana";
$ x -> arr ["Veg"] = "Burkāns";
$ y -> klients = $ x;
$ y -> klients -> __attr -> id = "176C4";

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


Džons
Smits


Bannana
Burkāns

Pirms 11 gadiem

Piezīme: get_defined_vars () neatgriež mainīgo atsauču kopu (kā es cerēju). Piemēram:

// definēt mainīgo
$ my_var = "foo";

// iegūstiet mūsu definēto mainīgo sarakstu
$ define_vars = get_defined_vars ();

// tagad mēģiniet mainīt vērtību, izmantojot atgriezto masīvu
$ define_vars ["my_var"] = "bārs";

echo $ my_var, "\ n";

?>

izvadīs "foo" (sākotnējā vērtība). Būtu jauki, ja get_defined_vars () būtu neobligāti argumenti, lai padarītu tās par atsaucēm, bet es domāju, ka tas ir diezgan specializēts pieprasījums. To var izdarīt pats (mazāk ērti) ar kaut ko līdzīgu:

$ define_vars = masīvs ();
$ var_names = masīva_atslēgas (get_defined_vars ());

foreach ($ var_names kā $ var_name)
{
$ define_vars [$ var_name] = & $ $ var_name;
}

?>

Pirms 1 gada

Iepriekš es šeit ievietoju informāciju par to, ka “šis” atrodas get_defined_vars.

Izrādās, ka tas ne vienmēr ir, bet dažos gadījumos tas parādīsies neizskaidrojami.

Php -r "
klases tests (
publiska funkcija a () (var_dump (masīva_atslēgas (get_defined_vars ())); $ a = 123;)
publiskā funkcija b () (var_dump (masīva_atslēgas (get_defined_vars ())); $ šis;)
}
$ t = jauns tests ();
$ t-> a ();
$ t-> b ();
"

Masīvs ()
masīvs ("šis")

Tas nenotiek PHP 7.2, bet notiks PHP 5.6.

Pirms 1 gada

Daži komentāri šeit norāda, ka šī funkcija neatgriezīs atsauces. Tomēr tas atgriež vārdus un vārdi ir "atsauces".

Es šeit neiesaku ieteikumus, kas to pārvērš par atsaucēm.

Publiskā funkcija x ($ a, $ b, $ c) (
foreach (masīva_atslēgas (get_defined_vars ()) kā $ atslēga)
ja ($ key! == "this")
$ šis-> y ($ ($ atslēga));
}

Publiska funkcija y (& $ ievade) (
$ ievade ++;
}

$ () Vietā varat izmantot arī $$.

Savā laikā esmu darījis dažas neveiklas lietas, lai izveidotu ārkārtīgi vispārīgu kodu, taču man nekad nav bijis jādara kaut kas līdzīgs iepriekš minētajam. Tas varētu pat nedarboties (bet vajadzētu, jo tas neatšķiras no $ a [$ key]).

Jūs varētu arī izmantot $$ taustiņu ++, bet es nekad neesmu redzējis tādu kodu, kas nebūtu šausmīgi slikts (izmantojot dinamisko, kur dinamika nav izdevīga).

Ja jūs kaut ko tādu darāt, tad rūpīgi pārbaudiet to.

LĪDZĪGI RAKSTI