R'de While Döngüleri: while, repeat ve break Anlatımı

while Döngüsü

R'de bir while döngüsü, bir koşul TRUE kaldığı sürece gövdesini çalıştırmaya devam eder. Bir for döngüsü bir şeyin her elemanı için bir kez çalışırken while, bilinmeyen sayıda kez çalışır - bir koşul değişene kadar:

count <- 1

while (count <= 5) {
  print(count)
  count <- count + 1
}

Her while döngüsünü çalıştıran üç parça vardır ve üçü de burada görünür:

1. Döngüden önce kurulum - count <- 1, koşula test edecek bir şey verir.

2. Koşul - alışıldık karşılaştırma operatörlerinden kurulmuş count <= 5, her turdan önce kontrol edilir.

3. Gövde içindeki güncelleme - count <- count + 1, döngüyü durmaya doğru taşır.

4. parçayı silin ve koşul sonsuza dek TRUE olur: döngü hiç bitmez. while döngüsünün tanımlayıcı riski budur ve bu sayfanın kalanı büyük ölçüde bunu yönetmekle ilgilidir.

Koşul Her Turdan Önce Kontrol Edilir

while önce koşulunu test eder, sonra gövdeyi çalıştırır. Bundan iki sonuç çıkar. Koşul başlangıçta zaten FALSE ise gövde sıfır kez çalışır:

stock <- 0

while (stock > 0) {
  print("selling one item")
  stock <- stock - 1
}

print("loop finished without running")

Ve kontrol, gövdenin ortasında değil tam turlar arasında gerçekleşir - bir tur başladıktan sonra, koşul yarı yolda FALSE olsa bile sonuna kadar çalışır. Gövdenin ortasında çıkmanız gerekiyorsa break bunun içindir (aşağıda).

İşlenmiş Bir Örnek: Bir Eşiğin Altına İnene Kadar Yarıya Bölme

while döngüsünün doğal yuvası "şu olana kadar devam et" durumudur: kaç tur süreceğini önceden bilemezsiniz, dolayısıyla for uymaz. 1000 sayısını 1'in altına düşene kadar kaç kez yarıya bölebilirsiniz?

value <- 1000
steps <- 0

while (value >= 1) {
  value <- value / 2
  steps <- steps + 1
}

print(steps)
cat("final value:", value, "\n")

On bölme, yaklaşık 0.977'de bitiyor. Bu kalıp - gövdenin küçülttüğü bir durum değişkeni, büyüttüğü bir sayaç - gerçek while döngülerinin büyük bir kısmını kapsar: hata yeterince küçülene kadar çalışan sayısal yöntemler, bir kaynak tükenene kadar süren simülasyonlar, bir çağrı başarılı olana kadar devam eden yeniden denemeler.

repeat + break: R'nin do-while Karşılığı

R'de do-while anahtar sözcüğü yoktur - koşulunu gövdeden sonra test eden bir döngü yoktur. Ama koşulsuz olarak sonsuza dek dönen repeat ve herhangi bir döngüden anında çıkan break vardır. break testini bir repeat gövdesinin sonuna koyun; tam olarak bir do-while kurmuş olursunuz - gövdesinin en az bir kez çalışması garanti olan bir döngü:

n <- 1

repeat {
  n <- n * 2
  if (n > 100) break
}

print(n)

Gövde ilk testten önce her zaman yürütülür, dolayısıyla n en az bir kez ikiye katlanır; döngü, 100'ü aşan ilk katlama olan 128'de çıkar. "İşi yap, sonra tekrar yapıp yapmayacağına karar ver" dürüst tanım olduğunda bu biçimi kullanın - girdi geçerli olana kadar okumak, biri niteliklere uyana kadar örnek çekmek. Ulaşılabilir bir break içermeyen bir repeat, yapısı gereği sonsuz bir döngüdür; bu yüzden önce break yazın, sonra gövdeyi doldurun.

break, while ve for döngülerinde aynı şekilde çalışır - genel "burada işimiz bitti" çıkışıdır ve gövde ortasında bir koşulu test eden if ifadeleriyle doğal olarak eşleşir.

while Döngüsü İçinde next

next, mevcut turun kalanını atlar ve koşul kontrolüne geri döner. while içinde tıpkı for içindeki gibi çalışır - while döngüsüne özgü tek bir tuzakla: güncelleme adımı next ifadesinden sonra geliyorsa, onu atlamak döngü değişkeninin hiç ilerlememesi demektir ve bir sonsuz döngü kurmuş olursunuz. Güncellemeyi next öncesine koyun:

i <- 0

while (i < 10) {
  i <- i + 1          # update FIRST...
  if (i %% 2 != 0) next  # ...then it's safe to skip odd numbers
  print(i)
}

Bu, 2 ile 10 arasındaki çift sayıları yazdırır. i <- i + 1 satırını next satırının altına taşıyın; ilk tek değer güncellemeyi sonsuza dek atlar. for döngülerinde bu tehlike yoktur (döngü değişkeni otomatik ilerler); sadece bir diziyi dolaşıyorken for tercih etmenin bir nedeni daha.

Sonsuz Döngülere Karşı Koruma

Her sonsuz döngü aynı hatadır: gövdedeki hiçbir şey koşulun bağlı olduğu değişkenleri değiştirmez - ya da yanlış yönde değiştirir. Etkileşimli olarak Esc veya Ctrl+C ile kesebilirsiniz, ama bir betikte süreç sadece asılı kalır. İki alışkanlık bunu önler.

Birincisi, koşulu yazarken hemen "gövdenin hangi satırı bunu FALSE'a doğru taşıyor?" diye sorun ve o satırın gövdedeki her yol üzerinde çalıştığından emin olun (yukarıdaki next tuzağına dikkat).

İkincisi, sonlanacağını kolayca kanıtlayamadığınız döngülere bir maksimum yineleme koruması ekleyin ki bir mantık hatası donmuş bir oturum yerine teşhis edilebilir bir sonuç üretsin. Burada Collatz tarzı bir döngüyü koruyor - çift sayıları defalarca yarıya böl, tek x değerini 3 * x + 1 yap, 1'e ulaşana kadar:

x <- 10
steps <- 0

while (x != 1 && steps < 10000) {
  if (x %% 2 == 0) x <- x / 2 else x <- 3 * x + 1
  steps <- steps + 1
}

cat("reached", x, "after", steps, "steps\n")

10'dan başlayan döngü 1'e 6 adımda ulaşır. Bir başlangıç değeri hiç 1'e ulaşmasaydı steps < 10000 koşulu yine de döngüyü bitirir ve yazdırılan durum size bir şeyin ters gittiğini söylerdi - görebildiğiniz yanlış bir yanıt, hiç yanıt vermeyen bir programı yener. Burada kısa devre yapan && doğru operatördür: iki taraf da tek değerdir ve koruma tek bir cümle gibi okunur.

while ve for: Seçim

Genel kural, önceden ne bildiğinizle ilgilidir:

• Ne üzerinde döndüğünüzü biliyorsanız (bir vektörün elemanları, 1'den n'e sayılar): bir for döngüsü kullanın - döngü değişkeni kendini yönetir.
• Yalnızca durma koşulunu biliyorsanız (yakınsayana kadar, eşiğin altına inene kadar, geçerli olana kadar): while kullanın.
• Herhangi bir test anlamlı olmadan önce gövdenin en az bir kez çalışması gerekiyorsa: sonlandırıcı bir break ile repeat kullanın.

Yalnızca bir vektörü dolaşmak için bir while döngüsünde elle sayaç sürdürdüğünüzü fark ederseniz, o kılık değiştirmiş bir for döngüsüdür - geçin.

Buradan Ne Çıkarıyorsunuz

• while (condition) { ... } önce kontrol eder, sonra çalışır - başlangıçta yanlış bir koşul sıfır tur demektir.
• Gövde koşulu FALSE'a doğru taşımalıdır; kurulum / koşul / güncelleme üçlüsü disiplinin tamamıdır.
• R'de do-while anahtar sözcüğü yoktur: repeat { body; if (done) break } deyimdir ve en az bir tur garanti eder.
• break herhangi bir döngüden çıkar; bir while içinde next kullanırken döngü değişkenini atlamadan önce güncelleyin, yoksa hiç ilerlemez.
• Bir maksimum yineleme koruması (&& steps < 10000), olası bir donmayı görünür ve hata ayıklanabilir yanlış bir yanıta dönüştürür.

Sırada: vektörler - bu sayfadaki her döngünün dolaştığı veri yapısı ve birçok R döngüsünün tamamen ortadan kalkabilmesinin nedeni.