控制语句
判断语句if
- 条件表达式没有括号
- 支持在条件语句汇总初始化表达式（可以是并行方式）（初始化的值只作用于if-else这个语句块，即使与语句块外面的变量重名也互不干扰）
- 可以写在一行内，但是格式化时一样回变成标准格式
- 左大括号必须和条件语句处于同一行
package main
import (
"fmt"
)
func main() {
a := 9
if a > 10 {
fmt.Println("a>10")
} else if a < 10 {
fmt.Println("a<10")
} else {
fmt.Println("a = 10")
}
}
for语句
- go只有一个循环语句关键词，但支持3种形式
- 初始化和步进表达式可以事多个值
- 条件语句每次循环都会被重新检查，因此不建议在条件语句中使用函数，尽量提前计算好条件并以变量或常量代替
- 左大括号必须和条件语句在同一行
第一种
package main
import (
"fmt"
)
func main() {
a := 1
// 第一种，直接循环
for {
a++
if a > 3 {
break
}
fmt.Println(a)
}
fmt.Println("over")
}
第二种
package main
import (
"fmt"
)
func main() {
a := 1
// 第二种，for加判断，类似while
for a <= 3 {
a++
fmt.Println(a)
}
fmt.Println("over")
}
/*
2
3
4
over
*/
第三种
package main
import (
"fmt"
)
func main() {
a := 1
// 第三种，for加赋值判断
for i := 0; i < 3; i++ {
a++
fmt.Println(a)
}
fmt.Println("over")
}
/*
2
3
4
over
*/
选择语句switch
- 可以使用任何类型或表达式作为条件语句
- 不需要写break，一旦条件符合自动终止
- 如果希望继续执行下一个case，需要使用fallthrough语句
- 支持一个初始化表达式（可以是并行方式），右侧需要跟分号
- 左大括号必须和条件语句在同一行
package main
import (
"fmt"
)
// 选择语句switch
func main() {
a := 1
switch a {
case 0:
fmt.Println("a=0")
case 1:
fmt.Println("a=1")
}
fmt.Println(a)
}
package main
import (
"fmt"
)
// 选择语句switch
func main() {
a := 1
// 这里case条件语句的时候switch后面不需要再加变量名
switch {
case a >= 0:
fmt.Println("a>=0")
fallthrough
case a >= 1:
fmt.Println("a>=1")
}
fmt.Println(a)
}
package main
import (
"fmt"
)
// 选择语句switch
func main() {
// 再switch后跟随声明定义
switch a := 1; {
case a >= 0:
fmt.Println("a>=0")
fallthrough
case a >= 1:
fmt.Println("a>=1")
fallthrough
default:
fmt.Println("none")
}
}
goto,break,continue跳转语句
- 三个语法都可以配合标签使用
- 标签名区分大小写，若不使用会造成编译错误
- break与continue配合标签可用于多层循环的跳出
- goto是调整执行位置，与其他两个语句配合标签的结果并不相同
/* break */
func main() {
// 定义标签
LABEL1:
// 无限循环
for {
for i := 0; i < 10; i++ {
if i > 3 {
// 指定跳出哪一层
break LABEL1
}
}
}
fmt.Println("OK")
} // OK 跳出了无限循环
/* 标签放在goto之后，利用goto跳出死循环 */
func main() {
// 无限循环
for {
for i := 0; i < 10; i++ {
if i > 3 {
// 指定跳到哪里
goto LABEL1
}
}
}
// 定义标签
LABEL1:
fmt.Println("OK")
} // OK
continue不带标签的时候为跳过生下的循环体，直接进入下次循环
package main
import (
"fmt"
)
func main() {
// 定义标签
LABEL1:
for i := 0; i < 10; i++ {
fmt.Println(i)
// 无限循环
for {
// 继续标签所在 循环
continue LABEL1
}
}
fmt.Println("OK")
}
数组array
- 定义数组：var <varName> []<type>, n>=0
- 数组长度也是类型的一部分，因此具有不同长度的数组为不同类型
- 注意区分指向数组的指针和指针数组
- 数组在go中为值类型（切片为引用类型）
- 数组之间可以使用==或!=进行比较，但不能使用>或<
- 可以使用new来创建数组，此方法返回一个指向数组的指针
- go支持多维数组
- 长度相同数组才是类型相同，长度不同就是不同的类型，不能直接赋值
- 数组声明之后也是存在零值的
/* 声明数组的几种方式 */
func main() {
// var <ArrayName> [n]<type> 注意n>=0
var a [2]int
var b [2]int
// 只有长度相同才可以直接赋值
a = b
// 另一种方式，大括号内跟准确的值
c := [2]int{1, 1}
//
d := [2]int{1}
// 索引赋值
e := [20]int{19: 1}
// 省略数组大小n
f := [...]int{1, 2, 3, 4, 5, 6}
g := [...]int{19: 1}
fmt.Println(a) // [0 0]
fmt.Println(b) // [0 0]
fmt.Println(c) // [1 1]
fmt.Println(d) // [1 0]
fmt.Println(e) // [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1]
fmt.Println(f) // [1 2 3 4 5 6]
fmt.Println(g) // [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1]
}
使用new关键词来创建数组返回一个指向数组的指针
package main
import (
"fmt"
)
func main() {
p := new([10]int)
fmt.Println(p) // &[0 0 0 0 0 0 0 0 0 0]
}
数组本身和指向数组的指针都可以直接通过索引修改数组
package main
import (
"fmt"
)
func main() {
a := [10]int{}
a[1] = 2
p := new([10]int)
p[1] = 2
fmt.Println(a) // [0 2 0 0 0 0 0 0 0 0]
fmt.Println(p) // &[0 2 0 0 0 0 0 0 0 0]
}
多维数组
package main
import (
"fmt"
)
func main() {
// 这里同样可以支持索引赋值，最外层可以使用三个.来代替
a := [2][3]int{
{1, 2, 3},
{4, 5, 6},
}
fmt.Println(a) // [[1 2 3] [4 5 6]]
}
go语言版本的冒泡排序：
package main
import (
"fmt"
)
// go语言版本冒泡排序
func main() {
a := [...]int{4, 8, 2, 7, 1, 9, 5, 6}
// 打印排序前
fmt.Println(a)
// 获取长度,提前赋值如果放在循环中每次都要执行
nums := len(a)
for i := 0; i < nums; i++ {
for j := i + 1; j < nums; j++ {
// 从大到小
if a[i] < a[j] {
temp := a[i]
a[i] = a[j]
a[j] = temp
}
}
}
fmt.Println(a)
}
// [4 8 2 7 1 9 5 6]
// [9 8 7 6 5 4 2 1]
