Silmused on prog­ram­mee­ri­mise üks põ­hi­mõis­teid. Need tagavad, et teatud koo­di­l­õi­gud täi­de­takse korduvalt teatud tingimuse alusel. R-keeles ka­su­ta­ta­vate while-sil­mus­tega kor­ra­takse lõiku seni, kuni eelnevalt määratud tingimus muutub valeks.

Milleks ka­su­ta­takse R-keeles while-tsükleid?

While-tsüklid ka­su­ta­takse tin­gi­mu­sest sõltuva koo­dib­lokki korduvaks täit­miseks. Niikaua, kui see tingimus on tõene, täi­de­takse while-tsüklis olev kood.

R-prog­ram­mee­ri­mises ka­su­ta­takse silmuseid sageli R-nimekirja ele­men­tide uuri­miseks ja nende suhtes in­di­vi­duaal­sete tegevuste soo­ri­ta­miseks. Näiteks võite kuvada ekraanil mis tahes stringi R-stringide ni­me­kir­jast. Lisaks ka­su­ta­takse R-s while-silmuseid koodi tin­gi­mus­likuks täit­miseks. While-silmuse sarnased silmused on paljude tuntud sor­tee­ri­mis­algo­ritmide aluseks, mis kor­ral­da­vad and­me­ba­asi teatud kri­tee­riumide järgi.

R-keeles while-tsüklite struktuur ja süntaks

R-keeles on while-tsüklite süntaks sarnane enamiku teiste prog­ram­mee­ri­mis­keelte while-tsüklite sün­tak­siga. Tsükli päises, mis algab märk­sõ­naga while, on tingimus määratud sulgudes. Tsükli korpuse täit­miseks peab viimane olema tõene. See korpus ei ole midagi muud kui tsükli päise järel olev omaette koo­dib­lokk, mis on sulgudes.

Selle il­lust­ree­ri­miseks oleme loonud näite. See R-tsükli näide näitab while-tsüklit, mis väljastab väärtused 1 kuni 10:

x <- 1
while (x <= 10) {
    print(x)
    x <- x + 1
}
R

Bubb­le­sort R-keeles näide

Bubb­le­sort on klas­si­ka­line sor­tee­ri­mis­algo­ritm, mida ka­su­ta­takse R-vektori või R-massiivi ele­men­tide sor­tee­ri­miseks kasvavas jär­je­kor­ras. Selles sor­tee­ri­mis­algo­rit­mis ka­su­ta­takse while-tsüklit sor­tee­ri­mis­koodi täit­miseks, kuni kõik vektori elemendid on sor­tee­ri­tud:

bubblesort <- function(x) {
    swapped <- TRUE
    n <- length(x) - 1
    while (swapped) {
        swapped <- FALSE
        for (i in 1:n) {
            if (x[i] > x[i+1]) {
                tmp <- x[i]
                x[i] <- x[i+1]
                x[i+1] <- tmp
                swapped <-TRUE
                }
        }
    }
    return(x)
}
R

Eespool toodud koodis luuakse R-funkt­sioon nimega bubb­le­sort. See tagab numb­ri­lise vektori jär­jes­ta­mise kasvavas jär­je­kor­ras. While-tsüklit ka­su­ta­takse va­he­tus­prot­sessi lä­bi­vii­miseks, mis on Bubb­le­sorti jaoks hä­da­va­ja­lik, kuni sor­tee­ri­mine on lõpetatud.

R-keeles while-tsükli kat­kes­ta­mine

Teatud tingimuse korral while-tsükli en­ne­täht­aeg­seks lõ­pe­ta­miseks võite kasutada märksõna „break”. See tagab, et tsükkel lõ­pe­ta­takse ja sinna ei pöörduta tagasi. Siin on näide „break”-lause ka­su­ta­mi­sest:

x <- 10
while (x >= 0) {
    print(x)
    if (x == 5) {
        break
        }
        x <- x - 1
}
R

Eespool toodud tsükkel väljastab ekraanile numbrid 10 kuni 5. Kui muutuja „x” jõuab väär­tu­seni 5, täi­de­takse R-keele tingimus „if” ja tsükkel lõ­pe­ta­takse en­ne­täht­aeg­selt käsu „break” abil.

Muud silmused R-is

R-keeles ei ole while-tsükkel ainus tsükkel. On olemas ka for-tsükkel, mida peetakse sageli loen­da­mise tsükliks, ja repeat-tsükkel, mida ka­su­ta­takse koodi mit­me­kord­seks täit­miseks , sõltumata tin­gi­mu­sest. Repeat-tsük­li­test tuleb väljuda märk­sõ­naga „break”, vastasel juhul on tegemist lõputute tsük­li­tega.

For-tsükkel R-is

For-tsükleid ka­su­ta­takse, kui ite­rat­sioo­nide arv on eelnevalt teada. Ite­rat­sioo­nide arv on tsükli peal­kir­jas sel­ge­sõ­na­li­selt määratud. For-tsükkel, mis väljastab numbrid 1 kuni 5, näeb välja järgmine:

for (z in 1:5) {
print(i)
}
R

Korda silmus R-is

R-keeles ka­su­ta­takse kor­dus­ringe koodi mit­me­kord­seks täit­miseks, sõltumata tin­gi­mu­sest. Kui te pole prog­ram­mee­ri­mises alles algaja, siis olete ilmselt tuttav do-while-ringidega teistest prog­ram­mee­ri­mis­keel­test, nagu Java. R-keeles pole sel­ge­sõ­na­list do-while-ringi, kus koo­dib­lokk täi­de­takse vähemalt üks kord. Kuid seda funkt­sio­naal­sust saab hõlpsasti rakendada kor­dus­rin­gi­dega:

x <- 1
repeat {
    print(x)
    if (x >= 10) {
        break
        }
x <- x + 1
}
R

Eespool toodud koo­di­näide väljastab numbrid 1 kuni 10. Kood täi­de­takse vähemalt üks kord (klas­si­ka­li­ses do-while-tsüklis koo­dib­lo­kis „do”) enne „if”-lauset, mis lõpetab tsükli, kui määratud tingimus on tõene. be736e550b1141b116c6745223aecfd7

d1d76d85f27f41c7f98c49bcb7641848

37b614e8ff1142c9025056cc2b26f936

f73edeee674565a3ba93d621869650b4

ef1f873d0fe0237afbeeec20ad1812be

Go to Main Menu