[游戏开发] 【Go】程序流程控制

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 游戏开发 -> 【Go】程序流程控制 -> 正文阅读

[游戏开发]【Go】程序流程控制

文章目录

分支控制

单分支

package main

import "fmt"

func main() {
	var age byte
	fmt.Println("请输入你的年龄：")
	_, _ = fmt.Scanln(&age)
	if age > 18 { // '{}'是必须有的，就算下面只有一行代码
		fmt.Println("你已经成年了，要对自己的行为负责了。")
	}
}

Go支持在if语句中直接定义一个变量，该变量的作用域只限于本if语句

package main

import "fmt"

func main() {
	if age := 20; age > 18 {
		fmt.Println("你已经成年了，要对自己的行为负责了。")
	}
}

双分支

package main

import "fmt"

func main() {
	var age byte
	fmt.Println("请输入你的年龄：")
	_, _ = fmt.Scanln(&age)
	if age > 18 {
		fmt.Println("你已经成年了，要对自己的行为负责了。")
	} else { // 这里的else以及左右两边的括号必须写在同一行
		fmt.Println("你还没成年，这次放过你。")
	}
}

判断闰年

package main

import "fmt"

func main() {
	var year uint
	fmt.Println("请输入年份，我来判断是否是闰年：")
	_, _ = fmt.Scanln(&year)
	if year%4 == 0 && year%100 != 0 || year%400 == 0 {
		fmt.Printf("%d年是闰年", year)
	} else {
		fmt.Printf("%d年不是闰年", year)
	}
}

多分支

package main

import "fmt"

func main() {
	var score uint
	fmt.Println("请输入你的考试成绩：")
	_, _ = fmt.Scanln(&score)
	if score == 100 {
		fmt.Println("奖励你一个手机")
	} else if score >= 80 {
		fmt.Println("奖励你一辆玩具车")
	} else if score >= 60 {
		fmt.Println("奖励你一本作业")
	} else {
		fmt.Println("你考得太差了，什么奖励都没有")
	}
}

switch

switch/case后是一个表达式（常量、变量、有返回值的函数等）
case后的表达式的值的数据类型必须和switch后的表达式的数据类型一致

package main

import "fmt"

func test() byte {
	return 1
}

func main() {
	var n byte = 1
	switch test() {
	case n: // 变量n的类型必须和switch后表达式的类型一致
		fmt.Println("ok1")
	case 2: // 常量的话没关系
		fmt.Println("ok2")
	default:
		fmt.Println("err")
	}
}

// 结果：ok1

case后可以带多个表达式，使用逗号分隔，表示或者的意思

package main

import "fmt"

func main() {
	var n byte
	fmt.Println("请输入星期的数字号：")
	_, _ = fmt.Scanln(&n)

	switch n {
	case 1, 2, 3, 4, 5, 6:
		fmt.Printf("星期%v", n)
	case 7:
		fmt.Println("星期日")
	default:
		fmt.Printf("没有星期%v", n)
	}
}

// 运行后输入1，结果是星期1
// 运行后输入7，结果是星期日

case后的表达式如果是常量，则要求不能重复
case后代码块的结尾处不需要break，程序匹配到一个case后就会执行对应的代码块，执行完就会退出switch，如果一个都匹配不到，则执行default
default不是必须的
switch后也可以不带表达式，类似if--else分支来使用

package main

import "fmt"

func main() {
	var grade float32
	fmt.Println("请输入你的成绩：")
	_, _ = fmt.Scanln(&grade)

	switch {
	case grade == 100:
		fmt.Println("哇，满分哦")
	case grade >= 80:
		fmt.Println("优秀")
	case grade >= 60:
		fmt.Println("良好")
	default:
		fmt.Println("不及格")
	}
}

switch后也可以直接声明一个变量，分号结束声明，但不推荐这样做，知道有就行

package main

import "fmt"

func main() {
	switch grade := 50; { // 分号别忘记写了
	case grade >= 60:
		fmt.Println("合格")
	default:
		fmt.Println("不合格")
	}
}

// 结果：不合格

switch穿透fallthrough，如果在case后代码块结尾处写上fallthrough语句，则会继续执行下一个case

package main

import "fmt"

func main() {
	var n = 1
	switch n {
	case 1:
		fmt.Println(1)
		fallthrough // 穿透到下一个case
	case 2:
		fmt.Println(2)
	default:
		fmt.Println("其他")
	}
}

// 结果：1(换行)2

type switch：switch语句还可以被用于type switch来判断某个interface变量中实际指向的变量类型

package main

import "fmt"

func main() {
	var x interface{}
	var y = 10.0
	x = y
	switch i := x.(type) {
	case nil:
		fmt.Printf("x的类型是%T", i)
	case int:
		fmt.Println("x是int类型")
	case float64:
		fmt.Println("x是float64类型")
	case func(int) float64:
		fmt.Println("x是func(int)类型")
	case bool, string:
		fmt.Println("x是bool或string类型")
	default:
		fmt.Println("未知类型")
	}
}

// 结果：x是float64类型

循环控制

for

循环条件是一个返回布尔值的表达式

package main

import "fmt"

func main() {
	for i := 0; i < 10; i++ {
		fmt.Println("Hello World", i)
	}
}

for后面只写循环条件

package main

import "fmt"

func main() {
	i := 0
	for i < 10 { // for后面只写循环条件
		fmt.Println("Hello World", i)
		i++
	}
}

for后面什么都不写，表示死循环

package main

import "fmt"

func main() {
	i := 0
	for { // for后面什么都不写，表示死循环
		fmt.Println("Hello World", i)
		i++
		if i == 10 {
			break
		}
	}
}

Go提供for-range的方式，可以很方便地遍历字符串和数组（数组的遍历等我们学到数组的时候再讲），案例说明如何遍历字符串

package main

import "fmt"

func main() {
	str := "Hello世界"

	// 下标遍历是按照字节遍历，遍历到汉字时乱码
	for i := 0; i < len(str); i++ {
		fmt.Printf("str[%d]=%c  ", i, str[i])
	}
	// len(str)的值为11，"Hello"占5字节，"世界"占6字节
	fmt.Println()

	// for-range遍历是按照字符遍历，可以正常显示汉字，但需要注意下标的变化
	for i, v := range str {
		fmt.Printf("str[%d]=%c  ", i, v)
	}
	// str[0]=H  str[1]=e  str[2]=l  str[3]=l  str[4]=o  str[5]=世  str[8]=界
}

结果：

如果字符串中含有中文，那么传统遍历字符串的方式就是错误的，会出现乱码。原因：传统的是按照字节来遍历，而一个汉字在UTF-8编码中占3个字节。解决办法：需要将字符串转成[]rune切片，这里只做演示，不过多说明，等后面学到再讲

package main

import "fmt"

func main() {
	str := "Hello世界"
	str2 := []rune(str)
	for i := 0; i < len(str2); i++ {
		fmt.Printf("str2[%d]=%c  ", i, str2[i])
	}
	// str2[0]=H  str2[1]=e  str2[2]=l  str2[3]=l  str2[4]=o  str2[5]=世  str2[6]=界
}

打印金字塔
一般地，如果一个数列从第2项起，每一项与它的前一项的差等于同一个常数，这个数列就叫做等差数列，这个常数叫做等差数列的公差，公差通常用字母d表示，等差数列通项公式：a_n=a₁+(n-1)d

package main

import "fmt"

func main() {
	rows := 5 // 金字塔高度
	for i := 1; i <= rows; i++ {

		// 先打印空格：首项是rows-1，公差是-1，所以通项为(rows-1)+(n-1)*(-1)=rows-1-n+1=rows-n
		for j := 1; j <= rows-i; j++ {
			fmt.Printf(" ")
		}

		// 然后再打印*：首项是1，公差是2，所以通项为1+(n-1)2=2n-1
		for j := 1; j <= 2*i-1; j++ {
			fmt.Printf("*")
		}

		fmt.Println() // 换行
	}
}

/*结果：
    *
   ***
  *****
 *******
*********
*/

打印镂空金字塔

package main

import "fmt"

func main() {
	rows := 5
	for i := 1; i <= rows; i++ {

		for j := 1; j <= rows-i; j++ {
			fmt.Printf(" ")
		}

		for j := 1; j <= 2*i-1; j++ {
			// 新增判断：每一行的第一个和最后一个打印*
			// 特殊情况：最后一行全部打印*
			if j == 1 || j == 2*i-1 || i == rows {
				fmt.Printf("*")
			} else {
				fmt.Printf(" ")
			}
		}

		fmt.Println()
	}
}

/*结果：
    *
   * *
  *   *
 *     *
*********
*/

break

引出问题：随机生成1 ~ 100的整数，直到生成99这个数，看一共生成了多少次？
生成随机整数的方法

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	// time.Now().Unix()返回从时间点January 1, 1970 UTC到当前时间点所经过的秒数
	fmt.Println(time.Now().Unix())

	/*
		rand包实现了伪随机数生成器。随机数从资源生成。
		包水平的函数都使用的默认的公共资源。该资源会在程序每次运行时都产生确定的序列。
		如果需要每次运行产生不同的序列，应使用Seed函数进行初始化。默认资源可以安全的用于多go程并发。
	*/
	// 使用给定的Seed将默认资源初始化到一个确定的状态，里面传入时间
	rand.Seed(time.Now().Unix())

	// 返回一个取值范围在[0,n)的随机int值
	fmt.Println(rand.Intn(100))
}

解决问题

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	var n, counter int
	rand.Seed(time.Now().Unix()) // 时间种子
	for {                        // 死循环
		n = rand.Intn(100) + 1 // 生成[1, 101)的随机整数
		counter++              // 生成一个整数计数器就+1
		fmt.Printf("%v  ", n)  // 输出每一次生成的整数
		if n == 99 {
			break
		}
	}
	fmt.Printf("\n一共花费了%v次才生成99这个数", counter)
}

break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块

package main

import "fmt"

func main() {
label: // 标签名随意写，但是后面要有冒号
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				break label
			}
			fmt.Printf("%v ", j) // 0 1
		}
	}
}

continue

continue用于跳出本轮循环

package main

import "fmt"

func main() {
	for i := 0; i < 5; i++ {
		if i == 2 {
			continue
		}
		fmt.Printf("%v ", i) // 0 1 3 4
	}
}

continue可以通过标签跳转到指定代码块

package main

import "fmt"

func main() {
tag:
	for i := 0; i < 2; i++ {
		for j := 0; j < 100; j++ {
			if j == 2 {
				continue tag
			}
			fmt.Printf("%v ", j) // 0 1 0 1
		}
	}
}

goto

goto语句可以无条件地转移到程序中指定的行
goto语句通常与条件语句配合使用，可以用来实现条件转移，跳出循环体等功能
一般不主张使用goto语句，以免造成程序流程的混乱，使理解和调试程序产生困难

package main

import "fmt"

func main() {
	for i := 0; i < 100; i++ {
		if i == 3 {
			goto abc
		}
		fmt.Printf("%v ", i)
	}
abc:
	fmt.Printf("程序结束")
}

// 结果：0 1 2 程序结束