Js ბიბლიოთეკა მასივებთან მუშაობისთვის. JavaScript მასივის მეთოდები. ▍reduce() მეთოდის ძლიერი მხარეები

ზოგიერთ შემთხვევაში საჭიროა კოდის შესრულება, სანამ არ მიაღწევს სასურველი შედეგი. ამისათვის PHP უზრუნველყოფს while, for და foreach მარყუჟებს.

PHP-ში მარყუჟის სინტაქსის დროს

Სინტაქსი ციკლიხოლო:

გამოყენების მაგალითი ხოლო მარყუჟი PHP-ში:

php while მარყუჟის ზემოთ მოცემულ მაგალითში, მრიცხველის ცვლადი $i პირველად ინიციალიზებულია 0-ზე.

while მარყუჟის მდგომარეობა არის $i< 10 . Это означает, что мы проверяем, меньше ли переменная, чем 10.

ყველაფერი რაც შედის ბრეკეტები– ეს არის მარყუჟის ინსტრუქციები (სხეული). ისინი მეორდებიან მანამ, სანამ მდგომარეობა არ დაბრუნდება მართალია. ზემოთ მოყვანილ მაგალითში $i იბეჭდება ეკრანზე და შემდეგ მრიცხველის ცვლადი იზრდება 1-ით. ეს მნიშვნელოვანია ისე, რომ მარყუჟის მდგომარეობა საბოლოოდ ჩავარდეს. თუ მარყუჟის პირობა ყოველთვის დაცულია, მაგალითად იმიტომ, რომ დაგავიწყდათ მრიცხველის $i ცვლადის გაზრდა, მაშინ სკრიპტი შევა. გაუთავებელი ციკლი. საბედნიეროდ, გარკვეული პერიოდის შემდეგ PHP დროშეწყვეტს თქვენი სკრიპტის შესრულებას.

თქვენ შეგიძლიათ გააკეთოთ როგორც მარყუჟის მდგომარეობა, ასევე მარყუჟის სხეული, როგორც გსურთ. მაგალითად, გამოიყენეთ ხოლო შიგნით, ხოლო php, გამოიყენეთ php სანამ გაიმეორეთ მასივის მეშვეობით (მასივი ) ან განსაზღვრეთ ერთზე მეტი მრიცხველი ცვლადი:

$წთ) (echo "count1: $count1; count2: $count2
"; $ counter1 += 2; // შემოკლებული გამოხატულება $counter1 = $counter1 + 2-ისთვის; $counter2 -= 3; // შემოკლებული გამოხატულება $count2 = $count2-3; ) ?>

მაგალითი განსაზღვრავს ორ ცვლადს: $ counter 1 და $ counter 2. ერთი ცვლადი იზრდება 2-ით, ხოლო მეორე მცირდება 3-ით. while ციკლი მუშაობს მანამ, სანამ ორივე პირობა დაკმაყოფილებულია $ count 1< $ max и $ count 2 >$ მინ.

შესვენების და გაგრძელების საკვანძო სიტყვების ეფექტი მარყუჟზე

ბრძანების გამოყენებით შესვენებაშეუძლია შეწყვიტოს while ციკლის შესრულება PHP. ვთქვათ, ვეძებთ კონკრეტული მომხმარებელი. შემდეგ შეგიძლიათ გაიაროთ ყველა მომხმარებელი გარკვეული პერიოდის განმავლობაში. თუ ვიპოვით სასურველი მომხმარებელი, შემდეგ შეაჩერეთ მარყუჟის გამოყენება საკვანძო სიტყვა შესვენება.

შესვენების საკვანძო სიტყვის გამოყენების მარტივი მაგალითი:

ხოლო ($ დათვლა< $max) { if ($count == 10) { echo "Останавливаемся на числе 10"; break; } echo "$count,"; $counter += $increment; // увеличивает $count на значение $increment } ?>

ეს კოდი იმეორებს რიცხვებში ზრდადი თანმიმდევრობით 0-დან $max = 30-მდე, $count ცვლადს ემატება $increment-ის მნიშვნელობა, სხვა სიტყვებით რომ ვთქვათ რიცხვი 2. მაგრამ თუ $count ცვლადი უდრის 10-ს, შემდეგი იქნება მოხდეს: while მარყუჟიდან გასვლა php.

საკვანძო სიტყვა გაგრძელება არ წყვეტს მარყუჟსხოლო php-ში არის მთლიანად, მაგრამ უბრალოდ გამოტოვებს მარყუჟის სხეულის დანარჩენ ნაწილს. ქვემოთ მოყვანილი მაგალითი ამას ადასტურებს:

ხოლო ($ დათვლა< $max) { $counter += $increment; // увеличивает $payer на $increment if ($count >= 10 && $ რაოდენობა<= 15) { echo "Число между 10 и 15
"; გაგრძელება;)
ექო "$count
"; } ?>

ეს ციკლი იწყება 0-დან და ზრდის მრიცხველს $max-მდე. $counter ცვლადი ყოველთვის იზრდება $increment ცვლადის მნიშვნელობით. ანუ იღებს მნიშვნელობებს 0, 2, 4 და ა.შ.

თუ $count ცვლადს აქვს მნიშვნელობა 10-დან 15-მდე, ტექსტი და განცხადება დაიბეჭდება ეკრანზე. გააგრძელეგამოტოვებს სხვა გამონათქვამებს მარყუჟის სხეულში. შედეგად, ჩვენ ვხედავთ, რომ რიცხვები 10, 12 და 14 არ არის გამომავალი.

do-while ციკლი PHP-ში

მცირე მოდიფიკაცია ხოლოარის do - while ციკლი. IN ამ შემთხვევაშიმარყუჟის მდგომარეობა შემოწმდება მხოლოდ მას შემდეგ, რაც მისი სხეული შესრულდება. ეს ნიშნავს, რომ მარყუჟის სხეული ერთხელ მაინც შესრულდება.

Do-while მარყუჟის სინტაქსი:

დავუშვათ, რომ ჩვენ გვინდა გენერირება შემთხვევითი რიცხვი, რომელიც უნდა იყოს 0-დან 10-მდე ან 20-დან 30-მდე. რანდის ფუნქციის განსაზღვრის მიხედვით ( $ მინ, $მაქს), შეგიძლიათ შემთხვევით გენერირება რიცხვი შორის $ მინდა $ მაქს:

10 && $ შემთხვევითი< 20) { $random = rand (0, 30); }
echo "ჩვენი შემთხვევითი ნომერი: $ შემთხვევითი"; ?>

php მარყუჟის გამოყენება კეთება— ხოლო, შეგიძლიათ მიიღოთ გამოხატვის მნიშვნელობა $ შემთხვევითი ცვლადის ინიციალიზაციის გარეშე. მარყუჟის სხეული შესრულებულია მდგომარეობის ტესტირებამდე. მაშინ ზემოთ მოყვანილი მაგალითი ასე გამოიყურება:

10 && $ შემთხვევითი< 20);
echo "ჩვენი შემთხვევითი ნომერი: $ შემთხვევითი"; ?>

დამწყებთათვის, do-while ციკლი შეიძლება ცოტა დამაბნეველი იყოს. თუ ბოლომდე არ გესმით მისი მიზანი, ეს არ არის პრობლემა. Do-while მარყუჟები პრაქტიკაში იშვიათად გამოიყენება.

პროგრამირების ერთ-ერთი ყველაზე მნიშვნელოვანი ინსტრუმენტი არის მარყუჟები. ისინი სასარგებლოა იმ შემთხვევებში, როდესაც რამის გაკეთება გჭირდებათ რამდენჯერმე.

თუ არსებობს ასეთი დავალება, მაგალითად, 1000-ჯერ აჩვენოთ ხაზი "გამარჯობა ყველას". შემდეგ, მარყუჟის გამოყენების გარეშე, ჯერ ერთი დიდი დრო დასჭირდება და მეორეც, არც ისე ლამაზად გამოიყურება. Ამიტომაც თქვენ სრულყოფილად უნდა იცოდეთ ციკლებირადგან ისინი ძალიან, ძალიან ხშირად გამოიყენება.

პროგრამირებაში ოთხი მარყუჟია, ეს არის while, do-while, for და foreach. თითოეულ მათგანს აქვს საკუთარი სინტაქსი და თითოეული გამოიყენება გარკვეულ შემთხვევებში.

ყველაზე ხშირად გამოყენებული მარყუჟები არის for და foreach, რასაც მოჰყვება while, ხოლო do-while ციკლი ძალიან იშვიათია.

და ჩვენ დავიწყებთ ცოტა ხნის მარყუჟით.

while მარყუჟის სინტაქსი ასეთია:

ჯერ ვაცხადებთ i ცვლადს, რომელიც არის მრიცხველი, ხოლო ციკლის შიგნით ვამატებთ ამ მრიცხველს. ფრჩხილებში ვწერთ ციკლში შესვლის/გასვლის პირობას.

კომენტარი! ჩაწერეთ გასვლის პირობა სწორად, წინააღმდეგ შემთხვევაში შეიძლება მოხდესუსასრულო ციკლი და შემდეგ სკრიპტი გაიყინება

. ასეთი ციკლი შეიძლება მოხდეს, თუ, მაგალითად, ჩვენ უბრალოდ დავწერთ true-ს გასასვლელ მდგომარეობაში.

მაგალითად, დავბეჭდოთ სტრიქონი "გამარჯობა ყველას!" 10 ჯერ.

Var i = 0; while(i"); i++;)

ცვლადი i შეიძლება დაიწყოს 0-დან ან 1-დან ან ნებისმიერი სხვა რიცხვიდან.

გასასვლელი პირობა არის ამავე დროს შესვლის პირობა. მარყუჟი მუშაობს შემდეგნაირად: ჯერ ამოწმებს i ცვლადი არის თუ არა 10-ზე ნაკლები და თუ პირობა მართალია, მაშინ შევდივართ ციკლში, წინააღმდეგ შემთხვევაში არა. ამ შემთხვევაში, თუ ცვლადი i უდრის, მაგალითად, 30-ს, მაშინ ციკლი არ შესრულდება, რადგან 30 არ არის 10-ზე ნაკლები.

შევედით ციკლში, დავბეჭდეთ სტრიქონი „გამარჯობა ყველას“, გავზარდეთ მრიცხველი და ისევ გადავდივართ მდგომარეობაზე, სადაც ისევ ვამოწმებთ, i ცვლადის მნიშვნელობა არის თუ არა 10-ზე ნაკლები, შემდეგ შევდივართ ციკლში, წინააღმდეგ შემთხვევაში გამოვდივართ. და ეს ხდება იმ მომენტამდე, როდესაც შესვლის პირობა გახდება false, ანუ i ცვლადის მნიშვნელობა იქნება 10. 10 არ არის 10-ზე ნაკლები, ამიტომ ჩვენ აღარ შევდივართ ციკლში, არამედ გადავდივართ.

კომენტარი!

არ დაგავიწყდეთ მრიცხველის (i++) გაზრდა, წინააღმდეგ შემთხვევაში თქვენ მიიღებთ უსასრულო მარყუჟს.

ჩვენ განვიხილეთ while ციკლი, ახლა მოდით გადავიდეთ do-while ციკლზე.

do-while მარყუჟის სინტაქსი ასეთია:

განსხვავება while მარყუჟსა და do-while ციკლს შორის არის ის, რომ do-while ციკლი შეიძლება შესრულდეს ერთხელ მაინც, მდგომარეობის მიუხედავად, ხოლო while მარყუჟი საერთოდ არ შესრულდება, თუ პირობა მცდარია.

კომენტარი!

ისევე როგორც while მარყუჟი, არ დაგავიწყდეთ i მრიცხველის გაზრდა.

მოდით გადავიდეთ პრაქტიკაზე. მაგალითად, გამოვთვალოთ რიცხვების ნამრავლი 1-დან 10-მდე.

Var i = 1; var წარმოება = 1; do(წარმოება *= i; i++; )while(i

Სინტაქსი შედეგი იქნება ნომერი 3628800. პირველ ეტაპზე ჩვენ მაშინვე შევედით ციკლში, მიუხედავად მისი მდგომარეობისა, სადაც შესრულდა ოპერაცია production *= i (ეს იგივეა, რაც წარმოება = წარმოება * 1). შემდეგ ჩვენ ვამატებთ მრიცხველს. გაზრდის შემდეგ მას აქვს 2 მნიშვნელობა. და ბოლოს ვამოწმებთ პირობას, თუ მრიცხველი 10-ზე ნაკლები ან ტოლია, მაშინ გადავდივართ მარყუჟის შემდეგ გამეორებაზე, წინააღმდეგ შემთხვევაში გამოვდივართ ციკლიდან და ვაგრძელებთ . მარყუჟისთვის

როგორც ზემოთ დავწერე, for loop საკმაოდ ხშირად ხდება, ასე რომ თქვენ უნდა იცოდეთ ის ძალიან კარგად. მარყუჟისთვისშემდეგი:

უკეთესი გაგებისთვის, მოდით გადავჭრათ

მარტივი დავალება

კომენტარი!

თუ მარყუჟში მხოლოდ ერთი განცხადებაა, მაშინ ხვეული ბრეკეტები არ არის საჭირო.

დემონსტრირებისთვის, მოდით გამოვაჩინოთ ეკრანზე 5-ჯერ რამდენიმე სტრიქონი, მაგალითად "Hello!"

For(var i = 1; i

კომენტარი! მარყუჟის შესრულების შემდეგ, ბოლო მნიშვნელობა რჩება ცვლადში i.ახლა მოდით გადავჭრათ პრობლემა ცოტა უფრო რთულად, მაგალითად, ჩვენ უნდა დავბეჭდოთ სტრიქონი "Hello" 100-ჯერ. და ისე რომ ეს ყველაფერი ერთ რიგში არ დასრულდეს, შემდეგ ყოველი მეათე გამეორების შემდეგ გადავიდეთ

ახალი ხაზი<= 100; i++){ document.write("привет!"); if(i % 10 == 0)  document.write("
. და ბოლოს დავბეჭდავთ i ცვლადის მნიშვნელობას.

For(var i = 1; i

ცვლადი i = " + i + ""); // i = 101

foreach loopროგორც წესი, გამოიყენება ობიექტებისა და მასივების განმეორებისთვის. ამიტომ, ამაზე ვისაუბრებ მასივებთან მუშაობის აღწერის სტატიაში.

შესვენების განცხადებამიზნად ისახავს მარყუჟიდან იძულებით გასვლას.

ოპერატორის გაგრძელება

საშუალებას გაძლევთ შეწყვიტოთ მარყუჟის მიმდინარე გამეორება და გადახვიდეთ შემდეგზე.<= 20; i++){ //Пропускаем текущею итерацию цикла if(i % 2 == 0) continue; summa += i; //Выходим совсем из цикла. if(i == 15) break; document.write(i + ". Итерация
. და ბოლოს დავბეჭდავთ i ცვლადის მნიშვნელობას.

უკეთ გასაგებად, ჩვენ ასევე მოვაგვარებთ მარტივ პრობლემას. ვთქვათ, გვინდა გამოვთვალოთ კენტი რიცხვების ჯამი 1-დან 20-მდე. და როცა მივაღწევთ მე-15 გამეორებას, გამოვალთ ციკლიდან. Var summa = 0; for(var i = 1; i

= " + ჯამი + "

"); //ჯამა = 64

ჩვენ ვინახავთ დოკუმენტს, ვხსნით მას ბრაუზერში და ვუყურებთ შედეგს. პრაქტიკაში, შეეცადეთ შეცვალოთ დაწერილი დამწერლობა ისე, რომ გამოითვალოს ლუწი რიცხვების ჯამი.ამით მთავრდება ეს სტატია. Ახლა შენ იცი while, do-while, მარყუჟების სინტაქსი და როგორ ვიმუშაოთ მათთან.

. ჩვენც შევხვდით

დაარღვიე და განაგრძე განცხადებები

do while და foreach მარყუჟებიგააკეთე მარყუჟი . . ხოლო

do...while loop

C#-ში ეს არის while-ის ვერსია პოსტ-მდგომარეობის შემოწმებით. ეს ნიშნავს, რომ მარყუჟის მდგომარეობა შემოწმდება მარყუჟის სხეულის შესრულების შემდეგ. ამიტომ, do...while მარყუჟები სასარგებლოა იმ სიტუაციებში, როდესაც განცხადებების ბლოკი ერთხელ მაინც უნდა შესრულდეს. შემდეგი არის do-while ციკლის განცხადების ზოგადი ფორმა:

სისტემის გამოყენება; System.Collections.Generic-ის გამოყენებით; System.Linq-ის გამოყენებით; System.Text-ის გამოყენებით; namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( სცადეთ ( // გამოთვალეთ რიცხვის ფაქტორიალი int i, შედეგი = 1, num = 1; Console.WriteLine ("შეიყვანეთ რიცხვი:"); i = int .Parse(Console .ReadLine());

foreach loop

ცვლადი i = " + i + "ემსახურება კოლექციის ელემენტებზე ციკლურ წვდომას, რომელიც წარმოადგენს ობიექტების ჯგუფს. C# განსაზღვრავს რამდენიმე ტიპის კოლექციას, რომელთაგან თითოეული არის მასივი. ქვემოთ მოცემულია foreach loop განცხადების ზოგადი ფორმა:

foreach (აკრიფეთ loop_variable_name კოლექციაში) განცხადება;

Აქ აკრიფეთ loop_variable_nameაღნიშნავს მარყუჟის საკონტროლო ცვლადის ტიპსა და სახელს, რომელიც იღებს კოლექციის შემდეგი ელემენტის მნიშვნელობას foreach მარყუჟის თითოეულ საფეხურზე. და კოლექცია აღნიშნავს ციკლურად მოთხოვნილ კოლექციას, რომელიც შემდგომში წარმოადგენს მასივს. ამიტომ, მარყუჟის ცვლადის ტიპი უნდა შეესაბამებოდეს მასივის ელემენტის ტიპს. გარდა ამისა, ტიპი შეიძლება აღინიშნოს var საკვანძო სიტყვით. ამ შემთხვევაში შემდგენელი განსაზღვრავს ციკლის ცვლადის ტიპს მასივის ელემენტის ტიპზე დაყრდნობით. ეს შეიძლება სასარგებლო იყოს გარკვეული ტიპის შეკითხვებთან მუშაობისთვის. მაგრამ, როგორც წესი, ტიპი ცალსახად არის მითითებული.

foreach loop განაცხადი მუშაობს შემდეგნაირად. როდესაც ციკლი იწყება, მასივის პირველი ელემენტი არჩეულია და ენიჭება ციკლის ცვლადს. ყოველი მომდევნო გამეორების საფეხურზე, მასივის შემდეგი ელემენტი არჩეულია და ინახება მარყუჟის ცვლადში. ციკლი მთავრდება მასივის ყველა ელემენტის არჩევისას.

foreach ციკლი საშუალებას გაძლევთ გაიმეოროთ კოლექციის თითოეული ელემენტი (ობიექტი, რომელიც წარმოადგენს სხვა ობიექტების სიას). ტექნიკურად, იმისათვის, რომ რაღაც ჩაითვალოს კოლექციად, მას უნდა ჰქონდეს IEnumerable ინტერფეისის მხარდაჭერა. კოლექციების მაგალითებია C# მასივები, კოლექციების კლასები System.Collection სახელთა სივრციდან და მორგებული კოლექციების კლასები.

Do while... ციკლი VBA Excel-ში, მისი სინტაქსი და ცალკეული კომპონენტების აღწერა. Do while... მარყუჟის გამოყენების მაგალითები.

Do while... Loop VBA Excel-ში შექმნილია განცხადებების ბლოკის გასამეორებლად, სანამ მითითებული პირობა არ დაკმაყოფილდება (აბრუნებს True-ს). ამ მარყუჟის სინტაქსი მსგავსია -ის, რომელიც მეორდება მანამ, სანამ პირობა არ დაკმაყოფილდება (უბრუნებს False-ს).

Do while... მარყუჟის სინტაქსი

Do while... მარყუჟის სინტაქსი გამოდის ორ გემოში, რომლებიც განსაზღვრავს, როდის მოხდება მდგომარეობის ტესტირება.

მდგომარეობა შემოწმებულია განცხადებების შესრულებამდე:

Do while პირობა [ განცხადებები ] [ გასვლა Do ] [ განცხადებები ] ციკლი

მდგომარეობა მოწმდება განცხადებების შესრულების შემდეგ:

Do [ განცხადებები ] [ Exit Do ] [ განცხადებები ] Loop while მდგომარეობა

კვადრატული ფრჩხილები მიუთითებს Do while... მარყუჟის არასავალდებულო ატრიბუტებზე.

კომპონენტები Do while... Loop

*თუ არ იყენებთ საკუთარ კოდს ციკლში, ციკლის გამოყენების მნიშვნელობა იკარგება.

**ძალიან სასარგებლო ოპერატორი Do while... მარყუჟისთვის, რადგან გარკვეულ პირობებში ის შეიძლება გახდეს უსასრულო. თუ ეს რისკი არსებობს, თქვენ უნდა შეგეძლოთ VBA უსასრულო ციკლიდან გასვლა Exit Do განაცხადის გამოყენებით.

Do while... მარყუჟების მაგალითები

უმარტივესი ციკლები

Do while... დაარეგულირეთ შესრულებადი განცხადებების პირობით:

Sub test1() Dim a As Byte Do while a< 10 a = a + 1 Loop MsgBox a End Sub

Do while... დაარეგულირეთ პირობითი შესრულებადი განცხადებების შემდეგ:

Subtest2() Dim a As Byte Do a = a + 1 Loop while a< 10 MsgBox a End Sub

ორივე შემთხვევაში MsgBox აჩვენებს რიცხვს 10. როდესაც ცვლადის მნიშვნელობა აიქნება 10-ის ტოლი, შემოწმებული პირობა დააბრუნებს მნიშვნელობას ყალბი, და მარყუჟი შეჩერდება.

ფურცლის რიგებში გასეირნება

ორ ციყვს ერთმანეთის საპირისპიროდ განლაგებული ღრუები აქვს. თითოეული ღრუ შეიცავს 100 კონუსს. თავისუფალ დროს ყრიან კონუსებს მოპირდაპირე ღრუში, მაგრამ ყოველთვის არ ურტყამს. ქვემოთ მოყვანილი ცხრილი გვიჩვენებს თითოეული ციყვის მიერ გადაგდებული კონუსების რაოდენობას და რამდენი მათგანი მოხვდა მიზანში.

ამ მონაცემებზე დაყრდნობით, თქვენ უნდა გაარკვიოთ რამდენი კონუსი დატოვა ციყვ 1-ს ღრუში. ამისათვის თქვენ უნდა გამოაკლოთ 100 კონუსს ციყვი 1-ის მიერ ჩაგდებული გირჩების რაოდენობა და დაამატოთ ციყვი 2-ის მიერ მის ღრუში ჩაგდებული კონუსები. გამოთვლებს ვიწყებთ მეორე ხაზიდან (პირველ სათაურში) და იმ პირობით, რომ Do while... მარყუჟი ჩვენ აღვნიშნავთ „მიმდინარე ხაზის პირველი უჯრედი არ არის ცარიელია“. ცხრილი უნდა დაიწყოს სამუშაო ფურცლის "A1" პირველი უჯრიდან, ხოლო მის ქვემოთ, მინიმუმ ერთი მწკრივი უნდა იყოს ცარიელი, უფრო ზუსტად, ამ მწკრივის პირველი უჯრედი.

ქვე-ტესტი3() Dim i, სანამ დრო, n სანამ i = 2 n = 100 Do while Cells(i, 1)<>"" თუ უჯრედები(i, 2) = "ციყვი 1" მაშინ n = n - უჯრედები(i, 3) სხვა n = n + უჯრედები(i, 4) ბოლო თუ i = i + 1 ციკლი MsgBox n ბოლო ქვე

MsgBox საინფორმაციო შეტყობინებაში ნაჩვენები შედეგი იქნება 40. შეგიძლიათ ცხრილის კოპირება Excel-ის სამუშაო ფურცელში და ექსპერიმენტი VBA კოდით.

Infinite loop და Exit Do

უსასრულო მარყუჟის მაგალითი:

Subtest4() Dim a As Byte Do while a< 10 a = a + 1 If a = 9 Then a = 0 End If Loop End Sub

ამ პროცედურის გაშვებისას, Do while... ციკლი უსასრულოდ იწყებს მუშაობას. მე მომიწია გაუთავებელი VBA მარყუჟების შეჩერება Excel 2000-სა და Excel 2016-ში. Excel 2000-ში კლავიატურის მალსახმობი დამეხმარა Ctrl + Breakდა Excel 2016-ში, როდესაც ხურავთ VBA რედაქტორს ჯვრით, გამოჩნდება ფანჯარა:

პროგრამის პასუხის მოლოდინს აზრი არ აქვს, ამიტომ დააჭირეთ „პროგრამის გადატვირთვას“ ან „პროგრამის დახურვას“.

ოპერატორის გამოყენების მაგალითი გასვლა Do:

Subtest5() Dim a As Byte, n რამდენი ხანი 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

როდესაც მარყუჟი 1000 გამეორებას მიაღწევს, ის წყდება და MsgBox საინფორმაციო შეტყობინება აჩვენებს რამდენჯერმე გაიმეორა Do while... ციკლი ამ მაგალითიდან.