Php villkorliga uttalanden if, switch och ternary statement.

Lektionen kommer att omfatta php villkorliga uttalanden: if -satsen och switch -satsen

PHP villkorliga uttalanden representeras av tre huvudkonstruktioner:

• skick operatör om,
• växeloperatör växla
• och ternär operatör.

Låt oss titta närmare på var och en av dem.

PHP if -uttalande

Fig 3.1. Villkorligt IF -uttalande, förkortad version

Ris. 3.2. IF ELSE villkorlig uttalande syntax

Ris. 3.3. Komplett syntax för IF elseif villkorligt uttalande

Låt oss sammanfatta:

Den fullständiga syntaxen är:

if (villkor) (// om villkoret är sant operator1; operator2;) elseif (villkor) (operator1; ...) else (// om villkoret är falskt operator1; operator2;)

• Den förkortade syntaxen kan innehåller inte en del av konstruktionen med annat och innehåller inte ett ytterligare villkor annarsif
• Istället för funktionsordet elseif kan du skriva annat om (separat)
• Det kan finnas flera andra i ett if -uttalande. Det första påträffade elseif -uttrycket som är lika med TRUE kommer att köras.
• Om det finns ett alternativt villkor annars, måste klausulen else komma sist i syntaxen.

Ett kolon: kan användas i ett villkorligt uttalande istället för lockiga hängslen. I det här fallet slutar operatören med serviceordet endif

Ris. 3.4. If och Endif villkorligt uttalande i php

Exempel:

if ($ x> $ y): eko $ x. "större än". $ y; elseif ($ x == $ y): // när du använder ":" kan du inte skriva separat annars om eko ​​$ x. "är lika med". $ y; annars: echo $ x. "not> och not =". $ y; endif;

Viktig: När du använder ett kolon istället för hängslen annars kan du inte skriva med två ord!

Logiska operationer i ett skick

Följande operationer kan finnas i if -satsen inom parentes:

Exempel: kontrollera värdet på en numerisk variabel: om det är mindre än eller lika med 10, - meddela ett meddelande "Tal mindre än eller lika med 10", i motsatt fall, meddela ett meddelande "Antalet är större än 10"

Lösning:

$ nummer = 15; om ($ nummer<=10) { echo "число меньше или равно 10"; } else { echo "число больше 10"; }

Block av php -kod kan brytas, betrakta ett exempel:

Exempel: Visa html -kod "A är lika med 4" om variabeln $ a verkligen är 4

1 Lösning:

1 2 3 4

2 Lösning:

1 2 3

A är lika med 4

A är lika med 4

PHP -jobb 3_1: Visa översättningen av färger från engelska till ryska, kontrollera värdet på variabeln (i vilken färgen är tilldelad: $ a = "blå")

Php -jobb 3_2: Hitta högst tre nummer

Jämförelseoperationer och lögnens regel

I if -satsen måste det finnas ett logiskt uttryck eller en variabel inom parentes som betraktas ur logisk algebras synvinkel och returnerar värden antingen sanna eller falska

De där. en enda variabel kan användas som villkor. Låt oss överväga ett exempel:

1 2 3 4

$ a = 1; om ($ a) (eko $ a;)

$ a = 1; om ($ a) (eko $ a;)

I exemplet kommer php -språköversättaren att överväga variabeln inom parentes för lögnregeln:

Regeln om LIE eller vad som anses vara falskt:

• logisk Falsk
• heltal noll ( 0 )
• giltig noll ( 0.0 )
• tom rad och linjen «0»
• array utan element
• objekt utan variabler
• speciell typ NULL

Således, i det övervägda exemplet, är variabeln $ a lika med en, respektive är villkoret sant och operatorn eko $ a; kommer att visa variabelns värde.

PHP -jobb 3_3: ges en variabel a med ett strängvärde. Om a är lika med namnet, sedan ut "Hej namn!", om a är lika med ett tomt värde, mata sedan ut "Hej främling!"

Logiska konstruktioner OCH ELLER och INTE i en villkorlig operatör

1. Ibland är det nödvändigt att se till att flera villkor uppfylls samtidigt. Då kombineras förutsättningarna logisk operatör OCH — && :

$ a = 1; if ($ a> 0 || $ a> 1) (eko "a> 0 eller a> 1";)

2. För att indikera att villkoret är falskt, använd logisk NOT operatör — ! :

1 2 3 4

$ a = 1; om (! ($ a< 0 ) ) { echo "a не < 0" ; }

$ a = 1; om (! ($ a<0)) { echo "a не < 0"; }

Byt PHP -uttalande

Switch -satsen eller "switch" ersätter flera på varandra följande if -satser. Genom att göra det jämför den en variabel med en uppsättning värden. Således är det det mest praktiska botemedlet. för att organisera multi-branching.

Syntax:

1 2 3 4 5 6 7 8 9 10

switch ($ variable) (case "value1": statement1; break; case "value2": statement2; break; case "value3": statement3; break; [default: statement4; break;])

switch ($ variabel) (case "value1": statement1; break; case "value2": statement2; break; case "value3": statement3; break;)

• Operatören kan kontrollera både strängvärden (i så fall anges de med citattecken) och numeriska (utan citattecken).
• Pausbesked i konstruktionen krävs. Den avslutar konstruktionen om villkoret är sant och uttalandet som motsvarar villkoret körs. Utan paus kommer alla ärenden att utföras oavsett sanningen.

Ris. 3.5. Villkorlig switch -uttalande

Exempel: en matris med fullständiga maskulina namn ges. Kontrollera det första elementet i matrisen och, beroende på namnet, utfärda en hälsning med ett kort namn.

Lösning:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

$ namn = array ("Ivan", "Peter", "Semyon"); switch ($ namn [0]) (fall "Peter": eko "Hej, Petya!"; paus; fall "Ivan": eko "Hej, Vanya!"; break; fall "Semyon": eko "Hej, Vanya! "; break; default: echo" Hej, $ namn! "; ha sönder; )

$ namn = array ("Ivan", "Peter", "Semyon"); switch ($ namn) (fall "Peter": eko "Hej, Petya!"; paus; fall "Ivan": eko "Hej, Vanya!"; bryt; fall "Semyon": eko "Hej, Vanya!"; bryt ; standard: eko "Hej, $ namn!"; bryt;)

PHP -jobb 3_4:

• Skapa en variabel $ day och tilldela den ett godtyckligt numeriskt värde
• Använd switch -satsen för att mata ut frasen "Det här är en arbetsdag" om värdet på variabeln $ day faller inom intervallet mellan 1 och 5 (inklusive)
• Mata ut frasen "Det är en ledig dag" om värdet på variabeln $ day är 6 eller 7
• Mata ut frasen "Okänd dag" om värdet för $ day -variabeln inte ligger i intervallet mellan 1 och 7 (inklusive)

Fyll i koden:

1 2 3 4 5 6 7 8 9 10 11 12

... omkopplare (...) (fall 1: fall 2: ... eko "Det här är en arbetsdag"; ha sönder; fall 6: ... standard: ...)

Växla (...) (fall 1: fall 2: ... eko "Detta är en arbetsdag"; paus; fall 6: ... standard: ...)

PHP ternär operatör

Ternär operatör, d.v.s. med tre operander, har en ganska enkel syntax, där till vänster om? villkoret är skrivet och till höger - två operatörer separerade med tecknet :, till vänster om tecknet körs operatören om villkoret är sant och till höger om tecknet: operatören körs om villkoret är falsk.

skick? operatör1: operatör2;

Hej kära nybörjare programmerare. Låt oss fortsätta studera de element som den består av.

I den här artikeln lär vi oss vad php -uttalanden är. Faktum är att vi känner till några av dem nästan från barndomen, bara vi känner dem som tecken (+, -, =,!,?).

I php kallas de alla för operatörer, vilket är ganska logiskt, eftersom de utför en viss åtgärd eller åtgärd.

Du kan till och med säga att alla utskrivbara tecken som inte är bokstäver eller siffror är operatorer i php. Men det är inte allt, eftersom det finns operatörer som består av bokstäver.

Låt oss börja i ordning.

Aritmetiska operatörer

Aritmetiska operatorer används för att manipulera tal.

+ - tilläggsoperatör;
- - subtraktionsoperatör;
/ - divisionsoperatör;
* - operatör för multiplikation;
% - operatör för att erhålla resten vid delning;
++ - operatör av inkrement med en (inkrement);
- - - operatör av minskning med en (minskning)

Vid skrivning placeras vanligtvis ett mellanslag före och efter operatören. Detta görs enbart för att underlätta att läsa koden, även om detta gap inte påverkar någonting, och om så önskas kan du klara dig utan det.

Komplexa uttryck är sammansatta enligt de regler som accepteras i aritmetik, det vill säga multiplikation och division har företräde framför addition och subtraktion, och när båda är närvarande i uttrycket, omges de senare inom parentes.

eko (6 + 7) * (7 + 8); // 195
?>

När du utför åtgärden att dividera ett heltal med ett heltal, om resten erhålls, konverteras resultatet automatiskt till ett reellt tal (flyttal).

eko 8/3; //2.66666666666
?>

Antalet tecken som visas för ett bråktal beror på värdet i precisionsdirektivet som finns i php.ini -filen. Detta är vanligtvis 12 tecken exklusive perioden.

Operatorn% används vanligtvis för att avgöra om ett tal är delbart med ett annat utan en rest eller inte.

eko 53328% 4; // 0
?>

Åtgärder med aritmetiska operatorer, med undantag för inkrement och decrement, anropas binär, eftersom de involverar två operander (term + term, utdelning / divisor, etc.)

Öknings- och minskningsåtgärderna kallas unary, eftersom de involverar en operand. Finns det några fler villkorlig drift, där tre operander är inblandade.

Inkrement (++) och decrement ( - -) operatörer gäller endast variabler.

Variabel typ heltal (heltal)

$ nästa = 3;
echo ++ $ nästa; // 4
?>

Variabel typsträng (sträng)

$ nästa = "abc";
eko $ nästa; // abd
?>

Bokstaven "d" visas istället för bokstaven "c" eftersom den är nästa i alfabetet, och vi har ökat värdet på variabeln med en.

Exemplen visar inkrementella åtgärder, och du kan utföra minskningsåtgärder på samma sätt.

Bitvisa operatörer

Bitvisa operatörer är utformade för att arbeta med binär data. Om någon inte har en aning om vad det är ska jag förklara. Binära tal är nummer som 1001000011100000111000.

Eftersom sådan information nästan aldrig används i utvecklingen av webbplatser kommer vi inte att fördjupa oss i dem i detalj. Jag kommer bara att visa dig hur de ser ut, så att när du möter sådana symboler kan du föreställa dig vad du har att göra med.

& - bitvis förening OCH (och);
~ - bitvis negation (inte);
| - bitvis förening ELLER (eller);
^ - bitvis uteslutning ELLER (xor);
<< — сдвиг влево битового значения операнда;
>> - höger förskjutning av operandets bitvärde;

Möte med dessa operatörer är ganska troligt, eftersom binär data ofta används i utvecklingen av datorgrafikprogram. Men för att studera dem, om någon behöver det, måste du gå en separat kurs om en annan resurs.

Jämförelseoperatörer

Jämförelseoperatorer är logiska operatorer och används för att jämföra variabler. Matriser och objekt kan inte jämföras med deras hjälp.

> - operatören är större;
=> - operatör större än eller lika;
< — оператор меньше;
<= — оператор меньше или равно;
== - operatörens jämlikhet;
! = - operatörens ojämlikhet;
=== - ekvivalensoperator (variabelns värde och typ är lika);
! == - icke -ekvivalensoperatör;

Som ett resultat av jämförelsen visas antingen en på skärmen, vilket motsvarar true (true), eller en tom sträng, som motsvarar false (false).

eko 1> 0; // 1
eko 1< 0 ; // пустая строка
eko 1 => 0; // 1
eko 1 == 1; // 1
?>

Så här används i sig själva jämförelseoperatörer nästan aldrig. Deras huvudsakliga syfte är att arbeta parallellt med if -uttalandet.

Villkorliga uttalanden om, annars, if.

Villkorliga operatörer kallas så eftersom de är utformade för att testa ett visst tillstånd, beroende på vilken en eller annan åtgärd som utförs.

Som argument tar if -satsen en boolsk variabel eller ett uttryck. Om villkoret är sant visas resultatet, om inte sant - en tom sträng.

om ($ nästa< $nexT)
{
eko "Risk för nederbörd"; // Visas Möjlig nederbörd
}
?>

$ next = "Luftfuktighet 80%";
$ nexT = "Luftfuktighet 90%";
if ($ next> $ nexT)
{
eko "Risk för nederbörd"; // Visa tom sträng
}
?>

Om du behöver ange två åtgärder i programmet, varav en kommer att utföras om värdet är sant, och den andra om det är falskt, används operatorn else tillsammans med if -satsen

$ next = "Luftfuktighet 80%";
$ nexT = "Luftfuktighet 90%";
if ($ next> $ nexT)
{
eko "Risk för nederbörd";
}
annan
{
eko "Ingen nederbörd förväntas";
}
?>

I detta fall kommer "Nederbörd förväntas inte" att visas, och om "Mer" -tecknet ändras till "Mindre" i uttrycket, visas "Möjlig nederbörd". Så här kontrollerar villkorliga operatörer tillståndet och matar ut rätt resultat enligt det.

Mycket ofta blir det nödvändigt att ställa in mer än två villkor, och sedan, för att testa dem i följd, används annarsif -operatören.

if ($ next> $ nexT)
{
eko "jag ser";
}
elseif ($ nästa<= $nexT)
{
eko "Snö";
}
elseif ($ nästa> = $ nexT)
{
eko "Regn";
}
elseif ($ nästa == $ nexT)
{
eko "Torka";
}
annan
{
eko "Risk för nederbörd";
}
?>

Detta program visar "Snow". Om inget av villkoren passar, visas "Nederbörd är möjlig".

Ett if -uttalande kan innehålla så många annat ifall du vill, och bara ett annat uttalande.

En alternativ notation är tillåten - utan lockiga hängslen. I det här fallet slutar raderna i if, else, elseif -satserna med ett kolon, och hela konstruktionen slutar med endif -nyckelordet (operator).

$ next = "Luftfuktighet 50%";
$ nexT = "Luftfuktighet 60%";
om ($ nästa<= $nexT):

eko "Snö";

elseif ($ nästa> = $ nexT):

eko "Regn";

elseif ($ nästa == $ nexT):

eko "Torka";

annan:

eko "Risk för nederbörd";
endif;
?>

Logiska operatörer

Logiska operatorer liknar bitvisa operatörer. Skillnaden mellan dem är att den förstnämnda fungerar med logiska variabler och den senare med siffror.

Logiska operatorer används när du behöver kombinera flera villkor, vilket minskar antalet if -satser, vilket i sin tur minskar risken för fel i din kod.

&& - anslutande fackförening AND;
och - även OCH, men med lägre prioritet;
|| - separera fackföreningar ELLER;
eller - också ELLER, men med lägre prioritet;
xor - exklusivt ett ELLER -element;
! - förnekelse;

Lägre prioritet betyder att om båda operatörerna är närvarande utförs den med den högre prioriteten först.

I framtiden, på exempel på mer komplexa skript, kommer vi att fördjupa oss mer i logiska operatörer.

Uppdragsoperatör

Tilldelningsoperatorn = tilldelar vänster operand värdet för den högra.

$ next = "Hej"
eko "Hej" // Hej
?>

Punktoperatör

Punktoperatören separerar heltalet från bråkdelen och sammanfogar flera strängar och ett tal till en hel sträng.

$ nästa = 22;
eko "Idag är efter". $ nästa. "frost förväntas"; // Frost väntas efter 22 idag
?>

Parentesoperatör

Liksom i matematik prioriterar parentesoperatören åtgärden som ingår i dem.

Först körs data som ingår inom parentes och sedan allt annat.

Curly brace operatör

Det finns tre sätt, eller till och med stil, i php att placera lockiga hängslen.

1. BSD -stil - parenteser är vänsterinriktade.

om ($ nästa)
{

}

2. GNU -stil - parenteser är indragna från vänster

om ($ nästa)
{
eko "Hej kära nybörjare programmerare";
}

3. K & R -stil - parentesen öppnas i satsraden

om ($ nästa) (
eko "Hej kära nybörjare programmerare";
}

Från början måste du välja en av stilarna och i framtiden, när du skriver manus, bara använda den. Dessutom spelar det ingen roll vilken stil du föredrar. Det är viktigt att det är enhetligt under hela programmet.

För tillfället tror jag att det räcker. I princip kan inte bara skyltar utan även funktioner och andra element vara operatörer, så det är mycket svårt att lista dem alla, och det finns inget behov av någonting.

Det räcker med att ha en uppfattning om de grundläggande grundläggande. Och resten kommer att analyseras med hjälp av praktiska exempel.

En irländare vandrar runt Sheremetyevo flygplats i gråt. En av de anställda bestämde sig för att sympatisera:
- Saknar du ditt hemland?
- Inte alls. Jag har precis tappat allt bagage
- Hur kunde detta ha hänt?
"Jag förstår inte. Det verkar som om jag har anslutit kontakten

De två huvudsakliga påståendena för att skapa tillståndsbaserade förgreningsstrukturer är if och switch. Den mest använda är if -satsen, som används i villkorliga hoppstrukturer. Å andra sidan, i vissa situationer, särskilt om du måste navigera genom en av de många grenarna beroende på värdet på ett enda uttryck, och användningen av ett antal if -satser leder till kodens komplexitet, switch -satsen blir bekvämare.

Innan du utforskar dessa operatörer måste du förstå booleska uttryck och operationer.

Logiska operationer

Booleanska operationer låter dig kombinera booleska värden (även kallade sanningvärden) för att producera nya booleska värden. Som visas i tabellen nedan stöder PHP standard logiska operationer (och, eller, inte, och xor), där de två första har alternativa versioner.

PHP Boolean Operations

Drift	Beskrivning
och	En operation vars resultat är sant om och bara om båda dess operander är sanna
eller	En operation vars resultat utvärderas till ett verkligt värde om en av dess operander (eller båda operanderna) utvärderas till ett verkligt värde
!	En operation vars resultat är sant om dess enda operand (specificerad till höger om operationstecknet) är falsk och falsk om operanden är sann
xor	En operation vars resultat är sant om någon av dess operander (men inte båda samtidigt) är sant
&&	Samma som och, men binder dess operander tätare än så här
||	Samma som eller, men binder dess operander tätare än så här

&& och || bör vara bekant för programmerare C. Drift! kallas vanligtvis inte för att det blir negationen av operanden som den appliceras på.

För att kontrollera om båda operanderna är SANT, använd OCH -operatorn, som också kan skrivas som ett dubbelstämpel (&&). Både AND och && är logiska operatörer, den enda skillnaden är att && operatören har högre företräde än OCH -operatören. Detsamma gäller operatörerna OR och ||. OCH -operatören returnerar SANT endast om båda operanderna är SANT; annars returneras FALSKT.

För att kontrollera om minst en operand är SANT, använd OR -operatorn, som också kan skrivas som en dubbel vertikal linje (||). Denna operator returnerar TRUE om minst en av operanderna är TRUE.

När du använder OR -operatören kan subtila logiska fel visas i programmet. Om PHP upptäcker att den första operanden är SANT kommer den inte att utvärdera värdet på den andra operanden. Detta sparar körningstid, men du måste vara försiktig så att du inte lägger in någon kod som beror på att programmet fungerar korrekt i den andra operanden.

XOR -operatören låter dig kontrollera om bara en av operanderna är SANT (men inte båda). Denna operator returnerar TRUE om en och endast en av operanderna är TRUE. Om båda operanderna är SANT, returnerar operatören FALSKT.

Du kan invertera ett booleskt värde med NOT -operatorn, som ofta skrivs som ett utropstecken (!). Det returnerar SANT om operanden är FALSE och FALSK om operanden är SANT.

Tabellen nedan visar några booleska uttryck och deras resultat:

Jämförelseverksamhet

Tabellen nedan visar jämförelseoperationer som kan användas med antingen tal eller strängar:

Jämförelseverksamhet

Drift	namn	Beskrivning
==	Är lika	En operation vars resultat är sant om dess operander är lika med varandra, annars falska
!=	Inte jämnlikt	En operation vars resultat är falskt om dess operander är lika med varandra, annars är det sant
<	Mindre	En operation som utvärderas till ett verkligt värde om den vänstra operanden är mindre än den högra operanden, annars utvärderas den till falskt
>	Mer	Operation, vars resultat är sant om den vänstra operanden är större än den högra, annars är den falsk
<=	Mindre än eller lika med	En operation som utvärderas till sann om den vänstra operanden är mindre än eller lika med den högra operanden, annars utvärderas den till falsk
>=	Mer eller lika	En operation som utvärderas till ett verkligt värde om den vänstra operanden är större än eller lika med den högra operanden, annars utvärderas den till falskt
===	Identiskt	En operation vars resultat är sant om båda operanderna är lika med varandra och är av samma typ, annars falska

Du bör vara försiktig så att du inte gör ett mycket vanligt misstag - att inte blanda ihop tilldelningsoperatorn (=) med jämförelsen (==).

Verksamhetens prioritet

Naturligtvis bör du inte överanvända den programmeringsstil där operationssekvensen huvudsakligen beror på användningen av företrädesregler, eftersom koden skriven i denna stil är svår för dem som senare kommer att studera den, men det bör noteras att jämförelse operationer har högre prioritet än logiska operationer. Det betyder att ett uttalande med ett checkuttryck som det nedan

PHP -kod $ var1 = 14; $ var2 = 15; om (($ var1< $var2) && ($var2 < 20)) echo "$var2 больше $var1 но меньше 20";

kan skrivas om som

PHP -kod ... if ($ var1< $var2 && $var2 < 20) ...

Om - annars uttalande

Instruktioner om tillåter körning av ett kodblock om det villkorliga uttrycket i detta uttalande är SANT; annars körs inte kodblocket. Vilket uttryck som helst kan användas som ett villkor, inklusive tester för icke-nollvärde, jämlikhet, NULL som involverar variabler och värden som returneras av funktioner.

Det spelar ingen roll vilka enskilda villkor som utgör villkorsklausulen. Om villkoret är sant exekveras programkoden som ingår i lockparenteser (()). Annars ignorerar PHP det och fortsätter med att kontrollera det andra villkoret och kontrollerar alla villkor du skrev ner tills det snubblar över uttalandet annan, varefter det automatiskt kommer att köra detta block. Det övriga uttalandet är valfritt.

Syntaxen för if -satsen är:

Om (villkorligt uttryck) (kodblock;)

Om det villkorliga uttrycket utvärderas till SANT, kommer kodblocket efter det att köras. I följande exempel, om variabeln $ användarnamn är "Admin", visas ett välkomstmeddelande. Annars händer ingenting:

PHP -kod $ användarnamn = "Admin"; if ($ användarnamn == "Admin") (eko "Välkommen till administratörssidan.";)

Om ett kodblock bara innehåller en instruktion, är lockiga hängslen valfria, men det är en bra vana att alltid sätta dem, eftersom de gör koden lättare att läsa och redigera.

Ett valfritt annat -uttalande är ett kodblock som körs som standard när det villkorliga uttrycket returnerar FALSKT. Anders -satsen kan inte användas separat från if -satsen, eftersom annars inte har ett eget villkorligt uttryck. Det vill säga annat och om i din kod alltid ska vara tillsammans:

If och annat uttalanden $ användarnamn = "ingen admin"; if ($ användarnamn == "Admin") (echo "Välkommen till administratörssidan.";) Annat (eko "Välkommen till användarsidan.";)

Kom ihåg att stänga ett kodblock i ett if -uttalande med ett lockigt hängslen om du sätter ett lock i början av blocket. Övrigt block måste också innehålla öppna och stänga lockiga hängslen, som i if -blocket.

Det här är bra, förutom när du måste kontrollera flera förhållanden i rad. För detta är instruktionen lämplig annat... Det låter dig testa ytterligare villkor tills en sann hittas eller annars blocket nås. Varje elseif -sats har sitt eget kodblock, som placeras omedelbart efter det betingade uttrycket för elseif -satsen. Sif -uttalandet kommer efter if -uttalandet och före annat -uttalandet, om det finns något.

Syntaxen för elseif -satsen är lite mer komplicerad, men följande exempel hjälper dig att räkna ut det:

Kontrollerar flera villkor $ användarnamn = "Gäst"; if ($ användarnamn == "Admin") (echo "Välkommen till administratörssidan.";) elseif ($ användarnamn == "Gäst") (eko "Ingen vy tillgänglig.";) else (eko "Välkommen till sidan användare. ";)

Här kontrolleras två villkor och olika åtgärder utförs beroende på värdet på $ användarnamnvariabeln. Och det finns fortfarande en möjlighet att göra något om variabelns värde skiljer sig från de två första.

Ternär operatör?:

Operatör?: Är en ternär (trippel) operatör som tar tre operander. Det fungerar på samma sätt som ett if -uttalande, men det returnerar värdet av ett av två uttryck. Uttrycket som ska utvärderas bestäms av det villkorliga uttrycket. Tjocktarmen (:) fungerar som en uttrycksseparator:

(skick) ? evalu_if_condition_true: evalu_if_condition_false;

Exemplet nedan kontrollerar värdet och returnerar olika strängar beroende på dess värde (TRUE eller FALSE):

Skapa ett meddelande med operatören?: $ logged_in = TRUE; $ user = "Igor"; $ banner = (! $ logged_in)? "Registrera!" : "Välkommen tillbaka, $ användare!"; echo $ banner;

Det är ganska uppenbart att ovanstående operatör motsvarar följande operatör:

PHP -kod $ logged_in = TRUE; $ user = "Igor"; if (! $ logged_in) ($ banner = "Register!";) else ($ banner = "Välkommen tillbaka, $ användare!";) echo $ banner;

Byt uttalande

Instruktioner växla jämför ett uttryck med flera värden. Som regel används en variabel som ett uttryck, beroende på värdet för vilket ett specifikt kodblock ska köras. Tänk dig till exempel variabeln $ action, som kan ha värdena "ADD" (add), "MODIFY" (change) och "DELETE" (delete). Switch -satsen gör det enkelt att definiera det kodblock som ska köras för vart och ett av dessa värden.

För att visa skillnaden mellan if och switch -satser, låt oss kontrollera en variabel mot flera värden. Exemplet nedan visar programkoden som genomför en sådan kontroll baserat på if -satsen och i följande exempel baserat på switch -satsen:

Kontrollerar att ett av flera värden överensstämmer (if -uttalande) if ($ action == "ADD") (echo "Execute addition."; echo "Antalet instruktioner i varje block är inte begränsat.";) elseif ($ action == "MODIFY") (echo "Execute change. ";) elseif ($ action ==" DELETE ") (eko" Utför borttagning. ";) Kontrollera att ett av flera värden överensstämmer (switch -statement) switch ($ action) (case "ADD": echo "Execute addition."; echo "Antalet instruktioner i varje block är inte begränsat."; break; case "MODIFY": echo "Execute change."; break; case "DELETE": eko "Execute delete."; Break;)

Switch -satsen tar värdet bredvid switch -nyckelordet och börjar jämföra det med alla värden bredvid sökorden. fall, i den ordning de visas i programmet. Om ingen matchning hittas körs ingen av blocken. När en matchning hittats körs motsvarande kodblock. Kodblocken nedan körs också - fram till slutet av switch -satsen eller tills nyckelordet ha sönder... Detta är användbart för att organisera en process som består av flera sekventiella steg. Om användaren redan har slutfört några steg kommer han att kunna fortsätta processen där han slutade.

Ett uttryck bredvid en switch -sats måste returnera ett primitivt värde, till exempel ett tal eller en sträng. En array kan endast användas som ett separat element med ett elementärt typvärde.

Standardval

Om värdet på det villkorliga uttrycket inte stämde överens med något av alternativen som erbjuds i falluttalanden, tillåter switch -satsen i det här fallet dig att göra något som liknar else -satsen if, elseif, else -konstruktion. För att göra detta måste du göra en instruktion som det sista alternativet i urvalslistan standard:

Generera ett felmeddelande med hjälp av standarduttalandet $ action = "REMOVE"; switch ($ action) (case "ADD": echo "Execute addition."; echo "Antalet instruktioner i varje block är inte begränsat."; break; case "MODIFY": echo "Execute change."; break; case "DELETE": echo "Execute delete."; Break; default: echo "Error: $ action command is not valid,". "Only ADD, MODIFY and DELETE commands can be used.";)

Utöver det vanliga stöder switch -satsen en alternativ syntax - en konstruktion av nyckelord omkopplare / ändomkopplare som definierar början och slutet av ett uttalande istället för lockiga hängslen:

Switch -satsen slutar med nyckelbrytaren nyckelord switch ($ action): case "ADD": echo "Execute addition."; echo "Antalet instruktioner i varje block är obegränsat."; ha sönder; fall "ÄNDRA": eko "Utför ändring."; ha sönder; case "DELETE": echo "Utför borttagning."; ha sönder; default: echo "Fel: kommandot $ action är inte giltigt". "bara kommandona ADD, MODIFY och DELETE kan användas."; ändbrytare;

Avbrott i utförandet

Om bara ett kodblock som motsvarar ett specifikt värde ska köras, bör nyckelordsbrytningen infogas i slutet av blocket. PHP -tolkaren, när den stöter på break -nyckelordet, kommer att hoppa till linjen efter den avslutande lockiga hängslen av switch -satsen (eller slutströmbrytaren). Men om du inte använder pausuttrycket fortsätter kontrollen i de efterföljande fallgrenarna i switchkonstruktionen. Ett exempel visas nedan:

Vad händer när det inte finns några pausuttalanden $ action = "MONTERINGSBESTÄLLNING"; switch ($ action) (case "ASSEMBLE ORDER": echo "Samla order.
"; case" PACKAGE ": echo" Pack.
"; case" SHIP ": echo" Leverera till kund.
"; }

Om variabeln $ action är inställd på "MONTERINGSBESTÄLLNING" kommer utdraget från detta avsnitt att vara följande:

Samla ordern. Att avsluta. Leverera till kunden.

Om vi ​​antar att byggstadiet redan har passerat och $ action -variabeln har värdet "PACKAGE", kommer följande resultat att uppnås:

Att avsluta. Leverera till kunden.

Ibland är frånvaron av pausuppgifter användbar, som i exemplet ovan, där orderstadier bildas, men i de flesta fall bör detta uttalande användas.

Datatyper Cykler 1 2 3 4 5 6 7 8 9 10

PHP stöder de logiska standardoperatörerna AND och &&, OR och || ,! (inte) och XOR. Med logiska operatorer kan du jämföra resultaten från två operander (värden eller uttryck) för att avgöra om en eller båda av dem returnerar sant eller falskt och väljer lämplig fortsättning av skriptet baserat på det returnerade värdet. Liksom jämförelseoperatörer returnerar logiska operatorer ett booleskt värde - sant eller falskt, beroende på värdena på vardera sidan av operatören.

Logisk ELLER (ELLER och ||)

Den logiska OR -operatorn betecknas som OR eller || ... Den utför en logisk ELLER -operation på två operander. Om en eller båda operanderna är sanna, returnerar den sant. Om båda operanderna är falska returnerar den falska. Du har förmodligen en fråga, varför gjorde du två versioner av en operatör? Innebörden av de två olika varianterna av operatören "logisk ELLER" är att de arbetar med olika prioriteringar.

Låt oss först titta på hur || operatören fungerar. ... Och så, om en eller båda dess operander är sanna, returnerar den sant. Om båda operanderna returnerar falska värden, kommer det att returnera falska.

OR -operatören fungerar på samma sätt som || med ett undantag, om OR -operatören används med en tilldelning, kommer den först att utvärdera och returnera värdet för den vänstra operanden, annars fungerar den precis som operatorn ||. , d.v.s. om en eller båda dess operander är sanna, returnerar den sant. Om båda operanderna returnerar falska värden, kommer det att returnera falska.

För att göra det tydligare hur de fungerar, låt oss ge följande exempel:

1 // Först tilldelas variabeln värdet false, och sedan beräknas den andra operanden // Prioritetsåtgärd: ($ var2 = false) eller true $ var2 = false eller true; eko $ var2; // false visas inte // ($ var3 = 0) eller 3 $ var3 = 0 eller 3; eko "
$ var3 "; // => 0?>

Alla jämförelser och logiska operatorer kan kombineras till mer komplexa konstruktioner:

Det finns en annan viktig punkt som är värd att nämna när det gäller både OR och || ... Den "logiska ELLER" -operatorn börjar sina beräkningar från sin vänstra operand, om den returnerar sant kommer den högra operanden inte att utvärderas. Detta sparar körningstid, men du måste vara försiktig så att koden som korrekt funktion av programmet kan bero på inte placeras i rätt operand.

Logiskt OCH (OCH och &&)

Den logiska OCH -operatören kallas OCH och &&. Den utför en logisk OCH -operation på två operander. Det returnerar sant om och bara om båda operanderna är sanna. Om en eller båda operanderna returnerar false, returnerar operatorn false. Betydelsen av de två olika versionerna av operatorn "logisk OCH" är densamma som för de två tidigare operatörerna, nämligen att de arbetar med olika prioriteringar.

Låt oss först ta en titt på hur && operatören fungerar. Och så, om båda dess operander är sanna, returnerar det sant. Om minst en eller båda operanderna returnerar falska kommer den också att returnera falskt.

OCH -operatören fungerar precis som & & -operatorn, med ett undantag, om OCH -operatören används med ett uppdrag kommer den först att utvärdera och returnera värdet på den vänstra operanden, annars fungerar det på samma sätt som && -operatören. Om minst en av dess operander returnerar falska, kommer den också att returnera falska, även om båda operanderna returnerar falska värden, kommer den att returnera falska.

För att förstå, låt oss nu överväga hur detta fungerar i praktiken:

$ bar3 "; // => 9?>

Exklusiv ELLER (XOR)

Den exklusiva OR -operatören betecknas som XOR. Det returnerar sant om en och endast en av operanderna är sanna. Om båda operanderna är sanna kommer operatören att returnera falskt.

Eftersom XOR -operatörens företräde är densamma som för AND- och OR -operatörerna (lägre än tilldelningsoperatorn), och den används i ett tilldelningsuttryck, utvärderar och returnerar den först värdet för den vänstra operanden.

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

Logiskt INTE (!)

Operatör logisk INTE, det kallas också negation betecknat med tecknet! ... Det är en unary operatör placerad inför en enda operand. Operatören Boolean NOT används för att invertera det booleska värdet på operanden och returnerar alltid sant eller falskt.

Om du behöver invertera värdet på ett uttryck, till exempel a & b, måste du använda parenteser :! (A && b). Även med hjälp av operatören! du kan konvertera valfritt värde av x till dess logiska ekvivalent genom att använda operatorn: !! x två gånger.

Det viktigaste i denna operatörs handling är villkoret. om översatt från engelska betyder om... Villkoret accepteras som ett argument (det som finns inom parentes). Ett booleskt uttryck eller en boolsk variabel kan användas som villkor. Om det är enklare, kommer uttrycket att betyda följande:

Om (skick) (
villkoret är uppfyllt, vi gör detta
}
annan
{
villkoret inte är uppfyllt, vi gör annars
}
Jag hoppas att logiken i den villkorade operationen är tydlig. Låt oss nu titta på ett exempel.

$ a = 5;
$ b = 25;

// Nu uppmärksamhet! Skick: Om $ b är större än $ a
// Skyltar> och< , как и в математике, обозначают больше и меньше
om ($ b> $ a)
{
// om villkoret är uppfyllt utför vi denna åtgärd
eko "$ b är större än $ a";
}
annan
{
// om inte nöjd, så detta
eko "$ a är större än eller lika med $ b";
}
?>
Demonstration Ladda ner källor
Som ett resultat kommer skriptet att matas ut 25 fler än 5... Exemplet är ganska enkelt. Jag hoppas att allt är klart. Nu föreslår jag att betrakta situationen som svårare, där flera villkor måste vara uppfyllda. Varje nytt villkor kommer att innehålla efter huvudvillkoret om ()- extra, som är skriven som annat om ()... Till slut blir det som vanligt annan.

Uppgift: Test utförs på skolan. Manuset måste beräkna poängen, med kunskap om villkoren för att få varje betyg och elevens poäng själv. Låt oss se hur vi skriver ner det, och glöm inte att läsa kommentaren.

$ test = 82; // låt oss säga att en elev skrev ett test för 82 poäng

// skriv det första villkoret för de fem
om ($ test> 90)
{
// om villkoret är uppfyllt utför vi denna åtgärd.
eko "Grade 5";
}
// && tecknet betyder "och, union", att villkoret är uppfyllt om både då och sedan sant
// det vill säga poängen är mindre än 91 och mer än 80, sedan 4. Annars läses villkoren vidare
annars om ($ test< 91 && $test > 80)
{
eko "Grade 4";
}
annars om ($ test< 81 && $test > 70)
{
eko "Grade 3";
}
annan
{
echo "Jag borde skriva testet igen ...";
}
?>
Demonstration Ladda ner källor
Vår elev som hinner slappna av och skriva ett test får normalt årskurs 4! Och jag hoppas att arbetsprincipen är tydlig.

En kort beskrivning av hur en villkorlig operation fungerar är också möjlig när du bara behöver en åtgärd om villkoret är uppfyllt.

$ ålder = 19; // variabel med ålder

Om ($ ålder> 17) (
echo "Det är det! Jag kan göra vad jag vill! Jag är redan $ age!";
}
Ett ganska bra exempel på en kort notation för en villkorlig operation. annan det är inte nödvändigt att skriva.

PHP -jämförelseoperatörer

Principen för den villkorade verksamheten är klar. Men som du förstår finns det många fler sätt att jämföra. Låt oss ta en titt på en tabell med jämförelseoperatörer nedan.

Exempel Titel Resultat
$ a == $ b är lika med True om $ a är lika med $ b
$ a === $ b Identiskt sant om $ a är lika med $ b och båda variablerna är av samma typ
$ a! = $ b Inte lika med True om $ a inte är lika med $ b
$ a === $ b Inte identiskt Sant om $ a inte är lika med $ b och båda typerna inte är desamma
$ a> $ b Större än sant om $ a är större än $ b
$ a< $b Меньше чем True, если $a меньше, чем $b
$ a> = $ b Större än eller lika med True om $ a är större än eller lika med $ b
$ a<= $b Меньше или равно True, если $a меньше или равно $b
Låt oss nu titta på operatörerna genom exempel:

// i motsats till vana = betyder att tilldela ett värde till en variabel och == lika
om ($ a == 5) (
eko "$ a är 5"; // skriver ut "5 är lika med 5"
) annat (
eko "$ a är inte lika med 5";
}

Om ($ a! = 6) (
eko "$ a är inte lika med 6"; // kommer att skriva ut "5 är inte lika med 6". Behövs vid förnekelse
) annat (
eko "$ a är på något sätt lika med 6";
}

// med mer och mindre tror jag att allt är klart. Därför är exemplet mer komplicerat
om ($ a<= 6){
ekot "$ a är mindre än eller lika med 6"; // kommer att skriva ut "5 är mindre än eller lika med 6"
) annat (
ekot "$ a är större än 6";
}

PHP logiska operatörer

Det finns tillfällen då du behöver jämföra inte en variabel utan två eller flera samtidigt i ett tillstånd. För detta finns det logiska operatörer.

Exempel Titel Resultat
$ a och $ b Boolean och TRUE om både $ a och $ b är TRUE.
$ a eller $ b Boolean "eller" TRUE om antingen $ a eller $ b är TRUE.
$ a xor $ b Exclusive "eller" TRUE if $ a, or $ b TRUE, men inte båda.
! $ a Negation TRUE om $ a inte är TRUE.
$ a && $ b Boolean "och" TRUE om både $ a och $ b är TRUE.
$ a || $ b booleskt eller SANT om antingen $ a eller $ b är SANT.
Har redan märkt det för operationer och och eller finns det ytterligare operatörer? Detta görs för att prioritera komplexa jämförelseoperationer. I tabellen listas logiska operatorer i prioritetsordning: från lägsta till högsta, det vill säga till exempel || har företräde framför eller.

Vi passerar till exempel

$ a = 5;
$ b = 6;
$ c = 7;

// villkor: Om 5 inte är lika med 6 (TRUE) OCH 6 inte är lika med 7 (TRUE)
om ($ a< 6 && $b != $c){
eko "Verkligen så!"; // kommer att skriva ut "Really so!" eftersom Båda villkoren är RIKTIGA
) annat (
eko "Ett av villkoren är inte sant";
}

// villkor: Om 6 inte är lika med 6 (FEL) ELLER 6 inte är lika med 7 (KORREKT)
om ($ b! = 6 || $ b! = $ c) (
eko "Det stämmer!"; // visar "Det stämmer!" minst ETT av villkoren är KORREKT
) annat (
eko "Båda villkoren är inte sanna";
}

Ternär operatör

Jag föreslår att du återkommer till problemet med ternär kod senare. Jag kunde inte låta bli att nämna det alls, eftersom det är en viktig konstruktion som avsevärt minskar kodens storlek. Jag föreslår att du tittar på koden direkt.

Koden i koden:(skick) ? värde a om sant: värde a om falskt

Således förkortar vi notationen av if -uttalandet. Denna åtgärd är dock endast giltig när värden tilldelas en variabel. Låt oss nu titta på det färdiga exemplet.

// Ett exempel på att använda den ternära operatören
$ inställningar = (tom ($ _ POST ["inställningar"]))? "Som standard": $ _POST ["inställningar"];

// Ovanstående kod liknar följande block med if / else
if (tom ($ _ POST ["inställningar"])) (
$ settings = "Standard"; // Om ingenting har passerat lämnar vi "Standard"
) annat (
$ inställningar = $ _POST ["inställningar"]; // Om godkänt, tilldelas $ inställningar det godkända värdet.
}
?>
Läs kodkommentarer och allt ska vara klart.

Tack för uppmärksamheten!