Smyčky v PHP. PHP foreach loop: dva způsoby použití Count while loop každý třetí záznam php
Příkazy smyčky se velmi často používají v jakémkoli programovacím jazyce. Téměř všechny problémy používají smyčky, takže stojí za to věnovat zvláštní pozornost jejich učení. V PHP existují 4 typy smyček:
- while (kontrola stavu předpony);
- do..while (kontrola stavu poperfixu);
- pro ;
- foreach ;
První tři smyčky jsou podobné standardním smyčkám z programovacích jazyků (C++, Pascal) a poslední (foreach) je podobná Perlu. Podívejme se na první tři operátory smyček samostatně a poslednímu se budeme věnovat v samostatné lekci. Všimněte si, že každá ze smyček umožňuje vnořené smyčky, tedy smyčku uvnitř smyčky.
Příkaz while v PHP
Poměrně jednoduchý smyčkový operátor, jehož syntaxe je velmi podobná syntaxi v jiných programovacích jazycích.
Zatímco syntaxe v PHP:
//může existovat složitá logická podmínka(operátoři; ) ?>
Podmínka obsahuje výraz, který musí být buď pravdivý (true) nebo nepravdivý (false). Pokud je podmínka pravdivá, provedou se příkazy ve složených závorkách. Poté se podmínka znovu zkontroluje na pravdivost. Pokud je podmínka nepravdivá, pak program do smyčky nevstoupí. V případě jediného příkazu lze složené závorky vynechat.
Poznámka: podmínka se může skládat z mnoha výrazů využívajících algebru logiky &&, ||, ! atd.
Stojí za to věnovat pozornost skutečnosti, že pokud jsou v podmínce operátory, musí se nějak změnit, jinak bude smyčka jednoduše probíhat v cyklech.
Zde je jednoduchý příklad použití while:
"; $i++; ) ?>
Výše uvedený příklad vytvoří následující výstup:
i = 0
i=1
i=2
i=3
i=4
Vezměte prosím na vědomí, že $i=5 nebude vytištěno, protože i se zvyšuje na samém konci smyčky, a proto jakmile dosáhne 5, podmínka pro vstup do smyčky prostě nebude splněna.
příkaz break v PHP
Pro okamžité ukončení smyčky existuje speciální příkaz break. Tento operátor se často používá k ukončení nekonečné smyčky, když je podmínka vždy pravdivá. Například výše popsaný příklad by mohl být napsán takto:
//podmínka je vždy pravdivá( echo "i =".$i."
"; $i++; if($i>=5) break; ) ?>
Výsledek bude stejný jako v předchozím příkladu.
Příkaz continue v PHP
Operátor pokračuje;
//podmínka je vždy pravdivá( echo "i =".$i."
ukončí aktuální iteraci smyčky přesunem na začátek, ale nezastaví smyčku úplně. Například:
"; $i++; if($i>=5) přerušit; jinak pokračovat; ) ?>
Výsledek tohoto příkladu bude stejný jako v předchozích příkladech.
Jak ukazuje praxe, operátoři pokračují;
"; } a zlomit;často pomáhají realizovat složité cykly.
"; } ?>
Dovolte mi uvést další příklad použití cyklu while:
//výsledky těchto dvou while se budou lišit //kvůli tvaru post-prefix a prefix
$i=0; while (++$i //forma předpony ( echo "i =".$i."
Příkaz cyklu do...while v PHP
Příkaz do...while je velmi podobný běžnému příkazu while. Jediným rozdílem je čas potřebný ke kontrole stavu. Cyklus do...while bude proveden alespoň jednou, protože kontrola probíhá na samém konci. Syntaxe do...while je:
Podívejme se na příklad:
"; $i++; ) while($i
Jeho výsledek je podobný prvním uvažovaným příkladům.
Stojí za zmínku, že operátoři pokračování;
"; } ?>
a zlomit;
lze také použít v takových cyklech.
Pro operátor smyčky v PHP
Syntaxe příkazu for je následující: Při startu dojde k počáteční inicializaci proměnných. usloviya musí obsahovat jednu nebo více podmínek ukončení smyčky. Shag obsahuje příkazy, které se provádějí na konci každé iterace. Například:
Výsledek této smyčky bude stejný jako v předchozích příkladech.
Velkou výhodou použití for je, že tělo smyčky může chybět a všechny potřebné operace se provádějí v sekci shag. Pro přehlednost uvádíme příklad:
", $i++); ?>
Komentář
: Funkce echo není v shag povolena.
Krok cyklu a podmínky mohou být velmi rozmanité. Můžete například psát nikoli i++, ale i+=5 (přírůstek o 5).
Příkaz break může mít volitelný číselný argument, který mu říká, kolik vnořených struktur má být ukončeno. Výchozí hodnota číselného argumentu je 1, která ukončí aktuální smyčku. Pokud je ve smyčce použit příkaz switch, pak break/break 1 opustí pouze konstrukci switch.
\n"; break 1; /* Ukončí pouze konstrukci přepínače. */ případ 10: echo "Iterace 10; pojďme ven
\n"; break 2; /* Ukončí konstrukci přepínače a smyčku while. */ ) ) // další příklad pro ($bar1 = -4; $bar1< 7; $bar1++) {
// проверка деления на ноль
if ($bar1 == 0) {
echo "Выполнение остановлено: деление на ноль невозможно.";
break;
}
echo "50/$bar1 = ",50/$bar1,"
";
}
?>
Samozřejmě, někdy byste raději jednoduše vynechali jednu z iterací smyčky, než abyste smyčku úplně ukončili, v takovém případě se to provede pomocí příkazu continue.
pokračovat
Chcete-li zastavit zpracování aktuálního bloku kódu v těle smyčky a přejít k další iteraci, můžete použít příkaz continue. Od operátoru přerušení se liší tím, že nezastaví smyčku, ale jednoduše přejde k další iteraci.
Operátor pokračování, stejně jako break, může mít volitelný číselný argument, který udává, na kolika úrovních vnořených smyček bude zbytek iterace přeskočen. Výchozí hodnota číselného argumentu je 1, která přeskočí pouze zbytek aktuální smyčky.
"; pokračovat; ) echo "50/$bar1 = ",50/$bar1,"
";
}
?>
Vezměte prosím na vědomí, že během běhu smyčky byla přeskočena nulová hodnota proměnné $counter, ale smyčka pokračovala další hodnotou.
goto
goto je operátor bezpodmínečného skoku. Používá se pro skok do jiné části programového kódu. Místo, kam se v programu musíte dostat, je označeno pomocí štítku (jednoduchého identifikátoru), za kterým následuje dvojtečka. Chcete-li pokračovat, požadovaný štítek se umístí za příkaz goto.
Jednoduchý příklad použití příkazu goto:
Příkaz goto má určitá omezení při jeho použití. Cílový štítek musí být ve stejném souboru a ve stejném kontextu, což znamená, že nemůžete skákat mimo hranice funkce nebo metody a nemůžete skákat uvnitř jedné z nich. Také nemůžete skočit do žádné smyčky nebo příkazu switch. Lze jej však použít k úniku z těchto konstrukcí (z cyklů a příkazů switch). Obvykle se místo víceúrovňových příkazů přerušení používá příkaz goto.
"; ) echo "po smyčce - před značkou"; // instrukce nebude provedena end: echo "Za značkou"; ?>
Smyčka for je jednou z nejčastěji používaných smyček v jakémkoli programovacím jazyce. V tomto článku se blíže podíváme na smyčku PHP for.
"; $i++; ) while($i
Cyklus for v PHP provede určitý počet bloků kódu na základě čítače. V tomto případě je počet, kolikrát musí být proveden blok kódu, určen předem před vstupem do těla smyčky.
for je jedním z nejsložitějších typů smyček. V PHP se smyčka for chová podobně jako C. Níže je struktura syntaxe:
for(výraz1;výraz2;výraz3) příkaz;
Ve výše uvedeném popisu klíčové slovo for označuje smyčku. Závorky definují výrazy a poté příkaz, který se má provést.
Jak funguje smyčka for v PHP?
Abychom pochopili, jak funguje cyklus for, musíme porozumět těmto třem výrazům. Výraz: výraz1 je první, který se provede pouze jednou před vstupem do smyčky. Provádí se bezpodmínečně. To znamená, že výraz bude proveden poprvé před vstupem do smyčky.
Výraz1 se nazývá inicializační výraz, protože se používá k inicializaci čítače, který se používá ve výrazu2 a výrazu3.
Výraz2 ( kontrola stavu) se kontroluje, aby se určilo, zda podmínka umožňuje provedení instrukce či nikoli. Poprvé běží po výrazu1 a poté před vstupem do smyčky.
Výraz2 obvykle obsahuje podmíněný příkaz k testování, zda podmínka vrátí hodnotu true nebo false . Pokud podmínka vrátí hodnotu true, provede se příkaz zapsaný ve smyčce.
Expression3 se provede na konci každé iterace po příkazu loop. Programátoři tomu obvykle říkají inkrementační výraz. Tento výraz používají ke zvýšení hodnoty čítače, který byl inicializován ve výrazu1 a vyhodnocen ve výrazu2.
Všechny tři výrazy jsou volitelné. Můžete také vytvořit smyčku PHP, jak je uvedeno níže:
for(;;) prohlášení;
for(;výraz2;výraz3) příkaz;
Pokud máme ve smyčce for více řádků, použijte složené závorky, jak je uvedeno níže:
for(výraz1;výraz2;výraz3)( příkaz1; příkaz2; příkaz3; )
Pro vývojový diagram smyčky
V prvním kroku se provede výraz1. Když se pozorně podíváte na blokové schéma, zjistíte, že pro výraz1 není žádná podmínka. výraz1 je podobný toku prováděného programu.
Další krok provede výraz2 bezprostředně po výrazu1. Kontroluje, zda je podmínka smyčky pravdivá. Pokud je podmínka pravdivá, smyčka bude pokračovat v provádění, jinak vlákno smyčku opustí.
Pokud výraz2 vrátí hodnotu true, pak třetí krok provede příkaz zapsaný ve smyčce for. Poté se provede třetí výraz expression3.
Po provedení expression3 vlákno znovu zkontroluje expression2 a cyklus pokračuje, dokud expression2 nevrátí hodnotu false.
Jednoduchý příklad cyklu for v PHP
Uvažujme případ, kdy potřebujete zobrazit čísla od 1 do 10 oddělená čárkami. Níže je uveden kód:
for($i=1;$i<=10;$i++) print $i.",";
Nebo s kudrnatou závorkou:
for($i=1;$i<=10;$i++) { print $i.","; }
Výraz $i=1 je výraz1 , který se provádí bezpodmínečně. Výraz1 použijeme k inicializaci proměnné na $i=1 .
Výraz2 je výraz $i :
$i=1; pro (;$i<=10;$i++) { print $i.","; }
$i=1; pro (;$i<=10;) { print $i.","; $i++; }
Složitý výraz ve smyčce for
Ve smyčce for můžete napsat tři výrazy. V každém výrazu ve smyčce for můžeme napsat více příkazů. Operátory musí být odděleny čárkami.
Podívejme se na příklad předchozího kódu pro tisk čísla od 1 do 10. Pomocí více operátorů ve výrazu můžete napsat níže uvedený kód:
for($i=1; $i<=10; print $i . ",", $i++);
Zde výraz3 je print $i.‘,‘, $i++ , který kombinuje dva operátory, jeden je print $i. „,“ a druhý je $ i++ .
Výše je příklad, kdy jsme ve výrazu expression3 použili více operátorů. V libovolném výrazu ale můžete použít i více operátorů. Například:
Podobně můžete vytisknout všechna lichá čísla menší než 10 pomocí následujícího kódu:
Pole a smyčka for v PHP
K iteraci polem můžete použít smyčku PHP for. Máme například pole, které obsahuje jména různých lidí. Musíme zobrazit všechna jména:
$names = array("Ankur", "John", "Joy"); $počet = počet($jména); for($counter=0;$counter<$count;$counter++){ print $names[$counter]; }
Můžete také použít vícerozměrné pole ve smyčce for:
$names = array(array("id" => 1, "name" => "Ankur"), array("id" => 2, "name" => "Joe"), array("id" => 3, "jméno" => "Jan"),); $počet = počet($jména); for ($counter = 0; $counter< $count; $counter++) { print "Name".$names[$counter]["name"]." ID".$names[$counter]["id"]."n"; }
Vnořená smyčka for
V PHP je možné použít vnořenou smyčku for. Příklad:
$metrix = pole(pole(1, 2, 3), pole(2, 1, 3), pole(3, 2, 1),); $pocet = pocet($metrix); for ($counter = 0; $counter< $count; $counter++) { $c_count = count($metrix[$counter]); for ($child = 0; $child < $c_count; $child++) { echo $metrix[$counter][$child]; } }
Máme vícerozměrné pole a k zobrazení hodnot jeho prvků používáme dvě smyčky PHP for.
Při použití vnořené smyčky můžete použít výraz rodičovské smyčky for v podřízené smyčce. Například:
pro ($i = 1; $i<= 5; $i++) {
for ($j = 1; $j <= $i; $j++) {
echo "*";
}
echo "
";
}
Výše uvedený program je jedním z nejoblíbenějších pro tisk symbolu * ve tvaru pravoúhlého trojúhelníku.
Přírůstek ve smyčce for
Téměř v každém z výše uvedených příkladů jsme použili výraz3, což je poslední výraz, jako instrukci přírůstku. Ve všech příkladech jsme také často zvýšili hodnotu o jednu, například $i++ nebo $j++ a tak dále. Počítadlo ale můžeme navýšit podle našich požadavků. Chcete-li například vytisknout všechna lichá čísla od 1 do 15, můžete inicializovat smyčku s hodnotou 1 a iterovat přes 15 a zvýšit počítadlo o 2:
for($counter = 1; $counter<=15;$counter=$counter+2){ print $counter.","; }
Výstupem výše uvedeného kódu bude " 1,3,5,7,9,11,13,15 " Zde inkrementujeme proměnnou čítače o +2 pomocí výrazu $counter=$counter+2 .
Opuštění smyčky for
Smyčku můžete za určitých podmínek přerušit pomocí klíčového slova break. Není součástí smyčky a používá se k přerušení provádění příkazů for , foreach , while , do-while a switch. Podívejme se, jak klíčové slovo break zastaví cyklus for.
Jednoduchý příklad, kde vytiskneme všechna čísla v poli do 100:
$series = array(1, 8, 5, 3, 100, 9, 7); for ($i = 0, $počet = počet($série); $i<= $count; $i++) { if (100 == $series[$i]) { break; } echo $series[$i] . " "; }
Zde přerušíme smyčku kontrolou, zda je hodnota prvku pole rovna 100.
Vnořenou smyčku PHP můžete také přerušit přes pole předáním hloubky, například break 1 , break 2 a tak dále. Viz příklad níže:
for ($i = 0;; $i++) ( switch ($i) ( case 1: echo "Toto je jedna"; break 1; //Toto přeruší pouze příkaz switch case 2: echo "Toto jsou dva"; break 1 // Toto opět přeruší pouze případ příkazu switch 3: echo "Toto jsou tři" break 2 // Tím se přeruší jak přepínač, tak smyčka for ) )
Zde break 1 přeruší příkaz switch, ale break 2 přeruší aktuální příkaz i nadřazený příkaz, tedy jak switch, tak for .
Použití pokračovat ve smyčce for
V předchozí části jsme se naučili, jak se vymanit ze smyčky. Ale co když potřebujete přeskočit jednu iteraci smyčky a vrátit se do smyčky? PHP má pro to klíčové slovo continue.
Připomeňme si příklad výstupu lichých čísel. Vše, co jsme udělali, bylo začít smyčku na 1, zvýšit počítadlo o 2 a vytisknout výsledek. Implementujme tento příklad pomocí continue:
pro ($i = 0; $i< 20; $i++) { if ($i % 2 == 0) { continue; } echo $i . ","; }
Ve výše uvedeném příkladu zkontrolujeme výraz $i%2 == 0 a pokud je pravdivý, pomocí klíčového slova continue přeskočíme zbytek cyklu a vrátíme se k výrazu3 ($i++) a poté k výrazu2 ($i:
Někdy je potřeba přenést data z databázové tabulky do pole pomocí PHP.
před 10 lety
Jen poznámka o použití příkazu continue k vynechání zbytku cyklu – ujistěte se, že nevydáváte příkaz continue z případu SWITCH – nebude pokračovat cyklus while, ale samotný příkaz switch.
I když se to někomu může zdát samozřejmé, pro mě to trvalo trochu testování, takže doufám, že to pomůže někomu jinému.
před 5 lety
Je zvláštní, že v návodu je uvedeno...
"Někdy, pokud je výraz while vyhodnocen jako FALSE od samého začátku, vnořené příkazy nebudou ani jednou spuštěny." "
Protože to NĚKDY nemůže být
Pokud se tak chová, pak je to chyba, protože VŽDY nesmí spustit vnořené příkazy ani jednou, pokud je výraz WHILE od samého začátku vyhodnocen jako FALSE.
Dalším způsobem, jak ukončit cyklus while, je použití příkazu BREAK.. viz manuál.
A pokud se výraz vyhodnotí jako NULL, je to stejné jako FALSE
while (výraz se rovná NULL) ( )
před 14 lety
Jen konstrukční poznámka pro stuarta - důvodem tohoto chování je to, že použití while(value = every(array)) zvyšuje vnitřní čítač pole při jeho procházení. Pokud tedy zamýšlíte opakovat smyčku, musíte počítadlo vynulovat. např:
$jedna = pole("10", "20", "30", "40");
$dva = pole("a", "b", "c", "d");
$i=0;
zatímco ($i< count($one)) {
reset($dva);
while($a = každý($dva)) (
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,
před 15 lety
While dokáže divy, pokud potřebujete něco do fronty pro zápis do souboru, zatímco k němu má přístup něco jiného.
Zde je můj jednoduchý příklad:
Zápis funkce ($data, $file, $write_mode = "w") (
$lock = $file . ".lock" ;
// spusťte opravu zápisu, abyste zastavili jakékoli kolize, které mohou nastat
write_fix($lock);
// vytvoří nový soubor zámku po write_fix() pro tuto relaci zápisu
dotyk ($lock);
// zápis do vašeho souboru
$otevřít = fopen($soubor, $režim_zápisu);
fwrite ($open, $data);
fclose($open);
// zruš svůj aktuální zámek
odpojit ($lock);
}
Funkce write_fix ($lock_file) (
while(file_exists ($lock_file )(
// dělat tady něco?
// možná na pár mikrosekund spát
// pro udržení stability, pokud to tak bude
// chvilku to trvá??
}
}
?>
Tato metoda se nedoporučuje používat s programy, které budou potřebovat dobrých několik sekund na zápis do souboru, protože funkce while zabere mnoho procesních cyklů. Tato metoda však funguje a je snadno implementovatelná. Seskupuje také funkce psaní do jedné snadno použitelné funkce, což usnadňuje život. :-)
před 17 lety
Na konci cyklu while (seznam / každý) bude ukazatel pole na konci.
To znamená, že druhá smyčka while na tomto poli bude přeskočena!
Ukazatel pole můžete vrátit zpět pomocí funkce reset($myArray).
$myArray =array("aa" , "bb" , "cc" , "dd" );
reset($myArray);
while (list ($key , $val ) = every ($myArray )) echo $val ;
?>
před 7 lety
Místo tohoto použití;
$arr = array("pomeranč" , "banán" , "jablko" , "malina" );
$i = 0;
zatímco ($i<
count
($arr
)) {
$a = $arr [ $i ];
echo $a . "\n" ;
$i++;
}
// nebo
$i = 0;
$c = počet($arr);
zatímco ($i<
$c
) {
$a = $arr [ $i ];
echo $a . "\n" ;
$i++;
}
?>
To by mohlo být efektivnější;
while ($a = $arr [ 1 * $i++]) echo $a . "\n" ;
?>
před 16 lety
Udělal jsem test procházení pole (jednoduché, ale dlouhé, číselné pole s numerickými klávesami). Můj test měl cyklus na metodu a vynásobil každý prvek pole 100. Toto byly moje výsledky:
******************************************************
30870 Procházení pole prvků
0,2373 seg později -> while (seznam ($key, $val) = každý ($array)) KONČÍ
0,1916 seg později -> while (seznam ($key,) = každý ($array)) KONČÍ
0,1714 seg později -> foreach ($array AS $key=>$value) KONČÍ
0,0255 seg později -> while ($next = next($array)) KONČÍ
0,1735 seg později -> foreach ($array AS $value) KONČÍ
**************************************************************
foreach je tlustší než chvíli (seznam - každý), pravda.
Nicméně while(next) bylo rychlejší než foreach.
Toto byly vítězné kódy:
$pole = $ulozit;
test_time("",1);
foreach ($array AS $key=>$value)
test_time("foreach (\$array AS \$key=>\$value)");
$pole = $ulozit;
test_time("",1);
reset($array);
while ($next = next($array))
( $klíč = klíč($pole);
$array[$key] = $array[$key] * 100;
}
test_time("zatímco (\$další = další(\$pole))");
*********************************************************
Zlepšení se zdá být obrovské, ale v reálné praxi není tak dramatické. Výsledky se lišily... Mám velmi dlouhé dvourozměrné pole a neviděl jsem rozdíl více než 2 sekundy, ale na skriptech delších 140 sekund. Všimněte si však, že ztrácíte kontrolu nad hodnotou $key (pokud nemáte numerické klávesy, kterým se obvykle vyhýbám), ale není to vždy nutné.
Obecně se držím foreach. Tentokrát jsem však u Apache dostával chyby Překročení povolené velikosti paměti. Pamatujte, že foreach kopíruje původní pole, takže to nyní vytváří dvě obrovská 2D pole v paměti a spoustu práce pro Apache. Pokud se vám zobrazuje tato chyba, zkontrolujte smyčky. Nepoužívejte celé pole na foreach. Místo toho získejte klíče a přistupte přímo k buňkám. Zkuste také použít unset a Referencing na obrovských polích.
Práce na poli a smyčkách je mnohem lepší řešení než ukládání do dočasných tabulek a deaktivace (mnohem pomalejší).
před 14 lety
Speedtest je zajímavý. Ale zdánlivě nejrychlejší způsob obsahuje úskalí pro začátečníky, kteří ho prostě používají, protože je rychlý a rychlý je cool ;)
Procházení polem pomocí next() odřízne první položku, protože takto funguje next() ;)
Pokud to opravdu potřebujete udělat tímto způsobem, ujistěte se, že vaše pole obsahuje na začátku prázdnou položku. Dalším způsobem by bylo použití
while ($this = aktuální ($array ))(
udělej_něco($toto);
dalsi($array);
}
?>
Vliv na rychlost to určitě má, ale netestoval jsem to. Doporučil bych držet se konvenčních metod, protože current(),next() v while smyčkách je pro mě příliš náchylné k chybám.
před 4 lety
Skvělý způsob, jak pořád něco hodnotit, dokud to neprojde testem.
zatímco (pravda) (
pokud ("test" ) ( // je počáteční podmínka pravdivá
// udělat něco, co také změní počáteční podmínku
) else ( // podmínka selhala
přerušení; // opustit smyčku
}
}
?>
před 4 lety
Jednoduchý program pyramidových vzorů využívající smyčku while
$i = 1;
zatímco ($i<=
5
)
{
$j = 1;
zatímco($j<=
$i
)
{
echo "* " ;
$j++;
}
echo"
"
;
$i++;
}
?>
// nebo alternativně můžete použít:
$i = 1;
zatímco ($i<=
5
):
$j = 1;
zatímco($j<=
$i
):
echo "* " ;
$j++;
na konci;
Echo"
"
;
$i++;
na konci;
?>
před 11 lety
Vzhledem k tomu, že php interpretuje pouze nezbytné prvky k získání výsledku, zjistil jsem, že je vhodné zřetězit různé dotazy SQL do jednoho příkazu:
$q1 = "nějaký dotaz na sadu tabulek";
$q2 = "podobný dotaz na jinou sadu tabulek";
if (($r1 = mysql_query ($q1 )) && ($r2 = mysql_query ($q2 ))) (
Zatímco (($row = mysql_fetch_assoc ($r1 ))||($row = mysql_fetch_assoc ($r2))) (
/* udělat něco s $row pocházejícím z $r1 a $r2 */
}
}
?>
před 3 lety
// test While Vs For php 5.6.17
$t1 = mikročas(true);
$a = 0;
zatímco($a++<=
1000000000
);
$t2 = microtime(true);
$x1 = $t2 - $t1 ;
echo PHP_EOL , " > while($a++<= 100000000); : "
, $x1 , "s" , PHP_EOL ;
$t3 = mikročas(true);
for($a = 0 ; $a<=
1000000000
;
$a
++);
$t4 = microtime(true);
$x2 = $t4 - $t3 ;
echo PHP_EOL , "> pro ($a=0;$a<= 100000000;$a++); : "
, $x2 , "s" , PHP_EOL ;
$t5 = mikročas(true);
$a = 0; for(; $a++<=
1000000000
;);
$t6 = microtime(true);
$x3 = $t6 - $t5 ;
echo PHP_EOL , " > $a=0; for(;$a++<= 100000000;); : "
, $x3 , "s" , PHP_EOL ;
//> while($a++<= 100000000); = 18.509671926498s
//> for($a=0;$a<= 100000000;$a++); = 25.450572013855s
//> $a=0; for(;$a++<= 100000000;); = 22.614907979965s
// ===================
//> while($a++ != 100000000); : 18,204656839371s
//> for($a=0;$a != 100000000;$a++); : 25,025605201721s
//> $a=0; for(;$a++ != 100000000;); : 22,340576887131s
// ===================
//> while($a++< 100000000); : 18.383454084396s
//> for($a=0;$a< 100000000;$a++); : 25.290743112564s
//> $a=0; for(;$a++< 100000000;); : 23.28609919548s
?>
před 16 lety
Toto je snadný způsob, jak pro všechny tvůrce kalkulaček udělat faktoriály. Kód je tento:
$c = ($a - 1);
$d = $a ;
zatímco ($c >= 1)
{
$a = ($a * $c );
$c --;
}
tisk (" $d ! = $a " );
?>
$a se mění a také c, takže musíme vytvořit novou proměnnou $d pro příkaz end.
Při psaní skriptů je velmi často nutné provést stejnou akci několikrát. K tomu slouží cykly. Smyčky v php, stejně jako v jiných jazycích, jsou rozděleny do několika typů:
- Smyčka s počítadlem pro
- Smyčka s podmínkou while, do-while
- Smyčka pro procházení polí foreach
Například při vytváření internetového obchodu musíme před zobrazením produktů na obrazovce odebrat produkty, jejichž stav skladu je nižší než 10. K tomu procházet polem se zbožím a pomocí podmíněného operátoru if zkontrolujeme počet zboží na skladě a odstraníme z pole veškeré zboží, jehož hodnota na skladě je menší než 10.
Pro smyčku v PHP
Smyčka s počítadlem pro- proveden určitý počet opakování. Podívejme se na příklad:
"; } ?>
V tomto příkladu bude smyčka provedena 11krát. Od 0 (protože proměnná $i = 0) do 10 (od $i<= 10). Каждую итерацию $i будет увеличено на 1 ($i++). Чтобы было понятней, сделаем еще один пример:
"; } ?>
Cyklus bude probíhat od 5 do 9($i< 10 (в предыдущем примере было <= 10)).
Smyčku lze také provést v opačném pořadí:
5; $i--) ( echo "Číslo iterace: $i
";
}
?>
Cyklus bude probíhat od 10 do 5.
Cyklus lze také provést s určitým krokem, podívejme se na příklad:
"; } ?>
Smyčka provede 3 iterace (0, 5, 10) s krokem 5. Při každé iteraci se počítadlo smyčky zvýší o 5.
foreach smyčka v PHP
foreach smyčka- nejběžnější cyklus. Vyžadováno téměř ve všech skriptech, zejména pokud skript PHP pracuje s databázemi. Používá se k procházení polí.
Podívejme se například na malý příklad:
$value) ( echo "Klíč: $klíč, Hodnota: $hodnota
";
}
?>
Když skript spustíte, uvidíte:
Klíč: 0, Hodnota: červená Klíč: 1, Hodnota: modrá Klíč: 2, Hodnota: zelená Klíč: barva, Hodnota: žlutá Klíč: test, Hodnota: design studio ox2.ru
Zatímco smyčka v PHP
zatímco smyčka se používá k provedení smyčky, pokud je splněna podmínka. Pokud podmínka není nikdy splněna, smyčka přejde do smyčky.
$i=0; while (++$i //forma předpony ( echo "i =".$i."
"; } ?>
Na obrazovce uvidíme čísla od 1 do 19
Do-while smyčka v PHP:
Cyklus do-při- funguje úplně stejně jako zatímco smyčka, jediný rozdíl je v tom, že podmínka je splněna po iteraci. Napíšeme příklad:
";) zatímco ($i< 20); //Выполняем цикл до те пор, пока $i < 20 ?>
Na obrazovce uvidíme čísla od 1 do 20. Upozorňujeme, že v předchozím příkladu s zatímco smyčka byl od 1 do 19, protože podmínka byla splněna před iterací smyčky.
Aby se přerušit cyklus existuje funkce přerušení, dovoluje dostat se ze smyčky, bez ohledu na to, kolik iterací zbývá do konce cyklu.
Aby bylo možné přeskočit iteraci a přejít k další iteraci, existuje pokračovat ve funkci.
Při tvorbě webů se téměř vždy používají cykly, bez ohledu na náklady na tvorbu webu, funkčnost a další věci. Berte je tedy vážně!
Při psaní skriptů je velmi často nutné provést stejnou akci několikrát. K tomu slouží cykly. Smyčky v PHP, stejně jako v jiných jazycích, jsou rozděleny do několika typů: Smyčka s čítačem pro Smyčka s chvíli, podmínka do-while Smyčka pro procházení polí foreach
OX2 2014-10-02 2014-10-02
