Условные операторы в Go

12 октября, 2019 11:52 дп 1 499 views | Комментариев нет

| | Комментировать запись

Условные операторы – неотъемлемая часть любого языка программирования. Они позволяют определять ситуации, в которых запускается или не запускается тот или иной фрагмент кода.

Выполняя все операторы без исключений, программа не умеет оценивать специфические условия. Условные операторы позволяют программе определить, выполняются ли какие-то условия, и понять, как вести себя в такой ситуации.

Давайте рассмотрим пару примеров, в которых используются условные выражения:

  • Если студент на тесте набирает больше 65%, программа сообщает, что тест сдан; если меньше, она сообщает, что нужно пересдать тест.
  • Если у абонента есть деньги на счете, начисляются бонусы; если нет, взымается штраф.
  • Если покупатель берет 10 апельсинов (или больше), он получает скидку 5%; если он покупает меньше 10 апельсинов, он платит стандартную цену.

Оценивая условия и выполняя код в зависимости от этих условий, программа становится более гибкой.

В данном мануале вы узнаете, как писать условные операторы на языке программирования Go.

Оператор if

Начнем с оператора if. Он оценивает, является ли условие истинным или ложным, и запускает код только в том случае, если утверждение истинно.

Давайте посмотрим, как это работает. В текстовом редакторе откройте файл и введите следующий код:

package main
import "fmt"
func main() {
grade := 70
if grade >= 65 {
fmt.Println("Passing grade")
}
}

В этом коде есть переменная grade, и мы присваиваем ей целочисленное значение 70. Затем идет оператор if, который оценивает значение переменной – оно должно быть больше или равно (>=) 65. Если это условие выполняется, программа выводит строку Passing grade.

Читайте также:

Сохраните программу как grade.go и запустите ее в локальной среде разработки из терминала с помощью команды:

go run grade.go

В этом случае значение переменной – 70, следовательно, условие >= 65 выполняется, поэтому после запуска программы вы получите следующий вывод:

Passing grade

Теперь давайте для эксперимента изменим значение переменной grade на 60 и посмотрим, изменится ли результат программы:

package main
import "fmt"
func main() {
grade := 60
if grade >= 65 {
fmt.Println("Passing grade")
}
}

Сохраните и запустите этот код, и вы не получите никакого вывода, потому что условие не было выполнено, а программа не знает, что делать дальше в таком случае.

Теперь давайте попробуем выполнить другой пример. Мы напишем программу, которая будет считать, находится ли остаток на банковском счете ниже 0. Создайте файл account.go и напишите следующий код:

package main
import "fmt"
func main() {
balance := -5
if balance < 0 {
fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
}
}

Когда мы запустим программу с помощью go run account.go, мы получим следующий вывод:

Balance is below 0, add funds now or you will be charged a penalty.

В программе мы инициализировали переменную balance со значением -5, которое меньше 0. Так как баланс соответствует условию оператора if (balance < 0), мы получим вывод, как только сохраним и запустим код. Опять же, если вы попробуете увеличить баланс до 0 или больше, вы не получите никакого вывода.

Оператор else

Было бы неплохо, чтобы программа что-то сделала, даже если оператор if оценивает условия как false. Давайте вернемся к примеру с оценками и попробуем сделать так, чтобы программа вывела результат независимо от того, пройден тест или нет.

Чтобы сделать это, добавьте оператор else к условному оператору в файле grade. Он будет выглядеть так:

package main
import "fmt"
func main() {
grade := 60
if grade >= 65 {
fmt.Println("Passing grade")
} else {
fmt.Println("Failing grade")
}
}

Поскольку переменная grade имеет значение 60, оператор if выдает результат false, поэтому программа не выводит результат Passing grade. Следующее выражение else подсказывает программе, что делать в этой ситуации.

Сохраните и запустите программу, и вы получите следующий вывод:

Failing grade

Если мы перепишем программу и присвоим переменной grade значение 65 или выше, мы снова получим Passing grade.

Чтобы добавить оператор else ко второму примеру (банковский счет), нужно переписать код следующим образом:

package main
import "fmt"
func main() {
balance := 522
if balance < 0 {
fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
} else {
fmt.Println("Your balance is 0 or above.")
}
}
Your balance is 0 or above.

Мы изменили значение переменной balance на положительное число, чтобы оператор else вывел строку на экран. Чтобы результат вывел первый оператор, if, нужно, чтобы в значении было отрицательное число.

Комбинируя операторы if и else, вы создаете условный оператор, состоящий из двух частей, с помощью которого программа будет выполнять определенные фрагменты кода независимо от того, выполнено ли условие if.

Операторы else if

Ранее мы уже говорили о логических опциях для условных операторов, где каждый оператор if оценивается как true или false.

Читайте также: Основы работы с логическими данными в Go

Но часто программа должна уметь оценивать более двух возможных результатов. Для этого можно использовать оператор else if, который помещается между операторами if и else. Оператор else if выглядит как оператор if и оценивает другое условие.

Вернемся к программе для оценки банковских счетов. Предположим, нам нужно получить три дискретных вывода для трех разных ситуаций:

  • Баланс ниже 0
  • Баланс равен 0
  • Баланс выше 0

Оператор else if нужно поместить между оператором if и оператором else следующим образом:

package main
import "fmt"
func main() {
balance := 522
if balance < 0 {
fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
} else if balance == 0 {
fmt.Println("Balance is equal to 0, add funds soon.")
} else {
fmt.Println("Your balance is 0 or above.")
}
}

Теперь программа может обработать три возможных вывода:

  • Если переменная balance равна 0, мы получим вывод оператора else if (Balance is equal to 0, add funds soon).
  • Если переменная balance имеет положительное значение, мы получим вывод оператора else (Your balance is 0 or above).
  • Если переменная balance имеет отрицательное значение, выводом будет строка из оператора if (Balance is below 0, add funds now or you will be charged a penalty).

А что если мы хотим, чтобы программа выводила больше трех результатов? Просто добавьте в код больше операторов else if.

Давайте перепишем программу grade.go код так, чтобы она возвращала несколько буквенных оценок, которые будут соответствовать диапазонам числовых оценок:

  • 90 и больше – А
  • 80-89 – В
  • 70-79 – С
  • 65-69 – D
  • 64 и меньше – F

Для запуска этого кода нам понадобится один оператор if, три else if и один else, который будет обрабатывать все оценки ниже 65 баллов.

Давайте перепишем код из предыдущего примера, чтобы теперь он выводил буквенные оценки. Оператор else можно не менять.

package main
import "fmt"
func main() {
grade := 60
if grade >= 90 {
fmt.Println("A grade")
} else if grade >= 80 {
fmt.Println("B grade")
} else if grade >= 70 {
fmt.Println("C grade")
} else if grade >= 65 {
fmt.Println("D grade")
} else {
fmt.Println("Failing grade")
}
}

Так как операторы else if будут оцениваться по порядку, мы можем записать их довольно просто. Эта программа выполняет следующие шаги:

  1. Если оценка больше или равна 90, программа выведет A grade. Если оценка меньше 90, программа перейдет к следующему оператору…
  2. Если оценка больше или равна 80, программа выведет В grade. Если оценка – 79 или меньше, программа перейдет к следующему оператору …
  3. Если оценка больше или равна 70, программа выведет С grade, а если оценка – 69 или меньше, она перейдет к следующему оператору …
  4. Если оценка больше или равна 65, программа выведет D grade, если 64 или меньше, перейдет к следующему оператору …
  5. Программа выведет Failing grade, потому что все вышеперечисленные условия не выполнены.

Вложенные операторы if

Как только вы разберетесь с операторами if, else if и else, вы можете перейти к вложенным условным операторам. Вложенные операторы if можно использовать в ситуациях, когда нужно проверить вторичное условие, если первое условие истинно. Для этого оператор if-else помещается внутри другого оператора if-else. Давайте посмотрим на синтаксис вложенного оператора if:

if statement1 { // outer if statement
fmt.Println("true")
if nested_statement { // nested if statement
fmt.Println("yes")
} else { // nested else statement
fmt.Println("no")
}
} else { // outer else statement
fmt.Println("false")
}

Этот код может выдать несколько результатов:

Если Statement1 оценивается как true, программа проверяет, истинный ли вложенный оператор nested_statement. Если оба оператора истинны, результат будет такой:

true
yes

Если же Statement1 оценивается как true, а nested_statement как false, то вывод будет таким:

true
no

Если оператор Statement1 оценивается как ложный, вложенный оператор if-else не будет выполняться, поэтому будет выполняться только оператор else, а в результате будет:

false

Мы также можем вложить в код несколько операторов if:

if statement1 { // outer if
fmt.Println("hello world")
if nested_statement1 { // first nested if
fmt.Println("yes")
} else if nested_statement2 { // first nested else if
fmt.Println("maybe")
} else { // first nested else
fmt.Println("no")
}
} else if statement2 { // outer else if
fmt.Println("hello galaxy")
if nested_statement3 { // second nested if
fmt.Println("yes")
} else if nested_statement4 { // second nested else if
fmt.Println("maybe")
} else { // second nested else
fmt.Println("no")
}
} else { // outer else
statement("hello universe")
}

Здесь внутри каждого оператора if в дополнение к оператору else if есть вложенный оператор if. Это добавит больше вариантов для каждого условия.

Давайте рассмотрим вложенные операторы if на примере программы grade.go. Сначала можно проверить, проходит ли оценка заданный минимум (больше или равно 65), а затем присвоить ей буквенную оценку. Если оценка не проходит минимум, программе не нужно выполнять код для буквенных оценок, вместо этого программа может выдать Failing grade. Расширенный код с вложенным оператором if будет выглядеть так:

package main
import "fmt"
func main() {
grade := 92
if grade >= 65 {
fmt.Print("Passing grade of: ")
if grade >= 90 {
fmt.Println("A")
} else if grade >= 80 {
fmt.Println("B")
} else if grade >= 70 {
fmt.Println("C")
} else if grade >= 65 {
fmt.Println("D")
}
} else {
fmt.Println("Failing grade")
}
}

Если мы запустим код с переменной grade, которая равна 92, первое условие будет выполнено, и программа выведет «Passing grade of:». Затем она проверит, является ли оценка более или равной 90, и, поскольку это условие также выполнено, она выведет A.

Если мы запустим код с переменной grade=60, то первое условие не будет выполнено, поэтому программа пропустит все вложенные операторы if и перейдет к оператору else, который выведет Failing grade.

Конечно, мы можем добавить к этому коду еще больше опций и использовать второй слой вложенных операторов if. К примеру, это позволит ставить оценки  A+, A и A-. Для этого сначала нужно проверить, проходит ли оценка требуемый минимум, затем узнать, попадает ли оценка в этот диапазон, а потом узнать, превышает ли оценка 96 (чтобы получить A+):

...
if grade >= 65 {
fmt.Print("Passing grade of: ")
if grade >= 90 {
if grade > 96 {
fmt.Println("A+")
} else if grade > 93 && grade <= 96 {
fmt.Println("A")
} else {
fmt.Println("A-")
}
...

Если переменная grade равна 96, программа будет работать таким образом:

  1. Убедится, что оценка больше или равна 65 (true).
  2. Выведет «Passing grade of:».
  3. Убедится, что оценка больше или равна 90 (true).
  4. Проверит, превышает ли оценка 96 (false).
  5. Проверит, чтобы оценка была больше 93 и меньше или равна 96 (true).
  6. Выводит оценку А.
  7. Пропускает вложенные операторы и выполняет оставшийся код.

Вывод этой программы будет таким:

Passing grade of: A

Вложенные операторы могут значительно расширить функциональность программы, добавив много новых уровней в код.

Заключение

Используя условные операторы, вы можете тоньше управлять работой программы. Условные операторы помогают программе понять, выполняется ли определенное условие. Если условие истинно, программа выполнит определенный код, а если оно ложно, она перейдет к другому фрагменту кода.

Читайте также: Выполнение арифметических операций в Go

Tags: ,

Добавить комментарий