Golang For Loop-opplæring [With Examples]

by
Tweet
Share
Share
Pin
0 Shares

Lær alt om Golang for loops ved å kode flere nyttige eksempler.

Nylig har programmeringsspråk som Rust, Golang og TypeScript blitt superpopulære blant utviklere. Hvis du er interessert i backend-utvikling og DevOps, bør du vurdere å lære Golang er et utmerket alternativ!

Hvis du er en nybegynner som forstår det grunnleggende i et programmeringsspråk, er loop-konstruksjoner et av de første konseptene du bør forstå.

Golang gir bare for loop-konstruksjonen. Og vi vil lære om for loops og også hvordan du kan emulere andre looper ved å bruke for loop.

La oss begynne!

Syntaks av Golang For Loop

I Golang kan du lage for loop ved å bruke følgende syntaks:

for initialization; condition; update {
    // do something
}

Her,

  • initialisering angir initialiseringen av looping-variabelen.
  • condition er sløyfebetingelsen som bestemmer utførelsen av sløyfekroppen. Så lenge looping-betingelsen evalueres til sann, blir setningene i loop-kroppen utført. Og når tilstanden blir falsk, går kontrollen ut av sløyfen.
  • oppdatering angir oppdateringen til looping-variabelen – vanligvis en økning eller en reduksjon.

💡 Legg merke til hvordan dette ligner på C for loop bare uten parentes.

Her er kontrollflyten i Golang for loops:

På tide å kode noen eksempler!⏰ For å kode med kan du enten bruke en lokal installasjon av Golang eller kjøre eksemplene på Go Playground.

Golang For Loop Eksempler

La oss bruke syntaksen vi nettopp har lært til å skrive vår første for loop. Her er en enkel for-løkke som skriver ut tallene 1 til 5 i trinn på ett. 

package main

import "fmt"

func main() {
	fmt.Println("For loop:")
	num := 5
	for i := 1; i <= num; i++ {
		fmt.Println(i)
	}
}

Vi initialiserer looping-variabelen i til 1, setter betingelsen til i <= 5, og øker looping-variabelen med én etter hver iterasjon. Og her er utgangen:

//Output
For loop:
1
2
3
4
5

La oss skrive en annen for loop. Denne sløyfen starter fra 5 og teller ned til 1; det fortsetter til looping-variabelen er større enn eller lik 1. Så vi reduserer looping-variabelen med én etter hver iterasjon.

package main

import "fmt"

func main() {
	fmt.Println("For loop:")
	num := 5
	for i := num; i >= 1; i-- {
		fmt.Println(i)
	}
}

Og vi får det forventede resultatet:

//Output
For loop:
5
4
3
2
1

Hva er omfanget av sløyfevariabelen?

Omfanget av looping-variabelen er begrenset til for loop-blokken, og er ikke tilgjengelig utenfor loopen.

  Hvordan justere tekst etter en kule i PowerPoint

For å bekrefte dette, la oss prøve å få tilgang til verdien av looping-variabelen i utenfor loopen:

package main

import "fmt"

func main() {
	fmt.Println("For loop:")
	num := 5
	for i := 1; i <= num; i++ {
		fmt.Println(i)
	}
	fmt.Println(i)

}

Som forventet får vi en feil som sier at i er en udefinert (og omfanget er begrenset til for-løkken):

// Output
./prog.go:11:14: undefined: i

Infinite For Loop i Golang

Kan vi ha uendelig for loops i Go? Ja, det kan vi sikkert!

Hvis du ser på kontrollflyten til for loop:

  • Løkkelegemet vil fortsette å kjøre så lenge tilstanden evalueres til sann.
  • Når tilstanden blir falsk, går kontrollen ut av sløyfen.
  • Så hvis betingelsen aldri blir usann (eller alltid er sann), har vi en uendelig løkke.

Men du kan også bruke for-løkken uten initialisering, tilstand og oppdatering – uten å støte på syntaksfeil. Så hvis du kan få løkken til å løpe uendelig selv ved å bruke en for løkkekonstruksjon som denne:

package main

import "fmt"

func main() {
	for {
	   fmt.Println("running...")
	}
}
//Output
running...
running...
running...
running...
running...
//and it goes on forever!

I dette eksemplet setter vi variabelen num til 5. Og sløyfebetingelsen er num >= 5. Så løkken løper så lenge num er større enn eller lik null. 

package main

import "fmt"

func main() {
	num := 5
	for num > 0 {
		fmt.Println(num)
	}
}

Fordi verdien av num aldri endres, evalueres betingelsen alltid til sann, og løkken går for alltid!

//Output
5
5
5
5
5
5
//and it goes on forever!

All Golang har bare for loop-konstruksjonen, vi kan prøve å emulere while og do-while looper ved å bruke for loops. Så la oss lære hvordan du gjør det!

  Hvordan skanne etter virus gjennom en antivirus API-tjeneste

Emulering mens loop ved hjelp av For Loop

While-løkken har vanligvis følgende form:

// initialize looping var
while (condition){
    // do something
    // update looping var
}

Hvis du husker, skrev vi i den første infinite for loop: vi brukte følgende for loop – uten initialisering, betingelse og oppdatering.

for {
// the simplest infinite loop
}

Så vi kan endre for-løkken til å inneholde bare betingelsen (i følgende form) for å emulere while-løkken:

//initialize looping var
for condition {
 // do something
 // update looping var
}

Her er while-løkken som tilsvarer den første for-løkken som vi skrev:

package main

import "fmt"

func main() {
	fmt.Println("Emulating while loop")
	num := 5
	for num > 0 {
		fmt.Println(num)
		num--
	}
}
//Output
Emulating while loop
5
4
3
2
1

Emulerer Do-While Loop ved å bruke For Loop

Hvis du har kodet i et språk som C, vet du at do-while loop-konstruksjonen har følgende form:

// initialize looping var
do {
//something
// update looping var
} while(condition);

Den viktigste forskjellen mellom while og do while loop er at while loopen sjekker tilstanden ved inntreden i loopen. Do-while-løkken, derimot, sjekker tilstanden ved utgang fra løkken.

Så, om en stund løkke, hvis betingelsen evalueres til falsk, vil løkkekroppen aldri utføres. Imidlertid, i en do-while-løkke, kjøres loop-kroppen selv om tilstanden evalueres til falsk.

Ved å bruke denne informasjonen kan vi emulere oppførselen til en do-while-løkke:

  • Skriv en uendelig for loop
  • Bruk en if condition-setning med riktig betingelse for å bryte ut av loopen

La oss si at du vil skrive en do-while-løkke der betingelsen for at loopbody skal utføres er num < 0. Så du kan skrive en for-løkke og bryte ut av loopen hvis num >= 0.

package main

import "fmt"

func main() {
	fmt.Println("Emulating do-while loop")
	num := 5
	for {
		fmt.Println("loop runs...")
		if num >= 0 {
			break
		}
	}
}

💡 Merk at å utføre løkken hvis num < 0 og bryte ut av løkken hvis num >= 0 er ekvivalente betingelser.

  Hvordan reversere bildesøk på iPhone eller iPad

Selv om betingelsen num > 0 i utgangspunktet er usann (num er 5), kjører løkken én gang, og emulerer en do-while-løkke.

//Output
Emulating do-while loop
loop runs...

Looping Gjennom Arrays Bruke For Loop

Når du går gjennom arrays i Golang ved å bruke en for loop og range, kan du få tilgang til både indeksene og elementene. Dette fungerer på samme måte som enumerate-funksjonen i Python.

Her lager vi numArray, en rekke heltall. Og gå gjennom den ved å bruke en for-løkke:

package main

import "fmt"

func main() {
	fmt.Println("Looping through an array")
	numArray := []int{3, 7, 0, 10, 8, 9}
	for idx, num := range numArray {
		fmt.Println("At index", idx, ": ", num)
	}
}

Som sett kan vi få tilgang til både indeksen og elementet på hver indeks samtidig:

//Output
Looping through an array
At index 0 :  3
At index 1 :  7
At index 2 :  0
At index 3 :  10
At index 4 :  8
At index 5 :  9

Bruke defer i Golang For Loop

I Golang kan du bruke defer nøkkelordet for å utsette funksjonskall.

Selv om det brukes i applikasjoner som ressursopprydding og feilhåndtering, kan det være nyttig å forstå hvordan du bruker defer i en for-løkke. La oss se hva som skjer når vi bruker defer inne i for-løkken for å utsette kallene til Println()-funksjonen.

package main

import "fmt"

func main() {
	fmt.Println("For loop:")
	num := 5
	for i := 1; i <= num; i++ {
		defer fmt.Println(i)
	}
}

💬 Når et funksjonskall blir utsatt, skyves funksjonskallet inn på stabelen og utføres i LIFO-rekkefølge. Denne kjøringen skjer først etter at funksjonen som omgir defer-setningen returnerer.

Så fmt.Println(5) blir utført først og fmt.Println(1) blir utført sist:

//Output
For loop:
5
4
3
2
1

Konklusjon

Her er et sammendrag av det du har lært i denne opplæringen:

  • I Golang kan du lage for løkker med syntaksen: for initialisering; betingelse; oppdater { //loop body}.
  • Kontrollflyten til for-løkken er ganske enkel. Løkkevariabelen initialiseres én gang, letebetingelsen bestemmer om løkketeksten skal utføres eller ikke, og oppdateringen refererer til oppdateringen av løkkevariabelen etter hver iterasjon.
  • Omfanget av sløyfevariabelen er begrenset til sløyfekroppen og er ikke tilgjengelig utenfor sløyfen.
  • Selv om Golang bare gir for loop-konstruksjonen, kan du emulere mens- og do-while-løkke-atferd ved å bruke for loops.
  • Noen få andre applikasjoner av for loop inkluderer looping gjennom arrays og utsettelse av funksjonskall inne i for loop body.

Deretter lærer du hvordan du bruker for loops i Python. God læring!🎉