Zoeken…


Invoering

Als een van de meest basisfuncties bij het programmeren, zijn lussen een belangrijk onderdeel van bijna elke programmeertaal. Lussen stellen ontwikkelaars in staat om bepaalde delen van hun code in te stellen voor herhaling door een aantal lussen die iteraties worden genoemd. Dit onderwerp behandelt het gebruik van meerdere soorten lussen en toepassingen van lussen in Go.

Basic Loop

for is de enige lus-instructie in go, dus een eenvoudige lusimplementatie zou er zo uit kunnen zien:

// like if, for doesn't use parens either.
// variables declared in for and if are local to their scope.
for x := 0; x < 3; x++ { // ++ is a statement.
    fmt.Println("iteration", x)
}

// would print:
// iteration 0
// iteration 1
// iteration 2

Breek en ga door

Het doorbreken van de lus en doorgaan naar de volgende iteratie wordt ook ondersteund in Go, zoals in veel andere talen:

for x := 0; x < 10; x++ { // loop through 0 to 9
    if x < 3 { // skips all the numbers before 3
        continue
    } 
    if x > 5 { // breaks out of the loop once x == 6
        break
    }
    fmt.Println("iteration", x)
}

// would print:
// iteration 3
// iteration 4
// iteration 5

De break en continue instructies accepteren bovendien een optioneel label, gebruikt om buitenste lussen te identificeren die met de instructie moeten worden getarget:

OuterLoop:
for {
    for {
        if allDone() {
            break OuterLoop
        }
        if innerDone() {
            continue OuterLoop
        }
        // do something
    }
}

Voorwaardelijke lus

Het sleutelwoord for wordt ook gebruikt voor voorwaardelijke lussen, traditioneel while lussen in andere programmeertalen.

package main

import (
    "fmt"
)

func main() {
    i := 0
    for i < 3 { // Will repeat if condition is true
        i++
        fmt.Println(i)
    }
}

speel het op speelplaats

Zal uitvoeren:

1
2
3

oneindige lus:

for {
    // This will run until a return or break.
}

Verschillende vormen van For Loop

Eenvoudig formulier met behulp van één variabele:

for i := 0; i < 10; i++ {
    fmt.Print(i, " ")
}

Gebruik twee variabelen (of meer):

for i, j := 0, 0; i < 5 && j < 10; i, j = i+1, j+2 {
    fmt.Println(i, j)
}

Zonder initialisatieverklaring:

i := 0
for ; i < 10; i++ {
    fmt.Print(i, " ")
}

Zonder een testuitdrukking:

for i := 1; ; i++ {
    if i&1 == 1 {
        continue
    }
    if i == 22 {
        break
    }
    fmt.Print(i, " ")
}

Zonder increment expressie:

for i := 0; i < 10; {
    fmt.Print(i, " ")
    i++
}

Wanneer alle drie initialisatie-, test- en incrementuitdrukkingen worden verwijderd, wordt de lus oneindig:

i := 0
for {
    fmt.Print(i, " ")
    i++
    if i == 10 {
        break
    }
}

Dit is een voorbeeld van een oneindige lus met teller geïnitialiseerd met nul:

for i := 0; ; {
    fmt.Print(i, " ")
    if i == 9 {
        break
    }
    i++
}

Wanneer alleen de testexpressie wordt gebruikt (werkt als een typische while-lus):

i := 0
for i < 10 {
    fmt.Print(i, " ")
    i++
}

Gebruik gewoon increment expression:

i := 0
for ; ; i++ {
    fmt.Print(i, " ")
    if i == 9 {
        break
    }
}

Herhaal over een bereik van waarden met behulp van index en waarde:

ary := [5]int{0, 1, 2, 3, 4}
for index, value := range ary {
    fmt.Println("ary[", index, "] =", value)
}

Herhaal over een bereik met alleen index:

for index := range ary {
    fmt.Println("ary[", index, "] =", ary[index])
}

Herhaal over een bereik met alleen index:

for index, _ := range ary {
    fmt.Println("ary[", index, "] =", ary[index])
}

Herhaal over een bereik met alleen waarde:

for _, value := range ary {
    fmt.Print(value, " ")
}

Herhaal over een bereik met behulp van sleutel en waarde voor kaart (mogelijk niet in volgorde):

mp := map[string]int{"One": 1, "Two": 2, "Three": 3}
for key, value := range mp {
    fmt.Println("map[", key, "] =", value)
}

Herhaal over een bereik met behulp van alleen de toets voor de kaart (mogelijk niet in volgorde):

for key := range mp {
    fmt.Print(key, " ") //One Two Three
}

Herhaal over een bereik met behulp van alleen de toets voor de kaart (mogelijk niet in volgorde):

for key, _ := range mp {
    fmt.Print(key, " ") //One Two Three
}

Herhaal over een bereik met alleen waarde voor kaart (mogelijk niet in volgorde):

for _, value := range mp {
    fmt.Print(value, " ") //2 3 1
}

Iterate over een bereik voor kanalen (wordt afgesloten als het kanaal gesloten is):

ch := make(chan int, 10)
for i := 0; i < 10; i++ {
    ch <- i
}
close(ch)

for i := range ch {
    fmt.Print(i, " ")
}

Herhaal over een bereik voor tekenreeks (geeft Unicode-codepunten):

utf8str := "B = \u00b5H" //B = µH
for _, r := range utf8str {
    fmt.Print(r, " ") //66 32 61 32 181 72
}
fmt.Println()
for _, v := range []byte(utf8str) {
    fmt.Print(v, " ") //66 32 61 32 194 181 72
}
fmt.Println(len(utf8str)) //7

zoals je ziet heeft utf8str 6 runen (Unicode-codepunten) en 7 bytes.

Getimede lus

package main

import(
    "fmt"
    "time"
)

func main() {
    for _ = range time.Tick(time.Second * 3) {
        fmt.Println("Ticking every 3 seconds")
    }
}


Modified text is an extract of the original Stack Overflow Documentation
Licentie onder CC BY-SA 3.0
Niet aangesloten bij Stack Overflow