TOC

Как написать условные выражения в Go

Вступление

Условные операторы являются частью каждого языка программирования. С помощью условных операторов мы можем иметь код, который иногда запускается, а иногда не запускается, в зависимости от условий программы на тот момент.

Когда мы полностью выполняем каждое утверждение программы, мы не просим программу оценить конкретные условия. Используя условные операторы, программы могут определить, выполняются ли определенные условия, а затем сказать, что делать дальше.

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

  • Если учащийся получает более 65% на своем тесте, сообщите, что его оценка проходит; если нет, сообщите, что ее оценка не удалась.

  • Если у него есть деньги на его счете, начисляйте проценты; если он не делает, взимать штраф.

  • Если они покупают 10 апельсинов или больше, рассчитайте скидку 5%; если они покупают меньше, то не надо.

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

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

Если заявления

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

В текстовом редакторе откройте файл и напишите следующий код:

grade.go

package main

import "fmt"

func main() {
   grade := 70

   if grade >= 65 {
       fmt.Println("Passing grade")
   }
}

С этим кодом у нас есть переменная + grade + и мы присваиваем ей целочисленное значение + 70 +. Затем мы используем оператор + if +, чтобы оценить, является ли переменная оценка больше или равна (+> = +) + 65 +. Если оно удовлетворяет этому условию, мы сообщаем программе распечатать string `+ Проходной балл + `.

Сохраните программу как + grade.go + и запустите ее в https://www.digitalocean.com/community/tutorial_series/how-to-install-and-set-up-a-local-programming-environment-for -go [локальная среда программирования из окна терминала] с командой + go run grade.go +.

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

OutputPassing grade

Давайте теперь изменим результат этой программы, изменив значение переменной + grade + на + 60 +:

grade.go

package main

import "fmt"

func main() {
   grade :=

   if grade >= 65 {
       fmt.Println("Passing grade")
   }
}

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

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

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 +, мы получим следующий вывод:

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

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

Остальные заявления

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

Чтобы сделать это, мы добавим оператор + else + к условию оценки выше, который построен следующим образом:

grade.go

package main

import "fmt"

func main() {
   grade := 60

   if grade >= 65 {
       fmt.Println("Passing grade")
   } else {
       fmt.Println("Failing grade")
   }
}

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

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

OutputFailing grade

Если затем мы переписаем программу, чтобы присвоить классу значение + 65 + или выше, вместо этого мы получим вывод «+ Passing grade +».

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

account.go

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.")
   }
}
OutputYour balance is 0 or above.

Здесь мы изменили значение переменной + balance + на положительное число, чтобы вывести оператор + else +. Чтобы получить первый оператор + if + для печати, мы можем переписать значение в отрицательное число.

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

Остальные заявления

До сих пор мы представили опцию Boolean для условных операторов, причем каждый оператор + if + оценивается как true или ложный. Во многих случаях нам нужна программа, которая оценивает более двух возможных результатов. Для этого мы будем использовать оператор * else if *, который в Go записывается как + else if +. Оператор + else if + или else if выглядит как оператор + if + и оценивает другое условие.

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

  • Баланс ниже 0

  • Баланс равен 0

  • Баланс выше 0

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

account.go

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 равен 0, скоро добавим средства. +)

  • Если переменная + balance + установлена ​​в положительное число, мы получим вывод из оператора + else + (+ Ваш баланс равен 0 или выше. +).

  • Если переменная + balance + установлена ​​в отрицательное число, выводом будет строка из оператора + if + (+ Баланс ниже 0, добавьте средства сейчас, или вам будет начислен штраф +).

Что если мы хотим иметь более трех возможностей? Мы можем сделать это, написав в нашем коде несколько операторов + else if +.

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

  • 90 или выше эквивалентно классу А

  • 80-89 эквивалентно классу B

  • 70-79 эквивалентно классу C

  • 65-69 эквивалентно классу D

  • 64 или ниже эквивалентно классу F

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

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

grade.go

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 оценка +», если оценка меньше 90, программа перейдет к следующему утверждению…

  2. Если оценка больше или равна 80, программа выведет «+ B оценка +», если оценка 79 или меньше, программа перейдет к следующему утверждению…

  3. Если оценка больше или равна 70, программа напечатает + C оценка +, если оценка 69 или меньше, программа перейдет к следующему утверждению…

  4. Если оценка больше или равна 65, программа напечатает «+ D оценка +», если оценка 64 или меньше, программа перейдет к следующему утверждению…

  5. Программа выведет + Failing grade +, потому что все вышеперечисленные условия не были выполнены.

Вложенные заявления If

Как только вы почувствуете себя комфортно с операторами + if,` + else if` и + else, вы можете перейти к вложенным условным операторам. Мы можем использовать вложенные операторы + if для ситуаций, когда мы хотим проверить вторичное условие, если первое условие выполняется как true. Для этого у нас может быть оператор 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. Если оба случая верны, результат будет:

_ _

Outputtrue
yes

_ _

  • Если, однако, + Statement1 + оценивается как true, а + nested_statement + оценивается как false, то результат будет:

_ _

Outputtrue
no

_ _

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

_ _

Outputfalse

_ _

Мы также можем иметь несколько операторов + 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 внутри каждого оператора` + if` в дополнение к оператору + else if +. Это позволит больше вариантов в каждом условии.

Давайте рассмотрим пример вложенных операторов + if + с нашей программой + grade.go +. Мы можем проверить, проходит ли оценка в первую очередь (больше или равно 65%), а затем оценить, какой буквенной оценке должна соответствовать числовая оценка. Однако, если оценка не проходит, нам не нужно проходить буквенные оценки, и вместо этого мы можем получить отчет программы о том, что оценка не пройдена. Наш модифицированный код с вложенным оператором + if будет выглядеть так:

grade.go

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- отдельно. Мы можем сделать это, сначала проверив, проходит ли оценка, затем проверив, является ли оценка 90 или выше, затем проверив, превышает ли оценка 96 за A +:

grade.go

...
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 (верно)

  2. Распечатка + проходной балл: +

  3. Проверьте, является ли оценка больше или равна 90 (верно)

  4. Проверьте, превышает ли оценка 96 (ложь)

  5. Проверьте, является ли оценка больше 93, а также меньше или равна 96 (верно)

  6. Печать + A +

  7. Оставьте эти вложенные условные операторы и продолжите с оставшимся кодом

Таким образом, результат программы для класса 96 выглядит следующим образом:

OutputPassing grade of: A

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

Заключение

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

Чтобы продолжить практиковать условные операторы, попробуйте использовать различные operators, чтобы лучше ознакомиться с условными операторами.

Related