Php exekvering av ett villkor i en loop. Använda flyktsekvenser
Det är osannolikt att du kan skriva ett seriöst skript i PHP utan att använda loopar. Vad är en cykel? Detta är en speciell typ av kontrollstruktur som låter dig köra samma kod upprepade gånger (och till och med oändligt). Följande loopar stöds i PHP:
De tre första slingorna är de du med största sannolikhet kommer att se i de flesta programmeringsspråk. Slingor, beroende på förhållandena, kan avbrytas eller fortsätta (fortsätt till nästa iteration utan att utföra loopkroppen). Låt oss ta en närmare titt på var och en av cyklerna.
för slinga
Syntax för slinga Nästa.
For(initiering; villkor; kommandon_efter_iteration) (loopkropp; )
Initieringsblocket initierar alltid räknaren, såväl som andra variabler (om nödvändigt). Villkorsblocket anger vid vilken tidpunkt slingan ska sluta köra. I blocket av kommandon som exekveras efter varje iteration av slingan ändras vanligtvis värdet på räknaren, liksom andra variabler (om nödvändigt).
// Array of values$array = array("Äpple", "Potatis", "Vattenmelon", "Blomma", "Vatten", "Mercury", "Syre", "Vete", "Ryssland", "Moskva ", " Dusch"); // Slingvillkoret låter så här: tills räknaren når ett värde lika med antalet // av arrayelement, exekveras slingans kropp för($i = 0; $i< count($array); $i++) {
print "
".($i + 1)". ".$array [$i].." ) Resultatet av cykeln blir som följer: 1. Potatis 4. Blomma Syre 8. Vete 10. Moskva.
Eftersom räknaren $i började från noll, lade vi till en till dess värde vid varje iteration för att få listan att se mer bekant ut. Efter varje iteration ökades räknarvärdet med ett, och när det nådde 11 stannade slingan. Låt oss nu ta en titt på do-while-slingan.
gör-under loop
Gör-under-slingan är annorlunda genom att den arbetar på ett eftertillstånd. Detta innebär att koden som finns i slingans kropp kommer att exekveras minst en gång. Slingsyntaxen är:
Gör (loop_body; ) while(villkor);
Denna loop används ganska sällan i webbprogrammering, men du kan behöva den i dina skript.
// Redan bekant array för oss $array = array("Äpple", "Potatis", "Vattenmelon", "Blomma", "Vatten", "Mercury", "Syre", "Vete", "Ryssland", "Moskva " , "Regn"); // Starta loopen $i = 1; gör (skriv ut"
".$i.". ".$array[($i - 1)]." ) while($i++< count($array));
/* Результат работы цикла будет таким:
1. Яблоко.
2. Картошка.
3. Арбуз.
4. Цветок.
5. Вода.
6. Ртуть.
7. Кислород.
8. Пшеница.
9. Россия.
10. Москва.
11. Ливень.
*/
Lägg märke till skillnaden mellan det vi skriver ut i den här slingan och for-slingan. Eftersom koden i huvuddelen av do-while-loopen exekveras minst en gång, sattes det initiala värdet för räknaren till noll. Hur en loop fungerar... kod exekveras, sedan testas ett villkor. Vid den första iterationen hade räknaren värdet 1. Efter iterationen visade sig en vara mindre än 11 (antalet element). Vid den senaste iterationen hade räknaren värdet 11, och det är inte på något sätt mindre än 11. Slingan stannade. While-slingan är väldigt lik do-while.
medan loop
While-slingan är förutsättning. Det kommer bara att köras när dess tillstånd är sant. Det vill säga, while-slingan kanske inte exekveras alls. Dess syntax är:
While(villkor) (loop_body; )
Tillsammans med for-slingan används while-slingan väldigt ofta.
$array = array("Äpple", "Potatis", "Vattenmelon", "Blomma", "Vatten", "Mercury", "Syre", "Vete", "Ryssland", "Moskva", "Regn"); $i = 1; while($i++<= count($array)) {
print "
".$i.". ".$array[($i - 1)]."."; ) /* Resultatet av slingan blir som följer: 1. Äpple. 2. Potatis. 3. Vattenmelon. 4. Blomma. 5. Vatten. 6. Kvicksilver 7. Syre 8. Vete.
While-slingan är den enklaste och mest begripliga för nybörjarutvecklare.
varje slinga
Foreach loop är inte som alla ovanstående. Det dök upp i PHP4 och är designat för att iterera över arrayer. Utvecklaren behöver inte uppfinna något för detta. Allt är enkelt och enkelt:
/** * Foreach loop ska förstås som "för varje av". * Matrisen som bearbetas av slingan skickas till en variabel som * endast är tillgänglig inuti slingans kropp. Om så önskas kan du också komma åt * array-nycklar. */ foreach(array som array_element) (loop_body; ) foreach(array som array_key => array_element) (loop_body; )
Funktionsprincip varje slinga helt annorlunda än for , while och do-while loopar. Därför är det ganska svårt för oerfarna utvecklare att förstå vad som exakt kan (och till och med bör) göras med det.
// Låt oss ändra den array vi redan känner till. Låt oss göra det associativt. $array = array("Äpple" => "frukt", "Potatis" => "grönsak", "Vattenmelon" => "bär", "Blomma" => "växt", "Vatten" => "vätska", “Mercury” => “metall”, “Syre” => “gas”, “Vete” => “bröd”, “Ryssland” => “vårt fosterland”, “Moskva” => “huvudstaden i vårt fosterland”, "Regn " => "popados"); $i = 1; // Vi kan göra detta foreach($array som $v) ( print "
".$i.". ".$v."."; $i++; ) /* Vi får det här oväntade resultatet: 1. frukt. 2. grönsak. 3. bär. 4. växt. 5. vätska. 6. metall. 7. gas. 8 .
".$i.". ".$k." är ".$v."; $i++; ) Nu blir resultatet så här 1. Ett äpple är en grönsak. 4. En blomma en växt 5. Kvicksilver är en gas. 10. Moskva är huvudstaden i vårt moderland.
Förstår du hur denna cykel fungerar? Om inte kan du ställa en fråga i kommentarerna till materialet.
Du kan använda konstruktioner i vilken loop som helst ha sönder eller Fortsätta. Ibland är det inte meningsfullt att fortsätta loopen eller så måste du gå vidare till nästa iteration.
$array = array("Äpple" => "frukt", "Potatis" => "grönsak", "Vattenmelon" => "bär", "Blomma" => "växt", "Vatten" => "vätska", “Mercury” => “metall”, “Syre” => “gas”, “Vete” => “bröd”, “Ryssland” => “vårt fosterland”, “Moskva” => “huvudstaden i vårt fosterland”, "Regn " => "popados"); $i = 1; // Ett exempel på hur en loop fungerar med konstruktionen continue foreach($array som $k => $v) (if($k != "Oxygen") continue; print "
".$i.". ".$k." är ".$v."; $i++; ) /* Resultatet blir så här 1. Oxygen är en gas */ $i = 1; array som $k = > $v) (if($k == "Oxygen") break; print "
".$i.". ".$k." är ".$v."; $i++; ) Resultatet blir 1. Ett äpple är en grönsak. 4. En blomma är en växt. 5. Vatten är en vätska 6. Kvicksilver är en metall.
3 år sedan
Do-while-öglor kan också användas inuti andra slingor, till exempel:
// genererar en matris med slumpmässiga jämna tal mellan 1 och 1000
$numbers = array();
$array_size = 10 ;
// för loop körs så länge som det andra villkoret utvärderas till sant
för ($i = 0; $i<
$array_size
;
$i
++) {
// körs alltid (så länge for-loopen körs)
gör (
$random = rand(1, 1000);
// om det slumpmässiga talet är jämnt (villkoret nedan är falskt), avslutas do-while-loop-exekveringen
// om det är ojämnt (villkoret nedan är sant), fortsätter loopen genom att generera ett nytt slumptal
) while (($random % 2 ) == 1 );
// jämnt slumptal skrivs till array och for-loop fortsätter iterationen tills det ursprungliga villkoret är uppfyllt
$numbers = $random ;
}
// sortering av array efter alfabet
Assort($numbers);
// utskriftsarray
Eko"
" ;" ;
print_r($nummer);
eka"
?>
11 år sedan
Det finns en stor skillnad du bör vara medveten om när du använder do-while loop vs. med en enkel while-loop: Och det är då kontrollvillkoret görs.
I en do--while-loop är utvärderingen av testtillståndet i slutet av loopen. Detta betyder att koden inuti slingan kommer att upprepas en gång innan tillståndet någonsin utvärderas. Detta är idealiskt för uppgifter som måste utföras en gång innan ett test görs för att fortsätta, till exempel test som är beroende av resultaten av loopen.
Omvänt utvärderar en vanlig medanslinga testvillkoret i början av loopen innan någon exekvering i loopblocket någonsin görs. Om ditt testvillkor av någon anledning utvärderas till falskt i början av loopen, kommer ingen av koden i din loop att exekveras.
2 år sedan
Det sista exemplet på den här sidan är helt enkelt missbruk av nyckelordet "break". Förslaget att använda 'goto' om du inte förstår missbruket av 'break' är också oroande. (Se manualsidan för 'goto' för mer än tillräckligt med skäl för att inte använda det.)
Det sista exemplet uttrycks i allmänhet bättre med ett typiskt if-else-uttalande.
om ($i<
5
) {
echo "jag är inte tillräckligt stor" ;
) annat (
$i *= $faktor ;
Om ($i >= $minimum_limit ) (
echo "jag är ok" ;
/* process i */
}
}
?>
Denna version är lättare att läsa och förstå. Och argument för kodgolf är ogiltiga, liksom denna version är 3 rader kortare.
Sammanfattningsvis, även om du säkert kan skriva kod som missbrukar nyckelordet `break`, bör du i praktiken inte ha koden lätt att läsa och förstå för den som ärver din kod.
10 år sedan
Jag är skyldig till att skriva konstruktioner utan hängslen ibland... att skriva göra--medan det verkade lite konstigt utan hängslen (( och )), men bara så att alla är medvetna om hur detta skrivs med en hängslen-- medan...
en normal stund:
while ($isValid) $isValid = doSomething ($input);
?>
ett göra--medan:
do $isValid = doSomething($input);
while ($isValid);
?>
Också ett praktiskt exempel på när man ska använda en do--medan när en enkel stund bara inte fungerar (lol)... kopiera flera noder på andra nivån från ett dokument till ett annat med DOM XML-tillägget
# öppna upp/skapa dokumenten och ta tag i rotelementet
$fileDoc = domxml_open_file("example.xml"); // befintlig xml vi vill kopiera
$fileRoot = $filDoc -> document_element();
$newDoc = domxml_new_doc ( "1.0" ); // nytt dokument vi vill kopiera till
$newRoot = $newDoc -> create_element("rootnode");
$newRoot = $newDoc -> append_child ($newRoot); // detta är noden vi vill kopiera till
# loop genom noder och klon (med djup)
$child = $filRoot -> first_child(); // first_child måste anropas en gång och kan bara anropas en gång
gör $newRoot -> append_child ($child -> clone_node (true)); // gör först, så att resultatet från first_child läggs till
while ($barn = $barn -> nästa_syskon()); // vi måste använda nästa_syskon för allt efter första_barn
?>
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 arter cykel. 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 initialiseringsuttrycket 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 linjer i en for-loop, använd tandställning som 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-loop
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 återigen bara att bryta switch-satsen fall 3: echo "This is three" break 2 // Detta kommer att bryta både switchen och for-loopen
Här kommer break 1 att bryta switch-satsen, men break 2 kommer att bryta den nuvarande satsen såväl som den överordnade, dvs både switch och för .
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 på 1, öka räknaren med 2 och skriva ut resultatet. Låt oss implementera det här exemplet 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.
9 år sedan
Bara en notering om att använda continu-satsen för att avstå från resten av en loop - se till att du inte utfärdar continu-satsen från ett SWITCH-fall - om du gör det fortsätter inte while-slingan, utan snarare själva switch-satsen.
Även om det kan verka självklart för vissa, tog det lite testning för mig, så förhoppningsvis hjälper detta någon annan.
1 år sedan
$i = - 1 ;
medan ($i) (
echo $i++;
}
?>
matar ut "-1" slutar sedan eftersom "0" (noll) utvärderas som FALSK.
detta visar varför det är viktigt för en PDO-sats som hämtar ett kolumnvärde i en while-loop för att explicit testa för FALSE.
4 år sedan
Konstigt att det står i manualen...
"Ibland, om while-uttrycket utvärderas till FALSE från allra första början, kommer de kapslade satserna" inte ens att köras en gång. "
För det kan inte vara IBLAND
Om det beter sig så är det en bugg, eftersom det ALLTID inte får köra de kapslade satserna ens en gång om WHILE-uttrycket evalueras till FALSE från första början.
Ett annat sätt att gå ur while-slingan är att använda BREAK-satsen.. se den i manualen.
Och om uttryck utvärderas till NULL är det samma som FALSE
while (uttrycket övergår till NULL)( )
17 år sedan
I slutet av while-loopen (lista/varje) kommer arraypekaren att vara i slutet.
Detta innebär att den andra while-slingan på den arrayen kommer att hoppas över!
Du kan sätta tillbaka arraypekaren med funktionen reset($myArray).
$myArray =array("aa" , "bb" , "cc" , "dd" );
reset($myArray);
while (lista ($key , $val ) = varje ($myArray )) echo $val ;
?>
3 år sedan
Enkelt pyramidmönsterprogram med while-loop
$i = 1 ;
medan($i<=
5
)
{
$j = 1 ;
medan($j<=
$i
)
{
echo "* " ;
$j++;
}
eka"
"
;
$i++;
}
?>
// eller alternativt kan du använda:
$i = 1 ;
medan($i<=
5
):
$j = 1 ;
medan($j<=
$i
):
echo "* " ;
$j++;
endwhile;
Eko"
"
;
$i++;
endwhile;
?>
6 år sedan
Istället för denna användning;
$arr = array("orange" , "banan" , "äpple" , "hallon" );
$i = 0 ;
medan ($i<
count
($arr
)) {
$a = $arr [ $i ];
eko $a . "\n" ;
$i++;
}
// eller
$i = 0 ;
$c = count($arr);
medan ($i<
$c
) {
$a = $arr [ $i ];
eko $a . "\n" ;
$i++;
}
?>
Detta skulle kunna vara mer effektivt;
medan ($a = $arr [ 1 * $i++]) eko $a . "\n" ;
?>
13 år sedan
Bara en konstruktionsanmärkning till stuart - anledningen till detta beteende är att användningen av while(value = each(array)) ökar den interna räknaren för arrayen när den går igenom. Om du tänker upprepa slingan måste du därför nollställa räknaren. t.ex:
$one = array("10", "20", "30", "40");
$two = array("a", "b", "c", "d");
$i=0;
medan($i< count($one)) {
reset($två);
medan($a = varje($två)) (
echo $a." - ".$one[$i].", ";
}
$i++;
a - 10, b - 10, c - 10, d - 10, a - 20, b - 20, c - 20, d - 20, a - 30, b - 30, c - 30, d - 30, a - 40, b - 40, c - 40, d - 40,
14 år sedan
Medan kan göra underverk om du behöver något för att skriva till en fil i kö medan något annat har tillgång till det.
Här är mitt enkla exempel:
Funktion skriv ($data, $file, $write_mode = "w") (
$lock = $fil . ".lås" ;
// kör skrivkorrigeringen för att stoppa eventuella sammandrabbningar som kan uppstå
write_fix($lås);
// skapa en ny låsfil efter write_fix() för denna skrivsession
touch ($lås);
// skriv till din fil
$öppen = fopen ($fil, $skrivläge);
fwrite ($öppen, $data);
fclose($öppen);
// döda ditt nuvarande lås
unlink ($lock);
}
Funktion write_fix ($lock_file) (
while(fil_exists ($lock_file )(
// göra något här?
// kanske sova i några mikrosekunder
// för att upprätthålla stabilitet, om detta kommer att göra det
// ta ett tag ??
}
}
?>
Denna metod rekommenderas inte för användning med program som kommer att behöva ett par sekunder för att skriva till en fil, eftersom while-funktionen kommer att äta upp många processcykler. Denna metod fungerar dock och är lätt att implementera. Den grupperar också skrivfunktionerna i en lättanvänd funktion, vilket gör livet enklare. :-)
3 år sedan
Ett coolt sätt att fortsätta utvärdera något tills det inte klarar ett test.
medan (sant) (
om ("testa") ( // är det initiala villkoret sant
// gör något som också ändrar initialtillstånd
) else ( // villkoret misslyckades
ha sönder; // lämna loop
}
}
?>
2 år sedan
// testa While Vs For php 5.6.17
$t1 = mikrotid(true);
$a = 0 ;
while($a++<=
1000000000
);
$t2 = mikrotid(sant);
$x1 = $t2 - $t1 ;
echo PHP_EOL , " > while($a++<= 100000000); : "
, $x1 , "s" , PHP_EOL ;
$t3 = mikrotid(true);
för($a = 0 ; $a<=
1000000000
;
$a
++);
$t4 = mikrotid(true);
$x2 = $t4 - $t3 ;
echo PHP_EOL , "> för($a=0;$a<= 100000000;$a++); : "
, $x2 , "s" , PHP_EOL ;
$t5 = mikrotid(true);
$a = 0 ; för(; $a++<=
1000000000
;);
$t6 = mikrotid(sant);
$x3 = $t6 - $t5 ;
echo PHP_EOL , " > $a=0; för(;$a++<= 100000000;); : "
, $x3 , "s" , PHP_EOL ;
//> while($a++<= 100000000); = 18.509671926498s
//> för($a=0;$a<= 100000000;$a++); = 25.450572013855s
//> $a=0; för(;$a++<= 100000000;); = 22.614907979965s
// ===================
//> while($a++ != 100000000); : 18.204656839371s
//> för($a=0;$a != 100000000;$a++); : 25.025605201721s
//> $a=0; for(;$a++ != 100000000;); : 22.340576887131s
// ===================
//> while($a++< 100000000); : 18.383454084396s
//> för($a=0;$a< 100000000;$a++); : 25.290743112564s
//> $a=0; för(;$a++< 100000000;); : 23.28609919548s
?>
15 år sedan
Jag gjorde ett test genom att korsa en array (enkel, men lång, numerisk array med numeriska tangenter). Mitt test hade en cykel per metod och multiplicerade varje matriselement med 100. Detta var mina resultat:
******************************************************
30870 Element Array Traversing
0,2373 seg later -> while (lista ($key, $val) = varje ($array)) ENDS
0.1916 seg later -> while (lista ($key,) = each ($array)) ENDS
0,1714 seg later -> foreach ($array AS $key=>$value) ENDS
0,0255 seg later -> while ($next = next($array)) ENDS
0,1735 seg later -> foreach ($array AS $value) SLUTAR
**************************************************************
foreach är fetare än ett tag (lista - varje), sant.
Men while(next) var snabbare än foreach.
Dessa var de vinnande koderna:
$array = $spara;
test_tid("",1);
foreach ($array AS $key=>$value)
test_time("foreach (\$array AS \$key=>\$värde)");
$array = $spara;
test_tid("",1);
reset($array);
while ($next = next($array))
( $nyckel = nyckel($array);
$array[$key] = $array[$key] * 100;
}
test_time("while (\$next = next(\$array))");
*********************************************************
Förbättringen verkar enorm, men den är inte så dramatisk i verkligheten. Resultaten varierade... Jag har en mycket lång tvådimensionell array och såg inte mer än en skillnad på 2 sekunder, men på 140+ sekunders skript. Observera dock att du tappar kontrollen över $key-värdet (om du inte har numeriska nycklar, vilket jag tenderar att undvika), men det är inte alltid nödvändigt.
Jag håller mig i allmänhet till foreach. Men den här gången fick jag felmeddelanden om tillåten minnesstorlek överskriden med Apache. Kom ihåg att foreach kopierar den ursprungliga arrayen, så detta gör nu två enorma 2D-arrayer i minnet och mycket arbete för Apache. Om du får det här felet, kontrollera dina loopar. Använd inte hela arrayen på en foreach. Få i stället nycklarna och få tillgång till cellerna direkt. Försök också använda unset och Referencing på de enorma arrayerna.
Att arbeta med din array och dina loopar är en mycket bättre lösning än att spara till tillfälliga tabeller och avaktivera (mycket långsammare).
10 år sedan
På grund av det faktum att php bara tolkar de nödvändiga elementen för att få ett resultat, fann jag det bekvämt att sammanfoga olika sql-frågor till ett påstående:
$q1 = "någon fråga på en uppsättning tabeller";
$q2 = "liknande fråga på en annan uppsättning tabeller";
if (($r1 = mysql_query ($q1 )) && ($r2 = mysql_query ($q2))) (
Medan (($row = mysql_fetch_assoc ($r1 ))||($row = mysql_fetch_assoc ($r2))) (
/* gör något med $row som kommer från $r1 och $r2 */
}
}
?>
14 år sedan
Hastighetstestet är intressant. Men det till synes snabbaste sättet innehåller en fallgrop för nybörjare som bara använder det för att det är snabbt och snabbt är coolt ;)
Att gå igenom en array med next() kommer att klippa den första posten, eftersom det är så här next() fungerar ;)
Om du verkligen behöver göra det på detta sätt, se till att din array innehåller en tom post i början. Ett annat sätt skulle vara att använda
medan ($this = aktuell ($array))(
do_something($detta);
nästa($array);
}
?>
Det finns en påverkan på hastighet för visst, men jag testade det inte. Jag skulle råda dig att hålla fast vid konventionella metoder eftersom current(),next() in while loopar är för felbenägen för mig.
Visste du,
Vad är ett tankeexperiment, gedanken experiment?
Detta är en icke-existerande praktik, en utomjordisk upplevelse, en fantasi om något som faktiskt inte existerar. Tankeexperiment är som vakna drömmar. De föder monster. Till skillnad från ett fysiskt experiment, som är ett experimentellt test av hypoteser, ersätter ett "tankeexperiment" på magiskt sätt experimentell testning med önskade slutsatser som inte har testats i praktiken, manipulerar logiska konstruktioner som faktiskt bryter mot själva logiken genom att använda obevisade premisser som bevisade sådana, att är genom substitution. Sålunda är huvuduppgiften för sökandena till "tankeexperiment" att lura lyssnaren eller läsaren genom att ersätta ett verkligt fysiskt experiment med dess "docka" - fiktiva resonemang på villkorlig frigivning utan någon fysisk kontroll.
Att fylla fysiken med imaginära "tankeexperiment" har lett till uppkomsten av en absurd, surrealistisk, förvirrad bild av världen. En riktig forskare måste skilja sådana "godisförpackningar" från verkliga värden.
Relativister och positivister hävdar att "tankeexperiment" är ett mycket användbart verktyg för att testa teorier (som också uppstår i våra sinnen) för konsekvens. I detta lurar de människor, eftersom all verifiering endast kan utföras av en källa oberoende av verifieringsobjektet. Den som ansöker om hypotesen kan inte själv vara ett test av sitt eget uttalande, eftersom orsaken till detta uttalande i sig är frånvaron av motsägelser i uttalandet som är synligt för sökanden.
Vi ser detta i exemplet med SRT och GTR, som har förvandlats till en unik typ av religion som styr vetenskap och allmän åsikt. Ingen mängd fakta som motsäger dem kan övervinna Einsteins formel: "Om ett faktum inte stämmer överens med teorin, ändra fakta" (I en annan version, "Stämmer inte faktumet överens med teorin? - Så mycket desto värre är det faktiskt ”).
Det maximala som ett "tankeexperiment" kan göra anspråk på är endast hypotesens interna konsistens inom ramen för sökandens egen, ofta ingalunda sanna, logik. Detta kontrollerar inte efterlevnaden av praxis. Verklig verifiering kan endast ske i ett verkligt fysiskt experiment.
Ett experiment är ett experiment eftersom det inte är en förfining av tanken, utan ett tankeprov. En tanke som är självständig kan inte verifiera sig själv. Detta bevisades av Kurt Gödel.