Выражение вычисляется, и если полученный результат равен true, то выполняется код в теле условного блока.
Если же результат равен false, условный блок пропускается.
if true {
fmt.Println("I'll be printed!")
}
if false {
fmt.Println("I won't!")
}
Как и многие другие языки, Go поддерживает множественное ветвление в условных командах.
Такие команды записываются в форме if...else if...else.
if grade == 100 {
fmt.Println("Perfect!")
} else if grade >= 60 {
fmt.Println("You pass.")
} else {
fmt.Println("You fail!")
}
Условные команды используют логическое выражение (результат которого равен true или false),
чтобы определить, должен ли выполняться содержащийся в них код.
if 1 == 1 {
fmt.Println("I'll be printed!")
}
if 1 >= 2 {
fmt.Println("I won't!")
}
if 1 > 2 {
fmt.Println("I won't!")
}
if 2 <= 2 {
fmt.Println("I'll be printed!")
}
if 1 < 2 {
fmt.Println("I'll be printed!")
}
if 2 != 2 {
fmt.Println("I won't!")
}
Если код должен выполняться только в том случае, когда условие дает результат false, используйте ! — оператор логического отрицания.
Этот оператор берет значение true и превращает его в false или же берет значение false и превращает его в true.
if !true {
fmt.Println("I won't be printed!")
}
if !false {
fmt.Println("I will!")
}
Если код должен выполняться только в том случае, когда истинны оба условия, используйте оператор && («и»).
А если он должен выполняться лишь тогда, когда истинно хотя бы одно из двух условий, используйте оператор || («или»).
if true && true {
fmt.Println("I'll be printed!")
}
if false || true {
fmt.Println("I'll be printed!")
}
if true && false {
fmt.Println("I won't!")
}
if false || false {
fmt.Println("I won't!")
}
В: Другой язык программирования требует, чтобы условие команды if заключалось в круглые скобки. В Go это не обязательно?
О: Нет. Более того, команда go fmt удалит все круглые скобки, добавленные вами, если только они не используются для определения порядка операций.
Циклы / Цикл for
Пример кода:
package main
import "fmt"
func main() {
for x := 4; x <= 6; x++ {
fmt.Println("x is now", x)
}
}
Разберем:
for x := 4; x <= 6; x++ {
fmt.Println("x is now", x)
}
for - ключевое слово
x:=4 - команда инициализации
x < 6 - Условное выражение
x++ - Операция приращения
{ - начало блока цикла
}конец блока цикла
fmt.Println("x is now", x) - тело блока цикла
Циклы всегда начинаются с ключевого слова for. В одной из стандартных разновидностей циклов за for следуют три сегмента кода, которые управляют циклом:
- Команда инициализации, обычно используемая для инициализации переменной.
- Условное выражение, которое определяет, когда следует прервать выполнение цикла.
- Оператор приращения, который выполняется после каждой итерации цикла.
Команда инициализации часто используется для инициализации переменной;
условное выражение обеспечивает выполнение цикла до того, как переменная достигнет определенного значения, и оператор приращения обновляет значение этой переменной.
Например, в приведенном фрагменте переменная t инициализируется значением 3, условие обеспечивает выполнение цикла, пока t > 0,
а оператор приращения уменьшает t на 1 при каждом выполнении цикла.
В конечном итоге t уменьшается до 0 и цикл завершается.
package main
import "fmt"
func main() {
for t := 3; t > 0; t-- {
fmt.Println(t)
}
fmt.Println("Blastoff!")
}
Операторы ++ и -- часто встречаются в командах приращения циклов.
++ увеличивает значение переменной на 1, а -- уменьшает его на 1.
Примеры кода:
x := 0
x++
fmt.Println(x)
x++
fmt.Println(x)
x--
fmt.Println(x)
for x := 1; x <= 3; x++ {
fmt.Println(x)
}
for x := 3; x >= 1; x-- {
fmt.Println(x)
}
В языке Go также поддерживаются операторы присваивания += и -=.
Они получают значение в переменной, добавляют или вычитают другое значение, а затем присваивают результат той же переменной.
Примеры кода:
x := 0
x += 2
fmt.Println(x)
x += 5
fmt.Println(x)
x -= 3
fmt.Println(x)
Операторы += и -= также могут использоваться в циклах для изменения переменной на величину, отличную от 1.
for x := 1; x <= 5; x += 2 {
fmt.Println(x)
}
for x := 15; x >= 5; x -= 5 {
fmt.Println(x)
}
Когда цикл завершается, выполнение программы продолжится с команды, следующей за блоком цикла.
При этом цикл продолжает выполняться, пока условное выражение остается истинным.
Этот факт может иметь нежелательные последствия;
ниже приведены примеры циклов, которые выполняются бесконечно или не выполняются ни одного раза:
бесконечный цикл:
for x := 1; true; x++ {
fmt.Println(x)
}
Цикл не выполнится никогда:
for x := 1; false; x++ {
fmt.Println(x)
}
Будьте осторожны!
Цикл может выполняться бесконечно.
В этом случае ваша программа никогда не остановится сама.
Если это случится, в активном окне терминала нажмите клавишу Control одновременно с клавишей C, чтобы прервать выполнение программы.
Операторы инициализации и приращения необязательны.
При желании операторы инициализации и приращения в заголовке цикла for можно опустить,
оставив только условное выражение (хотя вы должны проследить за тем, чтобы условие в какой-то момент становилось ложным, иначе в программе возникнет бесконечный цикл).
x := 1
for x <= 3 {
fmt.Println(x)
x++
}
x := 3
for x >= 1 {
fmt.Println(x)
x--
}
Пропуск частей цикла командами continue и break
В Go предусмотрены два ключевых слова для управления циклом.
Первое — continue — осуществляет немедленный переход к следующей итерации цикла;
при этом дальнейший код текущей итерации в блоке цикла пропускается.
for x := 1; x <= 3; x++ {
fmt.Println("before continue")
continue
fmt.Println("after continue")
}
В приведенном выше примере строка "after continue" никогда не выводится,
потому что ключевое слово continue всегда выполняет переход к началу цикла — до того, как отработает второй вызов Println.
Второе ключевое слово break приводит к немедленному выходу из цикла. Дальнейший код в блоке цикла не отрабатывается, другие итерации цикла не выполняются.
Управление передается первой команде, следующей за циклом.
for x := 1; x <= 3; x++ {
fmt.Println("before break")
break
fmt.Println("after break")
}
fmt.Println("after loop")
Здесь при первой итерации цикла выводится сообщение "before break", после чего команда break немедленно прерывает цикл;
сообщение "after break" не выводится, и цикл не выполняется повторно (хотя без break он бы выполнился еще два раза).
Управление передается команде, следующей за циклом.