Golang for sløyfe

Løkker er en av de mest kritiske funksjonene i programmering. Ved hjelp av løkker kan du gjentatte ganger utføre en kodeblokk uten å skrive den om og om igjen. Løkker hjelper til med å redusere feil i kode og forbedre lesbarheten ved å fjerne behovet for å duplisere et stykke kode flere ganger i samme program.

Denne guiden vil lære oss å jobbe med løkker i Go -programmeringsspråket.

Introduksjon

I motsetning til andre programmeringsspråk som inneholder over en sløyfekonstruksjoner som mens og lager løkker, gir Go en sløyfekonstruksjon: for loop.

Selv om det kan virke begrenset, kan vi utvide for -loopen til å utføre andre sløyfeoperasjoner som uendelige løkker, iterere over varer, mens løkker, og mer.

Ved hjelp av en enkelt sløyfekonstruksjon lar deg opprettholde ren og lesbar kode uten å bekymre deg for hva sløyfen skal brukes til en spesifikk operasjon.

Gå for sløyfe

La oss diskutere hvordan vi kan jobbe med for -loopen i Go. Vi klassifiserer en for loop som en iterasjonserklæring. Dette betyr at en for loop lar deg gjentatte ganger utføre en kodeblokk for det spesifiserte antall ganger.

Du kan for eksempel kjøre utskrift av noe x antall ganger eller lese prosessen et bestemt antall ganger.

Syntaksen til en for loop i go er som vist:

for [init]; [betingelse]; [post]
// LOOP -drift

Eksemplet ovenfor bruker klassikeren for sløyfesyntaks. Vi starter med å definere en innledende uttalelse etterfulgt av sløyfetilstanden, og til slutt en postoppgave eller en økning eller reduksjonsoperasjon.

La oss ta et eksempel for å skrive ut verdier fra 1 til 10. Vi kan lage en enkel for loop som:

for i: = 0; Jeg <= 10; i++
fmt.Println (i)

La oss dissekere deler av for -loopen ovenfor.

Vi starter med å erklære den første uttalelsen. I vårt eksempel erklærer vi en variabel kalt jeg og tildeler dens opprinnelige verdi som 0.

Neste del er sløyfetilstanden. Dette definerer tilstanden for å sjekke, og hvis du er sant, fortsett å utføre koden inne i for en sløyfe til den er falsk. I vårt eksempel sjekker vi om verdien av i er mindre enn eller lik 10.

Den siste delen er Post States. Dette definerer handlingen som skal utføres etter hver iterasjon av loopen. I vårt eksempel øker vi verdien av jeg med en ved å bruke inkrementoperatøren (++).

Full kodebit er som vist:

pakkehoved
Importer "FMT"
FUNCMAIN ()
print_ten ()

funcprint_ten ()
Fori: = 0; Jeg<= 10; i++
fmt.Println (i)

Når vi har kjørt ovennevnte kode, bør vi se programutskriftsnumrene fra 1 til 10 som:

$ gå løp for_loop.gå
0
1
--- output avkortet---
9
10

Løyfen kjøres 10 ganger, der hver iterasjon øker verdien på i 1. Dette fortsetter til verdien av i er ikke mindre enn 10. Når tilstanden er falsk, kommer sløyfen ut.

Merk: Du er ikke begrenset til å sette den første uttalelsen til 0. Du kan angi et hvilket som helst verdier av verdier. For eksempel kan vi opprette en for loop for å skrive ut de jevnt tallene mellom 20 og 50 ved hjelp av en for loop som vist:

Fori: = 20; Jeg<50; i++
ifi%2 == 0
fmt.Println (i)

I eksemplet over setter vi startverdien som 20 og en sløyfetilstand (hvis verdien av i er mindre enn 50). Vi tar deretter verdien av jeg og gir den til en IF -uttalelse. Hvis jeg mod 2 er lik 0, kan du skrive ut i.

Ovennevnte kode skriver ut de jevne tallene i området 20 og 50.

$ gå løp for_loop.gå
20
22
--- Kode avkortet ---
46
48

Husk at du kan angi hvilken som helst operasjon som postuttalelsen så lenge den endrer verdien av den første uttalelsen per hver iterasjon.

For eksempel:

FUNCMODIFY_INTERVAL ()
Fori: = 0; Jeg<100; i += 5
fmt.Println (i)

I eksemplet over øker vi verdien av i med 5 per hver loop -iterasjon.

Merk: Du kan også bruke en reduksjonsoperasjon som postuttalelse.

Bruker en for loop som en stund loop

Du kan opprette en stundsløyfe i Go ved å bruke en enkelt komponent i For-loop-konstruksjonen. Vi kan også referere til denne metoden som en tilstandssløyfe.

For eksempel:

i: = 1
fori<5
fmt.Println (i)
Jeg++

Her erklærer vi den første uttalelsen utenfor for-loop-blokken. Inne i for -loopen definerer vi tilstanden for å sjekke om verdien av i er mindre enn 5. Hvis det er sant, fortsetter vi å utføre operasjonene i for-loop-blokken.

Vi kan bruke nøkkelordet for å avslutte sløyfen når en spesifikk tilstand er nådd.

for
ifi == 10
gå i stykker

Bruker en for loop for å lage en uendelig sløyfe

Vi kan også lage en uendelig sløyfe ved hjelp av for-loop-konstruksjonen. Hvis vi hopper over tilstandsdelen av for -loopen, lager vi en uendelig sløyfe som vist i eksemplet nedenfor:

i: = 0
for
Jeg++

I eksemplets utdrag ovenfor vil sløyfen løpe for alltid, da tilstanden alltid er sann.

Bruker for løkker for å iterere over datatyper

Vi kan også bruke en for loop for å iterere over forskjellige datatyper som strenger, matriser og skiver. Disse typene løkker er også kjent som for rekkevidde løkker.

For eksempel itererer koden nedenfor over en matrise:

Databaser: = [] String "MongoDB", "SQL Server", "SQLite", "Cockroachdb", "Fauna DB"
Fori: = 0; Jegfmt.Println (databaser [i])

Hvis jeg er mindre enn lengden på matrisen, kan du skrive ut hvert element i matrisen og øke verdien på i.

Hvis vi kjører koden over, bør vi få en utdata som vist:

$ gå løp for_loop.gå
Mongodb
SQL Server
Sqlite
Kakerlakkdb
Fauna DB

Her skriver vi ut hvert element fra matrisen.

Vi kan også iterere over kart, som vist i eksemplet nedenfor:

my_map: = kart [streng] streng
"id": "1",
"Navn": "Jonh Doe",
"Lønn": "$ 150000",

for nøkkel, verdi: = Range my_map
fmt.Println (tast, verdi)

I dette eksemplet itererer vi over hver tast og den tilhørende verdien av kartet. Koden over skal returnere utdataene som:

$ gå løp for_loop.gå
Lønn $ 150000
ID 1
Navn Jonh Doe

Lukking

Denne guiden utforsket det grunnleggende om å jobbe med løkker i Go -programmeringsspråket. Ved hjelp av løkker kan du gjentatte ganger utføre et sett med instruksjoner uten å duplisere koden.

Takk for at du leser, og følg med for flere go -opplæringsprogrammer.