A PHP támogatja a szabványos AND és && , OR és || logikai operátorokat , ! (nem) és XOR . A logikai operátorok lehetővé teszik két operandus (érték vagy kifejezés) eredményeinek összehasonlítását annak meghatározására, hogy az egyik vagy mindkettő igaz vagy hamis értéket ad-e vissza, és kiválaszthatja, hogy a visszaadott érték alapján ennek megfelelően folytatja-e a parancsfájl végrehajtását. Az összehasonlító operátorokhoz hasonlóan a logikai operátorok is egyetlen logikai értéket adnak vissza – igaz vagy hamis, az operátor mindkét oldalán lévő értékektől függően.
Logikai VAGY (VAGY és ||)
A logikai VAGY operátort VAGY vagy ||-ként jelöljük . Logikai VAGY műveletet hajt végre két operanduson. Ha az egyik vagy mindkét operandus igaz, akkor igazat ad vissza. Ha mindkét operandus hamis, akkor hamis értéket ad vissza. Valószínűleg felmerül a kérdés: miért készítettek egy operátor két változatát? A logikai VAGY operátor két különböző változatának lényege, hogy eltérő prioritással működnek.
Először nézzük meg a || operátor működését. . Tehát, ha az egyik vagy mindkét operandus igaz, akkor igazat ad vissza. Ha mindkét operandus hamis értéket ad vissza, akkor false értéket ad vissza.
Az OR operátor ugyanúgy működik, mint a ||. egy kivétellel, ha az OR operátort egy hozzárendeléshez használjuk, akkor először kiértékeli és visszaadja a bal oldali operandus értékét, ellenkező esetben pontosan ugyanúgy működik, mint a || , azaz ha az egyik vagy mindkét operandus igaz, akkor igazat ad vissza. Ha mindkét operandus false értéket ad vissza, akkor false értéket ad vissza.
Hogy világosabbá tegyük működésüket, hozzuk a következő példát:
1 // Először a változóhoz false értéket rendelünk, majd a második operandust értékeljük ki // Prioritási művelet: ($var2 = hamis) vagy igaz $var2 = hamis vagy igaz; echo $var2; // a false nem kerül kinyomtatásra // ($var3 = 0) vagy 3 $var3 = 0 vagy 3; visszhang"
$var3"; // => 0 ?>
Bármely összehasonlító és logikai operátor összetettebb struktúrákká kombinálható:
Mind a legkülső, mind a || . A logikai VAGY operátor a bal oldali operandusával kezdi a számításokat, ha igazat ad vissza, akkor a jobb oldali operandus nem kerül kiértékelésre. Ezzel végrehajtási időt takarítunk meg, de ügyelni kell arra, hogy a jobb oldali operandusba ne kerüljön olyan kód, amelytől a program helyes működése függ.
Logikai ÉS (ÉS és &&)
A logikai ÉS operátort ÉS vagy && jelöli. Logikai ÉS műveletet hajt végre két operanduson. Akkor és csak akkor ad vissza igazat, ha mindkét operandus kiértékelése igaz. Ha az egyik vagy mindkét operandus false értéket ad vissza, az operátor false értéket ad vissza. A logikai ÉS operátor két különböző változatának jelentése megegyezik az előző két operátoréval, vagyis hogy eltérő prioritásokkal dolgoznak.
Először nézzük meg, hogyan működik az && operátor. Tehát, ha mindkét operandusa igaz, akkor igazat ad vissza. Ha legalább az egyik vagy mindkét operandus hamis értéket ad vissza, akkor az is hamis értéket ad vissza.
Az ÉS operátor egy kivétellel ugyanúgy működik, mint az && operátor, ha az ÉS operátort egy hozzárendeléshez használjuk, akkor először kiértékeli és visszaadja a bal oldali operandus értékét, ellenkező esetben pontosan ugyanúgy működik, mint az && operátor. Ha legalább az egyik operandus hamis értéket ad vissza, akkor az is hamis értéket ad vissza, és ha mindkét operandus hamis értéket ad vissza, akkor hamis értéket ad vissza.
Hogy megértsük, most nézzük meg, hogyan működik ez a gyakorlatban:
$bar3"; // => 9 ?>
Exkluzív VAGY (XOR)
A kizárólagos VAGY operátort XOR-ként jelöljük. Igazat ad vissza, ha csak egy operandusa igaz. Ha mindkét operandus igaz, az operátor false értéket ad vissza.
Mivel az XOR operátornak ugyanaz a prioritása, mint az ÉS és a VAGY operátornak (alacsonyabb, mint a hozzárendelési operátor), és hozzárendelési kifejezésben használatos, először kiértékeli és visszaadja a bal oldali operandus értékét.
6 $a1 = 19 x vagy 5 > 6; var_dump($a1); // => 19 var_dump(true xor true); // false var_dump((2< 3) xor (5 != 5)); // true ?>
Logikus NEM (!)
A logikai NEM operátort, más néven negációt, az előjel jelzi! . Ez egy unáris operátor, amely egyetlen operandus elé kerül. A logikai NOT operátor az operandus logikai értékének megfordítására szolgál, és mindig igaz vagy hamis értéket ad vissza.
Ha meg kell invertálnia egy kifejezés értékét, például a && b , akkor zárójeleket kell használnia: !(a && b) . Operátor segítségével is! Bármely x értéket átválthat logikai megfelelőjére a !!x operátor kétszeri használatával.
Utolsó frissítés: 2015.11.01
A PHP-ben többféle operátort használhatunk: aritmetikai, logikai stb. Nézzük meg az egyes művelettípusokat.
Aritmetikai műveletek
+ (kiegészítő művelet)
Például $a + 5
- (kivonási művelet)
Például $a - 5
* (szorzás)
Például $a * 5
/ (osztály)
Például $a / 5
% (az osztás maradékának megszerzése)
Például: $a=12; visszhang $a % 5; // egyenlő 2-vel
++ (érték növelése/növelése eggyel)
Például ++$a
Fontos megérteni a ++$a és $a++ kifejezések közötti különbséget. Például:
$a=12; $b=++$a; // $b egyenlő 13 echo $b;
Itt először hozzáadunk egyet a $a változó értékéhez, majd az értékét a $b változóval egyenlővé tesszük. Más lenne, ha a kifejezés így nézne ki: $b=$a++; . Itt először az $a változó értéke egyenlő volt a $b változóval, majd az $a változó értékét növeltük.
-- (érték csökkentése/csökkentése eggyel)
Például --$a . Illetve, mint a növekmény esetében, kétféle rögzítés létezik: --$a és $a--
Hozzárendelés operátorok
Egy változót egy adott értékkel egyenlő: $a = 5
Összeadás, majd az eredmény hozzárendelése. Például: $a=12; $a += 5; echo $a; // egyenlő 17-tel
Kivonás, majd az eredmény hozzárendelése. Például: $a=12; $a -= 5; echo $a; // egyenlő 7-tel
Szorzás, majd az eredmény hozzárendelése: $a=12; $a *= 5; echo $a; // egyenlő: 60
Osztás, majd az eredmény hozzárendelése: $a=12; $a /= 5; echo $a; // egyenlő: 2,4
Sorok összefűzése és az eredmény hozzárendelése. Két sorra vonatkozik. Ha a változók nem karakterláncokat tárolnak, hanem például számokat, akkor ezek értékeit karakterláncokká alakítják, majd végrehajtják a műveletet: $a=12; $a .= 5; echo $a; // egyenlő 125-tel // megegyezik a következővel: $b="12"; $b .="5"; // egyenlő 125-tel
Az osztás maradékának megszerzése, majd az eredmény hozzárendelése: $a=12; $a %= 5; echo $a; // egyenlő 2-vel
Összehasonlító műveletek
Az összehasonlító műveleteket általában feltételes struktúrákban használják, amikor két értéket kell összehasonlítani, és az összehasonlítás eredményétől függően bizonyos műveleteket kell végrehajtani. A következő összehasonlítási műveletek állnak rendelkezésre.
Az egyenlőség operátor összehasonlít két értéket, és ha egyenlők, akkor igazat ad vissza, ellenkező esetben hamis értéket ad vissza: $a == 5
Az identitás operátor két értéket is összehasonlít, és ha egyenlők, akkor igazat ad vissza, ellenkező esetben hamis értéket ad vissza: $a === 5
Összehasonlít két értéket, és ha nem egyenlők, akkor igazat ad vissza, ellenkező esetben false értéket ad vissza: $a != 5
Összehasonlít két értéket, és ha nem egyenlők, akkor igazat ad vissza, ellenkező esetben false értéket ad vissza: $a !== 5
Összehasonlít két értéket, és ha az első nagyobb, mint a második, akkor igazat ad vissza, ellenkező esetben false értéket ad vissza: $a > 5
Összehasonlít két értéket, és ha az első kisebb, mint a második, akkor igazat ad vissza, ellenkező esetben hamis értéket ad vissza: $a< 5
Összehasonlít két értéket, és ha az első nagyobb vagy egyenlő a másodikkal, akkor igazat ad vissza, ellenkező esetben hamis értéket ad vissza: $a >= 5
Összehasonlít két értéket, és ha az első kisebb vagy egyenlő a másodikkal, akkor igazat ad vissza, ellenkező esetben hamis értéket ad vissza: $a<= 5
Egyenlőség és identitás operátor
Mindkét operátor összehasonlít két kifejezést, és igazat ad vissza, ha a kifejezések egyenlőek. De vannak különbségek köztük. Ha az egyenlőségi művelet két különböző típusú értéket vesz fel, akkor azok egyre csökkennek - arra, amelyet a tolmács optimálisnak talál. Például:
Nyilvánvaló, hogy a változók különböző típusú, különböző értékeket tárolnak. De összehasonlítva ugyanarra a típusra - numerikusra - redukálódnak. És az $a változó 22-re csökken. A végén mindkét változó egyenlő lesz.
Vagy például a következő változók is egyenlőek lesznek:
$a = hamis; $b = 0;
Az ilyen helyzetek elkerülése érdekében az ekvivalencia műveletet használják, amely nemcsak a változó értékét, hanem típusát is figyelembe veszi:
$a = "22a"; $b = 22; if($a===$b) echo "egyenlő"; else echo "nem egyenlő";
Most a változók nem lesznek egyenlőek.
A != és !== egyenlőtlenségi operátorok hasonlóan működnek.
Logikai műveletek
A logikai műveleteket általában két összehasonlítási művelet eredményeinek kombinálására használják. Például egy bizonyos műveletet kell végrehajtanunk, ha több feltétel igaz. A következő logikai műveletek állnak rendelkezésre:
Igazat ad vissza, ha mindkét összehasonlítási művelet igazat ad vissza, ellenkező esetben hamis értéket ad vissza: $a == 5 && $b = 6
Hasonló az && művelethez: $a == 5 és $b > 6
Igaz értéket ad vissza, ha legalább egy összehasonlítási művelet igazat ad vissza, ellenkező esetben hamis értéket ad vissza: $a == 5 || $b = 6
Hasonló a művelethez || : $a< 5 or $b > 6
Igaz értéket ad vissza, ha az összehasonlítási művelet false értéket ad vissza: !($a >= 5)
Igaz értéket ad vissza, ha csak az egyik érték igaz. Ha mindkettő igaz, vagy egyik sem igaz, akkor hamis értéket ad vissza. Például: $a=12; $b=6; if($a xor $b) echo "igaz"; else echo "hamis";
Itt a logikai művelet eredménye hamis lesz, mivel mindkét változónak meghatározott értéke van. Változtassuk meg a kódot:
$a=12; $b=NULL; if($a xor $b) echo "igaz"; else echo "hamis";
Itt már igaz lesz az eredmény, mivel egy változó értéke nincs beállítva. Ha egy változó értéke NULL, akkor a logikai műveletekben az értéke hamisként lesz kezelve
Bitműveletek
A bitműveleteket egy szám egyes bitjein hajtják végre. A számokat bináris ábrázolásban tekintjük, például a 2 bináris ábrázolásban 010, a 7 szám 111.
& (logikai szorzás)
A szorzás bitenként történik, és ha mindkét operandus bitértéke 1, akkor a művelet 1-et ad vissza, ellenkező esetben a 0-t ad vissza például: $a1 = 4; //100 $b1 = 5; //101 echo $a1 & $b1; // egyenlő 4-gyel
Itt a bináris rendszerben a 4-es szám 100, az 5-ös pedig 101. Szorozzuk meg a számokat bitenként, és kapjuk (1*1, 0*0, 0 *1) = 100, azaz a 4-es szám decimális formátumban.
| (logikai kiegészítés)
A logikai szorzáshoz hasonlóan a műveletet kettes számjegyekkel is végrehajtják, de most egyet adunk vissza, ha egy adott számjegyben legalább egy számnak van egy. Például: $a1 = 4; //100 $b1 = 5; //101 echo $a1 | $b1; // egyenlő 5-tel
~ (logikai tagadás)
minden bitet megfordít: ha a bit értéke 1, akkor nullává válik, és fordítva. $b = 5; visszhang ~$b;
x< x>>y - az x számot y számjeggyel jobbra tolja. Például a 16>>1 a 16-ot (ami binárisan 10000) egy hellyel jobbra tolja, ami 1000-et vagy 8-at eredményez tizedesben.
Karakterláncok összefűzése
A pont operátor a karakterláncok összefűzésére szolgál. Például kössünk össze több sort:
$a="Szia,"; $b=" világ"; visszhang $a . $b . "!";
Ha a változók a karakterláncokon kívül más típusokat is képviselnek, például számokat, akkor ezek értékeit karakterláncokká alakítják, majd a karakterlánc-összefűzési művelet is megtörténik.
A leckében a feltételes php utasításokról lesz szó: az if utasításról és a switch utasításról
A PHP feltételes utasításait három fő konstrukció képviseli:
- állapot operátor ha,
- kapcsoló kezelő kapcsoló
- És hármas operátor.
Nézzük meg mindegyiket közelebbről.
PHP if utasítás
3.1. ábra. Feltételes IF utasítás, rövid változat
Rizs. 3.2. IF ELSE Feltételes utasítás szintaxisa
Rizs. 3.3. Az IF elseif feltételes utasítás teljes szintaxisa
Összefoglaljuk:
Teljes szintaxis:
if (feltétel) ( // ha a feltétel igaz operátor1; operátor2; ) elseif(feltétel) ( operátor1; ... ) else ( // ha a feltétel hamis operátor1; operátor2; )
- A rövidített szintaxis lehet nem tartalmazzák az else záradék részeit, és nem tartalmaznak további elseif feltételt
- Az elseif függvényszó helyett írhat else if (külön)
- Egy if konstrukcióban több elseif is lehet. Az első elseif kifejezés, amely megegyezik az IGAZ értékkel, végrehajtásra kerül.
- Ha van alternatív elseif feltétel, akkor az else záradéknak az utolsónak kell lennie a szintaxisban.
A feltételes kijelentésben használhatunk kettőspontot: göndör kapcsos zárójelek helyett. Ebben az esetben az állítás az endif segédszóval végződik
Rizs. 3.4. Feltételes utasítás If és Endif php-ban
Példa:
if($x > $y): echo $x." nagyobb, mint ".$y; elseif($x == $y): // ":" használatakor nem írhat külön külön, ha az echo $x." egyenlő ".$y; else: echo $x." not > and not = ".$y; endif;
Fontos: Ha egy konstrukcióban göndör kapcsos zárójel helyett kettőspontot használunk, az elseif nem írható két szóval!
Logikai műveletek egy állapotban
A zárójelben lévő if feltétel a következő műveleteket tartalmazhatja:
Példa: ellenőrizze egy numerikus változó értékét: ha kisebb vagy egyenlő, mint 10, jelenítsen meg egy üzenetet "10-nél kisebb vagy egyenlő szám", ellenkező esetben üzenet jelenik meg "10-nél nagyobb szám"
Megoldás:
$szám=15; if ($szám<=10) { echo "число меньше или равно 10"; } else { echo "число больше 10"; }
A PHP kódblokkok feltörhetők, nézzünk egy példát:
Példa: A html kód megjelenítése a képernyőn "egy egyenlő 4", ha az $a változó valóban egyenlő 4-gyel
1 Megoldás:
| 1 2 3 4 |
2 Megoldás:
| 1 2 3 | A egyenlő 4 |
A egyenlő 4
php feladat 3_1: Jelenítse meg a színek fordítását angolról oroszra, ellenőrizve a változó értékét (amelyhez a szín hozzá van rendelve: $a="blue")
php feladat 3_2: Keresse meg a maximum három számot
Összehasonlító műveletek és a hazugságszabály
A zárójelben lévő if konstrukciónak tartalmaznia kell egy logikai kifejezést vagy változót, amelyet a logikai algebra szempontjából tekintünk, és igaz vagy hamis értékeket ad vissza.
Azok. egyetlen változó működhet feltételként. Nézzünk egy példát:
| 1 2 3 4 | $a = 1; if ($a) ( echo $a; ) |
$a=1; if ($a) ( echo $a; )
A példában a PHP nyelvi fordító a zárójelben lévő változót hazugságszabálynak tekinti:
A HAZUGSÁG szabálya, vagy ami hamisnak számít:
- logikus Hamis
- egész nulla ( 0 )
- valódi nulla ( 0.0 )
- üres sorés húr «0»
- elemek nélküli tömb
- változó nélküli objektum
- speciális típus NULLA
Így a vizsgált példában az $a változó egyenlő eggyel, ennek megfelelően a feltétel igaz lesz, és az operátor visszhangzik $a; megjeleníti a változó értékét.
php feladat 3_3: Egy karakterlánc értékű a változót adunk meg. Ha a egyenlő a névvel, nyomtassa ki – Helló, név!, ha a egyenlő egy üres értékkel, akkor a kimenet "Üdv idegen!"
Logikai konstrukciók ÉS VAGY és NEM a feltételes operátorban
- Néha több feltétel egyidejű teljesüléséről is gondoskodni kell. Ezután a feltételek összeállnak logikai operátor ÉS — && :
- Ha egy feltétel hamis, akkor használja a lehetőséget logikai operátor NEM — ! :
$a=1; if ($a>0 || $a>1) ( echo "a > 0 vagy a > 1"; )
| 1 2 3 4 | $a = 1; if (! ($a< 0 ) ) { echo "a не < 0" ; } |
$a=1; if (!($a<0)) { echo "a не < 0"; }
PHP operátor váltása
A kapcsoló operátor vagy „kapcsoló” több egymást követő if konstrukciót helyettesít. Ennek során egy változót több értékkel hasonlít össze. Így ez a legkényelmesebb eszköz többágúság megszervezésére.
Szintaxis:
1 2 3 4 5 6 7 8 9 10 switch ($változó) ( case "érték1" : operátor1 ; break ; case "value2" : operátor2 ; break ; case "value3" : operator3 ; break ; [ default : operator4 ; break ; ] ) switch($változó)( case "érték1": operátor1; break; case "value2": operátor2; break; case "value3": operator3; break; )
- Az operátor ellenőrizheti mind a karakterlánc-értékeket (akkor idézőjelben adják meg), mind a számértékeket (idézőjelek nélkül).
- A konstrukcióban a break utasítás kötelező. Kilép a konstrukcióból, ha a feltétel igaz, és a feltételnek megfelelő operátor végrehajtódik. Szünet nélkül minden esetkijelentés végrehajtásra kerül, függetlenül azok igazságtartalmától.
Rizs. 3.5. Feltételes Switch utasítás
Példa: teljes férfineveket tartalmazó tömb van megadva. Ellenőrizze a tömb első elemét, és a névtől függően jelenítsen meg egy rövid névvel ellátott üdvözlést.
Megoldás:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | $nevek = tömb ("Ivan" , "Péter" , "Szemjon" ) ; switch ($names [ 0 ] ) ( kisbetű "Péter" : echo "Hello, Petya!" ; break ; case "Ivan" : echo "Hello, Vanya!" ; break ; case "Semyon" : echo "Szia, Ványa! " ; break ; alapértelmezett : echo "Szia! $names!"; szünet ; ) |
$nevek=array("Iván","Péter","Szemjon"); switch($names)( case "Peter": echo "Hello, Petya!"; break; case "Ivan": echo "Hello, Vanya!"; break; case "Semjon": echo "Hello, Vanya!"; break alapértelmezett: echo "Hello, $names!"
php feladat 3_4:
- Hozzon létre egy $day változót, és rendeljen hozzá egy tetszőleges numerikus értéket
- A kapcsoló konstrukció segítségével nyomtassa ki a kifejezést "Munkanap van", ha a $day változó értéke az 1-től 5-ig terjedő számok tartományába esik (beleértve)
- Nyomtassa ki a kifejezést "Szünnap van", ha a $day változó értéke egyenlő a 6-os vagy 7-es számokkal
- Nyomtassa ki a kifejezést "Ismeretlen nap", ha a $day változó értéke nem esik az 1 és 7 közötti számok tartományába (beleértve)
Töltse ki a kódot:
| 1 2 3 4 5 6 7 8 9 10 11 12 | ... kapcsoló (... ) ( 1. eset : 2. eset : ... visszhang "Munkanap van"; szünet ; 6. eset : ... alapértelmezett : ... ) |
Switch(...)( 1. eset: 2. eset: ... echo "Ez egy munkanap"; szünet; 6. eset: ... alapértelmezett: ... )
PHP hármas operátor
Háromtagú operátor, azaz három operandussal, meglehetősen egyszerű szintaxissal rendelkezik, amelyben a ? a feltételt írjuk, és a jobb oldalon két operátor van elválasztva a jellel: , az előjeltől balra az operátor hajtódik végre, ha a feltétel igaz, az előjeltől pedig jobbra: az operátor hajtódik végre, ha a feltétel hamis.
feltétel? operátor1 : operátor2 ;
A PHP a következő szabványt támogatja logikai operátorok: "ÉS" és "&&" (logikai ÉS), "VAGY" és "||" (logikai VAGY), "!" (logikai NEM) és "XOR" (kizárólagos VAGY). Mindegyik logikai kifejezésekben a programvégrehajtás egyik vagy másik menetének meghatározására szolgál a kifejezés által visszaadott eredménytől függően, és bináris operátorokra vonatkoznak, kivéve a "!" , ami egynemű. Logikai operátorok használatakor azok operandusai Boole-adattípusra () konvertálódnak, és az eredmény az operandusok adott logikai értékétől és a logikai operátor típusától függ (lásd 1. táblázat).
1. számú táblázat. Logikai operátorok
Különbség az "AND" és az "&&" operátorok, valamint az "OR" és "||" között az, hogy az "AND", "OR" és "XOR" operátorok prioritása alacsonyabb, ami még a hozzárendelési operátoroknál is alacsonyabb (lásd a PHP operátortáblázatát).
Fontos megérteni, hogy az értelmező hogyan dolgozza fel a logikai kifejezéseket. Ha egy kifejezésben "||" operátorral az első (bal) operandus értéke true lesz, vagy az "&&" operátorral rendelkező kifejezésben az első operandus értéke false , akkor a második (jobb) operandus nem kerül kiszámításra. Ez annak köszönhető, hogy a végeredmény ilyen esetekben nem változik (lásd 1. táblázat), ezért nem kell időt tölteni a második operandus kódjának feldolgozásával. Ügyelni kell azonban arra, hogy ne a megfelelő operandusba helyezzünk kódot, amelytől a program helyes működése múlhat.
A logikai operátorok használatát a 2. számú példa mutatja.
hamis $a=0||hamis; //Most $a==igaz, mert 5->igaz és 8->igaz $a=5& //Most $a==hamis, mert "0"->false $a="0"& //Most $a==igaz $a=!false; //Most $a==false, mert 5->igaz $a=!5; /* A foo() függvény nem kerül meghívásra a söntök miatt */ $a=(false&&foo()); $b=(true||foo()); $c=(false és foo()); $d=(igaz vagy foo()); /* Különbség "||" az "or"-ból és az "&&" az "és"-ből */ //Úgy viselkedik, mint ($a=(false||true)) $a=false||true; //Úgy működik, mint (($a=hamis) vagy igaz) $a=hamis vagy igaz; //Hasonlóan cselekszik ($a=(false&&true)) $a=false& //Úgy viselkedik, mint (($a=false) és igaz) $a=hamis és igaz; //Most $a==5, úgy működik, mint (($a=5) xor 0) $a=5 xor 0; //Most $a==5, úgy működik, mint (($a=5) és 0) $a=5 és 0; //Most $a==5, úgy működik, mint (($a=5) vagy 0) $a=5 vagy 0; //Most $a==true, úgy működik, mint ($a=(5||0)) $a=5||0; //Most $a==hamis, úgy működik, mint ($a=(5&&0)) $a=5& //Most $a==igaz, úgy működik, mint ($a=(5 x vagy 6)) $a=(5 xor 6); ?>
2. példa. Logikai operátorok használata
>> Elolvastam néhány ilyen választ, és őszintén szólva nem találtam olyat, amely megmagyarázná a "||" és az "OR" operátorok közötti különbségeket.
A különbséget az operátori elsőbbségről szóló hivatkozás ismerteti.
A "||" az operátorok kiértékelése a hozzárendelés előtt ("="), míg a "vagy" operátorok kiértékelése a hozzárendelés után történik. A második példádban azt mondod a PHP-nek, hogy először rendelje hozzá a "(choice1 != false ? "hah" : "boo")" eredményét a $val értékhez, majd az "or"-t az utasítás többi részéhez. Próbálja ki az alábbi példát, és látni fogja, mire gondolok (vegye figyelembe az extra zárójeleket az elsőbbség érvényesítéséhez):
define ("választás1" , hamis );
define ("választás2" , "kutya" );
define ("alapértelmezett1" , "egyéb" );
$val = array();
$val [ "1. teszt" ] = (választás1 != false ? "hah" : "boo" ) || (choice2 != false ? "hah2" : "boo2" ) || (default1 != false ? "hah3" : "boo3" );
$val [ "1b teszt" ] = ((választás1 != hamis ? "hah" : "boo" ) || (választás2 != hamis ? "hah2" : "boo2" ) || (alapértelmezett1 != hamis ? "hah3" " : "boo3" ));
$val [ "Test 2" ] = (choice1 != false ? "hah" : "boo" ) vagy (choice2 != false ? "hah2" : "boo2" ) vagy (default1 != false ? "hah3" : " boo3" );
$val [ "Test 2b" ] = ((choice1 != false ? "hah" : "boo" ) vagy (choice2 != false ? "hah2" : "boo2" ) vagy (default1 != false ? "hah3" : "boo3" ));
Foreach ($val mint $teszt => $eredmény ) (
print("$teszt: "); var_dump ($eredmény); nyomtatni"
\n
\n" ;
}
?>
teszt a hto dot com-on
Mert az if blokk VAGY rövidítése többet tud produkálni
olvasható kód kevesebb gépeléssel, csábító olyan függvények létrehozása, amelyek meghibásodás esetén FALSE-t, vagy siker esetén valamilyen más adattípust adnak vissza. Mint a mysql_connect, amely "siker esetén MySQL hivatkozásazonosítót, sikertelenség esetén FALSE-t ad vissza."
A kezdő php php fejlesztőnek kerülnie kell olyan függvények létrehozását, amelyek sikertelenség esetén FALSE-t, siker esetén pedig egész számot adnak, ha van esély arra, hogy az egész szám nulla legyen.
bla bla bla ;
$i = add_me_liberty () or die("VÉGZETES DB HIBA!" );
bla bla bla ;
?>
ironmo67 a yahoo dot com-on
Felfedezett egy kissé bosszantó különbséget a PHP és a Perl között:
if (! some_function ()) return false ;
?>
nem lehet szebbre átírni:
function some_function ()( hamis értéket ad vissza; )
some_function () vagy return false ;
?>
A következők azonban működni fognak:
function some_function ()( hamis értéket ad vissza; )
some_function() vagy die();
?>
Kitalálod miért? Egyszerűen a die() egy függvény, a "return" pedig egy utasítás (mint például a print() és az echo közötti különbség). Ez nagyon rossz, mert az if(!)() verziót fáradtnak és olvashatatlannak találom, de hé, ez jobb, mint az if (some_c_function == 0) ( csinálj valamit).
Az alábbi viták nagy része elkerülhető lett volna egyszerűen azzal, hogy egyértelművé vált, hogy &, | és ^ *nem* logikai operátorok. Ezért nem szerepelnek ezen az oldalon. Ezek olyan operátorok, amelyek a számok bináris megjelenítésére hatnak. Nem veszik fel a logikai értékeket (azaz "igaz" vagy "hamis") argumentumként anélkül, hogy először 1-es és 0-s számmá konvertálnák őket. Nem adnak vissza logikai értékeket , de számokat természetesen később úgy is kezelheti, mintha azok logikai értékek lennének (ebben az esetben a 0 értéke "hamis" lesz, minden más pedig "igaz" lesz), de ez a következménye. A PHP típusú öntési szabályok, és semmi köze az operátorok viselkedéséhez.
Ha logikai műveleteket szeretne, használjon logikai operátorokat; Ha bitenkénti műveleteket akarsz, használj bitenkénti operátorokat ... az egyik használata a másikhoz jó módszernek tűnik a dolgok megnehezítésére.
kws_ a hotpop dot com-on
"Csak azért, mert megteheti, nem jelenti azt, hogy meg kell."
Azt is érzem, hogy a rövidzárlat-kiértékelés megkerülése és a feltételes kifejezésekben a mellékhatásokra való támaszkodás rossz stílus gyakorlása. Sokkal jobb gyakorlatnak tűnik az önmagát egyértelmű és egyértelmű konstrukciókkal dokumentáló kódot írni, mint egy bonyolult és nehezen olvasható kifejezést és megjegyzésekkel magyarázni (vagy ami még rosszabb, ha egyáltalán nem dokumentálja!) Valójában a forráskódnak kellene inkább a programozó szemére kell írni, mint a számítógépére.
A bitenkénti operátorok logikai kontextusban való használata sértheti az olvasó elvárásait, és zavart okozhat, mivel a bitenkénti operátorok bitmezős operandusokat feltételeznek.
Azt is gondolom, hogy ha feltételezzük, hogy a rövidzárlat kiértékelése a legjobb a logikai konstrukciók számára, IS a fordító „jogai” között, mivel ha a logikai operátorokat a rendeltetésüknek megfelelően használják, akkor a rövidzárlat feltételezése logikussá teszi a *VÉGRE* (ismét, helyes használat esetén) optimalizálja a logikai kifejezések kiértékelését.
Nem az a célom, hogy bárkit is közvetlenül lángra lobogtassak vagy megsértsek, hanem csak elriasztani a rossz stílust, és arra ösztönözni az új (sőt néhány tapasztalt) programozót, hogy írjanak világos és bőbeszédű kódot, és gondoljanak a programozókra, ne pedig számítógépek, amelyek végül megpróbálják megfejteni alkotásait.
A braintreno kérdésére válaszolva:
A második példa, amit hozott, a helyes módja ennek! Egyáltalán nem bonyolult logika, ez teszi olvashatóvá a kódot azáltal, hogy nem támaszkodik homályos mellékhatásokra!! Sokkal könnyebben olvasható, mint az első, és sokkal könnyebb karbantartani.
Ahhoz, hogy a CheckThisOrOther() függvény csak a felhasználóhoz visszhangozza az információkat, meg kell fosztani a kódolási licenctől. Ha valaha is fenntartanom kellene a forgatókönyveidet, utálni kellene téged.
Ez nem olyan lángoltás, mint amilyennek hangzik! A forráskódot nem a számítógépek futtatására írják, hanem a kódolók olvasására! Tartsa ezt a szívén, és munkatársai hálásak lesznek érte!
braintrino
Shadedecho hozzászólása, amely arra kényszeríti mindkét VAGY kifejezés értékelését, valójában pontosan az, amit meg kell tenni a rövidzárlat-optimalizálás elnyomására.
Sokszor előfordulhat, hogy nem akarja, hogy a fordító rövidre zárja a kiértékelést, különösen akkor, ha egy és/vagy helyzetet szeretne végrehajtani. A rövidzárlat-kiértékelés VAGY műveletet hajt végre, ÉS/VAGY műveletet nem!!!
Például, ha azt szeretném, hogy ellenőrizze a felhasználó lekérdezési űrlapját, hogy a felhasználó nem válaszolt-e valamelyik bejegyzésre ÉS/VAGY ha a felhasználó ugyanazt a választ több bejegyzéshez is megismételte, akkor vissza kell küldenem az űrlapot az ügyfélnek. tájékoztatni, hogy mit szeretnék javítani.
Funkció SomeAnswersAreMissing()
{
...
echo "Hoppá! Nem válaszoltál néhány kérdésre.";
visszatér IGAZ;
}
Funkció SomeAnswersAreDuplicated()
{
...
echo "Hoppá! Mindkettőre ugyanúgy válaszolhatsz.";
visszatér IGAZ;
}
If (SomeAnswersAreMissing() || SomeAnswersAreDuplicated())
SendFormAgain();
Ha ezt teszem, a felhasználó csak a hiányzó válaszra vonatkozó figyelmeztetést fogja látni, de a duplikált válaszra vonatkozó figyelmeztetést nem, még akkor is, ha mindkettő igaz. Ez nem tájékoztató jellegű a felhasználó számára, mert kétszer újra be kell küldenie az űrlapot, mielőtt rájött, hogy mindent rosszul csinált, és meghiúsítja a feltörést. Ez nem felhasználóbarát.
Ha (SomeAnswersAreMissing() | SomeAnswersAreDuplicated())
SendFormAgain();
Ekkor mindkét figyelmeztető üzenet egyszerre kerül elküldésre, és a felhasználó egy újraküldéssel javíthatja azt.
Köszönöm Shadedecho, kerestem a módot, hogy felülírjam a fordító hülye rövidzárlat-optimalizálását. A számítógép nem tudja csak úgy feltételezni, hogy a rövidzárlat a legjobb:(
BTW, természetesen megteheti:
$you_made_a_ error = hamis;
Ha(Néhány válasz hiányzik())
if (SomeAnswersAreDuplicated())
$you_made_a_ error = igaz;
Ha ($elkövettél_hibát)
SendFormAgain();
De ez szövevényes logika!!!
komló
Kedves Újonc!
(mivel nem látom, hogy a tapasztalt programozók fejében ilyen ötletek kavarognának...)
Kérjük, ne figyeljen Shadedecho 2003. március 14-i 04:02-i bejegyzésére! Erősen támaszkodik a homályos mellékhatásokra, ami nemcsak nagyon rossz programozási gyakorlat, de nem is éri el azt az optimalizálást, amilyennek gondolja.
Ennek megfelelő módja
echo $a;
}
A shadedecho által elvárt munka (bár a példa egésze meglehetősen alkalmatlan):
$a .= bla();
$a .= blah2();
Ha ($a) ( echo $a; )
Ha elolvassa azt a vitát, amelyre hivatkozik, rá fog jönni, hogy valóban két különböző db táblából akart minden külön bejegyzést lekérni. Még ott is téved. Ennek megfelelő módja az első tábla, majd a második tábla feldolgozása.
Ez nem csak sokkal olvashatóbb, mint a "|"-es megoldás, hanem a legkevésbé sem lassabb.
shadedecho
Úgy tűnik (sok frusztráló, de végső soron hasznos keresés és fórumokon, például a tek-tips-eken folytatott vita után), hogy a
|| és az && "rövidre van zárva", ahogy korábban megjegyeztük, DE a | és a & operátorok (amelyeket a PHP bitenkénti operátorként dokumentált) nem rövidre zárt megfelelőikként viselkednek.
bla() (
echo "szia< br>";
return " from bla ()< br>";
}
bla2() függvény (
echo "világ\"< br>";
return " from bla2()< br>";
}
If (($a .= blah()) || ($a .= blah2())) (
echo $a;
}
Ez a következő kimenetet eredményezné:
Helló
bla-tól ()
Figyeljük meg, hogy a "világ" nem kapott visszhangot"d" és a "from blah2()" nem koncat"d az $a változóba, mert az első hozzárendelés $a-hoz sikeres volt, így a "rövidzárlat" beindul, és a logikai teszt befejeződik a többi részének kiértékelése nélkül.
AZONBAN, ha a || csak | ebben az "if" utasításban a következő kimenetet kapod:
Helló
világ
bla-tól ()
from bla2()
Eureka! a logikai teszt minden része kiértékelésre kerül, a várt balról jobbra haladva, és amennyire én látom az összes normál elsőbbségi szabályt követve.
Ennek teljesen értelme van... A bitenkénti operátorokat használva az a bitenkénti szintű művelet, amely két nem bitenkénti művelet (a hozzárendelések) eredményén történik. Ha egy nem bitenkénti művelet nullát ad vissza (más szóval a hozzárendelt érték nullának vagy 0-nak bizonyul), a bitenkénti operátor ehhez kötődik (vagy még pontosabban "látja") "0"-ként, különben nem nullát látna (bitsor, amelyben legalább egy "1" van).
Aztán bitenként | a két értékre történik, és ha valamelyik nem nulla ("1" bit van benne), akkor az eredményben ezek az "1" bitek lesznek benne (nem nulla), és az if utasítás minden nem nulla értéke igaz egy logikai tesztben. Hasonlóképpen, ha mindkét operandus a | nulla vagy 0, akkor az eredmény egy nulla érték lenne, amelyet az "if" hamisnak értelmezne.
A fenti if utasítás bitenkénti | (ebben az esetben) két nullától eltérő értéken (bitszinten "1"-el), így a | művelet nullától eltérő értéket ad vissza, amelyet az if utasítás IGAZ-ként értelmez!
Tehát ebben a speciális esetben, amikor nem rövidre zárt logikai teszteket próbál összefűzni, ezek az operátorok bitenkénti szinten dolgoznak az operandusaikon, és mivel nem összehasonlító operátorok, hanem matematikai operátorok, nem lehetnek rövidek. áramkörbe van kapcsolva, és az eredmény egy nem zárlatos "boolean teszt".
Tudom, biztosan azt hiszi, őrült vagyok, amiért megpróbálok megkerülni egy ilyen beépített optimalizálást, de biztosíthatom, hogy ennek nagyon jó oka van, és ha érdekel, megnézheti ezt a szálat, ahogy én. egy nagyon hosszú bejegyzés, ami elmagyarázza, mit próbáltam csinálni:
Ez a 9. bejegyzés, ahol megtalálod az adatbázis-lekérdezésem leírását, amelyet optimalizálni akartam.
Ami valószínűleg nem az, amit akarsz.
Ez segítséget jelenthet azoknak, akik szeretik a kódjukat úgy olvasni, mint az angol, és azt gondolhatják, hogy ezeknek az operátoroknak a prioritási különbségei viszonylag egzotikusak: nem azok.
Ami engem illet, belefutottam ebbe a problémába, mert nincs szimbolikus logikai XOR (például nincs ^^), ezért XOR-t kellett használnom, majd arra jutottam, hogy hasonló helyeken az ÉS és a VAGY, majd az én elromlott a kód :)
Szóval most muszáj
$a = ($b xor $c);
Jesse Thompson
bend.com
yohgaki a hotmail dot com-on
PHP4-ben "and", "or", "&&", "||" -- mindegyik "zárlatos", mint a C/C++-ban. PHP3-ban szerintem nem volt.
A "rövidzárlat" azt jelenti, hogy a nyelv leállítja a kifejezés kiértékelését, amikor a feltételeket meghatározzák. (A legtöbb nyelv rövidzárlat-kiértékelést használ a logikai feltételhez)
$a = igaz;
$b = hamis;
if ($a || $b) (
}
Ez az "if" utasítás csak $a-t értékel, mivel $a igaz, és az egész feltételnek igaznak kell lennie. (azaz ha a $b egy függvény érték helyett, akkor a függvény nem kerül meghívásra)
muerte at web-ster dot com
Reméltem, hogy találok egy, a ||= függvényekhez hasonló operátort a perl-ben. Az első gondolatom a következő lenne:
$i = $i vagy "alapértelmezett"
De vagy nem így működik.
$i vagy $i = "alapértelmezett"
Az első példa NEM működik, mert a vagy operátor nem túlterhelhető, mint a Perlben.
dante at heartme dot com
Valami ilyesmit akartam csinálni:
$választás1 = "";
$választás2 = "kutya";
$default = "egyéb";
$val = $választás1 || $választás2 || $alapértelmezett;
De akkor a $val1 csak 1-et vagy 0-t tartalmaz. Ehelyett ezt tettem:
$választás1 = "";
$választás2 = "kutya";
$default = "egyéb";
$val = $választás1 vagy $választás2 vagy $alapértelmezett;
Most a $val a "kutya" karakterláncot tartalmazza. Ez az
fura, hogy a "vagy" különbözik a "||"-től...és ezt tenném
úgy gondolja, hogy a "||" elég okosnak kell lennie ahhoz, hogy kezelje
karakterláncok... ahogy a PERL teszi. Asszem nem. Talán az
tervezési választás.
