face bucle while și foreach
Bucla Do While... în VBA Excel, sintaxa acesteia și descrierea componentelor individuale. Exemple de utilizare a buclei Do While....
Bucla Do While... din VBA Excel este concepută pentru a repeta un bloc de instrucțiuni până când este îndeplinită o condiție specificată (returnează True). Sintaxa acestei bucle este similară cu cea a lui , care se repetă până când condiția este îndeplinită (returnând False).
Do While... Sintaxa buclei
Sintaxa Do While... Loop vine în două variante care determină când este testată condiția.
Condiția este verificată înainte de a executa instrucțiunile:
Condiție Do While [ instrucțiuni ] [ Exit Do ] [ instrucțiuni ] Buclă
Condiția este verificată după executarea instrucțiunilor:
Do [ instrucțiuni ] [ Exit Do ] [ instrucțiuni ] Condiție Loop While
Parantezele pătrate indică atributele opționale ale buclei Do While....
Componentele unei bucle Do While...
*Dacă nu folosiți propriul cod într-o buclă, se pierde sensul utilizării unei bucle.
**Un operator foarte util pentru bucla Do While..., deoarece în anumite circumstanțe poate deveni infinit. Dacă există acest risc, ar trebui să puteți ieși din bucla infinită VBA folosind o instrucțiune Exit Do.
Exemple de Do While... Loops
Cele mai simple cicluri
Do While... Buclă cu condiție la instrucțiunile executabile:
Sub test1() Dim a As Byte Do While a< 10 a = a + 1 Loop MsgBox a End Sub
Do While... Buclă cu o condiție după instrucțiunile executabile:
Sub test2() Dim a As Byte Do a = a + 1 Loop While a< 10 MsgBox a End Sub
În ambele cazuri, MsgBox va afișa numărul 10. Când valoarea variabilei A va fi egal cu 10, condiția verificată va returna valoarea Fals, iar bucla va fi oprită.
Mergând printre rândurile unui cearșaf
Cele două veverițe au goluri situate una vizavi de cealaltă. Fiecare scobitură conține 100 de conuri. În timpul liber, aruncă conuri în golul opus, dar nu lovesc întotdeauna. Tabelul de mai jos arată numărul de conuri aruncate de fiecare veveriță și câte dintre ele au lovit ținta.
Pe baza acestor date, trebuie să aflați câte conuri a rămas Veverița 1 în gol. Pentru a face acest lucru, trebuie să scădeți din 100 de conuri numărul de conuri aruncate de veverița 1 și să adăugați conurile aruncate în golul său de veverița 2. Începem calculele din a doua linie (în primul antet) și în condiția pentru bucla Do While... indicăm „prima celulă a liniei curente nu este goală”. Tabelul trebuie să înceapă din prima celulă a foii de lucru „A1”, iar sub acesta, cel puțin un rând trebuie să fie gol, mai precis, prima celulă a acestui rând.
Sub test3() Dim i As Long, n As Long i = 2 n = 100 Do While Cells(i, 1)<>"" Dacă Cells(i, 2) = "Sveverita 1" Atunci n = n - Cells(i, 3) Else n = n + Cells(i, 4) End If i = i + 1 Loop MsgBox n End Sub
Rezultatul afișat în mesajul de informații MsgBox va fi 40. Puteți copia tabelul într-o foaie de lucru Excel și puteți experimenta cu codul VBA.
Buclă infinită și Exit Do
Exemplu de buclă infinită:
Sub test4() Dim a As Byte Do While a< 10 a = a + 1 If a = 9 Then a = 0 End If Loop End Sub
Când această procedură este rulată, bucla Do While... începe să ruleze la nesfârșit. A trebuit să opresc buclele VBA nesfârșite în Excel 2000 și Excel 2016. În Excel 2000, comanda rapidă de la tastatură a ajutat Ctrl+Pauză, iar în Excel 2016, când închideți editorul VBA cu o cruce, apare o fereastră:
Nu are rost să așteptați ca programul să răspundă, așa că faceți clic pe „Reporniți programul” sau „Închideți programul”.
Exemplu de utilizare a operatorului Ieșiți Do:
Sub test5() Dim a As Byte, n As Long Do While a< 10 a = a + 1 n = n + 1 If a = 9 Then a = 0 End If If n = 1000 Then Exit Do End If Loop MsgBox n End Sub
Când bucla atinge 1000 de iterații, se încheie și mesajul de informații MsgBox va afișa de câte ori a fost repetată bucla Do While... din acest exemplu.
face bucle while și foreach
face bucla . . in timp ce
face...while buclaîn C# aceasta este o versiune a while cu o verificare post-condiție. Aceasta înseamnă că starea buclei este verificată după ce corpul buclei este executat. Prin urmare, buclele do...while sunt utile în situațiile în care un bloc de instrucțiuni trebuie executat cel puțin o dată. Următoarea este forma generală a unei instrucțiuni de buclă do-while:
do (operatori; ) while (condiție);
Dacă există un singur operator, acolade în această formă de notație sunt opționale. Cu toate acestea, ele sunt adesea folosite pentru a face construcția do-while mai lizibilă și a nu fi confundată cu construcția buclei while. Bucla do-while rulează atâta timp cât expresia condiționată este adevărată. Un exemplu de utilizare a unei bucle do-while este următorul program, care calculează factorialul unui număr:
Utilizarea sistemului; folosind System.Collections.Generic; folosind System.Linq; folosind System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args)) ( try ( // Calculați factorialul unui număr int i, rezultat = 1, num = 1; Console.WriteLine("Introduceți un număr:"); i = int .Parse(Console .ReadLine()); Console.Write("\n\nFactorial (0) = ", i do ( rezultat *= num++; ) while (num
buclă foreach
buclă foreach servește pentru accesul ciclic la elementele unei colecții, care este un grup de obiecte. C# definește mai multe tipuri de colecții, fiecare dintre acestea fiind o matrice. Următoarea este forma generală a instrucțiunii buclei foreach:
instrucțiunea foreach (tip loop_variable_name în colecție);
Aici tastați nume_variabilă_buclă denotă tipul și numele variabilei de control al buclei care primește valoarea următorului element al colecției la fiecare pas al buclei foreach. Și colecția denotă o colecție interogată ciclic, care în continuare reprezintă o matrice. Prin urmare, tipul variabilei buclei trebuie să se potrivească cu tipul elementului de matrice. În plus, un tip poate fi notat cu cuvântul cheie var. În acest caz, compilatorul determină tipul variabilei buclei pe baza tipului elementului de matrice. Acest lucru poate fi util pentru a lucra cu anumite tipuri de interogări. Dar, de regulă, tipul este specificat în mod explicit.
Declarația foreach buclă funcționează după cum urmează. Când începe bucla, primul element al matricei este selectat și atribuit variabilei buclei. La fiecare pas de iterație următor, următorul element de matrice este selectat și stocat într-o variabilă de buclă. Bucla se termină când sunt selectate toate elementele matricei.
O buclă foreach vă permite să iterați prin fiecare element al unei colecții (un obiect care reprezintă o listă de alte obiecte). Din punct de vedere tehnic, pentru ca ceva să fie considerat o colecție, trebuie să suporte interfața IEnumerable. Exemplele de colecții includ matrice C#, clase de colecții din spațiul de nume System.Collection și clase de colecții personalizate.
Unul dintre cele mai importante instrumente în programare este buclele. Sunt utile în cazurile în care trebuie să faceți ceva de un anumit număr de ori.
Dacă există o astfel de sarcină, de exemplu, să afișați linia „bună ziua tuturor” de 1000 de ori. Apoi, fără a folosi o buclă, în primul rând va dura mult timp și în al doilea rând, nu va arăta foarte frumos. De aceea trebuie să cunoști perfect ciclurile pentru că sunt folosite foarte, foarte des.
Există patru bucle în programare, acestea sunt while, do-while, for și foreach. Fiecare dintre ele are propria sintaxă și fiecare este folosit în anumite cazuri.
Cele mai frecvent utilizate bucle sunt for și foreach, urmate de while, iar bucla do-while este foarte rară.
Și vom începe cu o buclă while.
Sintaxa buclei while este următoarea:
Mai întâi, declarăm variabila i, care este un contor, iar în interiorul buclei incrementăm acest contor. În paranteze scriem condiția de intrare/ieșire din buclă.
Cometariu! Scrieți corect condiția de ieșire, altfel se poate întâmpla o buclă infinită și apoi scriptul se va îngheța. Un astfel de ciclu se poate întâmpla dacă, de exemplu, scriem pur și simplu adevărat în condiția de ieșire.
De exemplu, să tipărim șirul „Salut tuturor!” 10 ori.
Var i = 0; în timp ce(i "); i++; )
Variabila i poate începe de la 0 sau 1 sau de la orice alt număr.
Condiția de ieșire este în același timp și condiția de intrare. Bucla funcționează după cum urmează: În primul rând, verifică dacă variabila i este mai mică de 10, iar dacă condiția este adevărată, atunci intrăm în buclă, în caz contrar, nu. În acest caz, dacă variabila i este egală cu 30, de exemplu, atunci bucla nu se va executa, deoarece 30 nu este mai mic de 10.
Am intrat în ciclu, am imprimat linia „Bună ziua tuturor”, am incrementat contorul și din nou mergem la condiția, unde verificăm din nou dacă valoarea variabilei i este mai mică de 10, apoi intrăm în ciclu, altfel ieșim din el. Și asta se întâmplă până în momentul în care condiția de intrare devine falsă, adică valoarea variabilei i va fi 10. 10 nu este mai mic de 10, așa că nu mai intrăm în buclă, ci mergem mai departe.
Cometariu! Nu uitați să creșteți contorul (i++), altfel veți ajunge cu o buclă infinită.
Ne-am ocupat de bucla while, acum să trecem la bucla do-while.
Sintaxa buclei do-while este următoarea:
Diferența dintre o buclă while și o buclă do-while este că o buclă do-while poate fi executată cel puțin o dată, indiferent de condiție, în timp ce o buclă while nu va fi executată deloc dacă condiția este falsă.
Cometariu! La fel ca bucla while, nu uitați să creșteți contorul i.
Să trecem la practică. De exemplu, să calculăm produsul numerelor de la 1 la 10.
Var i = 1; var productie = 1; do( producție *= i; i++; )în timp ce(i
Rezultatul va fi numărul 3628800. La primul pas, am intrat imediat în buclă, în ciuda stării sale, unde a fost efectuată operația producție *= i (aceasta este aceeași cu producția = producție * 1). Apoi creștem contorul. După incrementare, are valoarea 2. Și la sfârșit verificăm condiția, dacă valoarea contorului este mai mică sau egală cu 10, atunci trecem la următoarea iterație a buclei, altfel ieșim din buclă și mergem mai departe. .
pentru buclă
După cum am scris mai sus, bucla for apare destul de des, așa că trebuie să o știți foarte bine.
sintaxa buclei for Următorul:
Pentru o mai bună înțelegere, să rezolvăm o problemă simplă. Să presupunem că trebuie să calculăm suma numerelor de la 1 la 1000 folosind o buclă for.
Var summa = 0; pentru(var i = 1; i
Salvăm documentul, îl deschidem în browser și vedem că rezultatul este 500500.
Cometariu! Dacă există o singură declarație într-o buclă, atunci acoladele nu sunt necesare.
Pentru a demonstra, să afișăm un șir pe ecran de 5 ori, de exemplu „Bună ziua!”
Pentru(var i = 1; i
Cometariu! După ce bucla este executată, ultima valoare rămâne în variabila i.
Acum să rezolvăm problema puțin mai complicată, de exemplu trebuie să tipărim șirul „Bună ziua” de 100 de ori. Și pentru ca toate acestea să nu apară într-un rând, apoi după fiecare a 10-a iterație, trecem la o nouă linie. Și la final vom tipări valoarea variabilei i.
Pentru(var i = 1; i<= 100; i++){
document.write("привет!");
if(i % 10 == 0) document.write("
"); ) document.write("
Variabila i = " + i + "
"); // i = 101buclă foreach De obicei, folosit pentru a itera obiecte și matrice. Prin urmare, voi vorbi despre asta în articolul care descrie lucrul cu matrice.
declarație de pauză este destinat să iasă forțat din buclă.
Continuați operatorul vă permite să întrerupeți iterația curentă a buclei și să treceți la următoarea.
Pentru o mai bună înțelegere, vom rezolva și o problemă simplă. Să presupunem că vrem să calculăm suma numerelor impare de la 1 la 20. Și când ajungem la a 15-a iterație, vom ieși din buclă.
Var summa = 0; pentru(var i = 1; i<= 20; i++){
//Пропускаем текущею итерацию цикла
if(i % 2 == 0) continue;
summa += i;
//Выходим совсем из цикла.
if(i == 15) break;
document.write(i + ". Итерация
"); ) document.write("
summa= " + suma + "
"); //summa = 64Salvăm documentul, îl deschidem în browser și ne uităm la rezultat.
Pentru a exersa, încercați să schimbați scriptul scris astfel încât să calculeze suma numerelor pare.
Aceasta încheie acest articol. Acum știi sintaxa buclelor while, do-while, for și cum să lucrați cu acestea. Ne-am întâlnit și noi întrerupeți și continuați declarațiile.
Bucle JavaScript asigura execuția repetată a calculelor repetitive. Ele optimizează procesul de codare prin executarea aceleiași instrucțiuni sau bloc de instrucțiuni care formează corpul unei bucle de un număr specificat de ori (folosind o variabilă contor) sau în timp ce o condiție specificată este adevărată. Buclele iterează peste o secvență de valori. Executarea unei bucle o dată este apelată repetare.
Performanța unei bucle este afectată de numărul de iterații și de numărul de operații efectuate în corpul buclei fiecărei iterații.
Următorii operatori de buclă există în JavaScript:
1) for este folosit când știi dinainte de câte ori trebuie să faci ceva;
2) for...in este folosit pentru a parcurge proprietățile obiectelor;
3) while este folosit atunci când nu știi de câte ori trebuie să faci ceva;
4) do...while funcționează în mod similar cu declarația while. Diferența este că do...while execută întotdeauna expresia din interiorul acoladelor cel puțin o dată, chiar dacă testul de condiție returnează false .
Tipuri de bucle în JavaScript, control al buclei
1. Pentru buclă
Bucla for este folosită pentru a itera elementele matricelor sau obiectelor asemănătoare matricei, cum ar fi argumente și HTMLCollection. Condiția este verificată înainte de fiecare iterație a buclei. Dacă verificarea are succes, codul din interiorul buclei este executat, în caz contrar codul din interiorul buclei nu este executat și programul continuă din prima linie imediat următoare buclei.
Următoarea buclă va imprima linia Bună ziua, JavaScript! Cinci ori.
Pentru (var i = 0; i< 5; i++) {
console.log(i + ": Hello, JavaScript!");
}
Orez. 1. Rezultatul executării unei bucle for pe consolă
1.1. Cum funcționează bucla for
Bucla for constă din trei operații diferite:
Pasul 1. initializare var i = 0; — declararea unei variabile contor care va fi verificată în timpul execuției buclei. Această variabilă este inițializată cu valoarea 0. Cel mai adesea, variabilele numite i, j și k acționează ca contoare de buclă.
Pasul 2. verificarea stării i< 5; — условное выражение, если оно возвращает true , тело цикла (инструкция в фигурных скобках) будет выполнено. В данном примере проверка условия идёт до тех пор, пока значение счётчика меньше 5 .
Pasul 3. operațiune finală i++ - operație de creștere a contorului, crește valoarea variabilei var i cu unu. În locul operației de creștere, poate fi utilizată și operația de decrementare.
La sfârșitul buclei, variabila var i este stocată la 1. Următoarea iterație a buclei este executată pentru (var i = 1; i< 5; i++) { } . Условное выражение вычисляется снова, чтобы проверить, является ли значение счётчика i всё ещё меньше 5 . Если это так, операторы в теле цикла выполняются ещё раз. Завершающая операция снова увеличивает значение переменной на единицу. Шаги 2 и 3 повторяются до тех пор, пока условие i < 5; возвращает true .
1.2. Imprimarea valorilor matricei
Pentru a imprima valorile unei matrice folosind o buclă for, trebuie să utilizați proprietatea lungime a matricei. Acest lucru vă va ajuta să determinați numărul de elemente din matrice și să faceți bucla de același număr de ori.
Scriptul de mai jos va afișa cinci mesaje cu numele culorilor:
Flori var = ["Trandafir", "Crin", "Lalea", "Iasomie", "Orhidee"]; pentru (var i = 0; i< flowers.length; i++){ alert(flowers[i] + " - это цветок."); }
Dacă valoarea proprietății length nu se modifică în timpul buclei, o puteți stoca într-o variabilă locală și apoi utilizați acea variabilă într-o expresie condiționată. În acest fel, puteți crește viteza buclei, deoarece valoarea proprietății lungime va fi preluată o singură dată pe întreaga durată a buclei.
Var flori = ["Trandafir", "Crin", "Lalea", "Iasomie", "Orhidee"], len = flori.lungime; pentru (var i = 0; i
2. Buclă pentru...în
Buclele For...in sunt folosite pentru a parcurge proprietățile obiectelor non-matrice. Acest bypass se mai numește și transfer. La traversare, se recomandă utilizarea metodei hasOwnProperty() pentru a filtra proprietățile care au fost moștenite de la prototip.
De exemplu, să creăm un obiect folosind un obiect literal.
Var user = (nume: „Alice”, vârsta: 25, țara: „Rusia”); pentru (var prop în utilizator) ( console.log(prop + ": " + utilizator); ) 
Orez. 2. Rezultatul executării buclei for...in pe consolă
Să presupunem că într-un scenariu înainte sau după crearea obiectului utilizator, prototipul obiectului Object a fost extins cu o metodă suplimentară clone().
Dacă (typeof Object.prototype.clone === „nedefinit”) ( Object.prototype.clone = funcție () (); )
Deoarece lanțul de moștenire prototip este verificat în mod constant de către interpret, toate obiectele au acces automat la noua metodă.
Orez. 3. Rezultatul repetării buclei for...in pe consolă Pentru a evita detectarea acestei metode în timp ce enumerați proprietățile obiectului utilizator, este utilizată metoda hasOwnProperty(), care va filtra proprietățile prototipului.
Var user = (nume: „Alice”, vârsta: 25, țara: „Rusia”); if (typeof Object.prototype.clone === „nedefinit”) ( Object.prototype.clone = funcția () (); ) for (var prop în utilizator) ( if (user.hasOwnProperty(prop)) ( console.log (prop + ": " + utilizator); 
Orez. 4. Rezultatul listării proprietăților unui obiect folosind metoda hasOwnProperty().
3. bucla while
Bucla while este o buclă cu o verificare preliminară a unei expresii condiționate. Declarația din interiorul buclei (bloc de cod între acolade) va fi executată dacă expresia condiționată este evaluată la true . Dacă prima verificare returnează false , blocul de instrucțiuni nu va fi executat nici măcar o dată.
După ce se termină iterația buclei, expresia condiționată este din nou testată pentru adevăr și procesul se repetă până când expresia devine false . În acest caz, programul va continua din prima linie imediat după buclă (dacă există una).
Această buclă va afișa tabelul de înmulțire pentru numărul 3:
Var i = 1; var msg = ""; in timp ce eu< 10) {
msg+= i + " x 3 = " + (i * 3) + "
"; i++; ) document.write(msg); 
Orez. 5. Rezultatul executării buclei while
4. Faceți... bucla în timp ce
Loop do...while; verifică condiția de continuare după ce bucla este executată. Spre deosebire de bucla while, în do...while; Corpul buclei este executat cel puțin o dată, deoarece condiția este verificată la sfârșitul buclei, și nu la început. Această buclă este folosită mai rar decât while , deoarece în practică o situație în care este necesară cel puțin o execuție a buclei este rară.
Var rezultat = ""; var i = 0; face ( i += 1; rezultat += i + " "; ) în timp ce (i< 5);
document.write(result);
Orez. 6. Rezultatul executării buclei do...while
În exemplul următor, instrucțiunile dintr-o buclă sunt executate o dată, chiar dacă condiția nu este adevărată.
Var i = 10; do ( document.write(i + " "); i++; ) în timp ce (i< 10);
5. Bucle infinite
Când creați orice buclă, puteți crea o buclă infinită care nu se va termina niciodată. O astfel de buclă ar putea continua să ruleze atâta timp cât computerul utilizatorului rulează. Majoritatea browserelor moderne pot detecta acest lucru și pot solicita utilizatorului să oprească rularea scriptului. Pentru a evita crearea unei bucle infinite, trebuie să fii sigur că condiția dată va reveni falsă la un moment dat. De exemplu, următoarea buclă specifică o condiție care nu returnează niciodată false, deoarece nu va fi niciodată mai mică de 10:
Pentru (var i = 25; i > 10; i++) ( document.write ("Această propoziție va rula pentru totdeauna...
");
}
6. Bucle imbricate
Se numește o buclă în interiorul unei alte bucle cuibărit. Cu fiecare iterație a buclei, bucla imbricată este executată complet. Buclele imbricate pot fi create folosind o buclă for și o buclă while.
Pentru (var count = 1; count< 3; count++) {
document.write(count + ". Строка цикла
"); pentru (var nestcount = 1; nestcount< 3; nestcount++) {
document.write("Строка вложенного цикла
");
}
}
Orez. 7. Rezultatul executării unei bucle for imbricate
7. Managementul ciclului
Bucla poate fi controlată folosind instrucțiuni break; și continuă; .
7.1. Pauza operatorului;
Pauza operatorului; încheie execuția buclei curente. Este folosit în cazuri excepționale când bucla nu se poate executa dintr-un motiv oarecare, cum ar fi dacă aplicația întâmpină o eroare. Cel mai adesea operatorul de pauză; face parte din constructul if.
Când declarația se rupe; folosit fără etichetă, vă permite să părăsiți o instrucțiune buclă sau switch. Următorul exemplu creează un contor ale cărui valori ar trebui să varieze de la 1 la 99, dar instrucțiunea break întrerupe bucla după 14 iterații.
Pentru (var i = 1; i< 100; i++) {
if (i == 15) {
break;
}
document.write(i);
document.write("
");
}
Orez. 8. Rezultatul operatorului break în bucla for
Pentru bucle imbricate, instrucțiunea break; folosit cu o etichetă care termină instrucțiunea numită. O etichetă vă permite să părăsiți orice bloc de cod. O instrucțiune numită poate fi orice instrucțiune externă unei instrucțiuni break; . Eticheta poate fi numele unei instrucțiuni if sau numele unui bloc de instrucțiuni cuprinse între acolade doar pentru a atribui o etichetă acelui bloc. Între cuvântul cheie break; iar numele etichetei nu permite o nouă linie.
Outerloop: for(var i = 0; i< 10; i++) {
innerloop:
for(var j = 0; j < 10; j++) {
if (j >3) pauză; // Ieși din bucla cea mai interioară dacă (i == 2) întrerupe bucla interioară; // Același lucru dacă (i == 4) break outerloop; // Ieșire din bucla exterioară document.write("i = " + i + " j = " + j + "
"); ) ) document.write("FINAL i = " + i + " j = " + j + "
");
7.2. Operatorul continuă;
Operatorul continuă; oprește iterația curentă a buclei și începe o nouă iterație. În acest caz, bucla while revine direct la condiția sa, iar bucla for evaluează mai întâi expresia de increment și apoi revine la condiție.
Acest exemplu va afișa toate numerele pare:
Var i; pentru(i = 1; i<= 10; i++) {
if (i % 2 !== 0) {
continue;
}
document.write("
număr par= " + i); ) 
Orez. 9. Rezultatul operatorului continue în bucla for
Operatorul continuă; poate fi folosit și în bucle imbricate cu o etichetă.
Outerloop: pentru (var i = 0; i "); pentru (var j = 0; j "); ) ) document.write("Toate buclele finalizate"+"
");
Orez. 10. Rezultatul operatorului de continuare cu o etichetă
Acest articol va acoperi încă două cicluri: in timp ceȘi face în timp ce. Sunt foarte asemănătoare între ele. Sintaxa lor este:
Fig.1 - sintaxa while 
Fig.2 - do while sintaxa
Singura diferență este că atunci când începe bucla in timp ce, starea este verificată imediat. Dacă returnează false ( fals), atunci corpul buclei nu va fi executat nici măcar o dată. Și când se utilizează face în timp ce, operatorul(ii) din corpul buclei vor fi executați imediat, iar apoi condiția din paranteze va fi verificată () după cuvântul cheie in timp ce. Și la fel, la întoarcere fals, bucla se termină în caz contrar, se execută următorul pas (iterație). Adică corpul buclei face în timp ce va fi executat cel puțin o dată, în orice scenariu.
Să vorbim despre ele separat. Sa incepem cu in timp ce. După cum am menționat mai sus, pentru ca corpul buclei să fie executat, este necesar ca la verificarea condițiilor din paranteză () , adevărat a fost returnat.
Condiția este verificată și corpul este executat până când condiția revine fals. Din aceasta rezultă că, pentru a întrerupe ciclul, trebuie să se întâmple ceva în corpul său care va afecta verificarea stării.
Aceasta poate fi valoarea unei variabile introduse de utilizator de la tastatură, care este prezentă în starea de testare a buclei. Sau ar putea fi o creștere sau o scădere a variabilei de control, care este implicată și în starea de testare.
Să luăm în considerare un exemplu cu modificarea valorii unei variabile de control în corpul unei bucle. Declarație de problemă: utilizatorul dorește să-și reîncarce contul de card prin terminal. El introduce suma de la tastatură. Oferiți programului posibilitatea de a modifica o sumă introdusă eronat.
Exemplu - bucla while C++
#include
#include folosind namespace std; int main() plata dubla = 0 ; int exit = 1 ; // variabilă de control în timp ce (ieșire == 1 ) cout<< ; cin >> plata ; cout<< ; cin >> exit ; // schimba variabila de control cout<< ; cout<< „Contul dumneavoastră a fost completat cu”<< payment << "$Multumesc! La revedere!"; cout<< „\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~\ n\n"; returnează 0; |
Variabila de control Ieșire declarat și inițializat la unul înaintea buclei in timp ce– linia 9. Prin urmare, la intrarea în buclă, verificarea stării în timp ce (ieșire == 1) va reveni Adevărat(puteți citi mai multe despre asta) iar programul va proceda la executarea corpului buclei. Această condiție este adesea scrisă astfel: în timp ce (ieșire). Cu această condiție, programul funcționează ca și cu cel precedent. Acest lucru se explică prin faptul că orice valoare a variabilei Ieșire diferit de zero va fi interpretat de compilator ca Adevărat. Corpul buclei va fi executat până când utilizatorul schimbă valoarea acestei variabile la 0. Apoi în timp ce (ieșire) va fi echivalent în timp ce (0). Adică, condiția de testare este falsă. Această intrare este mai frecventă deoarece este mai scurtă, deși nu la fel de clară ca cea din exemplu. Trebuie doar să te obișnuiești.
În rândurile 16 – 17 utilizatorului i se pune o întrebare și i se cere să facă o alegere: cout<< “Оплатить и выйти – нажмите 0. Изменить сумму – нажмите 1: “; Adică, dacă a greșit la introducerea sumei de completare, are posibilitatea să o corecteze apăsând pe 1.
De îndată ce utilizatorul introduce suma corectă și apasă 0 (care corespunde cu „Plătește și ieșire”), bucla va ieși și programul va continua să funcționeze. Ca urmare, pe ecran va apărea un mesaj despre valoarea reîncărcării contului - liniile 20 - 22.
Rezultat:
Aceeași problemă poate fi rezolvată folosind o buclă face în timp ce. În acest caz, inițial valoarea variabilei Ieșire ar putea fi orice. În orice caz, bucla va executa corpul și se va oferi să facă o alegere. Hai sa ne uitam:
#include
#include folosind namespace std; int main() setlocale(LC_ALL, "rus"); plata dubla = 0 ; int exit = 0 ; cout<< „Introduceți suma pentru a vă reîncărca contul: ”; cin >> plata ; cout<< "Plătiți și ieșiți - apăsați 0. Schimbați suma - apăsați 1: "; cin >> exit ; |
