Php exit from foreach. Kapslad för loop
I fallet med kapslade loopar kan det vara nödvändigt att lämna inte bara den nuvarande kapslade loopen, utan den omslutande loopen. I det här fallet kan du komma ur situationen på grund av ytterligare variabler: for (int i=0; i Inte en särskilt vacker lösning. Det är därför sådana fall är en ursäkt för "goto": for (int i=0; i Detta är kortare, mer elegant, men.. .. med "goto" som orsakade många psykiska sjukdomar, konkurser och fall i NASDAQ-indexet fiende, som vi kommer att prata om i nästa artikel. Finns det bättre tekniker på andra språk?
Java
Java använder en namngiven blockteknik för att bli av med goto. LOOP: for(int i=0; i Även om det skulle vara mycket tydligare så här: for(int i=0; i Det finns en stark misstanke om att de inte gjorde detta bara för att det ser väldigt ut som enkel byte nyckelord"goto" till "break".PHP
I PHP ser det, enligt min mening, mycket mer elegant ut att bryta sig ur en kapslad loop. Efter "break" indikeras antalet kapslade loopar som "break"-operatören måste "lämna". I exemplet ovan, som liknar det ovan för Java, måste "break" "korsa" två tandställning")" ska vara utanför två slingor. för($i=0; $i |
Denna förbättring inträffade för författaren till dessa rader långt innan han blev bekant med PHP. Denna "parallella uppfinning" bekräftar omöjligheten av ett fullständigt monopol på goda idéer. Men eftersom det inte bara fanns idéer om "break N", när då dejta PHP Jag märkte att det inte finns något "fortsätt N" i den. En idé som är ganska "symmetrisk" mot den tidigare. Även om det inte är särskilt lätt att ge ett verkligt exempel för att illustrera dess användbarhet för användningen av "fortsätt N". Kanske kommer läsare av dessa rader att föreslå något i kommentarerna till artikeln.
Slutsats
Och så, nu måste vi presentera resultaten i en systematiserad form i kombination med vår "symmetriska parentes" stil: (int i=0 loop i Att ersätta nyckelordet "break" med "exit", som det verkar, är mer överensstämmande med Men det här är för dem som föredrar att programmera med hjälp av engelska identifierare vet vilken typ av grafiskt (istället för syntaktisk) socker som IDE ska erbjuda programmeraren. Det skulle vara logiskt att se något sånt här:
Det visar sig väldigt tydligt. Pilarna från nyckelordet "exit" indikerar vilken loop som kommer att lämnas. Om "exit" har en numerisk operand, måste pilen passera gränserna för flera cykler. Värdet på operanden är lika med antalet återstående slingor. "Fortsätt"-satsen åtföljs av en annan typ av pil, vars utseende påminner dig om att återvända till början av loopen.
Än en gång vill jag notera det grafisk design Ovanstående exempel illustrerar bara idén, men är varken det enda eller det sista alternativet. Ikoner, pilar och andra grafiska element kan och kommer att ha ett annat utseende, men för närvarande visar de själva principen för textgrafisk sammansättning av programtext.
Recensioner
2013/05/07 16:37 , koba
Generellt sett är att bryta sig ut ur en djupt kapslad slinga utanför den yttre slingan den enda ursäkten för goto-älskare. I verkligheten förstår inte sådana amatörer, och deras motståndare visar inte (kanske de förstår inte heller), en omständighet som visar deras dåliga förståelse för programmeringsprinciper. Låt oss se vad är poängen med flera kapslade slingor, från vilka du måste gå ut från den innersta? Och innebörden är mycket enkel: en viss uppsättning av absolut likvärdiga element kontrolleras, men programmeraren, av en eller annan anledning, skär denna uppsättning i flera dimensioner. Det vill säga att han presenterade vissa element som ojämlika, men vill samtidigt behandla dem som lika. Naturligtvis kan sådana programmerare inte bara lösa denna motsägelse, utan vet inte ens om dess existens. Det vill säga, de ersätter skanning av setet som helhet med skanning av individuella dimensioner. Därför måste de använda en så besvärlig teknik som att hoppa ut.
Faktum är att när programmeraren inser att han har förvandlat lika element till ojämlika element, uppstår en lösning omedelbart med en enda slinga - en passage genom hela uppsättningen av lika element.
Det hände med goto och kapslade loopar så här: int matris[n][m];
int värde;
...
for(int i=0; i
printf("värde %d hittat i cell (%d,%d)\n",värde,i,j);
goto end_loop;
}
printf("värde %d hittades inte\n",värde);
end_loop: ; Det blev utan goto och med en slinga så här (exempel i C): int matris[n][m];
int värde;
...
int i = 0;
int j = 0;
int f;
medan (!((f = (matris[i][j] == värde)) !! (i == n) && (j == m)))
om (!(j = ++j % m)) i = ++i % n;
if (f) printf("värde %d hittat i cell (%d,%d)\n",värde,i,j);
else printf("värde %d hittades inte\n",värde);
Tja, låt oss föreställa oss att vi har en rad länkar som vi itererar igenom i en omslutande slinga. Elementen i denna array hänvisar till, säg, några andra arrayer med olika längd. Vi kommer att iterera genom dessa arrayer i den inre slingan. Är inte det logiskt? Och om vi står inför uppgiften att söka, efter att ha hittat det önskade elementet, ger vi djärvt kommandot "avsluta 2" och avslutar båda cyklerna. Ett mediokert problem, en medioker lösning, men på kortast möjliga sätt.
2014/01/31 10:40 , Pensulo
Ett exempel på att lösa problemet du föreslog i VisualBasic med bara en slinga: Const iMax As Integer = 100
Privat källa (1 till iMax) som variant
"Källa är en endimensionell array som består av länkar
" till andra endimensionella arrayer med variabel längd.
Funktion SearchInArray(Required As String) Som Boolean
i = 1: SearchInArray = False
Do
j = LBound(Source(i)) " Få startindex variabel array
SearchInArray = True
Avsluta Gör" i detta exempel du kan omedelbart använda "Avsluta funktion"
Avsluta om
j = j + 1
Om j > UBound(Source(i)) Då
" Analysera som går bortom det slutliga indexet för en variabel matris
i = i + 1
Avsluta om
Slinga tills i > iMax
Slutfunktion På samma sätt kan detta problem lösas på vilket språk som helst utan att använda utgångsoperatorn från den omslutande (yttre) slingan.
Lösningen med två cykler ges nedan. Jag skulle vilja notera att i det här fallet krävdes inte utgångsoperatorn från den omslutande (yttre) slingan: Funktion SearchInArray2(Required As String) As Boolean
Dim i As Integer: Dim j As Integer
i = 1: SearchInArray2 = False
Do
j = LBound(Källa(i))
Do
Om Källa(i)(j) = Krävs då
SearchInArray2 = Sant
Avsluta Gör "Återigen, i det här exemplet kan du omedelbart använda "Avsluta funktion"
Avsluta om
j = j + 1
Loop Till j > UBound(Source(i))
Om SearchInArray2 = True Då
" Denna analys kan utelämnas om "Exit-funktionen" användes tidigare
Avsluta Do
Avsluta om
i = i + 1
Slinga tills i > iMax
Avsluta funktion
Exemplet du gav använder ytterligare variabler för att tala om för den yttre slingan om den ska fortsätta eller inte. De där. uppenbarligen en längre lösning.
2014/02/25 15:49 , Ruslan
En kortare lösning är inte alltid bättre än en längre lösning. Feng Shui-lösningen blir i alla fall bättre.
2014/07/02 05:56 , utkin
Det visar sig väldigt tydligt. Pilarna från nyckelordet "exit" indikerar vilken loop som kommer att lämnas. Om "exit" har en numerisk operand, måste pilen passera gränserna för flera cykler. Värdet på operanden är lika med antalet återstående slingor. "Fortsätt"-satsen åtföljs av en annan typ av pil, vars utseende påminner dig om att återvända till början av loopen.
För ett sådant fragment, ja, det är väldigt bekvämt. För fullständigt program det kommer att bli den ljusaste, vilda vinägretten, som skadar ögonen med sin variation.
IDE bör ha inställningar som aktiverar eller inaktiverar visningen av vissa grafiska element, till exempel: "komplettera exit-satsen med en pil", "följ med villkorliga uttalanden med ikoner", etc. Då kan alla skräddarsy det efter eget tycke.
2014/11/07 11:30 , Sergey
2 koba Att minska nivån av slingkapsling (”plattning”) är en rent teknisk teknik, som i denna situation bara har ett mål - att undvika att lämna en djupt kapslad slinga. Resultatet uppnås dock till priset av förlust av tydlighet och förståelighet för koden. Att använda "exit 2" i den här situationen har inga skadliga konsekvenser, bevarar helt kodens effektivitet och, viktigast av allt, skadar inte lättheten att läsa och förstå koden.2014/11/27 09:06 , enburk
1
Även goto-alternativet är omedelbart läsbart. Du måste titta på den korrigerade versionen och fundera över vad författaren menade...
Jag skulle också föreslå att du skriver "exit exit" istället för "exit 2".
Också ett alternativ. Men när du korsar en flerdimensionell array i en slinga måste du skriva "exit exit ... exit".
2015/11/02 01:04 , Nick
2 Sergey+1
2 coba
men om det kommer till det, så var det för C möjligt att skriva det enklare: int matris[n][m];
int värde;
int f;
for(int i = n * m; --i >= 0 && f = (matris[i] != värde);
if (!f) printf("värde %d hittat i cell (%d,%d)\n",värde,i,j);
else printf("värde %d hittades inte\n",värde); Och i allmänhet fortsätter alla dessa, går sönder osv. bara syntaktisk socker.
continue ersätts enkelt av en if()()-sats. paus är inte precis socker, naturligtvis, eftersom en extra variabel behövs för att ersätta, men om goto inte skulle missbrukas, skulle det inte behövas break... (men "skulle" står i vägen)
P.S. Även denna inmatningsmatris[n][m]; - syntaktisk socker. Men om du tar bort detta socker från språk kommer du att ha assembler.
2D-matriser är det enklaste sättet att visa fallet där "goto" är användbart eftersom det är kortare. I avsaknad av andra alternativ förstås. Men "break N" eliminerar elegant detta förmodligen den enda rimliga användningen av "goto" - inte sant? Och för att arbeta med element i set är det bättre att använda "foreach" -slingan.
2016/07/03 13:36 , rst256
Nej, det är inte sant, det finns inget behov av att gå? Precis som att du inte behöver en extra cykel så är det bra rätt alternativ redan visat här.
Och här är den första koden med goto som kom till hands: static size_t utf8_decode(const char *s, const char *e, unsigned *pch) (
osignerad ch;
Om (s >= e) (
*pch = 0;
returnera 0;
}
Ch = (osignerad char)s;
om (kap< 0xC0) goto fallback;
om (kap< 0xE0) {
if (s+1 >= e !! (s & 0xC0) != 0x80)
gå tillbaka;
*pch = ((ch & 0x1F)<< 6) !
(s&0x3F);
retur 2;
}
om (kap< 0xF0) {
if (s+2 >= e !! (s & 0xC0) != 0x80
!! (s & 0xC0) != 0x80)
gå tillbaka;
*pch = ((ch & 0x0F)<< 12) !
((s&0x3F)<< 6) !
(s&0x3F);
retur 3;
}
{
osignerad res = 0;
gå tillbaka; /* ogiltig bytesekvens, reserv */
res = (res<< 6) ! (cc & 0x3F); /* add lower 6 bits from cont. byte */
kap<<= 1; /* to test next bit */
}
om (antal > 5)
gå tillbaka; /* ogiltig bytesekvens */
res != ((lm & 0x7F)<< (count * 5)); /* add first byte */
*pch = res;
returnera räkna+1;
}
Retirera:
*pch = ch;
retur 1;
) Om reservkoden verkar liten nog för dig för att skapa den istället för att anropa goto, lägg sedan till ett par hundra rader till den, det kommer inte att ändra essensen
Om (s >= e) (
*pch = 0;
returnera 0;
}
Ch = (osignerad char)s;
om (kap< 0xC0)
om (kap< 0xE0) {
if (s+1 >= e !! (s & 0xC0) != 0x80)
fallback(*pch, ch); retur 1;
*pch = ((ch & 0x1F)<< 6) !
(s&0x3F);
retur 2;
}
om (kap< 0xF0) {
if (s+2 >= e !! (s & 0xC0) != 0x80
!! (s & 0xC0) != 0x80)
fallback(*pch, ch); retur 1;
*pch = ((ch & 0x0F)<< 12) !
((s&0x3F)<< 6) !
(s&0x3F);
retur 3;
}
{
int count = 0; /* för att räkna antalet fortsättningsbyte */
osignerad res = 0;
medan ((ch & 0x40) != 0) ( /* fortfarande har fortsättningsbytes? */
int cc = (osignerad char)s[++count];
if ((cc & 0xC0) != 0x80) /* inte en fortsättningsbyte? */
fallback(*pch, ch); retur 1;/* ogiltig bytesekvens, reserv */
res = (res<< 6) ! (cc & 0x3F); /* add lower 6 bits from cont. byte */
kap<<= 1; /* to test next bit */
}
om (antal > 5)
fallback(*pch, ch); retur 1;/* ogiltig bytesekvens */
res != ((lm & 0x7F)<< (count * 5)); /* add first byte */
*pch = res;
returnera räkna+1;
}
) Duger det? Men om det var möjligt att returnera flera värden från en funktion, skulle "retur 1, pch" se vackrare ut.
2016/08/10 18:55 , rst256
Duger det? Men om det var möjligt att returnera flera värden från en funktion, skulle "retur 1, pch" se vackrare ut.
Kanske ja. Åtminstone var det vad jag gjorde när jag anpassade den här koden för en lexer. Du, som jag förstår det, är även fallback (*pch, ch) ett makro?
2017/09/19 13:27 , Comdiv
Många har sett titeln på Dijkstras artikel, men få har läst den. Dijkstra argumenterar mot icke-sekventiella processer, och goto är bara en kränkningsmetod som fanns på tidens språk. Nu har de skapat många specialiserade goto-analoger för specialfall, med tanke på att de har löst problemet, men trots att sådana begränsade gotos är bättre än en fullfjädrade goto så löser detta inte problemet i grunden. Där koden är korrekt, praktiseras inte icke-strukturella exit. Ett exempel är MISRA C, som är de facto-standarden för inbyggda system i bilar. I dessa krav är icke-strukturella hopp nästan helt förbjudna, inklusive för tidig återgång. Ett undantag görs för det enda avbrottet per cykel.
Jag frågade Andrey Karpov, utvecklaren av den statiska kodanalysatorn PVS-Studio, hur "goto"-operatören, såväl som "break", "fortsätt" och "retur" påverkar kvaliteten på analysatorns arbete. Han svarade med ett ord: "Dåligt." Det är sant att det inte är klart om han tillskrev detta bara till "goto" eller till andra operatörer också. Han lovade att skriva en artikel om detta ämne, men på något sätt kommer inspirationen inte till honom...
2018/06/24 21:39 , rst256
Det enda som spelar roll är hur väl vi förstår vår kod och hur tydligt vi föreställer oss dess arbete i var och en av de möjliga situationerna. Bortsett från oss själva kan ingen befria vår kod från fel och buggar: varken den strikta efterlevnaden av alla regler, eller det mest idealiska och pålitliga paradigmet, eller den bästa och mest avancerade statiska analysatorn.
Utan tvekan, utan hjärna - ingenstans. Ja, inte enkelt, men belastat med relevant kunskap. Men hjärnan kan bli trött, tappa uppmärksamhet och klarar inte av mängden information som samtidigt måste hållas i åtanke. Och det är här som hjälpverktyg kommer till undsättning. Du läser om vilka fel en kodanalysator hittar, och du tänker: "Nej, i en sådan palissad av bokstäver, siffror och symboler skulle jag leta efter ett fel tills jag blir grå." Allt har sin plats: för hjärnan - kreativt arbete, för verktyg - rutin. Nåväl, språket ska om möjligt varna för misstag.
For-loopen är en av de mest använda looparna i alla programmeringsspråk. I den här artikeln ska vi titta närmare på PHP för loop.
För loopoperator i PHP
En for-loop i PHP exekverar ett kodblock ett visst antal gånger baserat på en räknare. I detta fall bestäms antalet gånger som ett kodblock måste exekveras i förväg innan det går in i slingans kropp.
för är en av de mest komplexa typerna av loopar. I PHP beter sig en for-loop på samma sätt som C. Nedan är syntaxstrukturen:
for(uttryck1;uttryck2;uttryck3) uttalande;
I beskrivningen ovan indikerar nyckelordet for en loop. Parentesen definierar uttrycken och sedan satsen som ska köras.
Hur fungerar en for loop i PHP?
För att förstå hur for-loopen fungerar måste vi förstå dessa tre uttryck. Uttryck: uttryck1 är det första, som endast exekveras en gång innan det går in i slingan. Det genomförs villkorslöst. Detta betyder att uttrycket kommer att exekveras första gången innan det går in i loopen.
Expression1 kallas initieringsuttrycket eftersom det används för att initiera räknaren som används i expression2 och expression3 .
Uttryck 2 ( tillståndskontroll) kontrolleras för att avgöra om villkoret tillåter att instruktionen exekveras eller inte. Första gången den körs efter expression1 , sedan innan den går in i loopen.
Vanligtvis innehåller expression2 en villkorlig sats för att testa om villkoret returnerar sant eller falskt. Om villkoret returnerar sant, kommer satsen som skrivits i slingan att exekveras.
Expression3 exekveras i slutet av varje iteration efter loop-satsen. Vanligtvis kallar programmerare det för ett inkrementuttryck. De använder detta uttryck för att öka värdet på en räknare som initierades i expression1 och utvärderades i expression2 .
Alla tre uttrycken är valfria. Du kan också skapa en PHP-loop som nedan:
för(;;) uttalande;
for(;uttryck2;uttryck3) uttalande;
Om vi har flera rader in för slinga, använd lockiga hängslen som visas nedan:
for(uttryck1;uttryck2;uttryck3)(påstående1;påstående2;påstående3;)
För Loop Flödesschema
I det första steget exekveras expression1. Om du tittar noga på blockdiagrammet kommer du att finna att det inte finns något villkor för uttryck1. expression1 liknar flödet av programmet som körs.
Nästa steg kör expression2 omedelbart efter expression1. Den kontrollerar om loopvillkoret är sant. Om villkoret är sant kommer loopen att fortsätta att köras, annars kommer tråden att lämna loopen.
Om expression2 returnerar true, kommer det tredje steget att exekvera satsen som skrivits i for-loopen. Efter detta kommer det tredje uttrycket expression3 att exekveras.
Efter att expression3 har körts kontrollerar tråden expression2 igen, och loopen fortsätter tills expression2 returnerar false.
Ett enkelt exempel på en for-loop i PHP
Låt oss överväga fallet när du behöver visa siffror från 1 till 10 separerade med kommatecken. Nedan är koden:
för($i=1;$i<=10;$i++) print $i.",";
Eller med ett lockigt hängslen:
för($i=1;$i<=10;$i++) { print $i.","; }
Uttrycket $i=1 är expression1 , som körs ovillkorligt. Vi använder expression1 för att initiera variabeln till $i=1 .
Expression2 är uttrycket $i:
$i=1; för(;$i<=10;$i++) { print $i.","; }
$i=1; för(;$i<=10;) { print $i.","; $i++; }
Komplext uttryck i en for-loop
Du kan skriva tre uttryck i en for-loop. Vi kan skriva flera satser i varje uttryck i en for-loop. Operatörer måste separeras med kommatecken.
Låt oss titta på exemplet med föregående kod för att skriva ut ett nummer från 1 till 10. Genom att använda flera operatorer i ett uttryck kan du skriva koden nedan:
för($i=1; $i<=10; print $i . ",", $i++);
Här är expression3 print $i.’,’, $i++ , som kombinerar två operatorer, en är print $i. ',' och den andra är $ i++ .
Ovan är ett exempel där vi har använt flera operatorer i expression3 . Men du kan också använda flera operatorer i alla uttryck. Till exempel:
På samma sätt kan du skriva ut alla udda tal mindre än 10 med följande kod:
Array och for loop i PHP
Du kan använda en PHP for loop för att iterera genom en array. Till exempel har vi en array som innehåller namnen på olika personer. Vi måste visa alla namn:
$names = array("Ankur", "John", "Joy"); $count = count($names); for($counter=0;$counter<$count;$counter++){ print $names[$counter]; }
Du kan också använda en flerdimensionell array i en for-loop:
$names = array(array("id" => 1, "name" => "Ankur"), array("id" => 2, "name" => "Joe"), array("id" => 3, "namn" => "John")),); $count = count($names); för ($counter = 0; $counter< $count; $counter++) { print "Name".$names[$counter]["name"]." ID".$names[$counter]["id"]."n"; }
Kapslad för loop
Det är möjligt att använda en kapslad för loop i PHP. Exempel:
$metrix = array(array(1, 2, 3), array(2, 1, 3), array(3, 2, 1),); $count = count($metrix); för ($counter = 0; $counter< $count; $counter++) { $c_count = count($metrix[$counter]); for ($child = 0; $child < $c_count; $child++) { echo $metrix[$counter][$child]; } }
Vi har en flerdimensionell array och vi använder två PHP för loopar för att visa värdena för dess element.
När du använder en kapslad loop kan du använda den överordnade för looputtryck i den underordnade loopen. Till exempel:
för ($i = 1; $i<= 5; $i++) {
for ($j = 1; $j <= $i; $j++) {
echo "*";
}
echo "
";
}
Ovanstående program är ett av de mest populära för att skriva ut *-symbolen i form av en rätvinklig triangel.
Öka i en for-slinga
I nästan vart och ett av exemplen ovan använde vi expression3 , som är det sista uttrycket, som inkrementinstruktionen. Vi ökade också ofta värdet med ett i alla exempel, till exempel $i++ eller $j++ och så vidare. Men vi kan utöka räknaren enligt våra krav. Till exempel, för att skriva ut alla udda tal från 1 till 15, kan du initiera slingan med värdet 1 och iterera genom 15, öka räknaren med 2:
for($räknare = 1; $räknare<=15;$counter=$counter+2){ print $counter.","; }
Utdata från ovanstående kod kommer att vara " 1,3,5,7,9,11,13,15 " Här ökar vi räknarvariabeln med +2 med hjälp av uttrycket $counter=$counter+2 .
Går ur for-slingan
Du kan bryta en slinga under ett visst tillstånd med hjälp av nyckelordet break. Det är inte en del av en loop och används för att avbryta exekveringen av for , foreach , while , do-while och switch-satser. Låt oss se hur nyckelordet break stoppar en for-loop.
Ett enkelt exempel där vi skriver ut alla siffror i en array upp till 100:
$series = array(1, 8, 5, 3, 100, 9, 7); för ($i = 0, $count = count($series); $i<= $count; $i++) { if (100 == $series[$i]) { break; } echo $series[$i] . " "; }
Här bryter vi slingan genom att kontrollera om värdet på arrayelementet är lika med 100.
Du kan också bryta en kapslad PHP-loop genom en array genom att skicka djupet, till exempel break 1 , break 2 och så vidare. Se exemplet nedan:
for ($i = 0;; $i++) ( switch ($i) ( fall 1: echo "This is one"; break 1; //Detta kommer bara att bryta switch-satsen fall 2: echo "This is two"; break 1 ; // Detta kommer bara att bryta switch-satsen fall 3: echo "This is three" break 2;
Här bryter break 1 switch-satsen, men break 2 kommer att bryta den aktuella satsen såväl som föräldern, det vill säga både switchen och for .
Använd fortsätt i en for-loop
I föregående avsnitt lärde vi oss hur man bryter sig ur en loop. Men vad händer om du behöver hoppa över en iteration av loopen och gå tillbaka till loopen? PHP har nyckelordet fortsätt för detta.
Låt oss komma ihåg ett exempel på att mata ut udda tal. Allt vi gjorde var att starta slingan vid 1, öka räknaren med 2 och skriva ut resultatet. Låt oss implementera detta exempel med hjälp av fortsätt :
för ($i = 0; $i< 20; $i++) { if ($i % 2 == 0) { continue; } echo $i . ","; }
I exemplet ovan kontrollerar vi uttrycket $i%2 == 0 och om det är sant, med hjälp av nyckelordet continue, hoppar vi över resten av loopen och återgår till expression3 ($i++) och sedan till expression2 ($i:
Ibland behöver du överföra data från en databastabell till en array med PHP:
10001, "name" => "Ankur", "country" => "Indien"), array("id" => 20002, "name" => "Joy", "country" => "USA"), array ("id" => 10003, "name" => "John", "country" => "UK"), array("id" => 20001, "name" => "Steve", "country" => "Frankrike")),); ?>
| ID | namn | Land | " . $table_data[$i]["id"] . " | " . "" . $table_data[$i]["name"] . " | " . "" . $table_data[$i]["country"] . " | " . ""; } ?>
|---|
Ovanstående kod kommer att generera tabellen.
Mycket ofta när du skriver skript måste du utföra samma åtgärd flera gånger. Det är vad cykler är till för. Slingor i php, liksom på andra språk, är indelade i flera typer:
- Slinga med en för disk
- Loop with while, do-while condition
- Slinga för att korsa arrayer för varje
Till exempel, när vi skapar en webbutik, innan vi visar produkter på skärmen, måste vi ta bort produkter vars lagersaldo är under 10. För att göra detta måste vi slinga genom arrayen med varor och med hjälp villkorlig operatör om vi kontrollerar antalet produkter i lagret och tar bort alla produkter vars värde i lagret är mindre än 10 från arrayen.
För loop i PHP
Slinga med en för disk- utfört ett visst antal gånger. Låt oss titta på ett exempel:
"; } ?>
I det här exemplet kommer loopen att exekveras 11 gånger. Från 0 (eftersom variabeln $i = 0) till 10 (eftersom $i<= 10). Каждую итерацию $i будет увеличено на 1 ($i++). Чтобы было понятней, сделаем еще один пример:
"; } ?>
Slingan kommer att gå från 5 till 9($i< 10 (в предыдущем примере было <= 10)).
Slingan kan också utföras i omvänd ordning:
5; $i--) ( echo "Iterationsnummer: $i
";
}
?>
Cykeln kommer att köras från 10 till 5.
Cykeln kan också utföras med ett visst steg, låt oss titta på ett exempel:
"; } ?>
Slingan kommer att utföra 3 iterationer (0, 5, 10) med ett steg på 5. Varje iteration kommer loopräknaren att ökas med 5.
foreach loop i PHP
varje slinga- den vanligaste cykeln. Krävs i nästan alla skript, speciellt om php-skript fungerar med databaser. Används för att korsa arrayer.
Låt oss till exempel titta på ett litet exempel:
$value) ( eko "Key: $key, Value: $value
";
}
?>
När du kör skriptet ser du:
Nyckel: 0, Värde: röd Nyckel: 1, Värde: blå Nyckel: 2, Värde: grön Nyckel: färg, Värde: gul Nyckel: test, Värde: designstudio ox2.ru
Medan loop i PHP
medan loop används för att exekvera en loop så länge som ett villkor är uppfyllt. Om villkoret aldrig uppfylls kommer slingan att gå in i en slinga.
Låt oss titta på ett exempel:
"; } ?>
På skärmen kommer vi att se siffror från 1 till 19
Do-while loop i PHP:
Cykel göra medan- fungerar precis som medan loop, är den enda skillnaden att villkoret är uppfyllt efter iteration. Låt oss skriva ett exempel:
"; ) medan ($i< 20); //Выполняем цикл до те пор, пока $i < 20 ?>
På skärmen kommer vi att se siffror från 1 till 20. Observera att i föregående exempel med medan loop var från 1 till 19, eftersom villkoret var uppfyllt före loop-iterationen.
För att bryta cykeln existerar brytfunktion, tillåter hon komma ur slingan, oavsett hur många iterationer som återstår till slutet av slingan.
För att hoppa över en iteration och gå vidare till nästa iteration, finns det fortsätta funktionen.
När man skapar webbplatser används nästan alltid cykler, oavsett kostnad för att skapa sajten, funktionalitet och annat. Så ta dem på allvar!
Mycket ofta när du skriver skript måste du utföra samma åtgärd flera gånger. Det är vad cykler är till för. Slingor i PHP, liksom på andra språk, är uppdelade i flera typer: Slinga med en räknare för Slinga med en stund, gör-under-tillstånd Slinga för att korsa arrayer föreach
OX2 2014-10-02 2014-10-02