Transact SQL-syntax inkluderar två huvudtyper av kontrollstrukturer. Dessa är operatörerna: om, medan. Var och en av dessa strukturer har motsvarande begränsningar och krav för deras skrivning vad gäller standarder. Det finns också några Allmänna krav för alla givna strukturer. Alla dessa krav och begränsningar är utformade utifrån principerna om enkel efterföljande läsbarhet av källtexter.

Regler för att skriva kontrollstrukturer

Allt källa, belägen inuti kontrollstrukturer, såväl som kapslade logiska strukturer måste dras in med 2 tecken.

Det är inte tillåtet att använda andra instruktioner tillsammans med en kontroll på samma linje.

4.2.1.3 ”Början slut”-konstruktionen måste alltid starta på en ny linje.

Inkapsling av kontrollstrukturer är tillåten, med undantag för uttryckligen angivna undantag.

Villkorligt IF-uttalande

Formatera:

Det är också tillåtet att skriva:

Formatera: om [ logiskt uttryck 1 ]

Alla delar av det villkorliga uttalandet (if, else if, else, start, end) måste placeras med början från samma position

4.2.2.2 Inom de "logiska parenteserna" i en villkorlig sats, måste Transact SQL-språksatser placeras enligt standardtabstoppet på 2 tecken

När du skriver logiska operatorer i logiska uttryck måste du sätta mellanslag före och efter dem

När du skriver komplexa logiska uttryck är det förbjudet att infoga mellanslag mellan parenteser och en del av det logiska uttrycket

WHILE kontrollkonstruktion

Formatera: while ([ loop fortsättningsvillkor ])

(operatörer)

4.2.3.1 Inom de "logiska parenteserna" i while-strukturen måste Transact SQL-satser placeras enligt standardtabstopp på 2 tecken

Användningen av while-strukturen är grundläggande för att organisera olika pass med hjälp av markören.

Grundläggande operatörer

Transact SQL-syntax inkluderar fem grundläggande operatorer. Dessa är operatörerna: Välj, infoga, uppdatera, ta bort, markör. För var och en av dessa operatörer finns motsvarande begränsningar och krav för deras skrivning vad gäller standarder. Det finns också några generella krav för alla dessa operatörer. Alla dessa krav och begränsningar är utformade utifrån principerna om enkel efterföljande läsbarhet av källtexter.

Anteckning: Kontrollkonstruktioner av C-språket beaktas: "om-annat" och "om-annat om"-grenar, "medan" och "för"-loopar. Det finns också konstruktioner som är bäst att undvika: "switch", "do-while", "goto". Presentationen av ett program i form av en uppsättning funktioner, prototyper av funktioner, metoder för att överföra ingångs- och utdataparametrar beaktas. Är listade olika sorter minne: statisk, stack, dynamisk (heap) och metoder för att arbeta med minne i C. En sammansatt datatyp "struktur" introduceras. Materialet illustreras med många exempel på program: att lösa en andragradsekvation, beräkna en kvadratrot, beräkna gcd för två tal och den utökade euklidiska algoritmen, skriva ut de första N primtalen, rekursiv traversering av ett träd, etc.

Kontrollstrukturer

Kontrollkonstruktioner låter dig organisera loopar och grenar i program. Det finns bara ett fåtal konstruktioner i C, och hälften av dem behöver inte användas (de implementeras genom resten).

Tandställning

Lockiga hängslen låter dig kombinera flera elementära uttalanden till ett sammansatt uttalande eller block. I alla syntaktiska konstruktioner kan en sammansatt operator användas istället för en enkel.

I C kan du placera deklarationer av lokala variabler i början av ett block. Lokala variabler som definieras inom ett block skapas vid inträde i blocket och förstörs vid utträde.

I C++ kan lokala variabler deklareras var som helst, inte bara i början av ett block. Men precis som i C förstörs de automatiskt när de lämnar blocket.

Här är ett programfragment som utbyter värdena för två verkliga variabler:

dubbel x, y; . . . (dubbel tmp = x; x = y; y = tmp; )

Här, för att byta ut värdena för två variabler x och y, lagrar vi först värdet på x i hjälpvariabeln tmp. Då skrivs värdet av y till x, och det tidigare värdet av x lagrat i tmp skrivs till y. Eftersom tmp-variabeln bara behövs inuti det här fragmentet, stängde vi in ​​den i ett block och deklarerade tmp-variabeln inuti det blocket. När du lämnar blocket kommer minnet som upptas av tmp-variabeln att frigöras.

om uttalande

If-satsen låter dig organisera förgrening i ett program. Den har två former: "om"-satsen och "if...else"-satsen. "Om"-operatorn har formen

om (villkor) åtgärd;

operatorn "if...else" har formen

if (villkor) action1; annat åtgärd2;

Du kan använda vilket uttryck som helst av logisk eller heltalstyp som ett villkor. Kom ihåg att när du använder ett heltalsuttryck, motsvarar värdet "true" alla värden som inte är noll. När en "if"-sats körs, utvärderas först det villkorliga uttrycket efter if. Om det är sant så utförs åtgärden, om det är falskt händer ingenting. Till exempel, i följande fragment skrivs det maximala värdet för variablerna x och y till variabeln m:

dubbel x, y, m; . . . m = x; om (y > x) m = y;

När en "if...else"-sats körs, om villkoret är sant, exekveras åtgärden som skrivits efter if; annars utförs åtgärden efter annat. Till exempel skrivs det föregående fragmentet om enligt följande:

dubbel x, y, m; . . . om (x > y) m = x; annars m = y;

När du behöver utföra flera åtgärder beroende på sanningen i ett tillstånd, bör du använda lockiga hängslen, kombinera flera påståenden till ett block, till exempel,

dubbel x, y, d; . . . if (d > 1,0) ( x /= d; y /= d; )

Här divideras variablerna x och y med d endast om värdet på d är större än ett.

Lockiga hängslen kan användas även när det bara finns ett uttalande efter if eller annat. De förbättrar strukturen i programtexten och underlättar eventuella ändringar. Exempel:

dubbel x, y; . . . om (x != 0,0) (y = 1,0; )

Om vi ​​behöver lägga till ytterligare en åtgärd som utförs om "x inte är noll", så lägger vi helt enkelt till en linje innanför de lockiga klammerparenteserna.

Välj bland flera alternativ: om...annan om...

Flera if...else villkorliga uttalanden kan skrivas sekventiellt (dvs åtgärden efter else kan återigen vara en villkorlig sats). Som ett resultat realiseras det välja mellan flera alternativ. Urvalskonstruktionen används mycket ofta i programmering. Exempel: givet en reell variabel x måste du skriva värdet på funktionen tecken(x) i den reella variabeln y.

Hej kära nybörjare programmerare.

Du förstår säkert redan från tidigare artiklar att ett program består av uttryck, strängar, tal, operatorer, funktioner som exekveras i en viss sekvens.

Ordningen för programexekvering bestäms av programmeraren och han använder språkkontrollkonstruktioner för detta. Det vill säga, en kontrollstruktur är ett kommando för en eller annan ordning för programexekvering.

Innan jag går vidare till beskrivningen av kontrollkonstruktioner måste jag varna dig för att du kommer att se många välbekanta namn, eftersom konstruktionen kan vara operatörer, funktioner, loopar, som vi redan har diskuterat i tidigare artiklar.

Konstruktioner (möjliga definitioner - instruktion, kommando) kan vara antingen enkelrad eller sammansatt, det vill säga sammansatta till ett block. Ett block är också en separat struktur, som sekventiellt exekverar de strukturer som finns i det.

Det finns sex huvudgrupper av kontrollkonstruktioner i PHP. Detta:

1. Villkorliga uttalanden.
2. Cyklar.
3. Valfria mönster.
4. Annonsdesigner.
5. Värdeavkastningskonstruktioner.
6. Konstruktioner av inneslutningar.

Låt oss titta på dem i detalj, och allt i ordning.

Villkorliga uttalanden

Vi har redan blivit bekanta med de villkorade operatörerna om, annars, elseif i artikeln "PHP-operatörer", så nu, med tanke på dem som kontrollstrukturer, kommer vi att kunna upprepa vad vi har täckt, vilket, som vi vet, aldrig är överflödig.

Villkorliga uttalanden är de mest använda konstruktionerna, inte bara i PHP utan i alla algoritmiska språk programmering.

Enkelradsexempel om konstruktioner

if ($next == 0 )
{
echo "Detta är en programmeringsspråkkonstruktion";
}
?>

Detta exempel på en if-sats anger att variabeln $next måste vara lika med noll. Om detta villkor är sant, kommer eko att exekveras. Om inte öppnas en tom sida.

Följande kommer att vara ett exempel på en sammansatt struktur.

$nästa = 0 ;
if ($next == 0 )
{
echo $vegetables " Grönsaker
";
echo $frukt. " Frukter
";
echo $bär. "Bär
";
}
?>

Här tilldelas variabeln $next också värdet 0, och if-konstruktionen, efter att ha kontrollerat det, exekverar ett block av ekokonstruktioner.

Observera att för att bryta en rad i php använder vi taggen som är bekant för oss från html
. Vi kommer att träffas igen i framtiden html-taggar, används i php-kod.

Och jag kommer också att notera att indrag i PHP inte spelar någon roll, och endast förbättringar av kodläsbarhet tillämpas.

I det föregående exemplet övervägde vi alternativet när instruktionen exekveras om det angivna villkoret är sant.

Föreställ dig nu att vi behöver utföra något påstående inte bara när villkoret för if-konstruktionen är sant, utan också när villkoret inte är sant.

I detta fall gäller det annan konstruktion

$next = 1 ;
if ($next == 0 )
{
echo $grönsaker . "Grönsaker";
}
annan
{
echo $frukt . "Frukt";
}
?>

I det här fallet är det inte en tom sida som öppnas, utan en "frukt"-post.

elseif konstruktion

Denna konstruktion utökar ytterligare kapaciteten för om och annat-konstruktionerna. Föreställ dig att vi har mer än två uttalanden, varav ett måste utföras.

I detta fall läggs elseif-konstruktionen till de tidigare konstruktionerna.

$nästa = 0 ;
if ($next == 0 )
{
echo $grönsaker . "Grönsaker";
}
elseif ($next == 0 )
{
echo $frukt . "Frukt";
}
annan
{
echo $bär . "Bär";
}
?>

I teorin är antalet elseifs obegränsat. Och oavsett hur många det finns kommer programmet att kontrollera var och en tills det hittar rätt alternativ, det vill säga sant .

Urvalskonstruktioner

Mycket ofta, när stora mängder operatörer, blir användningen av elseif-konstruktionen obekväm på grund av den stora mängden kod.

I det här fallet kommer det till undsättning växellåda design, kan du byta switch

Switch-case-konstruktionen liknar i sin handling den if-else-konstruktionen, men till skillnad från den senare låter den dig få fler än två alternativ som ett resultat.

Konstruktionens kropp är innesluten i krulliga klammerparenteser, och för varje värde som behöver bearbetas används en case-sats, som slutar med ett kolon, följt av en terminating break-sats.

$next= "Frukt";
switch ($next) (
fall "Grönsaker":
eko "potatis";
ha sönder ;
fall "Fruit":
eko "Äpplen";
ha sönder ;
fall "Bär":
eko "Cherry";
ha sönder ;
}
//Äpplen visas

I det här exemplet kommer villkoret först att bearbetas, sedan kommer en fallsats med ett värde som matchar detta villkor att hittas, och först efter det kommer switchkonstruktionen att börja exekveras.

För värden som inte anges i uppgiften, i switch-case-konstruktionen, används standardoperatören.

$next= "Svamp";
switch ($next) (
fall "Grönsaker":
eko "Potatis";
ha sönder ;
fall "Fruit":
eko "Äpplen";
ha sönder ;
fall "Bär":
eko "Cherry";
ha sönder ;
standard:
eko "Champinjoner";
}
//Champinjoner visas
?>

Om du utelämnar break-satsen kommer programmet att bearbeta och visa alla värden för switch-case-konstruktionen

$next= "Grönsaker";
switch ($next) (
fall "Grönsaker":
eko "Potatis";
fall "Fruit":
eko "Äpplen";
fall "Bär":
eko "Cherry";
standard:
eko "Champinjoner";
}
/* Utgång
Potatis
Äpplen
Körsbär
Champignon */
?>

En annan egenskap hos switch-case designen är möjligheten att kombinera flera alternativ till ett uttryck.

$next= "Lönn";
switch ($next) (
fall "Grönsaker":
fall "Fruit":
fall "Bär":
eko "Potatis
Äpplen
Körsbär";
ha sönder ;
fall "Lönn":
fall "Oak":
fall "gran":
eko "Skog";
ha sönder ;
standard:
eko "Champinjoner";
}
// Outputs Forest
?>

Cykler, eller upprepningsstrukturer.

Slingor är avsedda för upprepad (till skillnad från if-konstruktionen) exekvering av de operatorer som utgör konstruktionens kropp.

Processen att utföra en loop kallas iteration.

Det finns tre typer av loopar i php:

1. while och do-while är loopar med ett obestämt antal iterationer.
2. för - en slinga med ett förutbestämt antal iterationer.
3. foreach - cykel av bearbetning (uppräkning) av arrayen.

medan man bygger

Ett exempel på en enkel loop med ett påstående brukar det finnas fler.

$nästa = 1 ;
medan ($nästa<= 8 )
{
echo $nästa. "
" ;
$next++;
}
//Visar siffror från 1 till 8. Tag
ordnar dem i en kolumn
?>

Låt oss ta en närmare titt på vad som händer här, det vill säga hur det här programmet fungerar.

Den första raden deklarerar variabeln $next , som tilldelas värdet ett. Att tilldela ett värde kallas variabelinitiering.

På den andra raden kontrollerar programmet while-villkoret ($next<= 8) , которое будет являться истиной (true).

Den tredje raden exekverar den första slingan eftersom en är mindre än 8, och detta kvalificeras som sant

I den fjärde tilldelas variabeln, som i detta fall är en operator, en inkrementoperator (++), som ökar varje efterföljande värde på $next operatorn med ett.

Och programmet kommer att bearbeta och visa varje heltal efter ett tills det når 9. Och eftersom 9 visar sig vara falskt kommer loopen att sluta.

gör-under konstruktion skiljer sig genom att slingtillståndet kontrolleras inte före, utan efter iterationen.

Som ett resultat, innan loopen slutförs, kommer en iteration att exekveras, vilket är falskt

$nästa = 1 ;
do
{
echo $nästa;
}
medan ($next++<= 8 );
//Skriver ut siffror från 1 till 9 på en rad.
?>

Som du kan se, även om 9 är falsk, var nästa iteration fortfarande klar, varefter programmet kontrollerade villkoret och slingan avslutades.

Den för konstruktion, eller en slinga med en räknare, liknar i drift som while-slingan, men har en mer kompakt form av notation.

Det är bäst att använda när antalet iterationer är känt innan loopens början, och med dess hjälp kan du utföra åtgärder mer komplexa än enkel sortering genom räknarvärden.

I följande exempel kommer vi att skriva en innehållsförteckning för en liten bok.

för ($next = 1 ; $next< 5 ; $next++)
{
eko "- Sida" . $nästa. "
";
}
/*Utgångar
-Sida 1
-Sida 2
-Sida 3
-Sida 4
-Sida 5 */
?>

Låt oss i detalj överväga de tre uttrycken skrivna i slingans tillstånd (parenteser).

$nästa = 1; — en räknarvariabel som börjar räkna från ett.
$nästa< 5; — определяет продолжительность цикла.
$next++ — definierar steget för att ändra räknarvärdet. I vårt fall är det lika med en.

Uttryck separeras med semikolon. Du kan lägga flera kommandon i ett uttryck och separera dem med kommatecken. Då kan samma innehållsförteckning göras lite annorlunda

för ($next= 1 , $nev= 1 , $page= "-Page"; $nästa<= 5 ; $nev++, $next=$nev)
{
$page=$page . "-";
echo $sida, $nästa . "
";
}
/*Utgångar
-Sida 1
-Sida 2
-Sida---3
-Sida----4
-Sida-----5 */
?>

En annan egenskap hos for är förmågan att avstå från ekokonstruktionen.

Det är sant att det här alternativet inte är särskilt välkommet, eftersom det något komplicerar kodens läsbarhet på grund av dess ovanliga karaktär, men det har fortfarande rätt att existera.

I den introduceras tryckkonstruktionen i slingtillståndet

för ($next= 1 ; $next<= 5 ; print $next, print "
" , $next++);
/*Utgångar
1
2
3
4
5 */
?>

Ekokonstruktionen kan inte föras in i ett för-villkor.

Alla ovanstående konstruktioner, förutom do-while , har en alternativ form av notation - utan krulliga klammerparenteser.

I det här fallet slutar linjen med konstruktionen och tillståndet med ett kolon, och hela blocket stängs med ändkonstruktionen, vars fortsättning är den konstruktion som den appliceras på: endif, endwhile, och så vidare.

$nästa = 1 ;
medan ($nästa<= 10 ):
echo $nästa;
$next++;
endwhile ;
?>

för varje konstruktionär en speciell typ av loop designad endast för att iterera genom en array.

$next[ "tomato"] = "Röd";
$next[ "apple"] = "Grön";
$next[ "grapes"] = "Söt";
$next[ "mushroom"] = "Vit";
för varje ($next som $key => $value)
{
echo "$värde $nyckel
";
}
/*Utgångar
Röd tomat
Grönt äpple
Söta druvor
Porcini */
?>

För att lämna slingan omedelbart, om det behövs, finns det bryta konstruktion. Efter dess exekvering överförs kontrollen till uttrycket som följer loopen.

$next= 0 ;
medan ($next++< 10 )
{
if ($next== 7 ) break;
echo "$nästa
";
}
/*Utgångar
1
2
3
4
5
6 */
?>

Som du kan se avbröts slingan vid den sjunde iterationen.

Fortsätt byggandet, till skillnad från break , avbryter endast den aktuella iterationen och går vidare till nästa.

$next= 0 ;
medan ($next++< 5 )
{
if ($next== 3 ) fortsätt ;
echo "$nästa
";
}
/*Utgångar
1
2
4
5 */
?>

Som du kan se saknas iteration 3, eftersom den avbröts av fortsättningskonstruktionen

Annonsdesigner

Deklarationskonstruktioner i PHP representeras av två element. Dessa är deklarations- och typsättningskonstruktionerna.

Faktum är att de är helt identiska, och med lika framgång kan du använda både det ena och det andra för att få samma resultat.

För att göra koden lättare att förstå används huvudsakligen declare-konstruktionen. Den används för att ställa in kommandon (direktiv) för blockexekvering.

För närvarande erkänns två direktiv: bockar och kodning

Fästingdirektivet anger antalet fästingar

deklarera (tickar= 1 );

register_tick_function("tick_handler");

// Funktionen kommer att exekveras vid varje bock
?>

Kodningsdirektivet används för att specificera kodningen för hela skriptet.

declare(encoding= "UFT-8");
?>

Inklusionsdesigner

Inklusionskonstruktioner används för att mata in individuella skript och filer i ett program. Tack vare dem kan programmet monteras av färdigt material.

Inklusionskonstruktioner används också för att minska mängden skriptkod när du behöver skriva in lite text i koden. Sedan läggs txt-filen in i programmet.

Sant, i detta fall uppstår ett hot mot säkerheten för skriptet, och att lösa det, tillsammans med txt-fil Det är nödvändigt att ange en konstant i programmet och kontrollera dess existens i de medföljande filerna.

Totalt finns det 4 typer av inkluderingskonstruktioner i PHP, och alla tar bara ett argument - sökvägen till filen:

include - kopplar filen till programmet, om den saknas, utfärdar en varning;
kräver - kopplar filen till programmet, och om den saknas, stoppar skriptet;
include_once - tillåter endast en engångsinkludering av den inkluderade filen, och om den är frånvarande, utfärdar en varning;
require_once - tillåter endast engångsinkludering av den anslutna filen, och i dess frånvaro, stoppar skriptet;

Konstruktionerna include_once och require_once är praktiska eftersom de eliminerar förvirring när kapslade inkluderar, när det är möjligt att återinkludera filer som innehåller funktionsdeklarationer.

Finns det verkligen inga frågor kvar?

Sväng

Endast i vårt land är ordet "uh-huh" en synonym för orden "snälla", "tack", "god eftermiddag", "du är välkommen" och "förlåt", och ordet "kom igen" i de flesta fall ersätter "adjö".

Du kan inte vänta på någon kärlek som en buss vid -30°.

Alla PHP-skript bildas av ett antal konstruktioner. Konstruktioner kan vara operatörer, funktioner, slingor. Konstruktionerna slutar vanligtvis med semikolon. Dessutom kan konstruktioner grupperas tillsammans för att bilda en grupp konstruktioner med lockiga hängslen (...). En grupp av strukturer är också en separat struktur.

Idag ska jag kort prata om de grundläggande konstruktionerna av PHP. Låt oss börja:

Villkorliga uttalanden:

Villkorssatser är de vanligaste konstruktionerna i alla algoritmiska programmeringsspråk.

1. If-konstruktionen

if (booleskt uttryck)
operatör;
?>

If-konstruktionen innehåller ett logiskt uttryck. Om det logiska uttrycket är sant (true), kommer satsen efter if-konstruktionen att exekveras, och om det logiska uttrycket är falsk (false), kommer satsen efter if inte att exekveras. Här är ett exempel:

om ($a > $b) eko "värdet av a är större än b";
?>

2. Den andra konstruktionen

Ofta finns det ett behov av att exekvera satser inte bara i if-konstruktionens kropp, utan även om villkoret för if-konstruktionen inte är uppfyllt. I den här situationen kan du inte klara dig utan den andra konstruktionen. Denna konstruktion kommer att kallas if-else.

if (booleskt_uttryck)
instruktion_1;
annan
instruktion_2;
?>

Om Boolean_expression är sant, kör sedan
instruktion_1, annars - instruktion_2. Som på alla andra språk kan else-satsen utelämnas, i vilket fall ingenting görs för att erhålla rätt värde. Exempel:

if ($a > $b) (
eko "a är större än b" ;
) annat (
eko "a är INTE större än b";
}
?>

Om-annas-konstruktionen.

Var uppmärksam på placeringen av tjocktarmen (:)! Om du hoppar över det kommer ett felmeddelande att genereras.

if (booleskt_uttryck):
lag;
elseif(other_logical_expression):
andra_kommandon;
annan:
andra_kommandon;
endif
?>

3. elseif konstruktion

elseif är en kombination av if och else-konstruktioner. Denna konstruktion utökar den villkorliga om-annas konstruktionen.

if (booleskt_uttryck_1)
operator_1;
elseif (boolean_expression_2)
operator_2;
annan
operator_3;
?>

Ett praktiskt exempel på att använda elseif-konstruktionen:

if ($a > $b) (
eko "a är större än b" ;
) elseif ($a == $b ) (
eko "a är lika med b" ;
) annat (
eko "a är mindre än b" ;
}
?>

Kontrollstrukturer

Cykler:

Slingor låter dig upprepa ett visst (och till och med en obestämd tid - när slingans funktion beror på tillståndet) antal gånger olika uttalanden. Dessa påståenden kallas loopens kropp. Passagen av en slinga kallas en iteration.

1. Slinga med förutsättning medan

En loop med en stunds förutsättning fungerar enligt följande principer:

• Värdet på ett logiskt uttryck beräknas.
• Om värdet är sant exekveras slingans kropp annars går vi vidare till satsen som följer slingan.

medan (logiskt_uttryck)
instruktioner;
?>

I det här fallet är slingans kropp en instruktion. Vanligtvis består kroppen av en loop av ett stort antal påståenden. Exempel på en loop med en while-förutsättning:

$x = 0 ;
medan ($x++< 10 ) echo $ x ;
// Trycker 12345678910
?>

2. Slinga med do while postcondition

Till skillnad från while-loopen kontrollerar denna loop värdet på uttrycket inte före, utan efter varje pass. Således exekveras slingans kropp minst en gång.

do
{
loop_body;
}
while (logiskt_uttryck);
?>

Efter nästa iteration kontrolleras om det logiska_uttrycket är sant, och i så fall överförs kontrollen igen till början av slingan, annars avslutas slingan. Exempelskript:

$x = 1 ;
gör (
echo $x ;
) medan ($x++< 10 );
?>

3. Slinga med en för räknare

En räknarloop används för att exekvera slingans kropp ett specificerat antal gånger. Med hjälp av en for-loop kan (och bör) du skapa konstruktioner som kommer att utföra andra åtgärder än att bara iterera över ett räknarevärde.

för (initializing_commands; loop_condition; after_iteration-kommandon) (loop_body; )
?>

For-loopen börjar sitt arbete genom att utföra initialization_commands. Dessa kommandon körs endast en gång.

Efter detta kontrolleras loop_condition, om det är sant, exekveras loop_body. Efter att den sista satsen i kroppen har körts, exekveras efter_iteration-kommandona. Sedan kontrolleras loop_condition igen. Om det är sant, exekveras body_of_the-loop och commands_after_iteration.

för ($x = 0; $x< 10 ; $ x ++) echo $ x ;
//Utgångar 0123456789
?>

Det finns en alternativ syntax för for-loopen:

for(initializing_commands; loop_condition; after_iteration_commands):
operatörer;
endfor;
?>

4. Föreach array loop

foreach (array som $key=>$value)
lag;
?>

Kommandona exekveras cykliskt för varje element i arrayen, med nästa key=>value-par som hamnar i variablerna $key och $value. Exempel på en foreach loop:

$ names [ "Ivanov" ] = "Andrey" ;
$ names [ "Petrov" ] = "Boris" ;
$ names [ "Volkov" ] = "Sergey" ;
$ names [ "Makarov" ] = "Fedor" ;
foreach ($names som $key => $value) (
eka" $värde $nyckel
" ;
}
?>

Ovanstående skript utdata:

Andrey Ivanov
Boris Petrov
Sergey Volkov
Fedor Makarov

Foreach-slingan har en annan form av notation som bör användas när vi inte är intresserade av värdet på nyckeln för nästa element.

foreach (array som $value)
lag;
?>

Foreach-slingan fungerar inte på den ursprungliga arrayen, utan på en kopia av den. Detta innebär att eventuella ändringar som görs i arrayen inte kan vara "synliga" från slingans kropp. Detta gör att du kan använda inte bara en variabel som en array, utan också resultatet av någon funktion som returnerar en array (i det här fallet kommer funktionen att anropas endast en gång - innan slingan börjar, och sedan kommer arbetet att göras med en kopia av det returnerade värdet).

5. Pauskonstruktion

Mycket ofta, för att förenkla logiken i en komplex loop, är det bekvämt att kunna avbryta den under nästa iteration. Det är därför brytkonstruktionen existerar, som omedelbart lämnar slingan.

Den kan specificeras med en valfri parameter - ett nummer som indikerar vilken kapslad loop som ska lämnas. Standardinställningen är 1, d.v.s. lämnar den aktuella slingan, men andra värden används ibland.

ha sönder; // Standard
break(cykelnummer); // För kapslade loopar (numret på den avbrutna loopen anges)
?>

$x = 0 ;
medan ($x++< 10 ) {
om ($x == 3) bryta;
eko "Iteration $x
" ;
}
// När $x är 3 bryts slingan
?>

Slingan kommer att mata ut:

Iteration 1
Iteration 2

Om vi ​​behöver avbryta arbetet med en specifik (kapslad) slinga, måste vi skicka en parameter till break-konstruktionen - loop_number, till exempel break(1). Numreringen av cykler ser ut så här:

för (...) // Tredje slinga
{
för (...) // Andra slinga
{
för (...) // Första loop
{
}
}
}

6. Fortsätt byggandet

Fortsätt-konstruktionen, precis som break, fungerar bara "i tandem" med cykliska konstruktioner. Den avslutar omedelbart den aktuella iterationen av slingan och går vidare till en ny (om slingvillkoret för slingan med en förutsättning är uppfyllt, förstås). På samma sätt som för break, för fortsätt kan du specificera kapslingsnivån för slingan, som kommer att fortsätta när kontrollen återgår.

Med fortsätt kan du i princip spara antalet lockiga hängslen i din kod och öka dess läsbarhet. Detta behövs oftast i filterloopar, när du behöver iterera genom ett visst antal objekt och välja från dem endast de som uppfyller vissa villkor.

$x = 0 ;
medan ($x++< 5 ) {
om ($ x == 3 ) fortsätt;
eko "Iteration $x
" ;
}
// Slingan bryts först vid den tredje iterationen
?>

Skriptet kommer att mata ut:

Iteration 1
Iteration 2
Iteration 4
Iteration 5

Urvalsdesign:

switch fallet

Ofta, istället för flera if-else-satser placerade i rad, är det lämpligt att använda en speciell switch-case-valkonstruktion. Denna konstruktion är avsedd att välja åtgärder beroende på värdet på det angivna uttrycket.

Switch-case-konstruktionen påminner något om if-else-konstruktionen. Valkonstruktionen kan användas om det finns många möjliga alternativ, till exempel fler än 5, och för varje alternativ måste du utföra specifika åtgärder.

switch (uttryck) (
fall värde1: kommandon1;
fall värde2: kommandon2;
. . .
case valueN: kommandonN;
]
}
?>

Funktionsprincipen för växelhusdesignen är som följer:

• Värdet på uttrycket beräknas;
• En uppsättning värden visas. Låt värde1 vara lika med värdet på uttrycket som utvärderades i det första steget. Om break-konstruktionen inte är specificerad, kommer kommandona i, i+1, i+2, ..., N att utföras. Annars kommer endast kommandonummer i att utföras.
• Om inget värde från uppsättningen matchar uttryckets värde, exekveras standardblocket, om ett sådant anges.

Ett exempel på användning av switch-case-konstruktionen:

$x=1;
// Använd if-else
om ($x == 0) (
eko "x=0
" ;
) elseif ($x == 1) (
eko "x=1
" ;
) elseif ($x == 2) (
eko "x=2
" ;
}
// Använd switch-case
switch($x)(
fall 0:
eko "x=0
" ;
ha sönder;
fall 1:
eko "x=1
" ;
ha sönder;
fall 2:
eko "x=2
" ;
ha sönder;
}
?>

Ovanstående skript skrivs ut x=1 två gånger.

Returvärdeskonstruktion:

lämna tillbaka

Returkonstruktionen returnerar värden, främst från anpassade funktioner, som funktionsbegäran parametrar. När retur anropas avbryts exekveringen av den användardefinierade funktionen och returkonstruktionen returnerar specifika värden.
Om returkonstruktionen anropas från det globala omfånget (utanför användardefinierade funktioner), kommer skriptet också att avslutas, och return kommer också att returnera vissa värden.

Ett exempel på att använda returkonstruktionen för att returnera värden av typen heltal:

function retfunction()
{
retur 7 ;
}
echo retfunction(); // skriver ut "7".
?>

Ett exempel på returnerande arrayer som använder returkonstruktionen:

funktionsnummer()
{
returmatris (0 , 1 , 2 );
}
list($noll, $one, $två) = siffror();
eko $noll;
echo $one ;
echo $två;
// Skriver ut "012"
?>

Inkluderande design:

Inklusionskonstruktioner låter dig sätta ihop ett PHP-program (skript) från flera separata filer. Det finns två huvudsakliga inkluderar-konstruktioner i PHP: require och include.

1. kräver()

Require-konstruktionen låter dig inkludera kod innan skriptet körs.

kräver filnamn;

När programmet startar kommer tolken att ersätta instruktionen med innehållet i filens filnamn (denna fil kan också innehålla ett PHP-skript).

2. inkludera

Inkludera-satsen används också för att inkludera filer i PHP-skriptkod. Till skillnad från require-konstruktionen låter include-konstruktionen dig inkludera filer i PHP-skriptkoden medan skriptet körs.

inkludera filnamn;

3. require_once och include_once

Genom att använda engångsinkluderingskonstruktionerna require_once och include_once kan du vara säker på att samma fil inte kommer att inkluderas två gånger. Konstruktionerna require_once och include_once fungerar på samma sätt som requre och include. Den enda skillnaden i deras funktion är att innan en fil ingår, kontrollerar tolken om den angivna filen är inkluderad tidigare eller inte. Om ja, kommer filen inte att inkluderas igen.

Kontrollstrukturer

Introduktion

I de första fyra kapitlen i denna serie fokuserade vi på analysen av matematiska uttryck och tilldelningsoperatorer. I det här kapitlet kommer vi att fokusera på ett nytt och spännande ämne: analys och översättning av kontrollkonstruktioner som IF-satser.

Detta ämne ligger mig varmt om hjärtat eftersom det är en vändpunkt för mig. Jag lekte med uttrycksanalys precis som vi gjorde i den här serien, men jag kände ändå att jag fortfarande var långt ifrån att kunna stödja ett fullständigt språk. När allt kommer omkring har riktiga språk grenar, loopar, subrutiner och allt det där. Du kanske delade några av dessa tankar. För en tid sedan var jag dock tvungen att implementera kontrollkonstruktioner för en strukturerad assembler-förprocessor jag skrev. Föreställ dig min förvåning när jag upptäckte att detta var mycket lättare än den uttrycksanalys som jag redan hade gått igenom. Jag minns att jag tänkte "Hej, det här är lätt!" När vi är klara med den här lektionen är jag villig att slå vad om att du kommer att tänka samma sak.

Från boken Låt oss bygga en kompilator! av Crenshaw Jack

Kontrollkonstruktioner Inledning I de första fyra kapitlen i denna serie fokuserade vi på analysen av matematiska uttryck och tilldelningsoperatorer. I det här kapitlet kommer vi att fokusera på ett nytt och spännande ämne: analys och

Från boken The C# 2005 Programming Language and the .NET 2.0 Platform. av Troelsen Andrew

Iterativa konstruktioner Alla programmeringsspråk erbjuder konstruktioner som ger möjligheten att upprepa block av programkod tills ett villkor för att upprepningen ska avslutas är uppfyllt. Om du har erfarenhet av programmering är loop-satser i C# något för dig

Från Delphi-boken. Att lära sig genom exempel författare Parizhsky Sergey Mikhailovich

while- och do/while-konstruktioner While-slingan är användbar när ett block av satser måste exekveras tills ett specificerat tillstånd uppnås. Naturligtvis kräver detta att omfattningen av while-loopen definierar ett villkor för att avsluta loopen, annars du

författare Raymond Eric Stephen

Förgreningskonstruktioner Förgreningskonstruktioner gör en övergång till ett av blocken av programkod baserat på att kontrollera ett visst tillstånd. Dessa inkluderar om och

Från boken Konsten att programmera för Unix författare Raymond Eric Stephen

Cykliska konstruktioner För att organisera den cykliska exekveringen av programblock i Object Pascal-språket används tre typer av cykliska konstruktioner: for-do, while-do och repeat-tills. De skiljer sig åt i början och slutet

Från boken MySQL: A Professional's Guide författare Pautov Alexey V

Från boken Kurs "PHP-programmeringsspråk" författare Savelyeva Nina Vladimirovna

20.3. Unix Design Problems Plan 9 städar upp Unix, men lägger bara till ett nytt koncept (privat namnområde) till sin kärnuppsättning designidéer. Men finns det allvarliga problem med dessa grundläggande idéer? Kapitel 1 diskuterade flera

Från boken XSLT Technology författare Valikov Alexey Nikolaevich

5.2.10. Flödeskontrollkonstruktioner IF-, CASE-, LOOP-, WHILE-, REPLACE ITERATE- och LEAVE-konstruktionerna är fullt implementerade. Sådana strukturer kan kapslas. Till exempel,

Från boken Computerra PDA N151 (12/24/2011-12/30/2011) författare Computerra Magazine

Från boken Fundamental Algorithms and Data Structures in Delphi författare Bucknell Julian M.

XML-konstruktioner Förutom element, attribut och text kan dokument även innehålla andra konstruktioner som kommentarer, bearbetningsinstruktioner och delar av teckendata. Dessa grundläggande komponenter används för att flexibelt, men i strikt överensstämmelse med

Från boken Firebird DATABAS UTVECKLARGUIDE av Borri Helen

Vannakh Department: Gifts and Designs Författare: Mikhail Vannakh Publicerad 27 december 2011 Problem är en ganska tråkig sak. Men det finns en period då bekymmer är trevliga. Perioder är individuella när du förbereder någons födelsedag. Eller perioder av masskul,

Från boken The Art of Shell Scripting Language Programming av Cooper Mendel

Vilka är dessa konstiga $ifdef-strukturer i koden? All exempelkod som presenteras i boken, med några få särskilt noterade undantag, kommer att kompileras i Delphi 1, 2, 3, 4, 5 och 6, såväl som Kylix 1. (Framtida versioner av kompilatorer bör dock stödjas.

Från boken The End of the Holy War. Pascal vs C författaren Krivtsov M.A.

Programmeringskonstruktioner Följande avsnitt diskuterar de programmeringskonstruktioner som känns igen av PSQL. BEGIN ... END Blocks PSQL är ett strukturerat språk. Efter variabeldeklarationer omges procedursatser inom BEGIN- och END-satsparenteser. Pågående

Från författarens bok

Exempel 16-9. Omdirigering i if/then konstruktioner #!/bin/bashif [ -z "$1" ]sedan Filnamn=namn.data # Som standard om filen inte är specificerad.else Filnamn=$1fiTRUE=1if [ "$TRUE" ] # konstruktioner "om sant" och "om:" är också helt acceptabla, läs namneko $namefi<"$Filename"# ^^^^^^^^^^^^# Читает только первую строку из файла.exit

Från författarens bok

Från författarens bok

2. Mjukvarudesigner 2.1. Förgrening (val)

Dela den här artikeln:

Liknande artiklar

17 april 2015
Arbeta med funktionsguiden Hur man anropar funktionsguiden

17 april 2015
Hur man flyttar diskutrymme på enhet E till enhet C utan att installera om Windows

17 april 2015
Att göra en billig och enkel elpistol

17 april 2015
Internet Accelerator - optimering av Internetanslutning för Android Nya program för att snabba upp Internet apk