011 / go if / for / Условия / Циклы

Выражение вычисляется, и если полученный результат равен 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 удалит все круглые скобки, добавленные вами, если только они не используются для определения порядка операций.

Выражение вычисляется, и если полученный результат равен 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--
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

Пример кода:

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 он бы выполнился еще два раза).
Управление передается команде, следующей за циклом.

В 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 он бы выполнился еще два раза).

Управление передается команде, следующей за циклом.