Van (vagy nincs) egy $_GET["myvar"] változóm, amely a lekérdezési karakterláncomból származik, és szeretném ellenőrizni, hogy ez a változó létezik-e, és azt is, hogy az érték egyezik-e valamivel az if utasításban:
Amit csinálok és gondolok, az nem A legjobb mód csináld:
if(isset($_GET["myvar"]) && $_GET["sajátvar"] == "valami") : csinálj valamit
Ez egy egyszerű eset, de képzelje el, hogy sok ilyen $myvar változót kell összehasonlítania.
Ez hasonló az elfogadott válaszhoz, de helyette az in_array-t használja. Ebben a helyzetben jobban szeretem az üres()-et használni. Azt is javaslom, hogy használja az új string tömb deklarációt, amely elérhető a PHP 5.4.0+ verziójában.
$allowed = ["valami","semmi"]; if(!empty($_GET["sajátvar"]) && in_array($_GET["sajátvar"],$allowed))(..)
Itt van egy funkció több érték egyszerre történő ellenőrzésére.
$arrKeys = tömb_kulcsok($_GET); $allowed = ["valami","semmi"]; függvény checkGet($arrKeys,$allowed) ( foreach($arrKeys mint $kulcs) ( if(in_array($_GET[$key],$allowed)) ( $values[$key]; ) ) return $values; )
Az összes sajátomat használom hasznos funkció exst(), amely automatikusan deklarálja a változókat.
$elem1 = exst($arr["kulcs1"]); $érték2 = exst($_POST["kulcs2"], "újérték"); /** * Exst() függvény - Ellenőrzi, hogy a változó be van-e állítva * (másolja/illessze be a kód bármely helyére) * * Ha a változó be van állítva és nem üres, akkor a változót adja vissza (nincs átalakítás) * Ha a változó nincs beállítva vagy üres, a $default értéket adja vissza * * @param mix $var * @param mix $default * * @return mix */ function exst(& $var, $default = "") ( $t = "" ; if (!isset($var) || !$var) ( if (isset($default) && $default != "") $t = $alapértelmezett; ) else ( $t = $var; ) if (is_string ($t)) $t = trim($t); return $t; )
Nos, megúszhatod az if($_GET["myvar"] == "something")-t, mivel ez a feltétel feltételezi, hogy a változó is létezik. Ha nem, akkor a kifejezés is false értékre lesz értékelve.
Szerintem rendben van, ha feltételes feltételekkel csinálod, mint fent. Tényleg nem árt.
A kérdésem az, hogy van-e mód erre a változó kétszeri deklarálása nélkül?
Nem, ezt nem lehet helyesen megtenni két ellenőrzés nélkül. én is utálom.
Ennek egyik módja az, hogy az összes releváns GET-változót egy központi ponton importálja egy bizonyos típusú tömbbe vagy objektumba (a legtöbb MVC ezt automatikusan megteszi), és beállítja az összes később szükséges tulajdonságot. (Ahelyett, hogy kódon keresztül férne hozzá a lekérdezési változókhoz.)
If (isset($_GET["sajátvar"]) == "valami")
Mellowsoonnak és Pekkának köszönhetően kutakodtam itt, és erre jutottam:
* ok, egyszerű, de remekül működik, e sor után mindenhol elkezdheti használni a változót
* ezt követően használhatja a változóit (var1, var2, var3 ... stb.)
PS: A JSON objektumot fogadó függvénynek jobbnak kell lennie (vagy egy egyszerű elválasztott karakterláncnak a robbanáshoz/robbanáshoz);
A jobb megközelítéseket szívesen fogadjuk :)
FRISSÍTÉS:
Használja a $_REQUEST értéket a $_GET helyett, így lefedi a $_GET és $_POST változókat.
Isset($_REQUEST[$kulcs]) ? $_KÉRÉS[$kulcs] =0:0;
A játék során a következő megoldást találtam:
If($x=&$_GET["myvar"] == "valami") ( // csinálj dolgokat $x-el)
Amint azonnal megfontolhatja ezt a megközelítést:
Kötelező = array("myvar" => "defaultValue1", "foo" => "érték2", "bar" => "érték3", "baz" => "érték4"); $hiányzik = tömb_diff($kötelező, tömb_kulcsok($_GET)); foreach($hiányzik mint $kulcs => $alapértelmezett) ( $_GET[$key] = $alapértelmezett ; )
Beállítod az alapértelmezett értékeket és a nem fogadott paramétereket alapértelmezett értékre :)
Sajnos ezt az egyetlen módja csináld. De vannak megközelítések a nagy tömbökkel való munkavégzéshez. Például valami ilyesmit:
$szükséges = array("myvar", "foo", "bar", "baz"); $hiányzik = tömb_diff($kötelező, tömb_kulcsok($_GET));
A $hiányzó változó mostantól tartalmazza azon értékek listáját, amelyek kötelezőek, de nem szerepelnek a $_GET tömbben. A $hiányzó tömb használatával üzenetet jeleníthet meg a látogatónak.
Vagy használhat valami ilyesmit:
$szükséges = array("myvar", "foo", "bar", "baz"); $hiányzik = tömb_diff($kötelező, tömb_kulcsok($_GET)); foreach($hiányzik mint $m) ( $_GET[$m] = null; )
Mostantól minden szükséges elemnek van alapértelmezett értéke. Most már használhatja az if($_GET["myvar"] == "something")-t anélkül, hogy aggódnia kellene amiatt, hogy a kulcs nincs beállítva.
Frissítés
A kód megtisztításának másik módja egy olyan funkció használata, amely ellenőrzi, hogy az érték be van-e állítva.
függvény getValue($key) ( if (!isset($_GET[$key])) ( return false; ) return $_GET[$key]; ) if (getValue("myvar") == "valami") ( / /Csinálj valamit)
miért nem készítünk erre egy függvényt, az ellenőrizni kívánt változót alakítsuk át valós változóvá, pl.
Függvény _FX($name) ( if (isset($$name)) visszatér $$name; else return null; )
akkor _FX("param") == "123" , csak egy gondolat
találtam (sokat) legjobb kód ezt megteheti, ha ellenőrizni szeretne valamit a .
Ha [[ $1 = "" ]] akkor echo "$1 üres" echo "$1 megtelt" fi
Miért ez az egész? Minden benne van a Bashban, de alapértelmezés szerint üres, ezért a -z és a test -n nem tud segíteni.
Ha [ $(#1) = 0 ] akkor echo "$1 üres" echo "$1 megtelt" fi
Szeretném ellenőrizni, hogy létezik-e változó. Most valami ilyesmit csinálok:
Próbáld ki: myVar, kivéve NameError: # Csinálj valamit.
Vannak kivételek nélküli egyéb módszerek?
2018-05-09 13:10
A helyi változó létezésének ellenőrzéséhez:
Ha "myVar" a locals(): # myVar létezik.
Globális változó létezésének ellenőrzéséhez:
Ha "myVar" a globals(): # myVar létezik.
Annak ellenőrzése, hogy egy objektum rendelkezik-e attribútummal:
Ha hasattr(obj, "attr_name"): # obj.attr_name létezik.
2018-05-09 13:16
Az olyan változók használata, amelyek nincsenek meghatározva vagy beállítva (implicit vagy explicit módon), szinte mindig rossz Bármi mivel azt jelzi, hogy a program logikáját nem gondolták át megfelelően, és valószínűleg kiszámíthatatlan viselkedéshez vezet.
A következő trükk, amely hasonló a tiédhez, biztosítja, hogy a változó rendelkezik néhányérték használat előtt:
Próbáld ki: myVar, kivéve NameError: myVar = Nincs # Most már szabadon használhatod a myVar-t anélkül, hogy a Python panaszkodna.
Ezt azonban továbbra sem tartom jó ötletnek – véleményem szerint újra kellene alakítani a kódot, hogy ez a helyzet ne forduljon elő.
2018-05-09 13:19
A try / kivétel használata a legjobb módja egy változó létezésének ellenőrzésére. De szinte biztosan van jobb módja annak, amit csinálsz, mint a globális változók beállítása/tesztelése.
Például, ha inicializálni szeretné szintű változó modult, amikor először hívnak meg valamilyen függvényt, jobban jársz, ha a következő kódot használod:
Saját_változó = Nincs def InitMyVariable(): globális saját_változó, ha a_változóm értéke Nincs: saját_változó = ...
2018-05-09 13:27
objektumok/modulok esetén is megteheti
"var" in dir(obj)
Például,
>>> osztály Valami(objektum): ... át... >>> c = Valami() >>> c.a = 1 >>> "a" in dir(c) Igaz >>> "b" in dir (c) Hamis
2017-10-28 18:39
A legegyszerűbb módja az, hogy először inicializálja myVar = None
Akkor később:
Ha a myVar nem None: # Csináljon valamit
2018-06-04 18:46
Feltételezem, hogy a tesztet a user97370 válaszához hasonló függvényben fogják használni. Nem tetszik ez a válasz, mert szennyezi a globális névteret. A probléma megoldásának egyik módja egy osztály használata helyette:
Osztály InitMyVariable(objektum): my_variable = Nincs def __call__(self): ha a self.my_variable értéke None: self.my_variable = ...
Nem szeretem, mert bonyolítja a kódot, és olyan kérdéseket vet fel, mint hogy ez érvényesíti-e a Singleton programozási mintát? Szerencsére a Python egy ideig engedélyezte a függvényeknek, hogy attribútumokkal rendelkezzenek, ami ezt az egyszerű megoldást adja:
Def InitMyVariable(): ha az InitMyVariable.my_variable értéke None: InitMyVariable.my_variable = ... InitMyVariable.my_variable = Nincs
2018-03-25 20:31
2018-05-09 13:12
Az ilyen helyzetek kezelésére gyakran jól bevált módszer az, hogy nem ellenőrzi kifejezetten, hogy a változó létezik-e, hanem csak megy tovább, és az esetleg nem létező változó első használatát egy try/kivéve NameError-ba csomagolja.
Az anyagot elsősorban kezdő webprogramozóknak szánjuk.
Itt megpróbálom a lehető legrészletesebben leírni az adatok szűrésekor előforduló gyakori hibákat PHP szkriptés adja egyszerű tippeket hogyan kell megfelelően szűrni az adatokat.
A neten rengeteg cikk található az adatok szűréséről, de ezek, ahogy kell, nem teljesek és részletes példák nélkül.
Ha jelölőnégyzeteket vagy többszörös kijelöléseket használ számértékekkel, ellenőrizze a következőket:
$checkbox_arr = array_map("intval", $_POST["checkbox"]);
array_map
Szűréssel is találkozom a következő formában:
$szám = htmlspecialchars(intval($_GET["bemeneti_szám"]));
htmlspecialchars
Vagy:
$szám = mysql_escape_string(intval($_GET["bemeneti_szám"]));
mysql_escape_string
Csak egy mosoly okozhatja :)
Használja a mysql_escape_string vagy mysql_real_escape_string függvényt, például:
$bemeneti_szöveg = mysql_escape_string($_GET["bemeneti_szöveg"]);
Ha nem szándékozik belépni html címkék, akkor a legjobb a következő szűrést végrehajtani:
$bemeneti_szöveg = strip_tags($_GET["bemeneti_szöveg"]); $bemeneti_szöveg = htmlspeciális karakterek($bemeneti_szöveg); $bemeneti_szöveg = mysql_escape_string($bemeneti_szöveg);
strip_tags - HTML címkék lehúzása.
htmlspecialchars – speciálisat alakít át. karakterek a html entitásban.
Így védheti meg magát az XSS-támadásoktól, az SQL injekció mellett.
Ha szüksége van html címkékre, de csak a forráskód megjelenítésére, akkor elég a következőt használni:
$bemeneti_szöveg = htmlspecialchars($_GET["bemeneti_szöveg"]); $bemeneti_szöveg = mysql_escape_string($bemeneti_szöveg);
Ha Önnek fontos, hogy a változó értéke ne legyen üres, akkor használja a trim függvényt, például:
$bemeneti_szöveg = trim($_GET["bemeneti_szöveg"]); $bemeneti_szöveg = htmlspeciális karakterek($bemeneti_szöveg); $bemeneti_szöveg = mysql_escape_string($bemeneti_szöveg);
Sokáig javítottam egy hasonló hibát egy fórum modulban, amikor bármelyik felhasználó szerkesztheti az adminisztrációs üzenetet.
Ellenőrizheti, hogy az adott változó létezik-e (vagyis inicializálva van-e vagy sem). Ehhez a következő függvény szolgál:
Ha a változó be Ebben a pillanatban nem létezik (korábban sehol nem kapott értéket, vagy a függvény eltávolította nincs beállítva () ), majd a függvényt isset () visszatér hamis , másképp - igaz :
$x = 5;
if (isset($x))
visszhang ‘< BR >Változó $ x létezik, ‘, „értéke $ x < BR >”;
A képernyőn megjelenik:
Változó $ x létezik, értéke 5
Fontos megjegyezni, hogy nem használhatunk inicializálatlan változót a programban - ez figyelmeztetést generál az értelmezőtől PHP .
Annak megállapítására, hogy egy érték változó-e üres , a függvény használatos:
üres( változó);
Ha a változó értéke az nulla ,“0”, NULLA , üres sor (“” ),false, a változó nincs deklarálva, vagy van üres tömb , akkor ez a függvény visszatér igaz , másképp - hamis .
Ellenőrizni típus változó, függvények használatosak:
van _ int (változó);
van _ úszó (változó);
van _ nulla (változó);
van _ sor (változó);
van _ számszerű (változó); - ha a változó numerikus ( egész szám , úszó ) vagy csak számokat tartalmazó karakterlánc.
Ezek a függvények visszatérnek igaz ha a változó a megadott típusú.
Adatkimenet
Formázatlan kimenet
formátlan a karakterláncok vagy változók értékeinek kiadását a következő függvény hajtja végre:
visszhang változók listája;
visszhang vonal;
Ahol változók listája – a kimeneti változók nevei vesszővel elválasztva.
Ha webböngészővel dolgozunk, akkor ez a funkció a böngésző kliens oldalára (annak ablakába) irányítja a kimenetet.
Mint már említettük, ha egy sorba zárt dupla idézőjelek, vannak változónevek, akkor e nevek helyett a hozzájuk tartozó értékek jelennek meg. Sőt, ha egy ilyen sor címkéket tartalmaz HTML (a leírók szögletes zárójelben vannak), akkor a böngésző ezt megjeleníti HTML -kódot, ahogy értelmezésekor kellene HTML -dokumentum:
$év = 2012;
$üzenet = " Szeretnék mindenki boldogság !”;
visszhang"
Az én
Gratulálunk
!”;
visszhang"
Jött
$év
év
!
$üzenet
”;
?>
A szint címe megjelenik a képernyőn. H 3 és az azt követő üdvözlet a „szóval” boldogság!" félkövér dőlt betűkkel lesz kinyomtatva:
2012 van! kívánok mindenkinek boldogság!
Így hozhat létre dinamikus webhelyeket.
Formázott kimenet
Formázott A kimenet lehetővé teszi a megjelenített számok megjelenítését különböző számrendszerekben, és decimális rendszerben - in különféle típusok (formátumok ). Hasonló a formázott kimenethez Xi és a következő funkciók hajtják végre:
printf („formátum”, kimeneti lista);
sprintf („formátum”, kimeneti lista);
Az első funkció megjeleníti a formázott adatokat a böngészőablakban, és visszaadja a számukat.
A második funkció csak formázza a kimeneti adatokat, de nem adja ki azokat.
Formátum a kimeneti értékek konverziós leíróinak sorozata.
Transzformációs leíró mindegyik értéknél így néz ki:
% PlaceholderAlignmentLength.PrecisionType
- Összesített az a karakter, amellyel a konverziós eredményt a megadott értékre kell kitölteni hossz (alapértelmezett - hely ); ha ez egy másik karakter, akkor egy idézőjel előzi meg ( aposztróf ),
- igazítás - alapértelmezés szerint - által jobb a kimeneti mező széle; ha van mínusz ( - ), majd bal ,
- Hossz – kimeneti mező szélessége – az érték kiadásához lefoglalt karakterhelyek száma. Ha a kimeneti érték az adott értéknél kevesebb karakterközt tartalmaz hossz , akkor a fennmaradó hely be lesz töltve hézagok vagy töltse ki a karaktereket,
- Pontosság - a tizedesjegyek száma a szám tört részében,
- típus – a kimeneti érték típusa:
b –bináris ,
Val vel –szimbólum ,
d –egész decimális számrendszerben,
e –igazi exponenciális formában (lebegőpont),
f –igazi fixpontos formában,
s –vonal ,
O –egész nyolcas számrendszerben,
x –egész hexadecimális számrendszerben.
Példa:
php
$ zarp _1 = 6543.21;
$ zarp _2 = 45321.67;
$ fam _1 = "Balaganov";
$ fam _2 = "Bender";
printf ("< H 1> Bérszámfejtés h 1>");
printf("%".-12s%".10.2f rub.", $fam_1, $zarp_1);
visszhang"
";
printf("%".-12s%".10.2f rub.", $fam_2, $zarp_2);
visszhang"
";
?>
A pont helyőrzőnek lett kiválasztva ( ‘. ) . A vezetéknevek balra vannak igazítva ( - ) mezőszélességben 12 karakterek. A számok fixpontos formában jelennek meg egy szélességű mezőben 10 karakterekkel és pontossággal 2 tizedesvessző, jobbra igazítva.
