devbox
信息技术墨韵书生
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Go语言基础03（程序流程控制）_go语言流程控制案例

作者：信息技术墨韵书生 | 2024-01-29 10:59:45

赞

踩

go语言流程控制案例

Go语言基础（程序流程控制）


  \ \quad  在程序中，程序运行的流程控制决定了程序是如何执行的，主流的程序设计语言一般有三大流程控制语句：分别是 顺序控制、 分支控制和 循环控制。

  \ \quad  Go语言的常用流程控制有if、for、switch和goto。

一、顺序控制

1.1 顺序控制介绍

  \ \quad  所谓的顺序控制就是程序从上到下逐行的执行，中间没有任何判断和跳转。

1.2 流程图

1.3 顺序控制举例和注意事项

  • Golang中定义变量时要采用合法的前向引用。如：
    func main() {
	var num1 int = 10 // 声明 num1
	var num2 int = num1 + 20 // 使用 num1
	fmt.Println(num2)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    错误形式：不可以先使用变量后声明
    func main() {
	var num2 int = num1 + 20 // 使用 num1
	var num1 int = 10 // 声明 num1
	fmt.Println(num2)
}

    • 1
    • 2
    • 3
    • 4
    • 5

二、分支控制

  \ \quad  在实际应用中，有时需要通过某个判断来决定任务是否执行或者执行的方式。对于这样的情况，仅有顺序结构控制是不够的，需要选择结构，也就是分支控制语句。

  \ \quad  所谓的分支控制就是让程序执行到某个位置的时候有一个判断，判断结果为布尔值，如果布尔值为true则执行某一块代码，布尔值为false则执行另一块代码。分支控制主要有三种形式：单分支、双分支和多分支。

2.1 单分支结构

  • 若条件成立时需要执行某些操作，不成立时不执行操作，则需要编写单分支结构。
  • Golang中的if语句实现了单分支控制结构，用来实现有条件地执行语句的功能。
  • if语句单分支结构的语法形式如下，当条件判断表达式为true时，就会执行{ }的代码，如果为false则不执行。
    if condition {
	/* 在条件判断表达式为 true 时执行 */
}

    • 1
    • 2
    • 3
    • if：条件判断使用的关键字。
    • condition：条件判断表达式。
  • Go语言中的if语句后面的条件判断表达式，不需要也不能加小括号，即()，这是Go语言与其他语言if语句的区别。
  • Go语言if语句后面的大括号必须跟条件表达式写在一行，不能换行写，换行写会编译错误。
  • Go语言if语句{ }是必须有的，就算只写一行代码也必须加上。
  • Go的if还有一个强大的地方就是判断条件语句里面允许声明一个变量，这个变量的作用域只能在该条件逻辑块内，其他地方就不起作用了。
  • 单分支结构流程图：
  • 示例：判断年龄是否成年
    func main() {
	age := 20
	if age > 18 {
		fmt.Println("您已经成年")
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 条件判断语句里面声明变量
      func main() {
	if age := 20; age >= 18 {
		fmt.Println("您已经成年")
	}
}

      • 1
      • 2
      • 3
      • 4
      • 5

2.2 双分支结构

  • 若条件成立时需要执行某些操作，不成立时需要执行另外一些操作，则需要编写双分支结构。
  • 在Go语言中，关键字else是用于在if条件不满足时执行的代码逻辑。else后面一定不能加判断条件，否则会语法错误。
  • Go编程语言中if...else语句的语法如下，if在条件判断表达式为true时，其后紧跟的语句块执行，如果为false则执行else语句块。
    if condition {
	/* 在条件判断表达式为 true 时执行 */
} else {
	/* 在条件判断表达式为 false 时执行 */
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • if：条件判断使用的关键字。
    • condition：条件判断表达式。
  • 双分支结构流程图：
  • 示例：判断年龄是否成年，如果未成年则输出年龄
    func main() {
	if age := 16; age > 18 {
		fmt.Println("您已经成年")
	} else {
		fmt.Printf("%d岁还未成年", age)
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

2.3 多分支结构

2.3.1 if … else if 分支控制

  • 若条件成立时需要执行某些操作，不成立时需要执行后续多个逻辑判断，直到满足条件时执行某些操作，则需要编写多分支结构。
  • 在Go语言中，关键字if是用于测试某个条件（布尔型或逻辑型）的语句是否满足一定的条件，如果满足特定的条件，则会执行if后由大括号{ }括起来的代码块，否则就忽略该代码块继续执行后续的代码。
  • else if关键字用于在if语句条件不满足的情况下，继续执行else if里面的逻辑判断，如果满足条件则执行else if大括号里面的逻辑。
  • else if语句只能写在if语句的大括号的后面，且else if语句可以写任意多个。
  • Go编程语言中if ... else if语句的语法如下，if在条件判断表达式为true时，其后紧跟的语句块执行，如果为false则执行后续多个else if语句块，直到else if的条件判断表达式为true时执行紧跟的语句块。
    if condition {
	// do something
} else if condition1 {
	// do something1
} else if condition2 {
	// do something2
}
	...... 
	
} else if conditionN {
	// do somethingN
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • Go语言中的else if语句后面的条件判断表达式，同样也不需要加小括号，即()，类似于if语句。同理，Go语言else if语句后面的大括号必须跟else if条件表达式写在一行，不能换行写，换行写会编译错误。
    • 上述语句，如果if语句的条件表达式成立，那么就会只执行if的逻辑do something，如果if条件表达式不成立，那么会判断表达式condition1。
    • 如果表达式condition1成立，那么会执行do something1，仅仅在表达式condition1不成立时，才会判断表达式condition2，如果表达式condition2成立，那么执行do something2，否则，继续向后执行，直到条件判断表达式成立。如果所有条件判断表达式均不成立，则执行else代码块。
  • 多分支结构流程图：
    在这里插入图片描述
  • 示例：判断考试成绩等级
    func main() {
	var score float64
	fmt.Print("请输入成绩：")
	fmt.Scanf("%f", &score)
	if score >= 90 {
		fmt.Printf("%.2f分是A等", score)
	} else if score >= 80 {
		fmt.Printf("%.2f分是B等", score)
	} else if score >= 70 {
		fmt.Printf("%.2f分是C等", score)
	} else if score >= 60 {
		fmt.Printf("%.2f分是D等", score)
	} else {
		fmt.Printf("%.2f分是E等", score)
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

2.3.2 switch 语句

  • switch语句的作用类似于if语句，用于基于不同条件执行不同动作，每一个case分支都是唯一的，从上至下逐一测试，直到匹配为止。
  • Go语言的switch语句不同于其他语言的switch语句，Go语言的switch语句的表达式不需要为常量，且匹配项后面也不需要再加break语句，case语句最后自带break语句。
  • switch默认情况下case最后自带break语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough 。
  • Go编程语言中switch语句的语法如下：
    switch var1 {
	case val2:
		...
	case val3:
		...
	......
	case valN:
		...
	default:
		...
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • switch：判断使用的关键字。
    • var1：需要判断的变量或条件表达式。
    • case：每一个分支前面需要使用的关键字。
    • var2：判断var1是否满足var2的条件。
    • varN：判断var1是否满足varN的条件。
    • default：如果var1不满足上述所有的case，则会执行default分支。
    • 注：变量var1可以是任何数据类型，而 val1和val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型，或者最终结果为相同类型的表达式。
  • 可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。
    func main() {
	// 请用户输入年份，再输入月份，输出该月的天数（需要考虑闰年）
	var year int
	var month int
	fmt.Print("请输入年份：")
	fmt.Scanf("%d\n", &year)
	fmt.Print("请输入月份：")
	fmt.Scanf("%d\n", &month)
	switch month {
	case 1, 3, 5, 7, 8, 10, 12:
		fmt.Printf("%d年%d月有31天", year, month)
	case 4, 6, 9, 11:
		fmt.Printf("%d年%d月有30天", year, month)
	case 2:
		if year%400 == 0 || year%4 == 0 && year%100 != 0 {
			fmt.Printf("%d年%d月有29天", year, month)
		} else {
			fmt.Printf("%d年%d月有28天", year, month)
		}
	default:
		fmt.Printf("%d年%d月不是一个正确的年月", year, month)
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
  • switch语句流程图：
  • 使用fallthrough会强制执行后面的case语句，fallthrough不会判断下一条case的表达式结果是否为 true。
    func main() {
	// 请用户输入年份，再输入月份，输出该月的天数（需要考虑闰年）
	var year int
	var month int
	fmt.Print("请输入年份：")
	fmt.Scanf("%d\n", &year)
	fmt.Print("请输入月份：")
	fmt.Scanf("%d\n", &month)
	switch month {
	case 1,3,5,7,8,10,12:
		fmt.Printf("%d年%d月有31天", year, month)
	case 4:
		fallthrough
	case 6:
		fallthrough
	case 9:
		fallthrough
	case 11:
		fmt.Printf("%d年%d月有30天", year, month)
	case 2:
		if year%400 == 0 || year%4 == 0 && year%100 != 0 {
			fmt.Printf("%d年%d月有29天", year, month)
		} else {
			fmt.Printf("%d年%d月有28天", year, month)
		}
	default:
		fmt.Printf("%d年%d月不是一个正确的年月", year, month)
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

2.4 if 语句嵌套

  • 在Go语言中，if语句、else if语句和else语句可以进行任意的嵌套，但是else里面不可以嵌套else if语句。示例如下：
    func main() {
	var num int
	fmt.Print("请输入一个整数：")
	fmt.Scanf("%d\n", &num)
	if num >= 0 {
		if num == 0 {
			fmt.Printf("%d是零", num)
		} else if num <= 100 {
			if num >= 50 {
				fmt.Printf("%d的范围是50~100", num)
			} else {
				fmt.Printf("%d的范围是0~50", num)
			}
		} else {
			fmt.Printf("%d大于100", num)
		}
	} else {
		fmt.Printf("%d是负数", num)
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

三、循环控制

\quad 循环控制结构是指在程序中需要反复执行某个功能而设置的一种程序结构。它由循环体中的条件，判断继续执行某个功能还是退出循环。

3.1 for 循环

3.1.1 for 循环简介

  • 一般程序设计语言的循环可以分为for循环、while循环和do while循环，但是在Go语言中，只支持for循环。while循环和do while循环都可以使用for循环来实现。
  • Go语言for循环的循环体开始的大括号必须跟for写在同一行，不可以单独换行，类似于if语句的大括号。
  • Go语言for循环的语法如下：
    for init; condition; post {
	//do something
}

    • 1
    • 2
    • 3
    • for：循环控制使用的关键字；
    • init：初始语句。一般为赋值表达式，给控制变量赋初值；
      • 初始语句是在第一次循环前执行的语句，一般使用初始语句执行变量初始化，如果变量在此处被声明，其作用域将被局限在这个for的范围内。初始语句可以被忽略，但是初始语句之后的分号必须要写。
    • condition：条件表达式。一般为关系表达式或逻辑表达式，循环控制条件；
      • 每次循环开始前都会计算条件表达式，如果表达式为true，则循环继续，否则结束循环。条件表达式可以被忽略，忽略条件表达式后形成无限循环。
    • post：结束语句。一般为赋值表达式，为控制变量增量或减量。
      • 在每次循环结束时执行的语句，如果循环被break、goto、return、panic等语句（后续讲解）强制退出，结束语句不会被执行。
  • for循环语句流程图：
  • for语句执行过程如下：
    • 1、先使用赋值表达式init赋初值，然后判断赋值表达式init是否满足条件判别式condition，若满足循环条件，则执行循环体内语句，然后执行post，进入第二次循环。
    • 2、进入第二次循环后，判断条件判别式condition是否满足，若满足循环条件，则执行post，然后再次执行循环体内语句。若不满足循环条件，就终止for循环，执行for循环之后的语句。
    • 3、反复执行第2步。
  • Go语言for循环不支持逗号表达式，如果想在for中执行多个变量，需要使用平行赋值。示例如下：
    for i, j := 0, 0; i < 10 && j < 10; i, j = i+1, j+1 {
	//do something
}

    • 1
    • 2
    • 3
    而不能写成：
    for i, j := 0, 0; i < 10, j < 10; i++, j++ {
	fmt.Println(i)
}

    • 1
    • 2
    • 3
  • Go语言的for循环有3种形式，只有其中的一种使用分号：
    • 普通用法：for init; condition; post {}
    • 实现while循环：for condition {}
    • 无限循环：for {}
  • for循环的range格式可以对slice、map、array、string、chanel等（后续文章挨个讲解）进行迭代循环，返回（索引、值）或（键、值）。修改range后得到的value，不会影响原始数据。格式如下：
    • for index,char := range string {}
    • for index,value := range array {}
    • for index,value := range slice {}
    • for key,value := range map {}

3.1.2 for 循环案例

案例1：求1 ~ 100之间的所有数字之和
func main() {
	var sum int = 0
	for num := 1; num <= 100; num++ {
		sum += num
	}
	fmt.Printf("1 ~ 100 之间的所有数字之和：%d", sum)
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1 ~ 100 之间的所有数字之和：5050
案例2：求1 ~ 100之间的所有偶数之和
func main() {
	var sum int = 0
	for num := 0; num <= 100; num++ {
		if num%2 == 0 {
			sum += num
		}
	}
	fmt.Printf("1 ~ 100 之间的所有偶数之和：%d", sum)
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 1 ~ 100 之间的所有偶数之和：2550
案例3：求1 ~ 100之间的所有奇数之和
func main() {
	var sum int = 0
	for num := 1; num <= 100; num++ {
		if num%2 != 0 {
			sum += num
		}
	}
	fmt.Printf("1 ~ 100 之间的所有偶数之和：%d", sum)
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 1 ~ 100 之间的所有偶数之和：2500

3.2 循环控制关键字

3.2.1 break 关键字

1. 简介
  • Go语言中break语句可以结束for、switch或select（后续讲解）的代码块。
  • Go语言的break语句，有着与其他编程语言类似的功能，但不同的是，Go语言的break语句还可以选择要中断的循环。可以在break后面添加标签（label）来实现跳出多层作用域，因为很多时候select或switch往往是配合for循环使用的。label标签要求必须定义在对应的for、switch或select的代码块之前。
2. 案例
  • 要求用户输入用户名和密码，只要不是admin、12345678就一直提示 “用户名或密码错误，请重新输入！”。
    func main() {
	var username string
	var password string
	for {
		fmt.Print("请输入用户名：")
		fmt.Scanf("%s\n", &username)
		fmt.Print("请输入密码：")
		fmt.Scanf("%s\n", &password)
		if username != "dong" || password != "12345678" {
			fmt.Println("用户名或密码错误，请重新输入!")
		} else {
			fmt.Println("输入的用户名密码正确!")
			break
		}
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
  • 改进版：用户名密码输入错误，最多输错3次，超过3次，提示 “输入错误信息次数太多，结束整个程序！”。
    func main() {
	var username string
	var password string
	var count int = 1
	for {
		fmt.Print("请输入用户名：")
		fmt.Scanf("%s\n", &username)
		fmt.Print("请输入密码：")
		fmt.Scanf("%s\n", &password)
		if username == "dong" && password == "12345678" {
			fmt.Println("输入的用户名密码正确!")
			break
		} else {
			fmt.Printf("第%d次用户名或密码错误，请重新输入!\n", count)
			if count == 3 {
				fmt.Println("输入错误信息次数太多，结束整个程序!")
				break
			}
			count++
		}
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
  • break后面添加标签：当j等于6的时候，跳到最外层循环，并且不再执行循环体。
    func main() {
label:
	for i := 1; i <= 10; i++ {
		for j := 1; j <= 10; j++ {
			if j%6 == 0 {
				fmt.Println()
				break label
			}
			fmt.Printf("[%d,%d],", i, j)
		}
		fmt.Println()
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    输出：
    [1,1],[1,2],[1,3],[1,4],[1,5],

    • 1

3.2.2 continue 关键字

1. 简介
  • 在我们使用for循环时，在某种条件满足的情况下，需要跳过本次循环，继续执行下一次循环，在Go语言 中，跳过本次循环继续运行下一次循环使用的关键字为continue。
  • Go语言的continue语句，有着与其他编程语言类似的功能，但不同的是，Go语言的continue语句还可以选择具体跳过的循环。可以在continue后面添加标签（label）来实现跳出多层作用域，label标签要求必须定义在对应的for代码块之前。
  • continue与break的区别：break是直接终止了当前的循环，当前的循环不会再运行，而continue只是跳过本次循环，当前循环的后续循环还会继续运行。
2. 案例
  • continue跳过本次循环，继续执行下一次循环。
    func main() {
	for i := 1; i <= 10; i++ {
		for j := 1; j <= 10; j++ {
			if j%2 == 0 {
				continue
			}
			fmt.Printf("[%d,%d],", i, j)
		}
		fmt.Println()
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    输出：
    [1,1],[1,3],[1,5],[1,7],[1,9],     
[2,1],[2,3],[2,5],[2,7],[2,9],     
[3,1],[3,3],[3,5],[3,7],[3,9],     
[4,1],[4,3],[4,5],[4,7],[4,9],     
[5,1],[5,3],[5,5],[5,7],[5,9],     
[6,1],[6,3],[6,5],[6,7],[6,9],     
[7,1],[7,3],[7,5],[7,7],[7,9],     
[8,1],[8,3],[8,5],[8,7],[8,9],     
[9,1],[9,3],[9,5],[9,7],[9,9],     
[10,1],[10,3],[10,5],[10,7],[10,9],

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
  • continue后面添加标签：j等于6的时候跳到外层循环
    func main() {
label:
	for i := 1; i <= 10; i++ {
		for j := 1; j <= 10; j++ {
			if j%6 == 0 {
				fmt.Println()
				continue label
			}
			fmt.Printf("[%d,%d],", i, j)
		}
		fmt.Println()
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    输出：
    [1,1],[1,2],[1,3],[1,4],[1,5],     
[2,1],[2,2],[2,3],[2,4],[2,5],     
[3,1],[3,2],[3,3],[3,4],[3,5],     
[4,1],[4,2],[4,3],[4,4],[4,5],     
[5,1],[5,2],[5,3],[5,4],[5,5],     
[6,1],[6,2],[6,3],[6,4],[6,5],     
[7,1],[7,2],[7,3],[7,4],[7,5],     
[8,1],[8,2],[8,3],[8,4],[8,5],     
[9,1],[9,2],[9,3],[9,4],[9,5],     
[10,1],[10,2],[10,3],[10,4],[10,5],

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

3.2.3 goto关键字

1. 简介
  • Go语言中goto语句通过标签进行代码间的无条件跳转，可以无条件地转移到程序中指定的行。
  • goto label的label（标签）既可以定义在代码块前面，也可以定义在代码块后面，当跳转到标签所在地方时，继续执行标签下面的代码。
  • goto label的label（标签）如果定义在代码块前面，会重新定义并赋值变量。
2. 案例
func main() {
	for i := 1; i <= 10; i++ {
		for j := 1; j <= 10; j++ {
			if j%8 == 0 {
				goto label
			}
			fmt.Printf("[%d,%d],", i, j)
		}
	label:
		fmt.Println()
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

输出：

[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7],       
[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],       
[3,1],[3,2],[3,3],[3,4],[3,5],[3,6],[3,7],       
[4,1],[4,2],[4,3],[4,4],[4,5],[4,6],[4,7],       
[5,1],[5,2],[5,3],[5,4],[5,5],[5,6],[5,7],       
[6,1],[6,2],[6,3],[6,4],[6,5],[6,6],[6,7],       
[7,1],[7,2],[7,3],[7,4],[7,5],[7,6],[7,7],       
[8,1],[8,2],[8,3],[8,4],[8,5],[8,6],[8,7],       
[9,1],[9,2],[9,3],[9,4],[9,5],[9,6],[9,7],       
[10,1],[10,2],[10,3],[10,4],[10,5],[10,6],[10,7],

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

3.3 循环嵌套

  • Go语言的for循环也可以实现嵌套的效果，即for循环里面嵌套一个或多个for循环。这种写法就类似于Golang的if语句、else if语句和else语句的嵌套。
  • Go语言嵌套循环的格式：
    for [ | condition | init; condition; increment | Range] {
	for [ | condition | init; condition; increment | Range] {
		statement(s);
	}
	statement(s);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

3.4 循环综合案例

3.4.1 案例1：计算营业额

  • 2006年营业额80000元，每年增长25%，请问按此增长速度，到哪一年营业额将达到20万元？
    func main() {
	year := 2006
	turnover := 80000.0
	for ; turnover <= 200000; turnover += turnover * 0.25 {
		fmt.Printf("%d年营业额为%.2f元\n", year, turnover)
		year++
	}
	fmt.Printf("%d年营业额为%.2f元，达到了20万元！\n", year, turnover)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    输出：
    2006年营业额为80000.00元
2007年营业额为100000.00元                
2008年营业额为125000.00元                
2009年营业额为156250.00元                
2010年营业额为195312.50元                
2011年营业额为244140.62元，超过了20万元！

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

3.4.2 案例2：水仙花数

  • 找出100 ~ 999间的水仙花数
    • 水仙花数是指一个三位数，它的每位数字的立方和等于其本身。
    func main() {
	for num := 100; num < 1000; num += 1 {
		piece := num % 10
		ten := num % 100 / 10
		hundred := num / 100
		if piece*piece*piece+ten*ten*ten+hundred*hundred*hundred == num {
			fmt.Printf("%d是个水仙花数\n", num)
		}
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    输出：
    153是个水仙花数
370是个水仙花数
371是个水仙花数
407是个水仙花数

    • 1
    • 2
    • 3
    • 4

3.4.3 案例3：乘法口诀表

func main() {
	for i := 1; i <= 9; i++ {
		for j := 1; j <= 9; j++ {
			if j > i {
				break
			} else {
				fmt.Printf("%dx%d=%d\t", i, j, i*j)
			}
		}
		fmt.Println()
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读