Huling na-update: 11/1/2015
Sa PHP maaari tayong gumamit ng iba't ibang mga operator: aritmetika, lohikal, atbp. Tingnan natin ang bawat uri ng operasyon.
Mga operasyon sa aritmetika
+ (pagdaragdag ng operasyon)
Halimbawa, $a + 5
- (pagpapatakbo ng pagbabawas)
Halimbawa, $a - 5
* (pagpaparami)
Halimbawa, $a * 5
/ (dibisyon)
Halimbawa, $a / 5
% (pagkuha ng natitirang bahagi)
Halimbawa: $a=12; echo $a % 5; // katumbas ng 2
++ (pagtaas/pagtaas ng halaga ng isa)
Halimbawa, ++$a
Mahalagang maunawaan ang pagkakaiba sa pagitan ng mga expression na ++$a at $a++ . Halimbawa:
$a=12; $b=++$a; // $b ay katumbas ng 13 echo $b;
Dito, una, ang isa ay idinaragdag sa halaga ng variable na $a, at pagkatapos ay itinutumbas ang halaga nito sa variable na $b. Magiging iba kung ganito ang ekspresyon: $b=$a++; . Dito, una ang halaga ng variable na $a ay katumbas ng variable na $b, at pagkatapos ay ang halaga ng variable na $a ay nadagdagan.
-- (bawas/bawas halaga ng isa)
Halimbawa, --$a . At gayundin, tulad ng sa kaso ng pagtaas, mayroong dalawang uri ng pag-record: --$a at $a--
Mga Operator ng Pagtatalaga
Tinutumbas ang isang variable sa isang partikular na halaga: $a = 5
Pagdaragdag na sinusundan ng pagtatalaga ng resulta. Halimbawa: $a=12; $a += 5; echo $a; // katumbas ng 17
Pagbabawas na sinusundan ng pagtatalaga ng resulta. Halimbawa: $a=12; $a -= 5; echo $a; // katumbas ng 7
Multiplikasyon na sinusundan ng pagtatalaga ng resulta: $a=12; $a *= 5; echo $a; // katumbas ng 60
Dibisyon na sinusundan ng pagtatalaga ng resulta: $a=12; $a /= 5; echo $a; // katumbas ng 2.4
Pagsamahin ang mga hilera at italaga ang resulta. Nalalapat sa dalawang linya. Kung ang mga variable ay hindi nag-iimbak ng mga string, ngunit, halimbawa, mga numero, ang kanilang mga halaga ay na-convert sa mga string at pagkatapos ay ang operasyon ay ginanap: $a=12; $a .= 5; echo $a; // katumbas ng 125 // kapareho ng $b="12"; $b .="5"; // katumbas ng 125
Pagkuha ng natitirang bahagi at pagkatapos ay italaga ang resulta: $a=12; $a %= 5; echo $a; // katumbas ng 2
Mga Pagpapatakbo ng Paghahambing
Ang mga pagpapatakbo ng paghahambing ay karaniwang ginagamit sa mga kondisyong istruktura kapag kinakailangan upang ihambing ang dalawang halaga at, depende sa resulta ng paghahambing, magsagawa ng ilang mga aksyon. Ang mga sumusunod na operasyon sa paghahambing ay magagamit.
Ang operator ng pagkakapantay-pantay ay naghahambing ng dalawang halaga, at kung magkapareho ang mga ito, magbabalik ng true, kung hindi ay magbabalik ng false: $a == 5
Ang operator ng pagkakakilanlan ay naghahambing din ng dalawang halaga, at kung magkapareho ang mga ito, magbabalik ng true, kung hindi, magbabalik ng false: $a === 5
Naghahambing ng dalawang value, at kung hindi magkapantay ang mga ito, nagbabalik ng true, kung hindi, nagbabalik ng false: $a != 5
Naghahambing ng dalawang value, at kung hindi sila magkapantay, nagbabalik ng true, kung hindi ay nagbabalik ng false: $a !== 5
Naghahambing ng dalawang halaga, at kung ang una ay mas malaki kaysa sa pangalawa, pagkatapos ay nagbabalik ng true, kung hindi ay nagbabalik ng false: $a > 5
Naghahambing ng dalawang halaga, at kung ang una ay mas mababa sa pangalawa, pagkatapos ay nagbabalik ng true, kung hindi ay nagbabalik ng false: $a< 5
Naghahambing ng dalawang halaga, at kung ang una ay mas malaki kaysa o katumbas ng pangalawa, pagkatapos ay ibabalik ang true, kung hindi, ibabalik ang false: $a >= 5
Naghahambing ng dalawang halaga, at kung ang una ay mas mababa sa o katumbas ng pangalawa, pagkatapos ay nagbabalik ng true, kung hindi ay nagbabalik ng false: $a<= 5
Operator ng pagkakapantay-pantay at pagkakakilanlan
Ang parehong operator ay naghahambing ng dalawang expression at nagbabalik ng true kung ang mga expression ay pantay. Ngunit may mga pagkakaiba sa pagitan nila. Kung ang operasyon ng pagkakapantay-pantay ay tumatagal ng dalawang halaga ng iba't ibang uri, kung gayon ang mga ito ay nabawasan sa isa - ang isa na nahanap ng interpreter na pinakamainam. Halimbawa:
Malinaw, ang mga variable ay nag-iimbak ng iba't ibang mga halaga ng iba't ibang uri. Ngunit kapag inihambing, sila ay mababawasan sa parehong uri - numeric. At ang variable na $a ay mababawasan sa bilang na 22. At sa huli, ang parehong mga variable ay magiging pantay.
O, halimbawa, ang mga sumusunod na variable ay magiging pantay din:
$a = mali; $b = 0;
Upang maiwasan ang mga ganitong sitwasyon, ginagamit ang equivalence operation, na isinasaalang-alang hindi lamang ang halaga, kundi pati na rin ang uri ng variable:
$a = "22a"; $b = 22; if($a===$b) echo "equal"; iba echo "hindi katumbas";
Ngayon ang mga variable ay hindi magiging pantay.
Ang mga operator ng hindi pagkakapantay-pantay != at !== ay gumagana nang katulad.
Mga lohikal na operasyon
Ang mga lohikal na operasyon ay karaniwang ginagamit upang pagsamahin ang mga resulta ng dalawang paghahambing na operasyon. Halimbawa, kailangan nating magsagawa ng isang partikular na pagkilos kung maraming kundisyon ang totoo. Ang mga sumusunod na lohikal na operasyon ay magagamit:
Nagbabalik ng true kung ang parehong pagpapatakbo ng paghahambing ay nagbabalik ng true, kung hindi ay nagbabalik ng false: $a == 5 && $b = 6
Katulad ng && operation: $a == 5 at $b > 6
Nagbabalik ng true kung magbabalik ng true ang kahit isang operasyon sa paghahambing, kung hindi, magbabalik ng false: $a == 5 || $b = 6
Katulad ng operasyon || : $a< 5 or $b > 6
Nagbabalik ng true kung ang operasyon ng paghahambing ay nagbabalik ng false: !($a >= 5)
Nagbabalik ng true kung isa lang sa mga value ang totoo. Kung pareho ang totoo o alinman ay hindi totoo, nagbabalik ng mali. Halimbawa: $a=12; $b=6; if($a xor $b) echo "totoo"; iba echo "false";
Dito ang resulta ng lohikal na operasyon ay magiging mali dahil ang parehong mga variable ay may isang tiyak na halaga. Baguhin natin ang code:
$a=12; $b=NULL; if($a xor $b) echo "totoo"; iba echo "false";
Dito magiging totoo na ang resulta, dahil hindi nakatakda ang halaga ng isang variable. Kung ang isang variable ay may halagang NULL, kung gayon sa mga lohikal na operasyon ang halaga nito ay ituturing na hindi totoo
Mga pagpapatakbo ng bit
Ang mga bit operation ay ginagawa sa mga indibidwal na bit ng isang numero. Ang mga numero ay isinasaalang-alang sa binary na representasyon, halimbawa, 2 sa binary na representasyon ay 010, ang numero 7 ay 111.
& (lohikal na pagpaparami)
Ang multiplikasyon ay ginagawa nang bitwise, at kung ang parehong mga operand ay may mga bit na halaga na katumbas ng 1, ang operasyon ay nagbabalik ng 1, kung hindi, ang bilang na 0 ay ibinalik Halimbawa: $a1 = 4; //100 $b1 = 5; //101 echo $a1 & $b1; // katumbas ng 4
Narito ang numero 4 sa binary system ay 100, at ang numero 5 ay 101. I-multiply ang mga numero nang bitwise at makakuha ng (1*1, 0*0, 0 *1) = 100, iyon ay, ang numero 4 sa decimal na format.
| (lohikal na karagdagan)
Katulad ng lohikal na pagpaparami, ang operasyon ay ginagawa din sa mga binary digit, ngunit ngayon ay ibinabalik ang isa kung kahit isang numero sa isang naibigay na digit ay may isa. Halimbawa: $a1 = 4; //100 $b1 = 5; //101 echo $a1 | $b1; // katumbas ng 5
~ (lohikal na pagtanggi)
binabaligtad ang lahat ng mga bit: kung ang halaga ng bit ay 1, ito ay magiging zero, at kabaliktaran. $b = 5; echo ~$b;
x< x>>y - inililipat ang numerong x sa kanan sa pamamagitan ng y digit. Halimbawa, ang 16>>1 ay nagbabago ng 16 (na 10000 sa binary) isang lugar sa kanan, na nagreresulta sa 1000 o 8 sa decimal
Pinagsasama-samang Strings
Ang dot operator ay ginagamit upang pagdugtungin ang mga string. Halimbawa, ikonekta natin ang ilang linya:
$a="Hello,"; $b=" mundo"; echo $a . $b . "!";
Kung ang mga variable ay kumakatawan sa iba pang mga uri kaysa sa mga string, tulad ng mga numero, ang kanilang mga halaga ay na-convert sa mga string at pagkatapos ay ang string concatenation operasyon ay nangyayari din.
Ang pangunahing bagay sa pagkilos ng operator na ito ay ang kondisyon. kung isinalin mula sa Ingles ay nangangahulugan Kung. Ang kundisyon ay tinatanggap bilang argumento (kung ano ang nasa panaklong). Ang kundisyon ay maaaring isang lohikal na pagpapahayag o isang lohikal na variable. Sa madaling salita, ang kahulugan ng expression ay ito:
Kung (kondisyon)(
natupad ang kundisyon, gawin mo ito
}
iba pa
{
ang kundisyon ay hindi natutugunan, gawin itong iba
}
Sana malinaw ang logic ng conditional operation. Ngayon tingnan natin ang isang halimbawa.
$a = 5;
$b = 25;
// Ngayon pansin! Kundisyon: Kung ang $b ay mas malaki kaysa sa $a
// Mga palatandaan > at< , как и в математике, обозначают больше и меньше
kung($b > $a)
{
// kung ang kundisyon ay natugunan, pagkatapos ay gawin ang pagkilos na ito
echo "Ang $b ay mas malaki kaysa sa $a";
}
iba pa
{
// kung hindi naisakatuparan, ito na
echo "Ang $a ay mas malaki kaysa o katumbas ng $b";
}
?>
Pagpapakita Mag-download ng mga mapagkukunan
Bilang resulta, maglalabas ang script 25 higit sa 5. Ang halimbawa ay medyo simple. Sana malinaw na ang lahat. Ngayon iminumungkahi kong isaalang-alang ang isang mas kumplikadong sitwasyon, kung saan maraming mga kundisyon ang dapat matugunan. Ang bawat bagong kundisyon ay maglalaman pagkatapos ng pangunahing kundisyon kung()- pantulong, na nakasulat bilang iba kung(). Sa huli ito ay magiging gaya ng dati iba pa.
Gawain: Ang pagsusulit ay isinasagawa sa paaralan. Kailangang kalkulahin ng script ang marka, alam ang mga kondisyon para sa pagkuha ng bawat grado at ang marka ng mag-aaral mismo. Tingnan natin kung paano isulat ito, at huwag kalimutang basahin ang komentaryo.
$test = 82; // sabihin natin na sumulat ang isang estudyante ng pagsusulit na may 82 puntos
// isulat ang unang kundisyon para sa lima
if($test > 90)
{
// kung ang kundisyon ay natugunan, pagkatapos ay gawin ang pagkilos na ito.
echo "Rating 5";
}
// Ang && sign ay nangangahulugang "at, unyon", na ang kundisyon ay natutugunan kung pareho ang totoo
// iyon ay, ang marka ay mas mababa sa 91 at higit sa 80, pagkatapos ay 4. Kung hindi, ang mga kondisyon ay babasahin pa
iba pa kung ($test< 91 && $test > 80)
{
echo "Rating 4";
}
iba pa kung ($test< 81 && $test > 70)
{
echo "Rating 3";
}
iba pa
{
echo "Dapat nating isulat muli ang pagsubok...";
}
?>
Pagpapakita Mag-download ng mga mapagkukunan
Ang aming mag-aaral na may oras upang magpahinga at magsulat ng isang normal na pagsusulit ay tumatanggap rating 4! Sana malinaw ang prinsipyo ng operasyon.
Posible ring maitala sa madaling sabi ang pagpapatakbo ng isang kondisyong operasyon, kapag kailangan mo lamang ng aksyon kung ang kundisyon ay natutugunan.
$edad = 19; // variable na may edad
Kung ($edad > 17)(
echo "Ayan! Kaya kong gawin ang lahat ng gusto ko! $age na ako!";
}
Isang magandang halimbawa ng isang maikling notasyon ng isang kondisyong operasyon. iba pa hindi kailangan magsulat.
Mga Operator ng Paghahambing sa PHP
Ang prinsipyo ng pagpapatakbo ng isang kondisyong operasyon ay malinaw. Ngunit, gaya ng naiintindihan mo, marami pang paraan upang ihambing. Tingnan natin ang talahanayan sa ibaba na may mga operator ng paghahambing.Halimbawang Pangalan ng Resulta
$a == $b Katumbas ng Tama kung $a katumbas ng $b
$a === $b Magkapareho sa True kung ang $a ay katumbas ng $b at ang parehong mga variable ay pareho ang uri
$a != $b Hindi katumbas ng Tama kung ang $a ay hindi katumbas ng $b
$a === $b Hindi kapareho ng True kung ang $a ay hindi katumbas ng $b at ang parehong uri ay hindi pareho
$a > $b Higit sa True kung ang $a ay mas malaki sa $b
$a< $b Меньше чем True, если $a меньше, чем $b
$a >= $b Higit sa o katumbas ng True kung ang $a ay mas malaki sa o katumbas ng $b
$a<= $b Меньше или равно True, если $a меньше или равно $b
Ngayon tingnan natin ang mga operator na may mga halimbawa:
// salungat sa ugali = ay nangangahulugan ng pagtatalaga ng halaga sa isang variable, at == ay pantay
kung ($a == 5)(
echo "Ang $a ay 5"; // ay magpi-print ng "5 ay katumbas ng 5"
) iba (
echo "Ang $a ay hindi katumbas ng 5";
}
Kung ($a != 6)(
echo "Ang $a ay hindi katumbas ng 6"; // ay magpi-print ng "5 ay hindi katumbas ng 6". Kailangan sa kaso ng pagtanggi
) iba (
echo "$a kahit papaano ay katumbas ng 6";
}
// sa parami nang parami sa tingin ko ay malinaw na ang lahat. Samakatuwid ang halimbawa ay mas kumplikado
kung ($a<= 6){
echo "Ang $a ay mas mababa sa o katumbas ng 6"; // ay magpi-print ng "5 ay mas mababa sa o katumbas ng 6"
) iba (
echo "Ang $a ay mas malaki sa 6";
}
Mga Logical Operator ng PHP
May mga pagkakataon na kailangan mong ihambing hindi isang variable, ngunit dalawa o higit pa nang sabay-sabay sa isang kundisyon. Para dito mayroong mga lohikal na operator.Halimbawang Pangalan ng Resulta
$a at $b Lohikal na "at" TRUE kung pareho ang $a at $b ay TAMA.
$a o $b Lohikal na "o" TRUE kung alinman sa $a o $b ay TAMA.
$a xor $b Eksklusibo "o" TRUE kung ang $a o $b ay TAMA, ngunit hindi pareho.
! $a Negasyon ng TRUE kung $a ay hindi TOTOO.
$a && $b Lohikal na "at" TAMA kung ang parehong $a at $b ay TAMA.
$a || $b Boolean "o" TRUE kung alinman sa $a o $b ay TRUE.
Napansin na natin yan for operations At At o may mga karagdagang operator ba? Ginagawa ito upang bigyang-priyoridad ang mga kumplikadong pagpapatakbo ng paghahambing. Sa talahanayan, ang mga lohikal na operator ay nakalista sa pagkakasunud-sunod ng priyoridad: mula sa pinakamaliit hanggang sa pinakamalaki, iyon ay, halimbawa, || ay may mas mataas na priyoridad kaysa sa o.
Mag-move on na tayo sa mga halimbawa
$a = 5;
$b = 6;
$c = 7;
// kundisyon: Kung ang 5 ay hindi katumbas ng 6 (TRUE) AT ang 6 ay hindi katumbas ng 7 (TRUE)
kung ($a< 6 && $b != $c){
echo "Talaga!"; // ay magpi-print ng "Talagang gayon!" kasi TOTOO ang parehong kundisyon
) iba (
echo "Ang isa sa mga kundisyon ay hindi totoo";
}
// kundisyon: Kung ang 6 ay hindi katumbas ng 6 (FALSE) O 6 ay hindi katumbas ng 7 (TRUE)
kung ($b != 6 || $b != $c)(
echo "Ayan na!"; // ay magpapakita ng "Iyon na!", dahil kahit ISA sa mga kundisyon ay TOTOO
) iba (
echo "Ang parehong kundisyon ay mali";
}
Operator ng Ternary
Iminumungkahi kong bumalik ka sa isyu ng ternary code sa ibang pagkakataon. Hindi ko maiwasang banggitin ito, dahil isa itong mahalagang disenyo na makabuluhang binabawasan ang laki ng code. Iminumungkahi kong tingnan mo kaagad ang code.Ang diwa ng code:(kundisyon) ? ang halaga ng a kung totoo: ang halaga ng a kung mali
Kaya, pinaikli namin ang pahayag na kung. Gayunpaman, ang operasyong ito ay may bisa lamang kapag nagtatalaga ng mga halaga sa isang variable. Ngayon tingnan natin ang isang tapos na halimbawa.
// Halimbawa ng paggamit ng ternary operator
$settings = (walang laman ($_POST["setting"])) ? "Default" : $_POST["setting"];
// Ang code sa itaas ay katulad ng sumusunod na block gamit ang if/else
kung (walang laman ($_POST["mga setting"])) (
$settings = "Default"; // Kung walang ililipat, pagkatapos ay iwanan ito bilang "Default"
) iba (
$settings = $_POST["setting"]; // Kung naipasa, itatalaga sa $settings ang naipasa na halaga.
}
?>
Basahin ang mga komento sa code at dapat na malinaw ang lahat.
Salamat sa iyong atensyon!
Sinusuportahan ng PHP ang sumusunod na pamantayan mga lohikal na operator: "AT" at "&&" (lohikal na AT), "OR" at "||" (lohikal O), "!" (lohikal na HINDI) at "XOR" (eksklusibo O). Ang lahat ng mga ito ay ginagamit sa mga lohikal na expression upang matukoy ang isa o isa pang kurso ng pagpapatupad ng programa depende sa resulta na ibinalik ng expression at nauugnay sa mga binary operator, maliban sa operator na "!" , na unary. Kapag gumagamit ng mga lohikal na operator, ang kanilang mga operand ay na-convert sa Boolean data type (), at ang resulta ay depende sa ibinigay na mga lohikal na halaga ng mga operand at ang uri ng logical operator (tingnan ang talahanayan No. 1).
Talahanayan Blg. 1. Mga lohikal na operator
Pagkakaiba sa pagitan ng "AT" at "&&" na mga operator, at "OR" at "||" ay ang "AND" , "OR" at "XOR" na mga operator ay may mas mababang precedence, na mas mababa pa sa mga assignment operator (tingnan ang PHP operator table).
Mahalagang maunawaan kung paano pinoproseso ng interpreter ang mga Boolean expression. Kung sa isang expression na may operator na "||" ang unang (kaliwang) operand ay magkakaroon ng value na true o sa isang expression na may "&&" na operator ang unang operand ay magkakaroon ng value na false , pagkatapos ay ang pangalawang (kanan) na operand ay hindi na kakalkulahin. Ito ay dahil sa ang katunayan na ang huling resulta sa mga ganitong kaso ay hindi magbabago (tingnan ang talahanayan No. 1), at samakatuwid ay hindi na kailangang gumastos ng oras sa pagproseso ng code ng pangalawang operand. Gayunpaman, kailangan mong mag-ingat na huwag maglagay ng code sa tamang operand kung saan maaaring nakasalalay ang tamang operasyon ng programa.
Ang paggamit ng mga lohikal na operator ay ipinapakita sa halimbawa No. 2.
false $a=0||false; //Ngayon $a==totoo, kasi 5->true at 8->true $a=5& //Ngayon $a==false, dahil "0"->false $a="0"& //Ngayon $a==true $a=!false; //Ngayon $a==false, kasi 5->totoo $a=!5; /* Ang function na foo() ay hindi tatawagin dahil sa shunt */ $a=(false&&foo()); $b=(totoo||foo()); $c=(false at foo()); $d=(totoo o foo()); /* Pagkakaiba "||" mula sa "o" at "&&" mula sa "at" */ //Gumawa tulad ng ($a=(false||true)) $a=false||true; //Acts tulad ng (($a=false) o true) $a=false o true; //Acts like ($a=(false&&true)) $a=false& //Acts like (($a=false) at true) $a=false at true; //Ngayon $a==5, kumikilos tulad ng (($a=5) xor 0) $a=5 xor 0; //Ngayon $a==5, kumikilos tulad ng (($a=5) at 0) $a=5 at 0; //Ngayon $a==5, kumikilos tulad ng (($a=5) o 0) $a=5 o 0; //Ngayon $a==true, kumikilos tulad ng ($a=(5||0)) $a=5||0; //Now $a==false, acts like ($a=(5&&0)) $a=5& //Now $a==true, acts like ($a=(5 xor 6)) $a=(5 xor 6); ?>
Halimbawa Blg. 2. Gamit ang mga Boolean Operator
Kaya, alam na natin kung paano mag-execute ng code na nakakatugon sa isang partikular na kundisyon. Ngunit hanggang sa sandaling ito maaari lamang magkaroon ng isang kondisyon. Paano kung ang code ay dapat isagawa kung maraming mga kundisyon ang natutugunan nang sabay-sabay?
Upang malutas ang problemang ito, mayroong mga lohikal na operator:
= 5 && $presyo<= 10) echo "Это число находится между 5 и 10"; ?>
Ang && operator, tinatawag din lohikal AT, kino-convert ang mga halaga sa kaliwa at kanan sa isang uri ng Boolean, at pagkatapos ay nagbabalik mismo ng isang Boolean na halaga: true kung ang kaliwa at kanan ay totoo, o mali kung ang isa sa mga kundisyon ay mali.
Sa madaling salita, kung ang parehong mga kundisyon ay totoo, ang && operator ay nagbabalik ng totoo. Ito ang sinasalamin ng pangalan ng operator.
Operator || o lohikal O nagbabalik ng true kapag totoo ang kahit isa sa dalawang kundisyon:
5 || 1 > 2) echo "Ang kundisyon ay natutugunan."; ?>
Sa code sa itaas, ang echo command ay isasagawa dahil ang isa sa mga kundisyon ay totoo.
Lahat ng lohikal na operator sa PHP
Sa pagitan ng && at at mga operator, gayundin sa pagitan ng || at o may kaunting pagkakaiba - ang pagkakasunud-sunod ng pagpapatupad.
Tulad ng alam mo, ang pagpaparami ay may mas mataas na priyoridad kaysa sa pagdaragdag. Kaya, ang at at o mga operator ay may mas mababang priyoridad kaysa sa assignment operator =. Ang resulta ay makikita sa sumusunod na halimbawa:
Kakaiba, tama? Dahil ang y = ay may mas mataas na priyoridad, bibigyang-kahulugan ng PHP ang code tulad nito:
($var = true) at mali;
Yung. itinatakda muna nito ang $var sa true at pagkatapos ay gagawa ito ng true at false na operasyon, na walang kabuluhan dahil hindi ito nakakaapekto sa halaga ng variable.
Nasa ibaba ang isang talahanayan na may mga priyoridad ng operator. Nakilala mo na ang ilan sa kanila. Kung mas mataas ang operator sa talahanayan, mas mataas ang priyoridad nito.
- ++ -- ~ (int) (float) (string) (array) (object) (bool) @
- * / %
- + - .
- < <= > >=
- == != === !== <> <=>
- ? : (ternary operator)
- = += -= *= **= /= .= %= &= |= ^= <<= >>=
Ngayon ay matutukoy na natin na ang precedence ng mga operator ng paghahambing (==, !=, atbp.) ay mas mataas kaysa sa mga lohikal na operator. Ang impormasyong ito ay magiging kapaki-pakinabang sa amin upang makumpleto ang gawain.
Sinusuportahan ng PHP ang karaniwang mga lohikal na operator AND at && , OR at || , ! (hindi) at XOR . Binibigyang-daan ka ng mga lohikal na operator na ihambing ang mga resulta ng dalawang operand (isang value o isang expression) upang matukoy kung ang isa o pareho ay nagbabalik ng totoo o mali at piliin kung ipagpapatuloy ang pagpapatupad ng script nang naaayon batay sa ibinalik na halaga. Tulad ng mga operator ng paghahambing, ang mga lohikal na operator ay nagbabalik ng isang Boolean na halaga - totoo o mali, depende sa mga halaga sa magkabilang panig ng operator.
Lohikal O (O at ||)
Ang lohikal na OR operator ay tinutukoy bilang OR o || . Nagsasagawa ito ng lohikal na OR na operasyon sa dalawang operand. Kung ang isa o parehong operand ay totoo, ito ay nagbabalik ng totoo. Kung ang parehong operand ay false, ito ay nagbabalik ng false. Marahil ay may tanong ka: bakit gumawa sila ng dalawang bersyon ng isang operator? Ang punto ng dalawang magkaibang variant ng lohikal na OR operator ay gumagana ang mga ito na may magkaibang priyoridad.
Una, tingnan natin kung paano gumagana ang ||. . At kaya, kung ang isa o pareho sa mga operand nito ay totoo, ito ay nagbabalik ng true . Kung ang parehong mga operand ay nagbabalik ng mga maling halaga, ito ay magbabalik ng false .
Gumagana ang operator ng OR sa ||. na may isang pagbubukod, kung ang operator ng OR ay ginamit sa isang pagtatalaga, susuriin muna nito at ibabalik ang halaga ng kaliwang operand, kung hindi, ito ay gumagana nang eksakto sa || operator. , ibig sabihin. kung ang isa o pareho sa mga operand nito ay totoo, ito ay nagbabalik ng totoo. Kung ang parehong operand ay nagbabalik ng false, ito ay magbabalik ng false .
Upang gawing mas malinaw kung paano gumagana ang mga ito, narito ang sumusunod na halimbawa:
1 // Una ang variable ay itinalaga ang value na false, at pagkatapos ay sinusuri ang pangalawang operand // Priority action: ($var2 = false) o true $var2 = false o true; echo $var2; // false ay hindi naka-print // ($var3 = 0) o 3 $var3 = 0 o 3; echo"
$var3"; // => 0 ?>
Ang anumang paghahambing at lohikal na mga operator ay maaaring pagsamahin sa mas kumplikadong mga istruktura:
May isa pang mahalagang punto na dapat banggitin tungkol sa parehong OR at ||. . Sinisimulan ng lohikal na OR operator ang mga kalkulasyon nito sa kaliwang operand nito, kung ito ay nagbabalik ng true, ang tamang operand ay hindi susuriin. Makakatipid ito ng oras ng pagpapatupad, ngunit kailangang mag-ingat upang matiyak na ang code kung saan maaaring nakasalalay ang tamang operasyon ng programa ay hindi nakalagay sa kanang kamay na operand.
Lohikal na AT (AT at &&)
Ang lohikal na AND operator ay tinutukoy bilang AND o && . Nagsasagawa ito ng lohikal na AT operasyon sa dalawang operand. Nagbabalik ito ng true kung at kung ang parehong mga operand ay magsusuri sa true . Kung ang isa o parehong operand ay nagbalik ng false , ang operator ay nagbabalik ng false . Ang kahulugan ng dalawang magkaibang bersyon ng lohikal na AND operator ay kapareho ng dalawang naunang operator, ibig sabihin, na gumagana ang mga ito sa magkaibang priyoridad.
Una, tingnan natin kung paano gumagana ang && operator. At kaya, kung ang parehong mga operand nito ay totoo, ito ay nagbabalik ng true . Kung hindi bababa sa isa o pareho sa mga operand nito ang nagbalik ng false , ito ay magbabalik din ng false .
Gumagana ang operator ng AND katulad ng operator na && na may isang pagbubukod, kung ang operator ng AND ay ginamit sa isang pagtatalaga, susuriin at ibabalik muna nito ang halaga ng kaliwang operand, kung hindi, ito ay gumagana nang eksakto katulad ng && operator. Kung hindi bababa sa isa sa mga operand nito ang nagbalik ng false, ito rin ay magbabalik ng false, at kung ang parehong operand ay nagbabalik ng false, ito ay magbabalik ng false.
Upang maunawaan, tingnan natin ngayon kung paano ito gumagana sa pagsasanay:
$bar3"; // => 9 ?>
Eksklusibo O (XOR)
Ang eksklusibong OR operator ay tinutukoy bilang XOR. Nagbabalik ito ng totoo kung isa at isa lamang sa mga operand nito ang totoo. Kung ang parehong mga operand ay totoo, ang operator ay magbabalik ng mali.
Dahil ang XOR operator ay may parehong precedence gaya ng AND at OR operator (mas mababa kaysa sa assignment operator), at ito ay ginagamit sa isang assignment expression, sinusuri at ibinabalik muna nito ang halaga ng kaliwang operand.
6 $a1 = 19 xor 5 > 6; var_dump($a1); // => 19 var_dump(true xor true); // false var_dump((2< 3) xor (5 != 5)); // true ?>
Lohikal HINDI (!)
Ang lohikal na NOT operator, na tinatawag ding negation, ay ipinahiwatig ng sign! . Ito ay isang unary operator na inilagay bago ang isang solong operand. Ang logical NOT operator ay ginagamit upang baligtarin ang lohikal na halaga ng operand nito at palaging nagbabalik ng true o false .
Kung kailangan mong baligtarin ang halaga ng isang expression, tulad ng a && b , kakailanganin mong gumamit ng mga panaklong: !(a && b) . Gayundin sa tulong ng isang operator! Maaari mong i-convert ang anumang x value sa Boolean equivalent nito sa pamamagitan ng paggamit ng operator: !!x dalawang beses.
