Голанг Фор Лооп Туториал [With Examples]

Сазнајте све о Голанг за петље тако што ћете кодирати неколико корисних примера.

Недавно су програмски језици као што су Руст, Голанг и ТипеСцрипт постали супер популарни међу програмерима. Ако сте заинтересовани за бацк-енд развој и ДевОпс, требало би да размислите о томе да је учење Голанг одлична опција!

Ако сте почетник који усваја основе програмског језика, конструкције петље су један од првих концепата које треба да разумете.

Голанг обезбеђује само конструкцију фор петље. И научићемо о фор петљама, као и о томе како да емулирамо друге петље користећи фор петљу.

Почнимо!

Синтакса Голанг за петљу

У Голангу можете креирати фор петљу користећи следећу синтаксу:

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

овде,

  • иницијализација означава иницијализацију променљиве петље.
  • услов је услов петље који одређује извршење тела петље. Све док се услов петље процењује на тачно, наредбе у телу петље се извршавају. А када услов постане нетачан, контрола излази из петље.
  • упдате означава ажурирање променљиве петље – обично повећање или смањење.

💡 Приметите како је ово слично Ц фор петљи само без заграда.

Ево тока контроле у ​​Голангу за петље:

Време је за кодирање неких примера!⏰ Да бисте кодирали заједно, можете користити локалну инсталацију Голанг-а или покренути примере на Го Плаигроунд-у.

Голанг Фор Лооп Примери

Хајде да користимо синтаксу коју смо управо научили да напишемо нашу прву фор петљу. Ево једноставне фор петље која штампа бројеве од 1 до 5 у корацима од један.

package main

import "fmt"

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

Иницијализујемо променљиву петље и на 1, постављамо услов на и <= 5 и повећавамо променљиву у петљи за један након сваке итерације. А ево и излаза:

//Output
For loop:
1
2
3
4
5

Хајде да напишемо другу фор петљу. Ова петља почиње од 5 и одбројава се до 1; наставља се све док променљива у петљи не буде већа или једнака 1. Дакле, смањујемо променљиву петље за један после сваке итерације.

package main

import "fmt"

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

И добијамо очекивани излаз:

//Output
For loop:
5
4
3
2
1

Који је опсег променљиве петље?

Опсег променљиве петље је ограничен на блок петље фор и није доступан изван петље.

  Како добити упозорења када игра Нинтендо Свитцх крене у продају

Да бисмо ово потврдили, покушајмо да приступимо вредности променљиве петље и изван петље:

package main

import "fmt"

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

}

Као што се очекивало, наилазимо на грешку у којој се наводи да је и недефинисано (и његов опсег је ограничен на петљу фор):

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

Инфините Фор Лооп у Голангу

Можемо ли имати бесконачне фор петље у Го? Да, сигурно можемо!

Ако погледате контролни ток фор петље:

  • Тело петље ће наставити да се извршава све док услов буде тачан.
  • Када услов постане нетачан, контрола излази из петље.
  • Дакле, ако услов никада не постане нетачан (или је увек тачан), имамо бесконачну петљу.

Али такође можете да користите петљу фор без иницијализације, услова и ажурирања — без наиласка на синтаксичке грешке. Дакле, ако можете учинити да петља ради бесконачно чак и користећи конструкцију фор петље попут ове:

package main

import "fmt"

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

У овом примеру, поставили смо променљиву нум на 5. А услов петље је нум >= 5. Дакле, петља траје све док је нум већи или једнак нули.

package main

import "fmt"

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

Пошто се вредност нум никада не мења, услов се увек процењује на истинито, а петља траје заувек!

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

Сав Голанг има само конструкцију фор петље, можемо покушати да емулирамо вхиле и до-вхиле петље користећи фор петље. Па хајде да научимо како то да урадимо!

Емулација вхиле петље користећи Фор Лооп

Док петља генерално има следећи облик:

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

Ако се сећате, у првој бесконачној фор петљи смо написали: користили смо следећу фор петљу — без иницијализације, услова и ажурирања.

for {
// the simplest infinite loop
}

Дакле, можемо да модификујемо фор петљу тако да садржи само услов (у следећем облику) за емулацију вхиле петље:

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

Ево еквивалента вхиле петље првој фор петљи коју смо написали:

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

Емулација До-Вхиле петље користећи Фор Лооп

Ако сте кодирали на језику као што је Ц, знате да конструкција до-вхиле петље има следећи облик:

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

Кључна разлика између вхиле и до вхиле петље је у томе што петља вхиле проверава стање при уласку у петљу. До-вхиле петља, с друге стране, проверава услов по изласку из петље.

  Како преузети текстуалне поруке са иПхоне-а

Дакле, у петљи вхиле, ако се услов оцени као нетачан, тело петље се никада не извршава. Међутим, у до-вхиле петљи, тело петље се извршава чак и ако је услов нетачан.

Користећи ове информације, можемо емулирати понашање до-вхиле петље:

  • Напишите бесконачну фор петљу
  • Користите условни израз иф са исправним условом да бисте изашли из петље

Рецимо да желите да напишете до-вхиле петљу где је услов за извршење тела петље нум < 0. Дакле, можете написати фор петљу и изаћи из петље ако је нум >= 0.

package main

import "fmt"

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

💡 Имајте на уму да су извршавање петље ако је нум < 0 и излазак из петље ако је нум >= 0 еквивалентни услови.

Иако је услов нум > 0 у почетку нетачан (нум је 5), тело петље се покреће једном, емулирајући до-вхиле петљу.

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

Петља кроз низове користећи Фор петљу

Када пролазите кроз низове у Голангу користећи фор петљу и опсег, можете приступити и индексима и елементима. Ово функционише слично функцији енумерате у Питхон-у.

Овде креирамо нумАрраи, низ целих бројева. И прођите кроз њега користећи фор петљу:

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)
	}
}

Као што се види, можемо да приступимо и индексу и елементу у сваком индексу истовремено:

//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

Коришћење одлагања у Голанг Фор Лооп

У Голангу можете да користите кључну реч дефер да бисте одложили позиве функција.

  8 најбољих музичких Смарт Линк услуга које можете користити данас

Иако се користи у апликацијама као што су чишћење ресурса и руковање грешкама, може бити од помоћи разумети како се користи одлагање унутар фор петље. Хајде да видимо шта се дешава када користимо дефер унутар фор петље да одложимо позиве функције Принтлн().

package main

import "fmt"

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

💬 Када се позив функције одложи, позив функције се гура у стек и извршава у ЛИФО редоследу. Ово извршење се дешава тек након што се врати функција која окружује наредбу дефер.

Дакле, фмт.Принтлн(5) се извршава први, а фмт.Принтлн(1) се извршава последњи:

//Output
For loop:
5
4
3
2
1

Закључак

Ево резимеа онога што сте научили у овом водичу:

  • У Голангу можете креирати фор петље са синтаксом: за иницијализацију; стање; упдате { //тело петље}.
  • Контролни ток фор петље је прилично једноставан. Променљива петље се иницијализује једном, услов тражења одређује да ли ће се извршити или не тело петље, а ажурирање се односи на ажурирање променљиве петље након сваке итерације.
  • Опсег променљиве петље је ограничен на тело петље и није доступан изван петље.
  • Иако Голанг обезбеђује само конструкцију петље фор, можете емулирати понашање вхиле и до-вхиле петље користећи фор петље.
  • Неколико других примена фор петље укључује петљу кроз низове и одлагање позива функција унутар тела фор петље.

Затим научите како да користите фор петље у Питхон-у. Срећно учење!🎉