Silmukat ovat yksi oh­jel­moin­nin pe­rus­kä­sit­teis­tä. Ne var­mis­ta­vat, että tietyt koodin osat suo­ri­te­taan tois­tu­vas­ti tietyn ehdon val­li­tes­sa. R-kielessä while-sil­mu­koil­la osa tois­te­taan, kunnes aiemmin mää­ri­tel­ty ehto muuttuu epä­to­dek­si.

Mihin R:n while-sil­mu­koi­ta käytetään?

While-sil­mu­koi­ta käytetään tois­ta­maan koo­di­loh­kon suo­rit­ta­mis­ta tietyn ehdon pe­rus­teel­la. Niin kauan kuin tämä ehto on totta, while-silmukan koodi suo­ri­te­taan.

Sil­mu­koi­ta käytetään usein R-oh­jel­moin­nis­sa R-luettelon ele­ment­tien tut­ki­mi­seen ja tiettyjen toi­min­to­jen suo­rit­ta­mi­seen niille yk­si­tel­len. Voit esi­mer­kik­si tulostaa minkä tahansa merk­ki­jo­non näytölle R-merk­ki­jo­no­jen luet­te­los­ta. Lisäksi R:n while-sil­mu­koi­ta käytetään koodin eh­dol­li­seen suo­rit­ta­mi­seen. While-silmukan kaltaiset silmukat ovat monien tun­net­tu­jen la­jit­te­lual­go­rit­mien perusta, jotka jär­jes­tä­vät tie­to­kan­nan tiettyjen kri­tee­rien mukaan.

R-kielessä käy­tet­tä­vien while-sil­mu­koi­den rakenne ja syntaksi

R-kielessä while-sil­mu­koi­den syntaksi on sa­man­lai­nen kuin useim­mis­sa muissa oh­jel­moin­ti­kie­lis­sä. Silmukan otsikossa, joka aloi­te­taan while-avain­sa­nal­la, ehto mää­ri­tel­lään suluissa. Ehdon on oltava tosi, jotta silmukan runko voidaan suorittaa. Tämä runko on yk­sin­ker­tai­ses­ti silmukan otsikon jälkeinen oma koo­di­loh­ko, joka on suljettu aal­to­sul­kei­siin.

Tämän ha­vain­nol­lis­ta­mi­sek­si olemme luoneet esimerkin. Tämä R-silmukan esimerkki näyttää while-silmukan, joka tulostaa arvot 1:stä 10:een:

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

Bubble­sort R-esi­mer­kis­sä

Bubble­sort on klassinen la­jit­te­lual­go­rit­mi, jota käytetään R-vektorin tai R-taulukon ele­ment­tien la­jit­te­luun nouse­vas­sa jär­jes­tyk­ses­sä. Tässä la­jit­te­lual­go­rit­mis­sa while-silmukkaa käytetään la­jit­te­lu­koo­din suo­rit­ta­mi­seen, kunnes kaikki vektorin elementit on lajiteltu:

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

Yllä olevassa koodissa luodaan R-funktio nimeltä bubble­sort. Tämä varmistaa, että nu­mee­ri­nen vektori la­ji­tel­laan nouse­vas­sa jär­jes­tyk­ses­sä. While-silmukkaa käytetään suo­rit­ta­maan vaih­topro­ses­si, joka on vält­tä­mä­tön Bubble­sor­til­le, kunnes lajittelu on valmis.

Keskeytä while-silmukka R:ssä

Jos haluat poistua while-sil­mu­kas­ta en­ne­nai­kai­ses­ti tietyn ehdon täyt­tyes­sä, voit käyttää avain­sa­naa “break”. Tämä varmistaa, että silmukka pois­te­taan eikä siihen palata uudelleen. Seu­raa­vas­sa on esimerkki “break”-lauseesta:

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

Yllä oleva silmukka tulostaa näytölle numerot 10–5. Kun muuttuja ”x” saavuttaa arvon 5, R:n ”if”-ehto suo­ri­te­taan ja silmukka lo­pe­te­taan en­ne­nai­kai­ses­ti kut­su­mal­la ”break”.

Muut silmukat R:ssä

R-kielessä while-silmukka ei ole ainoa sil­muk­ka­tyyp­pi. On myös for-silmukka, jota pidetään usein erään­lai­se­na las­ken­ta­sil­muk­ka­na, sekä repeat-silmukka, jota käytetään koodin suo­rit­ta­mi­seen useita kertoja ehdosta riip­pu­mat­ta. Repeat-silmukat on lo­pe­tet­ta­va avain­sa­nal­la “break”, muuten ne ovat lo­put­to­mia sil­mu­koi­ta.

For-silmukka R-kielessä

For-sil­mu­koi­ta käytetään, kun toistojen määrä on tiedossa etukäteen. Toistojen määrä mää­ri­te­tään ni­men­omai­ses­ti silmukan otsikossa. For-silmukka, joka tulostaa numerot 1–5, näyttää tältä:

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

Toista silmukka R:ssä

R-kielessä tois­to­lenk­ke­jä käytetään koodin suo­rit­ta­mi­seen useita kertoja, riip­pu­mat­ta ehdosta. Jos et ole vasta aloit­ta­mas­sa oh­jel­moin­tia, olet to­den­nä­köi­ses­ti pe­reh­ty­nyt do-while-lenk­kei­hin muista oh­jel­moin­ti­kie­lis­tä, kuten Java. R-kielessä ei ole ek­spli­siit­tis­tä do-while-lenkkiä, jossa koo­di­loh­ko suo­ri­te­taan vähintään kerran. Mutta toiminto voidaan helposti toteuttaa tois­to­len­kil­lä:

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

Yllä oleva koo­die­si­merk­ki tulostaa numerot 1–10. Koodi suo­ri­te­taan vähintään kerran (klas­si­ses­sa do-while-sil­mu­kas­sa ‘do-koo­di­loh­kos­sa’) ennen ‘if’-lause­ket­ta, joka lopettaa silmukan, jos mää­ri­tet­ty ehto on tosi. 24791f2f3a335aba9148d493e9499358

Siirry pää­va­lik­koon