Php minden változó. Változók a PHP -ben

Php változók egyfajta információ tároló, amely különféle típusú adatokat (szöveget, számokat, tömböket stb.) tartalmazhat. Általánosságban elmondható, hogy a változók lehetővé teszik a bennük megadott információk létrehozását, tárolását, módosítását és a jövőbeni gyors elérését.

Hogyan hozzunk létre változót a PHP -ben

Kezdetben a változók tartalmazzák a jelet $ (dollár) - a változó használatának megjelölése, majd betűk Latin ábécé(a -tól z -ig, kicsi és nagy), a végén tartalmazhat számokat... A név aláhúzást is használhat (nem a végén).

Hogyan nevezhet változókat:

$ var
$ változó
1945 USD
$ _változó
Hogyan nem nevezhetők változók:

$ 1 - csak egy számjegyből áll
$ 1var - a változó nevét nem lehet számjeggyel kezdeni
$ / var - csak aláhúzás megengedett a további karakterekből _
$ változó - A phill dokumentáció megengedi a cirill betűket, de nem ajánlott
$ var iable - szóközök nem használhatók

Minden változóhoz érték tartozik. Érték hozzárendeléséhez használja a jelet = (egyenlő). A szkript feldolgozása során a változó értéke többször változhat a különböző körülményektől függően.

$ city = "Moszkva"; // a $ city változóhoz karakterláncot (idézőjelben) rendeltek Moszkva
$ év = 1147; // és a $ year változó 1147 -es számértéket kapott
?>

$ name = "Alexander";
$ Name = "Alexey";
echo "$ name, $ Name"; // megjeleníti "Alexander, Alexey"
?>

PHP változó kimenet

Külön meg kell fontolni a változók megjelenítésének módját kimeneti operátorok, amelynek munkájáról az utolsó leckében, a PHP oldal létrehozása tárgyaltunk. Kimeneti operátorok. ... Az alábbiakban számos szemléltető példát hozok fel megjegyzésekkel.

// Így rendelünk értékeket a változókhoz
$ name1 = "Alekszej";
$ name2 = "Sándor";

// Változók megjelenítése
echo $ name2; // Kimenet: Alexander
echo "név1 $ név1"; // név1 Alexey

// Egyszeres idézőjelek használatakor a kimenet
// változó neve, nem értéke
echo "név1 $ név1"; // print: name1 a $ name1

// csak megjelenítheti a változók értékeit
echo $ name1; // Alexey
echo $ név1, $ név2; Alekszej Sándor
echo $ name1. "". $ name2; Alekszej Sándor
echo "$ név1, $ név2"; // Alexey, Alexander

Visszhang<<Ez a "here document" szintaxist használja a kimenethez
több sor $ változó helyettesítéssel.
VÉGE;

PHP változó műveletek

Aritmetikai műveletek PHP -ben
Numerikus értékek esetén végezhet számtani műveleteket: összeadást, kivonást, szorzást stb.

- $ a(tagadás) Változtasd meg a $ a jelét.
$ a + $ b(összeadás) $ a és $ b összege.
$ a - $ b(kivonás) Különbség $ a és $ b között.
$ a * $ b(szorzás) $ a és $ b szorzata.
$ a / $ b(osztás) $ a hányadosa osztva $ b -val.
$ a% $ b(modulo) $ a egész maradéka osztva $ b -val.
Nézzünk példákat

$ a = 2; // megjegyzés, számok esetén idézőjelek nem használatosak
$ b = 3; // megjegyzés, számok esetén idézőjelek nem használatosak

$ eredmény = $ a + $ b; // változók hozzáadása
echo $ eredmény; // kinyomtatja 5

$ eredmény = $ b - $ a; // változók hozzáadása
echo $ eredmény; // kimenet 1

Növelési és csökkentési műveletek PHP -ben
Ezek a műveletek főleg ciklusok építésekor lesznek hasznosak, amelyekről egy kicsit később beszélünk.
Előtag- a változó ELŐTT írt operátorok ( - $ a; ++ $ a). A változó előtti értéket adja vissza.
Postfix- a változó után írt operátorok ( $ a--; $ a--). Visszaadja a változó módosított értékét.
Növekedés- értéknövelés.
Csökkenés- az érték csökkentése.

++ $ a Előtagnövelés. $ A -t növeli eggyel, és $ a -t ad vissza.
$ a ++ Postfix növekmény. $ A értékét adja vissza, majd eggyel növeli az $ a értéket.
- $ a Előtagcsökkentés. Egy dollárral csökkenti, és $ a értékét adja vissza.
$ a-- Postfix csökkentés. $ A értékét adja vissza, majd egyesével csökkenti az $ a értéket.
visszhang "

Postfix növekmény

";
$ a = 5;
echo "5 legyen:". $ a ++. "\ n";

Visszhang "

Előtagnövelés

";
$ a = 5;
echo "6 -nak kell lennie". ++ $ a. "\ n";
echo "6 -nak kell lennie". $ a. "\ n";

Visszhang "

Postfix csökkentés

";
$ a = 5;
echo "5 legyen:". $ a--. "\ n";

Visszhang "

Előtagcsökkentés

";
$ a = 5;
echo "4 legyen:". - $ a. "\ n";
echo "4 legyen:". $ a. "\ n";
?>

PHP hozzárendelési műveletek
Alapkezelőúgy néz ki, mint a = ... Első pillantásra úgy tűnhet, hogy ez az operátor egyenlő. Valójában ez nem így van. Valójában a hozzárendelési operátor azt jelenti, hogy a bal operandus a jobb kifejezés értékére van beállítva (azaz a kapott érték állítja be). Kombinált kezelők- ezek olyan operátorok, amelyek lehetővé teszik a változók korábbi értékeinek használatát a későbbi műveletekhez (hozzáfűzés egy karakterlánc -változóhoz (szöveggel) vagy számértékek hozzáadása).

$ a = ($ b = 2) + 4; // eredmény: $ a értéke 6, $ b értéke 2.

$ a = 2;
$ a + = 3; // az $ a értékét 5 -re állítja, hasonlóan az íráshoz: $ a = $ a + 3;
$ b = "Helló";
$ b. = "Világ!"; // a $ b -t "Hello World!" -re állítja, ahogy a $ b = $ b -t is. "Ott!";

Vannak még összehasonlító műveletekés összerakós játékaik, de a következő leckékben beszélünk róluk. Megpróbálok nem azonnal megijeszteni nagy mennyiségű információval!)

Ez a lecke a PHP változók hatókörét tárja fel. Elmagyarázza a különbséget a helyi és a globális hatókör között, bemutatja, hogyan férhet hozzá a globális változókhoz egy függvényen belül, hogyan kell dolgozni a szuperglobálisokkal, és hogyan hozhat létre statikus változókat.

Amikor elkezdi tanulni a PHP -t, és elkezdi használni a funkciókat és objektumokat, a változók hatóköre kissé zavaró. Szerencsére a PHP erre vonatkozó szabályai nagyon könnyen érthetők (más programozási nyelvekhez képest).

Mi a hatókör?

A változó hatóköre az a kontextus, amelyben a változót definiálták, és hol érhető el. A PHP két változó hatókörrel rendelkezik:

  • A globális- a változók bárhol elérhetők a szkriptben
  • Helyi- a változók csak abban a függvényben érhetők el, amelyben definiálták őket

A változó hatókör és különösen a helyi hatókör jelentősen megkönnyíti a kód kezelését. Ha minden változó globális, akkor a szkriptben bárhol megváltoztatható. Ez káoszhoz és nagy szkriptekhez vezetne, mivel nagyon gyakran a szkript különböző részei azonos nevű változókat használnak. A helyi kontextus kiterjesztésével meghatározhatja a változóhoz hozzáférő kód határait, így a kód robusztusabb, modulárisabb és könnyebben hibakereshető lesz.

A globálisan hatókörű változókat globálisnak, a lokálisan hatókörűeket pedig lokálisnak nevezzük.

Íme egy példa a globális és helyi változók működésére.

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

Szia Harry! $ GlobalName value: "Zoe" $ localName value: ""

Ebben a szkriptben két változót hoztunk létre:

  • $ globalName- ez egy globális változó
  • $ localName- ez helyi a sayHello () függvényben létrehozott változó.

A változó és a függvény létrehozása után a szkript meghívja a sayHello () parancsot, amely "Hello Harry!" ... A szkript ezután megpróbálja visszhangozni a két változó értékeit. Íme, mi történik:

  • Mivel $ globalName a függvényen kívül jött létre, a szkriptben bárhol elérhető, így a "Zoya" jelenik meg.
  • $ localName csak a sayHello () függvényben lesz elérhető. Mivel az echo kifejezés a függvényen kívül van, a PHP nem teszi lehetővé a helyi változó elérését. Ehelyett a PHP feltételezi, hogy a kód új változót hoz létre $ localName néven, amely egy üres karakterlánc alapértelmezett értékét kapja. ezért a második echo hívás kiírja a "" értéket a $ localName változóhoz.

Globális változók elérése egy függvényen belül

Globális változó elérése funkción kívül csak írd le a nevét. De a globális változó eléréséhez belső funkció, először a globális kulcsszót használva deklarálnia kell a változót globálisnak a függvényben:

Funkció myFunction () (global $ globalVariable; // Hozzáférés a $ globalVariable globális változóhoz)

Ha nem, a PHP feltételezi, hogy helyi változót hoz létre vagy használ.

Íme egy példa szkript, amely globális változót használ egy függvényen belül:

"; global $ globalName; echo" Hello $ globalName!
";) sayHello ();?>

Futtatáskor a szkript a következőt adja ki:

Szia Harry! Szia Zoya!

A sayHello () függvény a globális kulcsszót használja a $ globalName változó globálissá nyilvánításához. Ezután hozzáférhet a változóhoz, és megjelenítheti annak értékét ("Zoya").

Mik azok a szuperglobálisok?

A PHP speciális előre meghatározott globális tömbkészlettel rendelkezik, amelyek különböző információkat tartalmaznak. Az ilyen tömböket ún szuperglobális, mivel a szkriptben bárhonnan elérhetők, beleértve a belső funkcióteret is, és nem kell őket a globális kulcsszó használatával definiálni.

Itt található a PHP 5.3 -ban elérhető szuperglobálok listája:

  • $ GLOBALS - a szkript összes globális változójának listája (kivéve a szuperglobalokat)
  • $ _GET - Tartalmazza a böngésző által GET kéréssel küldött űrlapmezők listáját
  • $ _POST - tartalmazza a böngésző által POST -kéréssel küldött összes űrlapmező listáját
  • $ _COOKIE - tartalmazza a böngésző által küldött összes süti listáját
  • $ _REQUEST - tartalmazza az összes kulcs / érték kombinációt, amelyek a $ _GET, $ _POST, $ _COOKIE tömbökben találhatók
  • $ _FILES - tartalmazza a böngésző által betöltött összes fájl listáját
  • $ _SESSION - lehetővé teszi az aktuális böngésző munkamenet -változóinak tárolását és használatát
  • $ _SERVER - információkat tartalmaz a szerverről, például a végrehajtandó szkript fájlnevét és a böngésző IP -címét.
  • $ _ENV - A PHP -hez továbbított környezeti változók listáját tartalmazza, például a CGI változókat.
Például a $ _GET használatával lekérheti a szkriptkérés URL -karakterláncában szereplő változók értékeit, és megjelenítheti azokat az oldalon:

Ha a fenti szkriptet a http://www.example.com/script.php?yourName=Fred URL karakterlánccal futtatja, akkor a következőt adja ki:

Szia Fred!

Egy figyelmeztetés! Egy valódi szkriptben soha ne használjon ilyen adatátvitelt a gyenge biztonság miatt. Mindig ellenőrizze vagy szűrje adatait.

A $ GLOBALS superglobal nagyon kényelmes a használata, mivel lehetővé teszi a globális változókhoz való hozzáférés megszervezését egy függvényben anélkül, hogy a globális kulcsszót kellene használni. Például:

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

Statikus változók: valahol a közelben vannak

Ha helyi változót hoz létre egy függvényen belül, az csak a függvény futása közben létezik. Amikor a funkció véget ér, a helyi változó eltűnik. A függvény újbóli meghívásakor új helyi változó jön létre.

Ez a legtöbb esetben nagyszerűen működik. Így a funkciók önállóak, és minden híváskor mindig ugyanúgy működnek.

Vannak azonban olyan helyzetek, amikor kényelmes lenne létrehozni egy helyi változót, amely "megjegyzi" az értékét a függvényhívások között. Az ilyen változót statikusnak nevezzük.

Ha statikus változót szeretne létrehozni egy függvényben, akkor a statikus kulcsszót kell használnia a változó neve előtt, és feltétlenül meg kell adnia annak kezdeti értékét. Például:

Funkció myFunction () (statikus $ myVariable = 0;)

Tekintsünk egy olyan helyzetet, amikor kényelmes statikus változót használni. Tegyük fel, hogy létrehoz egy függvényt, amely meghívásakor létrehoz egy widgetet, és megjeleníti a már létrehozott kütyük számát. Megpróbálhat ilyen kódot írni egy helyi változóval:


"; echo createWidget ()." már létrehoztuk.
"; echo createWidget ()." már létrehoztuk.>
"; ?>

De mivel a $ numWidgets változó minden alkalommal létrejön, amikor a függvényt meghívjuk, a következő eredményt kapjuk:

Létrehozunk néhány kütyüt ... 1 már létrehoztuk. 1 már létrehoztuk. 1 már létrehoztuk.

De statikus változó használatával tárolhatjuk az értéket az egyik függvényhívásról a másikra:

"; echo createWidget ()." már létrehoztuk.
"; echo createWidget ()." már létrehoztuk.
"; echo createWidget ()."> már létrehoztuk.
"; ?>

A szkript most a várt eredményt adja:

Létrehozunk néhány kütyüt ... 1 már létrehoztuk. 2 már létrehoztuk. 3 már létrehoztuk.

Bár egy statikus változó megtartja értékét a függvényhívások között, csak a szkript végrehajtásakor érvényes. Amint a szkript befejezi a végrehajtást, az összes statikus változó, valamint a helyi és globális változók megsemmisülnek.

Ez minden! Gyakran ellenőrizze a PHP dokumentációját.

A Windows környezeti változói (környezet) különféle információkat tartalmaznak a rendszerbeállításokról és a felhasználó környezetéről. Megkülönböztetni a felhasználó, a rendszer és a folyamat környezeti változóit.

A legegyszerűbben úgy tekintheti meg a környezeti változók tartalmát Windows rendszeren, hogy megnyitja a rendszer tulajdonságait ( sysdm.cpl) -> Speciális -> Környezeti változók. Mint látható, a megnyitott részben két rész található: a felső a felhasználó környezeti változóit, az alsó a rendszerváltozókat tartalmazza.

Ezenkívül a környezeti változókat a rendszerleíró adatbázis tárolja. Az egyéni változókat a szakasz tárolja. Rendszer - in HKLM \ SYSTEM \ CurrentControlSet \ Control \ Session Manager \ Environment.

Az összes környezeti változó értékét megjelenítheti a Windows parancssorában. A parancs egyszerű:

A parancs felsorolja a környezeti változókat és azok értékeit.

A PowerShellben a paranccsal megjelenítheti az összes környezeti változót:

Ha csak egy változó értékét szeretné megjeleníteni, akkor az echo parancsot kell használnia, és a változó nevét százalékjelek közé kell írni. Például,

Echo% systemroot%

set> c: \ tmp \ env_var.txt

Egy adott folyamat környezeti változóit ingyenesen szerezhetjük be Process Explorer segédprogramok(a Sysinternals cégtől). Elég, ha megnyitja a folyamat tulajdonságait, és belép a lapra Környezet.

13 évvel ezelőtt

Egy kis dolog, amire figyelni kell:

Ha kikapcsolja a RegisterGlobals és a kapcsolódó szolgáltatásokat, majd használja a get_defined_vars () parancsot, akkor az alábbiakat láthatja:

Sor
[GLOBALS] => Tömb
[GLOBALS] => Tömb
* RECURSION *
[_POST] => Tömb ()
[_GET] => Tömb ()
[_COOKIE] => Tömb ()
[_FILES] => Tömb ()
)

[_POST] => Tömb ()
[_GET] => Tömb ()
[_COOKIE] => Tömb ()
[_FILES] => Tömb ()

)
?>

Vegye figyelembe, hogy a $ _SERVER nincs ott. Úgy tűnik, hogy a php csak akkor tölti be a $ _SERVER szuperglobális programot, ha valahol használják. Ezt megteheti:

nyomtatás " 

". htmlspecialchars (print_r (get_defined_vars (), true))."
" ;
nyomtatás " 
". htmlspecialchars (print_r ($ _SERVER, igaz))."
" ;
?>

Ezután a $ _SERVER megjelenik mindkét listában. Gondolom, ez nem igazán kapás, mert semmi rossz nem fog történni, így is, de érdekes érdekesség.

6 évvel ezelőtt

Mivel a get_defined_vars () csak akkor kapja meg a változókat, amikor meghívja a függvényt, egyszerű módja van annak, hogy a változókat az aktuális hatókörben határozza meg.

// A php szkript legteteje
$ vars = get_defined_vars ();

// Most tegye a dolgát
$ foo = "foo";
$ bar = "bár";

// Az összes hatókör meghatározása az aktuális hatókörben
$ vars = tömb_diff (get_defined_vars (), $ vars);

visszhang " 

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

15 évvel ezelőtt

Itt található egy funkció, amely hibakeresési jelentést generál megjelenítéshez vagy e -mailhez
get_defined_vars használatával. Kiválóan alkalmas pillanatkép készítéséhez anélkül
felhasználói bevitelre támaszkodva.

function createDebugReport ($ method, $ define_vars, $ email = "undefined") (
// Funkció hibakeresési jelentés létrehozásához megjelenítésre vagy e -mailben.
// Használat: createDebugReport (method, get_defined_vars (), email);
// Ahol a módszer "böngésző" vagy "e -mail".

// Híváslista létrehozása a "get_defined_vars" által visszaadott kulcsokhoz.
// Például: HTTP_POST_VARS, HTTP_GET_VARS és mások
// redundáns (ugyanaz, mint _POST, _GET)
// Adja meg azokat a varsokat is, amelyeket biztonsági okokból figyelmen kívül akar hagyni - azaz 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 ("h / d / y h: m: s");
$ message = "Hibakeresési jelentés létrehozta $ timestamp \ n";

// Szerezze be az utolsó SQL -hibát, ahol a $ link az erőforrás -azonosító
// a mysql_connect számára. Írjon megjegyzést vagy módosítsa az adatbázishoz vagy az absztrakciós beállításokhoz.
globális $ link;
$ sql_error = mysql_error ($ link);
if ($ sql_error) {
$ message. = "\ nMysql üzenetek: \ n". mysql_error ($ link);
}
// A MySQL befejezése

// Itt rekurzív függvényt használhat. Érted az ötletet ;-)
foreach ($ define_vars as $ key => $ val) (
if (is_array ($ val) &&! in_array ($ key, $ ignorelist) && count ($ val)> 0) (
$ message. = "\ n $ kulcstömb (kulcs = érték): \ n";
foreach ($ val as $ subkey => $ subval) (
if (! in_array ($ alkulcs, $ ignorelist) &&! is_array ($ subval)) {
$ message. = $ alkulcs. "=". $ subval. "\ n";
}
elseif (! in_array ($ alkulcs, $ ignorelist) && is_array ($ subval)) {
foreach ($ subval as $ subsubkey => $ subsubval) (
if (! in_array ($ alalkulcs, $ ignorelist)) {
$ message. = $ alkulcs. "=". $ alszubval. "\ n" ;
}
}
}
}
}
elseif (! is_array ($ val) &&! in_array ($ key, $ ignorelist) && $ val) (
$ message. = "\ nVáltozó". $ kulcs. "=". $ val. "\ n";
}
}

Ha ($ method == "böngésző") (
echo nl2br ($ üzenet);
}
elseif ($ method == "email") (
if ($ email == "undefined") (
$ email = $ _SERVER ["SERVER_ADMIN"];
}

$ mresult = mail ($ email, "Hibakeresési jelentés". $ _ENV ["HOSTNAME"]. "", $ message);
ha ($ mresult == 1) (
visszhang "A hibakeresési jelentés sikeresen elküldve. \ N";
}
más (
visszhang "Nem sikerült elküldeni a hibakeresési jelentést. \ N";
}
}
}
?>

17 évvel ezelőtt

Egyszerű rutin a get_defined_vars objektum XML -re konvertálásához.

függvény obj2xml ($ v, $ indent = "") (
while (lista ($ kulcs, $ val) = mindegyik ($ v)) (
if ($ key == "__attr") folytatja;
// Ellenőrizze a __attr
if (is_object ($ val -> __attr)) {
while (lista ($ key2, $ val2) = mindegyik ($ val -> __attr)) (
$ attr. = "$ key2 = \" $ val2 \ "";
}
}
else $ attr = "";
if (is_array ($ val) || is_object ($ val)) {
print ("$ indent< $key$attr >\ n ");
obj2xml ($ val, $ behúzás. "");
print ("$ indent\ n ");
}
else print ("$ indent< $key$attr >$ val\ n ");
}
}

// Példa objektum
$ x -> név -> első = "János";
$ x -> név -> last = "Smith";
$ x -> arr ["Fruit"] = "Bannana";
$ x -> arr ["Veg"] = "Sárgarépa";
$ y -> ügyfél = $ x;
$ y -> ügyfél -> __attr -> id = "176C4";

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


János
Kovács


Bannana
Sárgarépa

11 évvel ezelőtt

Megjegyzés: a get_defined_vars () nem ad vissza változó referenciákat (ahogy reméltem). Például:

// definiálunk egy változót
$ my_var = "foo";

// a meghatározott változók listájának beszerzése
$ define_vars = get_defined_vars ();

// most próbálja meg megváltoztatni az értéket a visszaadott tömbön keresztül
$ define_vars ["my_var"] = "bar";

echo $ my_var, "\ n";

?>

"foo" értéket ad ki (az eredeti érték). Jó lenne, ha a get_defined_vars () opcionális argumentummal hivatkozhatna rájuk, de úgy gondolom, hogy ez egy meglehetősen speciális kérés. Ezt saját maga is megteheti (kevésbé kényelmesen), például:

$ define_vars = array ();
$ var_nevek = tömbkulcsok (get_defined_vars ());

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

?>

1 évvel ezelőtt

Korábban már írtam itt arról, hogy "ez" a get_defined_vars fájlban van.

Kiderült, hogy nem mindig van ott, de bizonyos esetekben megmagyarázhatatlanul megjelenik.

Php -r "
osztályos teszt (
public function a () (var_dump (array_keys (get_defined_vars ())); $ a = 123;)
nyilvános függvény b () (var_dump (tömbkulcsok (get_defined_vars ())); $ ez;)
}
$ t = új teszt ();
$ t-> a ();
$ t-> b ();
"

Tömb ()
tömb ("ez")

Ez nem történik meg a PHP 7.2 -ben, de a PHP 5.6 -ban.

1 évvel ezelőtt

Néhány megjegyzés rámutat arra, hogy ez a függvény nem ad vissza hivatkozásokat. Viszont visszaadja a neveket, és a nevek "hivatkozások".

Nem javaslom azokat a javaslatokat, amelyek referenciákká alakítják át.

Nyilvános függvény x ($ a, $ b, $ c) (
foreach (tömbkulcsok (get_defined_vars ()) $ kulcsként)
ha ($ kulcs! == "ez")
$ this-> y ($ ($ kulcs));
}

Y nyilvános függvény (& $ bemenet) (
$ input ++;
}

A $ () helyett a $$ kifejezést is használhatja.

Néhány furcsa dolgot csináltam az én időmben, hogy rendkívül általános kódot készítsek, de soha nem kellett a fentiekhez hasonló dolgokat tennem. Lehet, hogy nem is fog működni (de kellene, mert nem különbözik a $ a [$ key] -től).

Megteheted a $$ key ++ billentyűt is, de még soha nem láttam ilyen kódot, ami nem volt rettenetesen rossz (dinamikus használata, ahol a dinamika nem előnyös).

Ha ilyesmit csinál, akkor alaposabban vizsgálja meg.

HASONLÓ CIKKEK