Php kõik muutujad. Muutujad PHP -s

Php muutujad on omamoodi teabekonteiner, mis võib sisaldada erinevat tüüpi andmeid (tekst, numbrid, massiivid jne). Üldiselt võimaldavad muutujad luua, salvestada, muuta ja tulevikus nendes märgitud teabele kiiresti juurde pääseda.

Kuidas luua PHP -s muutuja

Esialgu sisaldavad muutujad märki $ (dollar) - muutuja kasutamise tähis, seejärel tähed Ladina tähestik(alates a kuni z ja väikesed ja suured), lõpus võib sisaldada numbrid... Samuti on nimel lubatud kasutada alajoont (mitte lõpus).

Kuidas muutujaid nimetada:

$ var
$ muutuja
1945 dollarit
$ _muutuja
Kuidas muutujaid ei saa nimetada:

1 dollar - koosneb ainult numbrist
$ 1var - muutuja nime ei saa alustada numbriga
$ / var - lisamärke on lubatud ainult allajoonida _
$ muutuja - kirillitsa on php dokumentatsioonis lubatud, kuid pole soovitatav
$ var iable - tühikuid ei saa kasutada

Igale muutujale määratakse väärtus. Väärtuse määramiseks kasutage märki = (võrdne). Skripti töötlemise ajal võib muutuja väärtus sõltuvalt tingimustest korduvalt muutuda.

$ city = "Moskva"; // muutujale $ city määrati string (jutumärkides) väärtus Moskva
$ aasta = 1147; // ja muutujale $ year määrati arvväärtus 1147
?>

$ name = "Aleksander";
$ Name = "Aleksei";
kaja "$ nimi, $ nimi"; // kuvab "Aleksander, Aleksei"
?>

Muutuva väljundiga PHP

Eraldi peaksite kaaluma muutujate kuvamist, kasutades väljundoperaatorid, mille tööd uurisime viimases tunnis PHP lehe loomine. Väljundoperaatorid. ... Toon allpool mitmeid illustreerivaid näiteid koos kommentaaridega.

// Nii määrame muutujatele väärtused
$ name1 = "Aleksei";
$ name2 = "Aleksander";

// Muutujate kuvamine
echo $ name2; // Väljund: Aleksander
kaja "nimi1 on $ nimi1"; // nimi1 on Aleksei

// Üksikpakkumiste kasutamisel on väljund
// muutuja nimi, mitte väärtus
kaja "nimi1 on $ nimi1"; // print: nimi1 on $ nimi1

// saate lihtsalt kuvada muutujate väärtusi
kaja $ name1; // Aleksei
kaja $ nimi1, $ nimi2; // Aleksei Aleksander
echo $ name1. "". $ name2; // Aleksei Aleksander
kaja "$ nimi1, $ nimi2"; // Aleksei, Aleksander

Kaja<<Väljundiks kasutatakse siin dokumendi süntaksit
mitu rida muutuja $ muutujaga.
LÕPP;

PHP muutujate toimingud

Aritmeetilised toimingud PHP -s
Arvväärtuste puhul saate teha aritmeetilisi toiminguid: liitmine, lahutamine, korrutamine jne.

- $ a(eitus) Muutke $ a märki.
$ a + $ b(liitmine) $ a ja $ b summa.
a - $ b(lahutamine) Erinevus $ a ja $ b vahel.
$ a * $ b(korrutamine) $ a ja $ b korrutis.
$ a / $ b(jaotus) $ a jagatis jagatuna $ b.
$ a% $ b(modulo) $ a jääk täisarv jagatud $ b -ga.
Vaatame näiteid

$ a = 2; // pange tähele, numbrite puhul jutumärke ei kasutata
b b = 3; // pange tähele, numbrite puhul jutumärke ei kasutata

$ tulemus = $ a + $ b; // muutujate lisamine
echo $ tulemus; // trükitakse 5

$ tulemus = $ b - $ a; // muutujate lisamine
echo $ tulemus; // väljastab 1

Suurendamise ja vähendamise toimingud PHP -s
Need toimingud on kasulikud peamiselt silmuste ehitamisel, millest räägime veidi hiljem.
Eesliide- operaatorid kirjutasid ENNE muutujat ( - $ a; ++ $ a). Tagastab muutuja väärtuse enne muudatust.
Postfix- muutuja järel kirjutatud operaatorid ( $ a--; $ a--). Tagastab muutuja muudetud väärtuse.
Suurendamine- väärtuse suurendamine.
Vähenemine- väärtuse vähendamine.

++ $ a Eesliite juurdekasv. Suurendab $ a ühe võrra ja tagastab $ a.
$ a ++ Postfix juurdekasv. Tagastab väärtuse $ a ja seejärel suurendab $ a ükshaaval.
- $ a Eesliide kahandamine. Vähendab $ a ühe võrra ja tagastab väärtuse $ a.
$ a-- Postfix kahandus. Tagastab väärtuse $ a ja kahandab seejärel $ a ükshaaval.
kaja "

Postfix juurdekasv

";
$ a = 5;
kaja "Peaks olema 5:". $ a ++. "\ n";

Kaja "

Eesliite juurdekasv

";
$ a = 5;
kaja "Peaks olema 6:". ++ $ a. "\ n";
kaja "Peab olema 6:". $ a. "\ n";

Kaja "

Postfix kahandus

";
$ a = 5;
kaja "Peaks olema 5:". $ a--. "\ n";

Kaja "

Eesliide kahandamine

";
$ a = 5;
kaja "Peaks olema 4:". - $ a. "\ n";
kaja "Peaks olema 4:". $ a. "\ n";
?>

PHP määramistoimingud
Põhiline operaator paistab nagu = ... Esmapilgul võib tunduda, et see operaator on võrdne. Tegelikult see nii ei ole. Tegelikult tähendab omistamisoperaator seda, et vasakpoolne operand on seatud parema avaldise väärtusele (st see on määratud saadud väärtusega). Kombineeritud operaatorid- need on operaatorid, mis võimaldavad järgmiste toimingute jaoks kasutada muutujate varasemaid väärtusi (lisada stringimuutujale (koos tekstiga) või lisada arvväärtusi).

$ a = ($ b = 2) + 4; // tulemus: $ a on seatud väärtusele 6, $ b väärtusele 2.

$ a = 2;
$ a + = 3; // määrab $ a väärtuseks 5, sarnaselt kirjutamisega: $ a = $ a + 3;
$ b = "Tere";
$ b. = "Rahu!"; // määrab $ b väärtuseks "Tere maailm!", nagu ka $ b = $ b. "Seal!";

Neid on ka võrdlusoperatsioonid ja ajurünnak, aga nendest räägime järgmistes tundides. Püüan teid kohe mitte hirmutada suure hulga teabega!)

See õppetund uurib PHP muutujate ulatust. Selgitab erinevust kohaliku ja globaalse ulatuse vahel, näitab, kuidas pääseda funktsiooni globaalsetele muutujatele, kuidas töötada superglobaalidega ja kuidas luua staatilisi muutujaid.

Kui hakkate õppima PHP -d ning hakkate töötama funktsioonide ja objektidega, on muutujate ulatus pisut segane. Õnneks on PHP sellekohased reeglid väga lihtsad (võrreldes teiste programmeerimiskeeltega).

Mis on ulatus?

Muutuja ulatus on kontekst, milles muutuja määratleti ja kuhu sellele pääseb juurde. PHP -l on kaks muutuvat ulatust:

  • Globaalne- muutujatele pääseb juurde kõikjal skriptis
  • Kohalik- muutujatele pääseb juurde ainult selle funktsiooni sees, milles need on määratletud

Muutuv ulatus ja eriti kohalik ulatus muudab koodi haldamise palju lihtsamaks. Kui kõik muutujad oleksid globaalsed, saaks neid skriptis kõikjal muuta. See tooks kaasa kaose ja suured skriptid, kuna väga sageli kasutavad skripti eri osad sama nimega muutujaid. Kohaliku konteksti ulatuse määramisel määratlete muutujale juurdepääsetava koodi piirid, muutes koodi tugevamaks, modulaarsemaks ja hõlpsamini silumiseks.

Globaalselt hõlmatud muutujaid nimetatakse globaalseteks ja kohaliku ulatusega muutujaid nimetatakse kohalikuks.

Siin on näide globaalsete ja kohalike muutujate toimimisest.

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

Tere, Harry! $ GlobalName väärtus: "Zoe" $ localName väärtus: ""

Selles skriptis oleme loonud kaks muutujat:

  • $ globalName- see on globaalne muutuja
  • $ localName- see on kohalik muutuja, mis luuakse funktsiooni sayHello () sees.

Pärast muutuja ja funktsiooni loomist kutsub skript sayHello (), mis väljastab "Tere Harry!" ... Seejärel proovib skript kajastada kahe muutuja väärtusi. Siin on, mis toimub:

  • Sest $ globalName loodi väljaspool funktsiooni, on see skriptis kõikjal saadaval, seega kuvatakse "Zoya".
  • $ localName on saadaval ainult funktsiooni sayHello () sees. Kuna kajaavaldus on väljaspool funktsiooni, ei luba PHP juurdepääsu kohalikule muutujale. Selle asemel eeldab PHP, et kood loob uue muutuja nimega $ localName, mis saab tühja stringi vaikeväärtuse. see on põhjus, miks teine ​​kajakõne prindib muutuja $ localName väärtuse "".

Juurdepääs globaalsetele muutujatele funktsiooni sees

Globaalsele muutujale juurdepääsuks funktsioonist väljas lihtsalt kirjuta tema nimi. Kuid juurdepääs globaalsele muutujale sisemine funktsioon, peate esmalt muutuja globaalseks deklareerima funktsioonis, kasutades globaalset märksõna:

Funktsioon myFunction () (global $ globalVariable; // Juurdepääs globaalsele muutujale $ globalVariable)

Kui te seda ei tee, eeldab PHP, et loote või kasutate kohalikku muutujat.

Siin on näiteskript, mis kasutab funktsiooni sees globaalset muutujat:

"; global $ globalName; echo" Tere $ globalName!
";) ütle tere ();?>

Käivitamisel väljastatakse skript:

Tere, Harry! Tere Zoya!

Funktsioon sayHello () kasutab globaalset märksõna, et kuulutada muutuja $ globalName globaalseks. Seejärel pääseb ta muutujale juurde ja kuvab selle väärtuse ("Zoya").

Mis on superglobaalid?

PHP -l on spetsiaalne eelmääratletud globaalsete massiivide komplekt, mis sisaldavad erinevat teavet. Selliseid massiive nimetatakse superglobaalid, kuna need on saadaval kõikjal skriptis, sealhulgas sisemises funktsiooniruumis, ja neid ei pea määratlema globaalse märksõna abil.

Siin on PHP 5.3 -s saadaolevate superglobaalide loend:

  • $ GLOBALS - kõigi skripti globaalsete muutujate loend (välja arvatud superglobaalsed)
  • $ _GET - sisaldab kõigi brauseri GET -päringu abil esitatud vormiväljade loendit
  • $ _POST - sisaldab kõigi brauseri POST -päringu abil esitatud vormiväljade loendit
  • $ _COOKIE - sisaldab kõigi brauseri saadetud küpsiste loendit
  • $ _REQUEST - sisaldab kõiki võtme / väärtuse kombinatsioone, mis sisalduvad massiivides $ _GET, $ _POST, $ _COOKIE
  • $ _FILES - sisaldab kõigi brauseri laaditud failide loendit
  • $ _SESSION - võimaldab salvestada ja kasutada praeguse brauseri seansi muutujaid
  • $ _SERVER - sisaldab teavet serveri kohta, näiteks käivitatava skripti failinimi ja brauseri IP -aadress.
  • $ _ENV - sisaldab PHP -le edastatud keskkonnamuutujate loendit, näiteks CGI muutujaid.
Näiteks saate kasutada funktsiooni $ _GET, et saada skriptitaotluse URL -i stringi lisatud muutujate väärtused ja kuvada need lehel:

Kui käivitate ülaltoodud skripti URL -i stringiga http://www.example.com/script.php?yourName=Fred, väljastatakse see:

Tere Fred!

Hoiatus! Tõelise skripti korral ei tohiks te nõrga turvalisuse tõttu kunagi sellist andmeedastust kasutada. Alati peaksite oma andmeid kontrollima või filtreerima.

$ GLOBALS superglobalit on väga mugav kasutada, kuna see võimaldab teil korraldada funktsiooni globaalsetele muutujatele juurdepääsu ilma globaalset märksõna kasutamata. Näiteks:

";) sayHello (); // Prindib" Tere, Zoe! "?>

Staatilised muutujad: need asuvad kuskil lähedal

Kui loote funktsiooni sees kohaliku muutuja, eksisteerib see ainult funktsiooni töötamise ajal. Kui funktsioon lõpeb, kaob kohalik muutuja. Funktsiooni uuesti kutsumisel luuakse uus kohalik muutuja.

See toimib enamikul juhtudel suurepäraselt. Nii on funktsioonid iseseisvad ja töötavad alati iga kord, kui neid kutsutakse, sama.

Siiski on olukordi, kus funktsioonikutsete vahel oleks mugav luua kohalik muutuja, mis "mäletab" selle väärtust. Sellist muutujat nimetatakse staatiliseks.

Funktsioonis staatilise muutuja loomiseks peate muutuja nime ees kasutama staatilist märksõna ja andma sellele kindlasti algväärtuse. Näiteks:

Funktsioon myFunction () (staatiline $ myVariable = 0;)

Vaatleme olukorda, kus on mugav kasutada staatilist muutujat. Oletame, et loote funktsiooni, mis kutsumisel loob vidina ja kuvab juba loodud vidinate arvu. Võite proovida sellist koodi kirjutada kohaliku muutuja abil:


"; echo createWidget ()." oleme juba loonud.
"; echo createWidget ()." oleme juba loonud.>
"; ?>

Kuid kuna muutuja $ numWidgets luuakse iga kord, kui funktsiooni kutsutakse, saame järgmise tulemuse:

Loome mõned vidinad ... 1 oleme juba loonud. 1 oleme juba loonud. 1 oleme juba loonud.

Kuid staatilise muutuja abil saame väärtuse salvestada ühest funktsioonikutsest teise:

"; echo createWidget ()." oleme juba loonud.
"; echo createWidget ()." oleme juba loonud.
"; echo createWidget ()."> oleme juba loonud.
"; ?>

Skript annab nüüd oodatud väljundi:

Loome mõned vidinad ... 1 oleme juba loonud. 2 oleme juba loonud. 3 oleme juba loonud.

Kuigi staatiline muutuja säilitab funktsioonikutsete vahel oma väärtuse, kehtib see ainult skripti täitmise ajal. Niipea, kui skript on täitmise lõpetanud, hävitatakse kõik staatilised muutujad, samuti kohalikud ja globaalsed muutujad.

See on kõik! Kontrollige sageli PHP dokumentatsiooni.

Windowsi keskkonnamuutujad (keskkond) sisaldavad mitmesugust teavet süsteemiseadete ja kasutaja keskkonna kohta. Eristage kasutaja, süsteemi ja protsessikeskkonna muutujaid.

Lihtsaim viis Windowsis keskkonnamuutujate sisu vaatamiseks on avada süsteemi atribuudid ( sysdm.cpl) -> Täpsem -> Keskkonnamuutujad. Nagu näete, on avatud jaotises kaks jaotist: ülemine sisaldab kasutaja keskkonnamuutujaid, alumine aga süsteemseid.

Lisaks salvestatakse süsteemi registrisse keskkonnamuutujad. Kohandatud muutujad salvestatakse sektsiooni. Süsteem - sisse HKLM \ SYSTEM \ CurrentControlSet \ Control \ Session Manager \ Environment.

Windowsi käsureal saate kuvada kõigi keskkonnamuutujate väärtused. Käsk on lihtne:

Käsk loetleb keskkonnamuutujad ja nende väärtused.

PowerShellis saate käsu abil kuvada kõik keskkonnamuutujad:

Kui soovite kuvada ainult ühe muutuja väärtust, peate kasutama käsku echo ja muutuja nimi peab olema protsendimärkidega. Näiteks,

Kaja% systemroot%

määrake> c: \ tmp \ env_var.txt

Konkreetse protsessi keskkonnamuutujaid saab saada tasuta Process Exploreri utiliidid(firmalt Sysinternals). Piisab, kui avada protsessi omadused ja minna vahekaardile Keskkond.

13 aastat tagasi

Väike asi, millele tähelepanu pöörata:

Kui lülitate RegisterGlobals ja sellega seotud funktsioonid välja, siis kasutage get_defined_vars (), võite näha midagi sellist:

Massiiv
[GLOBALS] => Massiiv
[GLOBALS] => Massiiv
* KORDUS *
[_POST] => Massiiv ()
[_GET] => Massiiv ()
[_COOKIE] => Massiiv ()
[_FILES] => Massiiv ()
)

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

)
?>

Pange tähele, et $ _SERVER pole seal. Tundub, et php laadib superglobaalse $ _SERVER ainult siis, kui seda kusagil kasutatakse. Saate seda teha:

prindi " 

". htmlspecialchars (print_r (get_defined_vars (), true))."
" ;
prindi " 
". htmlspecialchars (print_r ($ _SERVER, true))."
" ;
?>

Ja siis ilmub $ _SERVER mõlemasse loendisse. Ma arvan, et see ei ole tõepoolest nõme, sest kummalgi juhul ei juhtu midagi halba, kuid sellegipoolest on see huvitav uudishimu.

6 aastat tagasi

Kuna get_defined_vars () saab muutujad alles kohas, kuhu te funktsiooni kutsute, on praeguse ulatuse piires muutujate määratlemiseks lihtne viis.

// Teie php -skripti tipp
$ vars = get_defined_vars ();

// Tehke nüüd oma asju
$ foo = "loll";
$ bar = "baar";

// Hankige kõik praeguses ulatuses määratletud muutujad
$ vars = array_diff (get_defined_vars (), $ vars);

kaja " 

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

15 aastat tagasi

Siin on funktsioon, mis loob kuvamiseks või meilimiseks silumisaruande
kasutades get_defined_vars. Suurepärane detailse hetktõmmise tegemiseks ilma selleta
tuginedes kasutaja sisendile.

funktsioongeneDebugReport ($ meetod, $ define_vars, $ email = "undefined") (
// Funktsioon silumisaruande loomiseks kuvamiseks või meilimiseks.
// Kasutamine :geneDebugReport (meetod, get_defined_vars (), email);
// Kus meetodiks on "brauser" või "e -post".

// Loo ignoreerimisnimekiri võtmetele, mille tagastab "get_defined_vars".
// Näiteks HTTP_POST_VARS, HTTP_GET_VARS jt
// ülearune (sama mis _POST, _GET)
// Lisage ka varud, mida soovite turvalisuse kaalutlustel ignoreerida - s.t. 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 = date ("k / p / a h: m: s");
$ message = "Silumisaruanne lõi $ timestamp \ n";

// Hankige hea SQL -i viga, kus $ link on ressursi identifikaator
// mysql_connect jaoks. Kommenteerige või muutke oma andmebaasi või abstraktsiooni seadistust.
globaalne $ link;
$ sql_error = mysql_error ($ link);
kui ($ sql_error) (
$ message. = "\ nMysql -sõnumid: \ n". mysql_error ($ link);
}
// Lõpeta MySQL

// Siin võiks kasutada rekursiivset funktsiooni. Saate ideest aru ;-)
foreach ($ define_vars kui $ võti => $ val) (
if (is_array ($ val) &&! in_array ($ key, $ ignorelist) && count ($ val)> 0) (
$ message. = "\ n $ võtmemassiiv (võti = väärtus): \ n";
foreach ($ val kui $ alamvõti => $ alamvalik) (
if (! in_array ($ alamvõti, $ ignorelist) &&! is_array ($ subval)) {
$ message. = $ alamvõti. "=". $ alamvalik. "\ n";
}
elseif (! in_array ($ alamvõti, $ ignorelist) && is_array ($ subval)) {
foreach ($ subval kui $ subsubkey => $ alamvalik) (
if (! in_array ($ alamvõti, $ ignorelist)) {
$ message. = $ alamvõti. "=". $ alamvalik. "\ n" ;
}
}
}
}
}
elseif (! is_array ($ val) &&! in_array ($ võti, $ ignorelist) && $ val) (
$ message. = "\ nMuutuv". $ võti. "=". $ val. "\ n";
}
}

Kui ($ method == "brauser") (
echo nl2br ($ sõnum);
}
elseif ($ method == "email") (
kui ($ email == "undefined") (
$ email = $ _SERVER ["SERVER_ADMIN"];
}

$ mresult = mail ($ email, "Silumisaruanne". $ _ENV ["HOSTNAME"]. "", $ message);
kui ($ mresult == 1) (
kaja "Silumisaruanne saadeti edukalt. \ N";
}
muu (
kaja "Silumisaruande saatmine ebaõnnestus. \ N";
}
}
}
?>

17 aastat tagasi

Lihtne rutiin get_defined_vars objekti teisendamiseks XML -i.

funktsioon obj2xml ($ v, $ indent = "") (
while (loend ($ võti, $ val) = iga ($ v)) (
kui ($ võti == "__attr") jätkab;
// Kontrolli __attr
if (is_object ($ val -> __attr)) {
while (loend ($ key2, $ val2) = iga ($ val -> __attr)) (
$ attr. = "$ key2 = \" $ val2 \ "";
}
}
else $ attr = "";
if (is_array ($ val) || is_object ($ val)) {
print ("$ taane< $key$attr >\ n ");
obj2xml ($ val, $ taane. "");
print ("$ taane\ n ");
}
else print ("$ taane< $key$attr >$ val\ n ");
}
}

// Näidisobjekt
$ x -> nimi -> esimene = "John";
$ x -> nimi -> viimane = "Sepp";
$ x -> arr ["Puu"] = "Bannana";
$ x -> arr ["Veg"] = "Porgand";
$ y -> klient = $ x;
$ y -> klient -> __attr -> id = "176C4";

$ z = get_defined_vars ();
obj2xml ($ z ["y"]);
?>
väljastab:


John
Smith


Bannana
Porgand

11 aastat tagasi

Märkusena ei tagasta get_defined_vars () muutujaviidete komplekti (nagu ma lootsin). Näiteks:

// defineerige muutuja
$ my_var = "loll";

// hankige meie määratletud muutujate loend
$ define_vars = get_defined_vars ();

// proovige nüüd väärtust tagastatud massiivi kaudu muuta
$ define_vars ["my_var"] = "baar";

echo $ my_var, "\ n";

?>

väljastab "foo" (algväärtus). Oleks tore, kui saidil get_defined_vars () oleks valikuline argument nende viitamiseks, kuid ma kujutan ette, et see on üsna spetsialiseeritud taotlus. Saate seda ise teha (vähem mugavalt) näiteks:

$ define_vars = massiiv ();
$ var_names = array_keys (get_defined_vars ());

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

?>

1 aasta tagasi

Ma postitasin siin varem selle kohta, et "see" on get_defined_vars.

Selgub, et see pole alati olemas, kuid teatud juhtudel ilmneb see seletamatult.

Php -r "
klassi test (
avalik funktsioon a () (var_dump (massiivi_võtmed (get_defined_vars ())); $ a = 123;)
avalik funktsioon b () (var_dump (massiivi_võtmed (get_defined_vars ())); $ see;)
}
$ t = uus test ();
$ t-> a ();
$ t-> b ();
"

Massiiv ()
massiiv ("see")

PHP 7.2 puhul seda ei juhtu, kuid PHP 5.6 puhul.

1 aasta tagasi

Mõned kommentaarid viitavad sellele, et see funktsioon ei tagasta viiteid. See aga tagastab nimed ja nimed on "viited".

Ma ei soovitaks siin soovitusi, mis muudavad selle viiteteks.

Avalik funktsioon x ($ a, $ b, $ c) (
foreach (massiivi_võtmed (get_defined_vars ()) kui $ võti)
kui ($ võti! == "see")
$ see-> y ($ ($ võti));
}

Avalik funktsioon y (& $ sisend) (
$ sisend ++;
}

$ () Asemel võite kasutada ka $$.

Olen omal ajal teinud mõningaid hulljulgeid asju, et teha ülimalt üldist koodi, kuid ma ei ole kunagi pidanud tegema midagi sarnast ülaltoodule. See ei pruugi isegi töötada (aga peaks, sest see ei erine $ a [$ võti]).

Võiksite teha ka $$ klahvi ++, kuid ma pole kunagi näinud sellist koodi, mis poleks kohutavalt halb (kasutades dünaamikat seal, kus dünaamika pole kasulik).

Kui teete midagi sellist, siis kontrollige seda täiendavalt.

Sarnased artiklid