Go Academy · Lektion

select-sætningen

Multiplexing af channels med select

Lektion 1 af 413 trin

select-sætningen er en gratis Go Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Go Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Go Academy-kurset indeholder 4 lektioner i alt.

Hvad er select?

select-sætningen lader en goroutine vente på flere kanalhandlinger samtidigt. Den vælger det første case, der er klar til at fortsætte, på samme måde som en switch, men til kanaler.

Grundlæggende syntaks

Hvert case i en select er en afsendelse eller modtagelse via en kanal:

select {
case msg := <-ch1:
    fmt.Println("ch1:", msg)
case msg := <-ch2:
    fmt.Println("ch2:", msg)
}

Ikke-blokerende med default

Hvis du tilføjer et default-case, bliver select ikke-blokerende — hvis ingen kanal er klar, går den straks videre til default.

select {
case v := <-ch:
    fmt.Println(v)
default:
    fmt.Println("no value ready")
}

Tilfældig udvælgelse

Når flere cases er klar på samme tid, vælger Go én tilfældigt — alle klar cases har samme sandsynlighed for at blive valgt. Det forhindrer udsultning.

Afsendelse i select

Cases kan også være kanalafsendelser. Et afsendelses-case er klar, når kanalen har plads i bufferen (eller en modtager venter).

select {
case ch1 <- val1:
    fmt.Println("sent to ch1")
case ch2 <- val2:
    fmt.Println("sent to ch2")
}

Tom select blokerer for evigt

En nøgen select{} uden cases blokerer den aktuelle goroutine for evigt. Det er en almindelig idiom til at holde hovedgoroutinen i live, mens andre goroutines kører.

func main() {
    go serve()
    select {} // block forever
}

Løkker med select

Pak en select ind i en for-løkke for løbende at multiplexe kanaler. Tilføj en done-kanal for at afslutte på en ren måde.

for {
    select {
    case v := <-data:
        process(v)
    case <-done:
        return
    }
}

Nil-kanaler

En nil-kanal blokerer for evigt i et select-case og deaktiverer dermed reelt dette case. Du kan bruge det til dynamisk at aktivere eller deaktivere cases under kørsel.

var ch chan int // nil
select {
case v := <-ch: // never selected
    _ = v
case v := <-other:
    fmt.Println(v)
}

Select med lukkede kanaler

En modtagelse fra en lukket kanal lykkes altid med det samme og returnerer nulværdien. Brug formen med to værdier til at registrere, at kanalen er lukket.

select {
case v, ok := <-ch:
    if !ok { return } // channel closed
    use(v)
}

Prioritetsmønstre

Go understøtter ikke prioriteter direkte i select. Hvis du vil prioritere én kanal, kan du indlejre selects eller bruge en løkke, der først tjekker kanalen med høj prioritet ved hjælp af default.

for {
    select {
    case v := <-highPriority:
        handle(v)
    default:
        select {
        case v := <-lowPriority:
            handle(v)
        }
    }
}

Opsummering indtil videre

select venter på flere kanaler, vælger et tilfældigt klart case, understøtter default til ikke-blokerende kørsel, og nil-kanaler deaktiverer cases. Et almindeligt mønster er: for+select+done.

Hurtigt tjek

Hvad sker der, når flere cases i en select er klar på samme tid?

Besvar den i den interaktive lektion

Opsummering: select-sætningen

Vigtige punkter:

select blokerer, indtil et kanal-case er klar
Flere klare cases → tilfældig udvælgelse
default gør kørsel ikke-blokerende
En nil-kanal deaktiverer sit case
for+select+done er den almindelige multiplexing-løkke

Gratis at komme i gang

Lær Go med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 51
Lektioner: 203

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “select-sætningen” gratis?

Ja — alle 3 lektioner i læringssporet Go Academy, inklusive “select-sætningen”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Go Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “select-sætningen”?

Multiplexing af channels med select Du øver dig i Go Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Go Academy?

Der kræves ingen tidligere erfaring. Go Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “select-sætningen”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Go Academy-lektion?

Ja. Alle Go Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Go Academy