Php logický operátor exkluzívny resp. PHP: Logické operátory – manuál. Operátor zátvoriek

PHP podporuje nasledujúci štandard logické operátory: "AND" a "&&" (logické AND), "ALEBO" a "||" (logické ALEBO), "!" (logické NIE) a "XOR" (exkluzívne OR). Všetky sa používajú v logických výrazoch na určenie konkrétneho priebehu vykonávania programu v závislosti od výsledku vráteného výrazom a odkazujú na binárne operátory, s výnimkou znaku "!" ktorý je unárny. Pri použití logických operátorov sa ich operandy konvertujú na typ údajov Boolean () a výsledok závisí od daných logických hodnôt operandov a typu logického operátora (pozri tabuľku 1).

Stôl 1. Logické operátory

Rozdiel medzi operátormi „AND“ a „&&“ a „OR“ a „||“ je, že operátory "AND", "OR" a "XOR" majú nižšiu prioritu, ktorá je dokonca nižšia ako pri operátoroch priradenia (pozri tabuľku PHP operátorov).

Je dôležité pochopiť, ako interpret narába s boolovskými výrazmi. Ak výraz s operátorom "||" prvý (ľavý) operand bude mať hodnotu true alebo vo výraze s operátorom "&&" bude mať prvý operand hodnotu nepravda, potom sa druhý (pravý) operand nevyhodnotí. Je to spôsobené tým, že konečný výsledok sa v takýchto prípadoch už nezmení (pozri tabuľku 1), a preto nie je potrebné strácať čas spracovaním kódu druhého operandu. Treba si však dávať pozor, aby ste nevložili kód do správneho operandu, od ktorého môže závisieť správna činnosť programu.

Použitie logických operátorov je znázornené v príklade #2.

nepravda $ a = 0 || nepravda; // Teraz $ a == pravda, pretože 5-> pravda a 8-> pravda $ a = 5 & // Teraz $ a == nepravda, pretože "0" -> nepravda $ a = "0" & ​​​​// Teraz $ a == pravda $ a =! Nepravda; // Teraz $ a == false, pretože 5-> pravda $ a =! 5; / * Funkcia foo () nebude volaná kvôli skratom * / $ a = (false && foo ()); $ b = (pravda || foo ()); $ c = (false a foo ()); $ d = (true alebo foo ()); / * Rozdiel "||" from "or" a "&&" from "and" * / // Funguje ako ($ a = (false || true)) $ a = false || true; // Pôsobí ako (($ a = nepravda) alebo pravda) $ a = nepravda alebo pravda; // Pôsobí ako ($ a = (false && true)) $ a = nepravda & // Správa sa ako (($ a = nepravda) a pravda) $ a = nepravda a pravda; // Teraz $ a == 5, funguje ako (($ a = 5) xor 0) $ a = 5 xor 0; // Teraz $ a == 5, funguje ako (($ a = 5) a 0) $ a = 5 a 0; // Teraz $ a == 5, funguje ako (($ a = 5) alebo 0) $ a = 5 alebo 0; // Teraz $ a == pravda, správa sa ako ($ a = (5 || 0)) $ a = 5 || 0; // Teraz $ a == nepravda, správa sa ako ($ a = (5 && 0)) $ a = 5 & // Teraz $ a == pravda, správa sa ako ($ a = (5 x alebo 6)) $ a = (5 x alebo 6); ?>

Príklad č.2. Používanie booleovských operátorov

Takže už vieme, ako spustiť kód, ktorý spĺňa určitú podmienku. Ale až do tohto bodu mohla existovať iba jedna podmienka. Čo ak sa však kód musí vykonať, keď je splnených niekoľko podmienok naraz?

Na vyriešenie tohto problému existujú logické operátory:

= cena 5 && $<= 10) echo "Это число находится между 5 и 10"; ?>

Operátor &&, tiež nazývaný logické AND, prevedie hodnoty vľavo a vpravo na boolovský typ a potom sám vráti boolovskú hodnotu: true, ak sú ľavá a pravá strana pravdivé, alebo nepravda, ak je jedna z podmienok nepravdivá.

Inými slovami, ak sú obe podmienky splnené, operátor && vráti hodnotu true. To odráža názov operátora.

Prevádzkovateľ || alebo logické ALEBO vráti hodnotu true, keď je splnená aspoň jedna z dvoch podmienok:

5 || 1> 2) echo "Podmienka je splnená."; ?>

Vo vyššie uvedenom kóde sa vykoná príkaz echo, pretože jedna z podmienok je splnená.

Všetky boolovské operátory v PHP

Medzi && a a, ako aj || a alebo je tam drobný rozdiel - poradie vykonávania.

Ako viete, násobenie má prednosť pred sčítaním. Takže operátory a a alebo majú nižšiu prioritu ako operátor priradenia =. Výsledok je možné vidieť na nasledujúcom príklade:

Zvláštne, však? Keďže y = má vyššiu prioritu, PHP bude kód interpretovať takto:

($ var = pravda) a nepravda;

Tie. najprv nastaví premennú $ var na hodnotu true a potom dôjde k operácii true a false, čo nedáva zmysel, pretože neovplyvňuje hodnotu premennej.

Nižšie je uvedená tabuľka s prioritami operátora. S niektorými ste sa už stretli. Čím vyššie je operátor v tabuľke, tým vyššia je jeho priorita.

• ++ - ~ (int) (float) (reťazec) (pole) (objekt) (bool) @
• * / %
• + - .
• < <= > >=
• == != === !== <> <=>
• ? : (ternárny operátor)
• = += -= *= **= /= .= %= &= |= ^= <<= >>=

Teraz môžeme určiť, že priorita porovnávacích operátorov (==,! =, atď.) je vyššia ako priorita logických operátorov. Tieto informácie budú pre nás užitočné pri dokončení úlohy.

Dva hlavné príkazy na vytváranie štruktúr vetvenia na základe podmienok sú if a switch. Najpoužívanejší je príkaz if, ktorý sa používa v konštrukciách podmieneného skoku. Na druhej strane, v určitých situáciách, najmä ak musíte poskytnúť prechod pozdĺž jednej z mnohých vetiev v závislosti od hodnoty jedného výrazu a použitie viacerých príkazov if vedie ku zložitosti kódu, príkaz switch sa stáva pohodlnejším.

Pred preskúmaním týchto operátorov musíte pochopiť boolovské výrazy a operácie.

Logické operácie

Booleovské operácie vám umožňujú kombinovať boolovské hodnoty (nazývané aj pravdivostné hodnoty), aby ste vytvorili nové boolovské hodnoty. Ako je uvedené v tabuľke nižšie, PHP podporuje štandardné booleovské operácie (and, or, not a xor), pričom prvé dve majú alternatívne verzie.

PHP boolovské operácie

Prevádzka	Popis
a	Operácia, ktorej výsledok je pravdivý vtedy a len vtedy, ak sú pravdivé oba jej operandy
alebo	Operácia, ktorá sa vyhodnotí na skutočnú hodnotu, ak sa jeden z jej operandov (alebo obidva) vyhodnotí ako skutočná hodnota
!	Operácia, ktorej výsledok je pravdivý, ak jej jediný operand (špecifikovaný napravo od znamienka operácie) je nepravdivý, a nepravdivý, ak je operand pravdivý
xor	Operácia, ktorá sa vyhodnotí ako true, ak je pravdivý niektorý z jej operandov (ale nie oba).
&&	Rovnaké ako a, ale viaže svoje operandy pevnejšie ako toto
||	Rovnaké ako or, ale viaže svoje operandy pevnejšie ako toto

&& a || by mal byť oboznámený programátorom v jazyku C. Prevádzka! zvyčajne sa nazýva nie preto, že sa stáva negáciou operandu, na ktorý sa vzťahuje.

Ak chcete skontrolovať, či sú oba operandy PRAVDA, použite operátor AND, ktorý možno zapísať aj ako dvojitý ampersand (&&). AND aj && sú logické operátory, jediný rozdiel je v tom, že operátor && má prednosť pred operátorom AND. To isté platí pre operátory OR a ||. Operátor AND vráti hodnotu TRUE iba vtedy, ak sú oba operandy TRUE; v opačnom prípade sa vráti FALSE.

Ak chcete skontrolovať, či je aspoň jeden operand PRAVDA, použite operátor OR, ktorý možno zapísať aj ako dvojitú zvislú čiaru (||). Tento operátor vráti TRUE, ak je aspoň jeden z operandov TRUE.

Pri použití operátora OR sa môžu v programe objaviť jemné logické chyby. Ak PHP zistí, že prvý operand je PRAVDA, nevyhodnotí hodnotu druhého operandu. To šetrí čas vykonávania, ale musíte byť opatrní, aby ste do druhého operandu nevložili žiadny kód, ktorý závisí od správnej činnosti programu.

Operátor XOR vám umožňuje skontrolovať, či je iba jeden z operandov PRAVDA (ale nie oba). Tento operátor vráti TRUE, ak je jeden a len jeden z operandov TRUE. Ak sú oba operandy TRUE, operátor vráti hodnotu FALSE.

Booleovskú hodnotu môžete invertovať pomocou operátora NOT, ktorý sa často píše ako výkričník (!). Vracia TRUE, ak je operand FALSE, a FALSE, ak je operand TRUE.

V tabuľke nižšie sú uvedené niektoré boolovské výrazy a ich výsledky:

Porovnávacie operácie

V tabuľke nižšie sú uvedené porovnávacie operácie, ktoré možno použiť na čísla alebo reťazce:

Porovnávacie operácie

Prevádzka	názov	Popis
==	rovná sa	Operácia, ktorej výsledok je pravdivý, ak sa jej operandy navzájom rovnajú, v opačnom prípade je nepravdivý
!=	Nerovná sa	Operácia, ktorej výsledok je nepravdivý, ak sa jej operandy navzájom rovnajú, inak je pravdivá
<	Menšie	Operácia, ktorá sa vyhodnotí ako pravdivá, ak je ľavý operand menší ako pravý operand, inak sa vyhodnotí ako nepravda
>	Viac	Operácia, ktorá sa vyhodnotí ako pravdivá, ak je ľavý operand väčší ako pravý operand, inak sa vyhodnotí ako nepravda
<=	Menšie alebo rovné	Operácia, ktorej výsledok sa vyhodnotí ako pravda, ak je ľavý operand menší alebo rovný pravému operandu, inak sa vyhodnotí ako nepravda
>=	Viac alebo rovnaké	Operácia, ktorej výsledok sa vyhodnotí ako pravda, ak je ľavý operand väčší alebo rovný pravému operandu, inak sa vyhodnotí ako nepravda
===	Zhodne	Operácia, ktorej výsledok je pravdivý, ak sú oba operandy rovnaké a rovnakého typu, v opačnom prípade je nepravda

Mali by ste si dať pozor, aby ste neurobili jednu veľmi častú chybu – nepomýlili si zadanie (=) s porovnaním (==).

Priorita operácií

Samozrejme, nemali by ste nadužívať štýl programovania, v ktorom je postupnosť operácií spôsobená najmä používaním pravidiel priority, keďže kód napísaný týmto štýlom je náročný pre tých, ktorí ho budú neskôr študovať, ale treba poznamenať, že porovnanie operácie majú vyššiu prioritu ako logické operácie. To znamená, že vyhlásenie s kontrolným výrazom, ako je ten nižšie

PHP kód $ var1 = 14; $ var2 = 15; ak (($ var1< $var2) && ($var2 < 20)) echo "$var2 больше $var1 но меньше 20";

možno prepísať ako

PHP kód ... ak ($ ​​var1< $var2 && $var2 < 20) ...

If - else vyhlásenie

Inštrukcie ak umožňuje vykonanie bloku kódu, ak je podmienený výraz v tomto príkaze PRAVDA; inak sa blok kódu nevykoná. Akýkoľvek výraz môže byť použitý ako podmienka, vrátane testov na nenulovú hodnotu, rovnosť, NULL zahŕňajúce premenné a hodnoty vrátené funkciami.

Nezáleží na tom, ktoré jednotlivé kondicionály tvoria podmieňovaciu vetu. Ak je podmienka pravdivá, vykoná sa kód programu uzavretý v zložených zátvorkách (()). V opačnom prípade to PHP ignoruje a prejde na kontrolu druhej podmienky, pričom kontroluje všetky podmienky, ktoré ste si zapísali, až kým nenarazí na príkaz inak, po ktorom automaticky vykoná tento blok. Príkaz else je voliteľný.

Syntax príkazu if je:

If (podmienený výraz) (blok kódu;)

Ak sa podmienený výraz vyhodnotí ako TRUE, vykoná sa blok kódu za ním. Ak je v nasledujúcom príklade premenná $ username nastavená na "Admin", zobrazí sa uvítacia správa. Inak sa nič nedeje:

PHP kód $ username = "Admin"; if ($ username == "Admin") (echo "Vitajte na stránke správcu.";)

Ak blok programového kódu obsahuje iba jednu inštrukciu, potom sú zložené zátvorky voliteľné, napriek tomu je dobrým zvykom vkladať ich vždy, pretože uľahčujú čítanie a úpravu kódu.

Voliteľný príkaz else je blok kódu, ktorý sa štandardne vykoná, keď podmienený výraz vráti hodnotu FALSE. Príkaz else nemožno použiť oddelene od príkazu if, pretože príkaz else nemá svoj vlastný podmienený výraz. To znamená, že else a if by mal byť vo vašom kóde vždy spolu:

If a else vyhlásenia $ username = "žiadny admin"; if ($ username == "Admin") (echo "Vitajte na stránke správcu.";) else (echo "Vitajte na stránke používateľa.";)

Nezabudnite uzavrieť blok kódu v príkaze if zloženou zátvorkou, ak na začiatok bloku vložíte zloženú zátvorku. Blok else musí tiež obsahovať otváracie a zatváracie zložené zátvorky, ako v bloku if.

To všetko je dobré, okrem prípadov, keď potrebujete skontrolovať niekoľko podmienok za sebou. Na to je návod vhodný ináč Ak... Umožňuje kontrolu dodatočných podmienok, kým sa nenájde pravdivá alebo kým sa nedosiahne blok else. Každý príkaz elseif má svoj vlastný blok kódu, ktorý je umiestnený hneď za podmieneným výrazom príkazu elseif. Príkaz elseif nasleduje po príkaze if a pred príkazom else, ak existuje.

Syntax príkazu elseif je trochu komplikovanejšia, ale nasledujúci príklad vám pomôže pochopiť ju:

Kontrola viacerých podmienok $ používateľské meno = "Hosť"; if ($ username == "Admin") (echo "Vitajte na stránke správcu.";) elseif ($ username == "Hosť") (echo "No view available.";) else (echo "Vitajte na stránke" užívateľ." ;)

Tu sa testujú dve podmienky a vykonávajú sa rôzne akcie v závislosti od hodnoty premennej $ username. A stále je tu možnosť niečo urobiť, ak sa hodnota premennej líši od prvých dvoch.

Ternárny operátor?:

Operátor ?: je ternárny (trojitý) operátor, ktorý má tri operandy. Funguje ako príkaz if, ale vracia hodnotu jedného z dvoch výrazov. Výraz, ktorý sa má vyhodnotiť, je určený podmieneným výrazom. Dvojbodka (:) slúži ako oddeľovač výrazov:

(podmienka)? vyhodnotiť_ak_podmienku_pravda: vyhodnotiť_ak_podmienku_nepravda;

Nižšie uvedený príklad kontroluje hodnotu a vracia rôzne riadky v závislosti od jej hodnoty (TRUE alebo FALSE):

Vytvorte správu pomocou operátora ?: $ prihlásený_prihlásený = TRUE; $ user = "Igor"; $ banner = (! $ prihlásený)? "Registrovať!" : "Vitajte späť, $ užívateľ!"; echo $ banner;

Je celkom zrejmé, že vyššie uvedený operátor je ekvivalentný s nasledujúcim operátorom:

PHP kód $ prihlásený_prihlásený = TRUE; $ user = "Igor"; if (! $ prihlásený_in) ($ banner = "Zaregistruj sa!";) else ($ banner = "Vitajte späť, $ užívateľ!";) echo $ banner;

Výpis prepnutia

Inštrukcie prepínač porovnáva výraz s viacerými hodnotami. Spravidla sa ako výraz používa premenná v závislosti od hodnoty, ktorej sa má konkrétny blok kódu vykonať. Predstavte si napríklad premennú $ action, ktorá môže mať hodnoty „ADD“, „MODIFY“ a „DELETE“. Príkaz switch uľahčuje definovanie bloku kódu, ktorý by sa mal vykonať pre každú z týchto hodnôt.

Aby sme ukázali rozdiel medzi príkazmi if a switch, porovnajme premennú s viacerými hodnotami. Nižšie uvedený príklad ukazuje programový kód, ktorý implementuje takúto kontrolu na základe príkazu if a v nasledujúcom príklade na základe príkazu switch:

Kontrola súladu s jednou z niekoľkých hodnôt (ak je vyhlásenie) if ($ action == "ADD") (echo "Vykonať sčítanie."; echo "Počet inštrukcií v každom bloku nie je obmedzený.";) elseif ($ action == "MODIFY") (echo "Vykonať zmenu. ";) elseif ($ action == "DELETE") (echo "Vykonať odstránenie.";) Kontrola súladu s jednou z niekoľkých hodnôt (príkaz prepínača) prepínač (akcia $) (vec "PRIDAŤ": echo "Vykonať sčítanie."; echo "Počet inštrukcií v každom bloku nie je obmedzený."; zlom; veľkosť písmen "MODIFY": echo "Vykonať zmenu."; prerušenie; veľkosť písmen "DELETE" : echo "Vykonať vymazanie."; prerušiť;)

Príkaz switch prevezme hodnotu vedľa kľúčového slova switch a začne ju porovnávať so všetkými hodnotami vedľa kľúčových slov. prípad v poradí, v akom sa zobrazujú v programe. Ak sa nenájde žiadna zhoda, žiadny z blokov sa nevykoná. Po nájdení zhody sa vykoná príslušný blok kódu. Vykonajú sa aj nižšie uvedené bloky kódu – až do konca príkazu switch alebo až po kľúčové slovo prestávka... Je to užitočné pri organizácii procesu, ktorý pozostáva z niekoľkých po sebe idúcich krokov. Ak používateľ už vykonal niektoré kroky, bude môcť pokračovať v procese tam, kde prestal.

Výraz vedľa príkazu switch musí vrátiť primitívnu hodnotu, ako je číslo alebo reťazec. Pole možno použiť iba ako samostatný prvok s hodnotou elementárneho typu.

Predvolený výber

Ak sa hodnota podmieneného výrazu nezhoduje so žiadnou z možností ponúkaných v príkazoch case, príkaz switch vám v tomto prípade umožňuje urobiť niečo podobné ako príkaz else konštrukcie if, elseif, else. Aby ste to dosiahli, musíte urobiť pokyn ako poslednú možnosť vo výberovom zozname predvolená:

Generovanie chybového hlásenia pomocou predvoleného príkazu $ akcia = "ODSTRÁNIŤ"; prepínač (akcia $) (vec "PRIDAŤ": echo "Vykonať sčítanie."; echo "Počet inštrukcií v každom bloku nie je obmedzený."; zlom; veľkosť písmen "MODIFY": echo "Vykonať zmenu."; prerušenie; veľkosť písmen "DELETE" : echo "Vykonať vymazanie."; break; predvolené: echo "Chyba: príkaz $ action nie je platný,". "možno použiť iba príkazy ADD, MODIFY a DELETE.";)

Okrem bežného príkazu switch podporuje alternatívnu syntax - konštrukciu kľúčových slov spínač / koncový spínač ktoré definujú začiatok a koniec príkazu namiesto zložených zátvoriek:

Príkaz switch končí kľúčovým slovom endwitch prepínač ($ akcia): case "ADD": echo "Vykonať pridávanie."; echo "Počet inštrukcií v každom bloku nie je obmedzený."; prestávka; prípad "MODIFY": echo "Vykonať zmenu."; prestávka; case "DELETE": echo "Vykonať vymazanie."; prestávka; predvolená hodnota: echo "Chyba: príkaz akcie $ nie je platný,". "možno použiť iba príkazy ADD, MODIFY a DELETE."; koncový spínač;

Prerušenie exekúcie

Ak sa má vykonať iba blok kódu, ktorý sa zhoduje s konkrétnou hodnotou, potom by sa na koniec tohto bloku malo vložiť prerušenie kľúčového slova. PHP interpret, keď narazí na kľúčové slovo break, preskočí na riadok za uzatváracou zloženou zátvorkou príkazu switch (alebo kľúčového slova endwitch). Ak však nepoužijete príkaz break, kontrola pokračuje v nasledujúcich prípadoch konštrukcie prepínača. Príklad je uvedený nižšie:

Čo sa stane, keď neexistujú žiadne prerušenia $ akcia = "OBJEDNÁVKA NA MONTÁŽ"; prepínač (akcia $) (prípad "ZOSTAVENIE OBJEDNÁVKY": echo "Vyzdvihnúť objednávku.
"; puzdro" BALENIE ": echo" Bal.
"; prípad" SHIP ": echo" Doručiť zákazníkovi.
"; }

Ak je premenná $ action nastavená na "ZOSTAVENIE OBJEDNÁVKY", výstup tohto úryvku bude takýto:

Vyzdvihnite objednávku. Aby som to zabalil. Doručiť zákazníkovi.

Ak predpokladáme, že fáza zostavenia už prešla a akčná premenná $ má hodnotu „PACKAGE“, potom sa získa nasledujúci výsledok:

Aby som to zabalil. Doručiť zákazníkovi.

Niekedy je užitočná absencia príkazov break, ako v príklade vyššie, kde sa tvoria stupne poradia, ale vo väčšine prípadov by sa mal použiť tento príkaz.

Typy údajov Cykly 1 2 3 4 5 6 7 8 9 10

PHP podporuje štandardné logické operátory AND a &&, OR a || ,! (nie) a XOR. Booleovské operátory vám umožňujú porovnať výsledky dvoch operandov (hodnoty alebo výrazy), aby ste zistili, či jeden alebo oba vrátili hodnotu true alebo false, a na základe vrátenej hodnoty zvoliť vhodné pokračovanie skriptu. Podobne ako operátory porovnávania, aj logické operátory vracajú jednu boolovskú hodnotu – true alebo false, v závislosti od hodnôt na oboch stranách operátora.

Logické ALEBO (ALEBO a ||)

Logický operátor OR sa označuje ako OR alebo || ... Vykonáva logickú operáciu OR na dvoch operandoch. Ak sú jeden alebo oba operandy pravdivé, vráti hodnotu true. Ak sú oba operandy nepravdivé, vráti hodnotu false. Pravdepodobne máte otázku, prečo ste urobili dve verzie jedného operátora? Zmyslom dvoch rôznych variantov operátora „logické OR“ je, že pracujú s rôznymi prioritami.

Najprv sa pozrime, ako funguje operátor ||. ... A tak, ak sú jeden alebo oba jeho operandy pravdivé, vráti hodnotu true. Ak oba operandy vrátia nepravdivé hodnoty, vrátia nepravdu.

Operátor OR funguje rovnako ako || s jednou výnimkou, ak sa s priradením použije operátor OR, najskôr vyhodnotí a vráti hodnotu ľavého operandu, inak funguje presne ako operátor ||. , t.j. ak sú jeden alebo oba jeho operandy pravdivé, vráti hodnotu true. Ak oba operandy vrátia nepravdivé hodnoty, vrátia nepravdu.

Aby bolo jasnejšie, ako fungujú, tu je príklad:

1 // Najprv sa premennej priradí hodnota false a potom sa vypočíta druhý operand // Akcia priority: ($ var2 = nepravda) alebo pravda $ var2 = nepravda alebo pravda; echo $ var2; // false sa nezobrazuje // ($ var3 = 0) alebo 3 $ var3 = 0 alebo 3; ozvena"
$ var3 "; // => 0?>

Akékoľvek porovnávacie a logické operátory možno kombinovať do zložitejších konštruktov:

Existuje ďalší dôležitý bod, ktorý stojí za zmienku v súvislosti s OR aj || ... Operátor "logické OR" začína svoje výpočty od svojho ľavého operandu, ak vráti hodnotu true, potom sa pravý operand nevyhodnotí. To šetrí čas vykonávania, ale musíte byť opatrní, aby ste nevložili kód, od ktorého závisí správna činnosť programu od správneho operandu.

Logické AND (AND a &&)

Logický operátor AND sa označuje ako AND alebo &&. Vykonáva logickú operáciu AND na dvoch operandoch. Vráti hodnotu true vtedy a len vtedy, ak sú oba operandy pravdivé. Ak jeden alebo oba operandy vrátia hodnotu false, operátor vráti hodnotu false. Význam dvoch rôznych verzií operátora „logického AND“ je rovnaký ako u dvoch predchádzajúcich operátorov, teda že pracujú s rôznymi prioritami.

Najprv sa pozrime, ako funguje operátor &&. Ak sú teda oba jeho operandy pravdivé, vráti hodnotu true. Ak aspoň jeden alebo oba jeho operandy vrátia hodnotu false, vráti aj hodnotu false.

Operátor AND funguje rovnako ako operátor &&, s jednou výnimkou, ak sa operátor AND použije s priradením, najskôr vyhodnotí a vráti hodnotu ľavého operandu, inak funguje rovnako ako operátor &&. Ak aspoň jeden z jeho operandov vráti hodnotu false, vráti aj hodnotu false, a ak oba operandy vrátia hodnoty false, vráti hodnotu false.

Pre pochopenie sa teraz zamyslime nad tým, ako to funguje v praxi:

$ bar3 "; // => 9?>

Exkluzívne OR (XOR)

Výhradný operátor OR je označený ako XOR. Vráti hodnotu true, ak je pravdivý iba jeden z operandov. Ak sú oba operandy pravdivé, operátor vráti nepravdu.

Keďže priorita operátora XOR je rovnaká ako priorita operátorov AND a OR (nižšia ako operátor priradenia) a používa sa vo výraze priradenia, najprv vyhodnotí a vráti hodnotu ľavého operandu.

6 $ a1 = 19 x alebo 5 > 6; var_dump ($ a1); // => 19 var_dump (true xor true); // false var_dump ((2< 3) xor (5 != 5)); // true ?>

Logické NIE (!)

Operátor logické NIE, nazýva sa to aj negácia označená znamienkom! ... Je to unárny operátor umiestnený pred jedným operandom. Operátor Boolean NOT sa používa na invertovanie boolovskej hodnoty svojho operandu a vždy vracia hodnotu true alebo false.

Ak potrebujete prevrátiť hodnotu výrazu, napríklad a && b, budete musieť použiť zátvorky:! (A && b). Aj s pomocou operátora! ľubovoľnú hodnotu x môžete previesť na jej logický ekvivalent použitím operátora: !!x dvakrát.

>> Prečítal som si niekoľko z týchto odpovedí a celkom úprimne "nenašiel som žiadnu, ktorá by vysvetľovala rozdiely medzi operátormi" || "a" ALEBO ".

Rozdiel je vysvetlený v odkaze na prioritu operátora.

"||" operátory sa vyhodnocujú pred priradením ("="), zatiaľ čo operátory "alebo" sa vyhodnocujú po priradení. Vo vašom druhom príklade hovoríte PHP, aby najprv priradilo výsledok "(choice1! = False?" Hah ":" boo ")" k $ val, potom "alebo" k zvyšku príkazu. Vyskúšajte príklad nižšie a uvidíte, čo tým myslím (všimnite si ďalšie zátvorky na vynútenie priority):

definovať ("výber1", nepravda);
definovať ("výber2", "pes");
definovať ("predvolené1", "iné");
$ val = pole ();

$ val ["Test 1"] = (výber1! = nepravda? "hah": "boo") || (výber2! = nepravda? "hah2": "boo2") || (predvolené1! = nepravda? "hah3": "boo3");
$ val ["Test 1b"] = ((výber1! = nepravda? "hah": "boo") || (výber2! = nepravda? "hah2": "boo2") || (predvolená možnosť1! = nepravda? "hah3 ":" boo3 "));
$ val ["Test 2"] = (výber1! = nepravda? "hah": "boo") alebo (výber2! = nepravda? "hah2": "boo2") alebo (predvolená možnosť1! = nepravda? "hah3": " boo3 ");
$ val ["Test 2b"] = ((výber1! = nepravda? "hah": "boo") alebo (výber2! = nepravda? "hah2": "boo2") alebo (predvolené1! = nepravda? "hah3": "boo3"));

Foreach ($ val ako $ test => $ výsledok) (
vytlačiť ("$ test:"); var_dump ($ výsledok); vytlačiť "
\ n
\ n ";
}
?>

test na hto dot com

Pretože skratka OR pre blok if môže produkovať viac
čitateľný kód s menším písaním, je lákavé vytvárať funkcie, ktoré vrátia FALSE pri zlyhaní alebo nejaký iný dátový typ pri úspechu. Napríklad mysql_connect, ktorý "Vracia identifikátor odkazu MySQL pri úspechu alebo FALSE pri neúspechu."

Začínajúci vývojár php php by sa mal vyhýbať vytváraniu funkcií, ktoré by mohli produkovať FALSE pri zlyhaní a celé číslo pri úspechu, ak existuje nejaká šanca, že celé číslo môže byť nula.

bla bla bla;
$ i = give_me_liberty () or die ("FATAL DB ERROR!");
bla bla bla;
?>

ironmo67 na yahoo dot com

Objavil trochu nepríjemný rozdiel medzi PHP a Perlom:

if (! some_function ()) return false;
?>

nedá sa prepísať na krajšie:

funkcia nejaka_funkcia () (návrat false;)
nejaká_funkcia () alebo návrat false;
?>

Nasledujúce však bude fungovať:

funkcia nejaka_funkcia () (návrat false;)
nejaká_funkcia () alebo zomrieť ();
?>

Uhádnete prečo? Jednoducho, die () je funkcia a "return" je vyhlásenie (ako rozdiel medzi printom () a echom). To je naozaj zlé, pretože verziu if (!) () považujem za unavenú a nečitateľnú, ale hej, je to lepšie, ako keby (some_c_function == 0) (urobte niečo).

Mnohým diskusiám nižšie sa dalo predísť jednoducho tým, že by bolo jasné, že &, | a ^ nie sú * logické operátory. To je dôvod, prečo nie sú uvedené na tejto stránke. Sú to operátory, ktoré pôsobia na binárne čísla. Neberú logické hodnoty (tj "pravda "alebo" nepravda ") ako argumenty bez toho, aby ich najskôr konvertovali na čísla 1 a 0. Nevracajú ani logické hodnoty. hodnoty , ale čísla. Iste, neskôr môžete s týmito číslami zaobchádzať, akoby to boli logické hodnoty (v takom prípade sa 0 pretypuje na „nepravda“ a všetko ostatné sa prehodí na „pravda“), ale to je „dôsledok PHP pravidlá pretypovania a nemajú nič spoločné so správaním operátorov.

Ak chcete logické operácie, použite logické operátory; ak chcete bitové operácie, použite bitové operátory ... použitie jedného pre druhý sa javí ako dobrý spôsob, ako veci sťažiť.

kws_ zavináč hotpop dot com

"Len preto, že môžeš, neznamená, že by si mal."

Tiež mám pocit, že obchádzanie skratového hodnotenia a spoliehanie sa na vedľajšie účinky v podmienených výrazoch je cvičenie zlého štýlu. Písanie kódu, ktorý sa dokumentuje pomocou jasných a priamočiarych konštrukcií, mi pripadá ako oveľa lepšia prax ako používať spletitý a ťažko čitateľný výraz a vysvetľovať ho komentármi (alebo ešte horšie, nezdokumentovať ho vôbec!) Skutočne, zdrojový kód by mal byť napísaný pre oči programátora viac ako pre počítač.

Používanie bitových operátorov v logickom kontexte by mohlo narušiť očakávania čitateľa a môže spôsobiť zmätok, pretože bitové operátory implikujú operandy bitových polí.

Tiež mám pocit, že za predpokladu, že vyhodnotenie skratu je najlepšie pre logické konštrukcie, JE v rámci „práv“ kompilátora, pretože keď sa logické operátory používajú na zamýšľaný účel, predpoklady, že skratovanie robí *SÚ * logické, a robia (opäť pri správnom použití) optimalizovať vyhodnocovanie logických výrazov.

Nie je mojím úmyslom priamo páliť alebo urážať nejakého jednotlivca, ale len odradiť od používania zlého štýlu a povzbudiť nových (a dokonca aj niektorých skúsených) programátorov, aby písali jasný a podrobný kód a mysleli skôr na programátorov ako na počítače, ktoré sa môžu nakoniec pokúsiť rozlúštiť vaše výtvory.

Odpoveď na braintreno:

Druhý príklad, ktorý ste uviedli, je správny spôsob, ako to urobiť! Vôbec to nie je spletitá logika, je to to, čo robí váš kód čitateľným tým, že sa nespolieha na nejasné vedľajšie účinky!! Číta sa oveľa ľahšie ako prvý a oveľa jednoduchšie sa udržiava.

Ak chcete nechať funkciu CheckThisOrOther () ozvať informácie samotnému používateľovi, mali by ste byť zbavení svojej kódovacej licencie. Ak by som niekedy musel udržiavať niektorý z tvojich scenárov, musel by som ťa nenávidieť.

To nie je myslené tak, ako by to mohlo znieť! Zdrojový kód nie je napísaný pre počítače, aby ho spustili, ale pre kóderov na čítanie! Majte to na srdci a vaši spolupracovníci vám za to poďakujú!

braintrino

Príspevok Shadedecho na vynútenie hodnotenia oboch výrazov OR je v skutočnosti presne to, čo by sa malo urobiť na potlačenie optimalizácie skratu.

Existuje veľa príležitostí, kedy nechcete, aby kompilátor skrátil akékoľvek vyhodnotenie, najmä ak chcete urobiť situáciu a/alebo situáciu. Vyhodnotenie skratu vykoná operáciu ALEBO, ale nie operáciu A/ALEBO !!!

Napríklad, ak chcem skontrolovať formulár dopytu používateľa, aby som zistil, či používateľ nezabudol odpovedať na niektorú položku A / ALEBO ak používateľ duplikoval rovnakú odpoveď pre viac ako jednu položku, potom musím formulár odoslať späť na klientovi oznámi, čo chcem opraviť.

Funkcia Niektoré odpovede chýbajú ()
{
...
echo "Ojoj! Neodpovedali ste na niektoré otázky.";
vrátiť TRUE;
}

Funkcia SomeAnswersAreDuplicated ()
{
...
echo "Ojoj! Môžete odpovedať obom rovnakým spôsobom.";
vrátiť TRUE;
}

Ak (niektoré odpovede chýbajú () || niektoré odpovede sú duplikované ())
SendFormAgain ();

Ak to urobím, používateľovi sa zobrazí iba upozornenie na chýbajúcu odpoveď, ale nie upozornenie na duplicitnú odpoveď, aj keď sú obe pravdivé. Toto nie je informatívne pre používateľa, pretože bude musieť znova odoslať formulár dvakrát, kým si uvedomí, čo všetko urobil zle, a zmariť ich hacknutie. To nie je užívateľsky prívetivé.

Ak (niektoré odpovede chýbajú () | niektoré odpovede sú duplikované ())
SendFormAgain ();

Potom sa obe varovné správy odošlú súčasne a používateľ to môže opraviť jedným opätovným odoslaním.

Ďakujem shadedecho, hľadal som spôsob, ako prepísať hlúpu optimalizáciu skratu kompilátora. Počítač nemôže len predpokladať, že skrat je najlepší :(

BTW, samozrejme, že môžete:

$ you_made_a_mistake = nepravda;

Ak (someAnswersAreMissing ())

if (SomeAnswersAreDuplicated ())
$ you_made_a_mistake = pravda;

Ak ($ you_made_a_mistake)
SendFormAgain ();

Ale to je spletitá logika!!!

hop

Vážený nováčik,

(keďže „nevidím, že by sa v mysliach skúsených programátorov vkrádali takéto nápady...)

Prosím, nedávajte pozor na príspevok shadedecho zo 14. marca 2003 04:02! Vo veľkej miere sa spolieha na nejasné vedľajšie účinky, čo je nielen veľmi zlá programátorská prax, ale tiež nedosahuje optimalizáciu, ktorú si myslí.

Správny spôsob, ako to urobiť

echo $ a;
}

Práca, ako chce shadedecho, je (hoci príklad ako celok je dosť nevhodný):

$ a. = bla ();
$ a. = blah2 ();

Ak ($ a) (echo $ a;)

Ak si prečítate diskusiu, na ktorú odkazuje, zistíte, že skutočne chcel získať všetky odlišné položky z dvoch rôznych tabuliek db. Aj tam sa mýli. Správny spôsob, ako to urobiť, je spracovať prvú tabuľku a potom spracovať druhú tabuľku.
Nielenže je to oveľa čitateľnejšie ako obídenie s „|“, ale nie je ani najmenej pomalšie.

shadedecho

Zdá sa (po dlhom frustrujúcom, ale v konečnom dôsledku užitočnom vyhľadávaní a diskusiách na fórach, ako sú tek-tips), že
|| a && sú "skratované", ako už bolo uvedené, ALE | Operátory a & (dokumentované PHP ako bitové operátory) sa správajú ako ich neskratované náprotivky.

Funkcia bla () (
echo "ahoj< br>";
návrat "z bla ()< br>";
}

Funkcia bla2 () (
echo "svet \< br>";
návrat "z bla2 ()< br>";
}

Ak (($ a. = Blah ()) || ($ a. = Blah2 ())) (
echo $ a;
}

Výsledkom by bol nasledujúci výstup:

Ahoj
od bla ()

Všimnite si, že „svet“ „nedostal ozvenu“ d a „od blah2 ()“ „nedostal concat“ d do premennej $ a, pretože prvé priradenie k $ a bolo úspešné, takže „skrat“ spustí sa a booleovský test sa ukončí bez vyhodnotenia zvyšku.

VŠAK, ak nahradíte || len s | v tomto príkaze "if" dostanete výstup:

Ahoj
sveta
od bla ()
od bla2 ()

Eureka! všetky časti boolovského testu sa vyhodnocujú očakávaným spôsobom zľava doprava a podľa všetkých bežných pravidiel prednostnosti, pokiaľ vidím.

To dáva úplný zmysel... Pri použití bitových operátorov dochádza k operácii na úrovni bitov s výsledkom dvoch nebitových operácií (priradení). Ak nebitová operácia vráti hodnotu null (inými slovami, priradená hodnota sa ukáže ako nula alebo 0), bitový operátor by sa na ňu naviazal (alebo vhodnejšie by ju „videl“) ako „0“, inak by videl nenulovú hodnotu (reťazec bitov s aspoň jednou "1").

Potom trochu | sa vykonáva na dvoch hodnotách, a ak je niektorá z nich nenulová (má v sebe bity "1"), výsledok bude mať tieto bity "1" (nenulové) a príkaz if bude interpretovať všetky nenulové bity. nulová hodnota ako pravdivá v boolovskom teste. Podobne, ak oba operandy k | boli null alebo 0, výsledkom by bola nulová hodnota, ktorá by sa „ak“ interpretovala ako nepravda.

Vyššie uvedený príkaz if robí bitový | na (v tomto prípade) dvoch nenulových hodnotách (s "1" s na bitovej úrovni), takže | operácia vráti nenulovú hodnotu, ktorá je potom reinterpretovaná príkazom if ako TRUE!

Takže v tomto špeciálnom prípade, keď sa pokúšate spojiť neskratované booleovské testy, tieto operátory pracujú na svojich operandoch na bitovej úrovni, a keďže nejde o porovnávacie operátory, ale o matematické operátory, nemôžu byť krátke. zapojené do obvodu a výsledné správanie je neskratovaný „booleovský test“.

Viem, musíte si myslieť, že som blázon, keď sa snažím obísť vstavanú optimalizáciu, ako je táto, ale uisťujem vás, že to má veľmi dobrý dôvod, a ak vás to zaujíma, môžete si pozrieť toto vlákno ako ja veľmi dlhý príspevok, ktorý vysvetľuje, čo som sa snažil urobiť:

Je to 9. príspevok nižšie, kde nájdete môj popis môjho databázového dotazu, ktorý som chcel optimalizovať.

Čo pravdepodobne nie je to, čo chcete.

To môže pomôcť tým, ktorí chcú, aby sa ich kód čítal ako angličtina, a mohli by si myslieť, že rozdiely v prioritách týchto operátorov sú relatívne exotické: nie sú „t.

Pokiaľ ide o mňa, narazil som na tento problém, pretože neexistuje žiadny symbolický logický XOR (napríklad nie ^^), takže som musel použiť XOR a potom som prišiel na to, že na podobných miestach by som mal použiť AND a OR a potom môj kód sa pokazil :)

Tak teraz už musím
$ a = ($ b x alebo $ c);

Jesse Thompson
bend.com

yohgaki zavináč hotmail bodka com

V PHP4 "and", "alebo", "&&", "||" - všetky sú "skrat" ako v C / C ++. V PHP3 si myslím, že to tak nebolo.

„Skrat“ znamená, že jazyk zastaví vyhodnocovanie výrazu, keď sú určené podmienky. (Väčšina jazykov používa vyhodnotenie skratu pre logickú podmienku)

$ a = pravda;
$ b = nepravda;
ak ($ ​​a || $ b) (
}

Tento príkaz "if" vyhodnotí iba $ a, pretože $ a je pravdivý a celá podmienka musí byť pravdivá. (t. j. ak $ b je funkcia namiesto hodnoty, funkcia sa nezavolá)

muerte na web-ster dot com

Dúfal som, že nájdem operátor podobný funkciám || = v perle. Moja prvá myšlienka by bola:

$ i = $ i alebo "predvolené"

Ale alebo to „takto nefunguje. Ak chcete svojim premenným priradiť predvolenú hodnotu, iba ak ešte nie sú priradené, MÔŽETE však urobiť:

$ i alebo $ i = "predvolené"

Prvý príklad NEFUNGUJE, pretože operátor alebo nie je preťažený, ako je to v Perle.

dante v Heame dot com

Chcel som urobiť niečo takéto:

$ voľba1 = "";
$ choice2 = "pes";
$ default = "iné";
$ val = $ výber1 || $ výber2 || $ predvolená;

Ale potom $ val1 bude obsahovať iba 1 alebo 0. Namiesto toho som urobil toto:

$ voľba1 = "";
$ choice2 = "pes";
$ default = "iné";
$ val = $ choice1 alebo $ choice2 alebo $ predvolené;

Teraz $ val obsahoval reťazec "pes". To "s
divné, že "alebo" sa líši od "||" ... a ja by som to urobil
myslím, že "||" by mal byť dosť chytrý, aby to zvládl
struny ... ako to robí PERL. Asi nie. Možno to "s
výber dizajnu.