如何在 Go 中编写条件语句

介绍

条件声明是每个编程语言的一部分,有条件声明,我们可以有代码,有时运行,有时不运行,取决于该程序当时的条件。

当我们完全执行一个程序的每个陈述时,我们并不要求该程序评估特定条件,通过使用条件陈述,程序可以确定是否满足某些条件,然后被告知下一步该做什么。

让我们看看一些我们使用条件陈述的例子:

  • 如果学生在考试中获得超过65%,报告她的成绩通过;如果没有,报告她的成绩失败 *如果他有钱在他的帐户中,计算利息;如果他没有,收取罚款 *如果他们购买10个橙子或更多,计算5%的折扣;如果他们购买少,那么不要

通过评估条件并根据这些条件是否满足而分配运行代码,我们正在编写条件代码。

本教程将带您通过编写Go编程语言的条件陈述。

如果声明

我们将从如果声明开始,它将评估一个声明是否是真实的或错误的,并且只在声明是真实的情况下运行代码。

在简单的文本编辑器中,打开一个文件并写下以下代码:

 1[label grade.go]
 2package main
 3
 4import "fmt"
 5
 6func main() {
 7    grade := 70
 8
 9    if grade >= 65 {
10    	fmt.Println("Passing grade")
11    }
12}

有了这个代码,我们有变量级别并给它70的整数值,然后我们使用如果陈述来评估变量级别是否大于或等于(>= )到65。

将该程序保存为grade.go,并在 从终端窗口的本地编程环境中运行它,使用命令go run grade.go。

在这种情况下,70 does 等级符合大于或等于 65 的条件,因此在运行程序后,您将收到以下输出:

1[secondary_label Output]
2Passing grade

现在让我们通过将级别变量值更改为60来改变这个程序的结果:

 1[label grade.go]
 2package main
 3
 4import "fmt"
 5
 6func main() {
 7    grade := 60
 8
 9    if grade >= 65 {
10    	fmt.Println("Passing grade")
11    }
12}

当我们保存并运行 this 代码时,我们不会收到任何输出,因为条件是 not 满足的,我们没有告诉程序执行另一个陈述。

再举一个例子,让我们计算一下银行账户余额是否低于0,然后创建一个名为account.go的文件,然后写下以下程序:

 1[label account.go]
 2package main
 3
 4import "fmt"
 5
 6func main() {
 7    balance := -5
 8
 9    if balance < 0 {
10    	fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
11    }
12}

当我们使用go run account.go运行该程序时,我们将收到以下输出:

1[secondary_label Output]
2Balance is below 0, add funds now or you will be charged a penalty.

在程序中,我们将变量平衡初始化为-5的值,这小于0。由于平衡满足了如果陈述(平衡 < 0)的条件,一旦我们保存并运行代码,我们将收到字符串输出。

其他声明

很可能我们会希望程序做一些事情,即使一个如果陈述被评估为错误,在我们的分级示例中,我们将想要输出是否分级通过或失败。

要做到这一点,我们将添加一个else声明,以此构建如下等级条件:

 1[label grade.go]
 2package main
 3
 4import "fmt"
 5
 6func main() {
 7    grade := 60
 8
 9    if grade >= 65 {
10    	fmt.Println("Passing grade")
11    } else {
12    	fmt.Println("Failing grade")
13    }
14}

由于等级变量有60的值,所以如果声明被评估为错误,因此程序不会打印通过等级。

当我们保存并运行程序时,我们将收到以下输出:

1[secondary_label Output]
2Failing grade

然后,如果我们重写程序以给评级一个值为65或更高,我们将获得输出通过评级。

为了在银行账户示例中添加一个else声明,我们将代码重写如下:

 1[label account.go]
 2package main
 3
 4import "fmt"
 5
 6func main() {
 7    balance := 522
 8
 9    if balance < 0 {
10    	fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
11    } else {
12    	fmt.Println("Your balance is 0 or above.")
13    }
14}

1[secondary_label Output]
2Your balance is 0 or above.

在这里,我们将平衡变量值更改为正数,以便else陈述打印。

通过将如果声明与else声明相结合,您正在构建一个两个部分的条件声明,该声明会告诉计算机执行某些代码,无论如果条件是否满足。

如果声明

到目前为止,我们已经提出了条件陈述的 Boolean选项,每个如果陈述评估为真或假。在许多情况下,我们将想要一个程序,以评估两个以上可能的结果。

在银行账户程序中,我们可能希望为三个不同的情况有三个不对称的输出:

  • 余额低于 0
  • 余额等于 0
  • 余额高于 0

else if声明将如下放置在if声明和else声明之间:

 1[label account.go]
 2package main
 3
 4import "fmt"
 5
 6func main() {
 7    balance := 522
 8
 9    if balance < 0 {
10    	fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
11    } else if balance == 0 {
12    	fmt.Println("Balance is equal to 0, add funds soon.")
13    } else {
14    	fmt.Println("Your balance is 0 or above.")
15    }
16}

现在,有三种可能发生的输出,一旦我们运行该程序:

  • 如果平衡变量等于0,我们将从else if陈述中获取输出(平衡等于0,很快添加资金)() *如果平衡变量设置为正数,我们将从else陈述中获取输出(您的平衡为0或以上)。

但是,如果我们想要有三个以上的可能性,我们可以通过在我们的代码中写入多个else if声明来做到这一点。

在grade.go程序中,让我们重写代码,以便有几个字母等级对应于数字等级的范围:

  • 90 或以上等同于 A 级
  • 80-89 等同于 B 级
  • 70-79 等同于 C 级
  • 65-69 等同于 D 级
  • 64 或以下等同于 F 级

要运行此代码,我们需要一个如果陈述,三个else如果陈述,以及一个else陈述来处理所有失败案例。

让我们从上一个例子中重写代码,以便有打印每个字母等级的字符串,我们可以保持我们的else陈述相同。

 1[label grade.go]
 2package main
 3
 4import "fmt"
 5
 6func main() {
 7    grade := 60
 8
 9    if grade >= 90 {
10    	fmt.Println("A grade")
11    } else if grade >= 80 {
12    	fmt.Println("B grade")
13    } else if grade >= 70 {
14    	fmt.Println("C grade")
15    } else if grade >= 65 {
16    	fmt.Println("D grade")
17    } else {
18    	fmt.Println("Failing grade")
19    }
20}

由于else if声明会按顺序进行评估,我们可以保持我们的声明相当基本。

如果等级大于90,程序会打印A级,如果等级小于90,程序会继续到下一个陈述... 2.如果等级大于或等于80,程序会打印B级,如果等级小于79,程序会继续到下一个陈述... 3.如果等级大于或等于70,程序会打印C级,如果等级小于69,程序会继续到下一个陈述... 4.如果等级大于或等于65,程序会打印D级,如果等级小于64,程序会继续到下一个陈述... 5.程序会打印失败级,因为上述所有条件都没有满足

如果发表声明

一旦你对如果,else如果和else的陈述感到舒适,你可以转到嵌入的条件陈述。我们可以使用嵌入的如果陈述来检查如果第一个条件执行为真实的次要条件的情况下。

 1if statement1 { // outer if statement
 2    fmt.Println("true")
 3
 4    if nested_statement { // nested if statement
 5    	fmt.Println("yes")
 6    } else { // nested else statement
 7    	fmt.Println("no")
 8    }
 9
10} else { // outer else statement
11    fmt.Println("false")
12}

一些可能的输出可以从这个代码中产生:

  • 如果'statement1' 评估为 true,则程序会评估 'nested_statement' 是否也评估为 true. 如果两种情况都是 true,则输出将是:
1[secondary_label Output]
2true
3yes
  • 但是,如果'statement1' 评估为 true,但 'nested_statement' 评估为 false,则输出将是:
1[secondary_label Output]
2true
3no
  • 如果陈述1评估为假,嵌入的 if-else 陈述将不会运行,因此else陈述将单独运行,输出将是:
1[secondary_label Output]
2false

我们也可以在我们的代码中嵌入多个如果陈述:

 1if statement1 { // outer if
 2    fmt.Println("hello world")
 3
 4    if nested_statement1 { // first nested if
 5    	fmt.Println("yes")
 6
 7    } else if nested_statement2 { // first nested else if
 8    	fmt.Println("maybe")
 9
10    } else { // first nested else
11    	fmt.Println("no")
12    }
13
14} else if statement2 { // outer else if
15    fmt.Println("hello galaxy")
16
17    if nested_statement3 { // second nested if
18    	fmt.Println("yes")
19    } else if nested_statement4 { // second nested else if
20    	fmt.Println("maybe")
21    } else { // second nested else
22    	fmt.Println("no")
23    }
24
25} else { // outer else
26    statement("hello universe")
27}

在此代码中,除了else if陈述之外,每个if陈述内部还有一个嵌入式if陈述,这将允许每个条件内提供更多的选项。

让我们看看我们的grade.go程序中嵌入的如果陈述的一个例子。我们可以检查一个等级是否先通过(大于或等于65%),然后评估数字等级应等于哪个字母等级。

 1[label grade.go]
 2
 3package main
 4
 5import "fmt"
 6
 7func main() {
 8    grade := 92
 9    if grade >= 65 {
10    	fmt.Print("Passing grade of: ")
11
12    	if grade >= 90 {
13    		fmt.Println("A")
14
15    	} else if grade >= 80 {
16    		fmt.Println("B")
17
18    	} else if grade >= 70 {
19    		fmt.Println("C")
20
21    	} else if grade >= 65 {
22    		fmt.Println("D")
23    	}
24
25    } else {
26    	fmt.Println("Failing grade")
27    }
28}

如果我们运行代码以变量级别设置为整数值92,那么第一个条件就会满足,然后程序会打印出通过级别的:。

如果我们运行代码的级别变量设置为60,那么第一个条件没有满足,所以程序会跳过嵌入的如果陈述,并移动到else陈述,并打印出失败级别。

当然,我们可以为此添加更多的选项,并使用第二层嵌入式如果声明。也许我们会想要单独评估A+,A和A级的等级。我们可以这样做,首先检查等级是否通过,然后检查等级是否为90或以上,然后检查等级是否为A+超过96:

 1[label grade.go]
 2...
 3if grade >= 65 {
 4    fmt.Print("Passing grade of: ")
 5
 6    if grade >= 90 {
 7    	if grade > 96 {
 8    		fmt.Println("A+")
 9
10    	} else if grade > 93 && grade <= 96 {
11    		fmt.Println("A")
12
13    	} else {
14    		fmt.Println("A-")
15    	}
16...

在此代码中,对于一个级别变量设置为96,该程序将运行如下:

检查是否大于或等于65(真) 2 打印通过级别: 3 检查是否大于或等于90(真) 4 检查是否大于96(假) 5 检查是否大于93以及小于或等于96(真) 6 打印A 7 留下这些嵌入的条件声明并继续使用剩余的代码

因此,96级程序的输出看起来是这样的:

1[secondary_label Output]
2Passing grade of: A

嵌入的如果语句可以为您的代码添加几个特定的条件级别。

结论

通过使用条件陈述,如如果陈述,你将对你的程序所执行的内容有更大的控制权。条件陈述告诉程序评估是否满足某种条件。

要继续练习条件式陈述,请尝试使用不同的操作员(https://andsky.com/tech/tutorials/how-to-do-math-in-go-with-operators)来更熟悉条件式陈述。

Published At
Categories with 技术
Tagged with
comments powered by Disqus