Go语言 数据类型，流程控制
人生苦短，Let's Go !
package main // 必须要有一个main包
import "fmt"
func main() {
fmt.Println("人生苦短，Let's Go!")
}
package main // 必须要有一个main包
import "fmt"
func main() {
fmt.Println("Hello Golang!")
}
// go语言以包作为管理单位
// 每个文件必须先声明包
// 程序必须有一个main包
package main
import "fmt"
// 入口函数
func main() { //左括号必须和函数名同行
// 打印
// "hello go"打印到屏幕， Println()会自动换行
// 调用函数，大部分都需要导入包
/*
这也是注释， 这是块注释
*/
fmt.Println("hello go!") // go语言语句结尾是没有分号
fmt.Println("hello world!")
}
变量的使用
package main // 必须有一个main包
import "fmt" // 导入包，必须要使用
func main() {
// 变量，程序运行期间，可以改变的量
// 1、声明格式，var 变量名 类型，变量声明了，必须要使用
// 2、只是声明没有初始化的变量，默认值为0
// 3、同一个{}里，声明的变量名是唯一的
var a int
fmt.Println("a =", a) // a = 0
// 4、可以同时声明多个变量
var b, c int
fmt.Printf("b = %d, c = %d\n", b, c)
// 5、变量的赋值
a = 10
b = 20
c = 30
fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
// 6、变量的初始化，声明变量时，同时赋值
var d int = 100 // 初始化，声明变量时，同时赋值（一步到位）
d = 200 // 赋值，先声明，后赋值
fmt.Println("d =", d)
// 7、自动推导类型，必须初始化，通过初始化的值确定类型（常用）
name := "zhouwanchun"
// %T 打印变量所属的类型
fmt.Printf("name type is %T.\n", name)
}
自动推导类型
package main
import "fmt"
func main() {
// 赋值，赋值前必须先声明变量
var a int
a = 10 // 赋值，可以使用n次
a = 20
a = 30
fmt.Println("a =", a)
// := 自动推导类型，先声明变量b，再给b赋值为20
// 自动推导，同一个变量名只能使用一次，用于初始化那次
b := 20
fmt.Println("b =", b)
// b := 30 // 前面已经有变量b了，不能再新建一个变量b
b = 30 // 只是赋值，是可以的
fmt.Println("b =", b)
}
Printf和Println的区别
package main
import "fmt"
func main() {
a := 10
// 一段一段处理，自动加换行
fmt.Println("a =", a)
// 格式化输出，把a的内容放在%d的位置
// "a = 10\n" 这个字符串输出到屏幕，"\n"代表换行符
fmt.Printf("a = %d\n", a)
b := 20
c := 30
fmt.Println("a =", a, ",b =", b, ",c =", c)
fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}
多重赋值和匿名变量
package main
import "fmt"
// Go函数可以返回多个值
func test() (a, b, c int) {
return 1, 2, 3
}
func main() {
// a := 10
// b := 20
// c := 30
a, b := 10, 20
// 交换2个变量的值
var tmp int
tmp = a
a = b
b = tmp
fmt.Printf("a = %d, b = %d\n", a, b)
// i := 10
// j := 20
i, j := 10, 20
i, j = j, i
fmt.Printf("i = %d, j = %d\n", i, j)
i = 10
j = 20
// _匿名变量，丢弃数据不处理，_匿名变量配合函数返回值使用，才有优势
tmp, _ = i, j
fmt.Println("tmp =", tmp)
var c, d, e int
c, d, e = test() // return 1, 2, 3
fmt.Printf("c = %d, d = %d, e = %d\n", c, d, e)
}
常量的使用
package main
import "fmt"
func main() {
// 变量：程序运行期间，可以改变的量，变量声明需要var
// 常量：程序运行期间，不可以改变的量，常量声明需要const
const a int = 10
// a = 20 // err报错，常量不允许修改
fmt.Println("a =", a)
const b = 11.2 // 没有使用:=
fmt.Printf("b type is %T\n", b)
fmt.Println("b =", b)
}
多个变量或常量的定义
package main
import "fmt"
func main() {
// 不同类型的变量的声明定义
var a int = 1
var b float64 = 2.0
var (
c int = 1
d float64 = 2.0
)
fmt.Println("a =", a)
fmt.Println("b =", b)
fmt.Println("c =", c)
fmt.Println("d =", d)
// 可以自动推导类型
var (
e = 1
f = 2.0
)
e, f = 10, 3.14
fmt.Println("e =", e)
fmt.Println("f =", f)
// 选中代码，按Ctrl+/，注释和取消注释代码的快捷键
// const i int = 10
// const j float64 = 3.14
const (
i int = 10
j float64 = 3.14
)
fmt.Println("i =", i)
fmt.Println("j =", j)
// 可以自动推导类型
const (
m = 10
n = 3.14
)
fmt.Println("m =", m)
fmt.Println("n =", n)
}
ioto枚举
package main
import "fmt"
func main() {
// 1、iota常量自动生成器，每隔一行，自动累加1
// 2、iota给常量赋值使用
const (
a = iota // 0
b = iota // 1
c = iota // 2
)
fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
// 3、iota遇到const，重置为0
const d = iota
fmt.Println("d =", d)
// 4、可以只写一个iota
const (
a1 = iota // 0
b1
c1
d1
)
fmt.Printf("a1 = %d, b1 = %d, c1 = %d, d1 = %d\n", a1, b1, c1, d1)
// 5、如果是同一行，值都一样
const (
i = iota
j1, j2, j3 = iota, iota, iota
k = iota
)
fmt.Printf("i = %d, j1 = %d, j2 = %d j3 = %d, k = %d\n", i, j1, j2, j3, k)
}
bool类型
package main
import "fmt"
func main() {
// 声明变量，没有初始化，零值（初始化为false）
var a bool
fmt.Println("a =", a)
a = true
fmt.Println("a =", a)
// 自动推到类型
var b = false
fmt.Println("b =", b)
c := false
fmt.Println("c =", c)
}
浮点型
package main
import "fmt"
func main() {
var f1 float32 // 声明变量
f1 = 3.14
fmt.Println("f1 =", f1)
f2 := 3.14 // 自动推导类型
fmt.Printf("f2 type is %T\n", f2)
fmt.Println("f2 =", f2)
// float64存储小数比float32更准确
}
字符类型
package main
import "fmt"
func main() {
var ch byte // 声明字符类型
ch = 97
fmt.Println("ch =", ch)
// 格式化输出，%c以字符方式打印，%d以整型方式打印
fmt.Printf("ch = %d = %c\n", ch, ch)
// 大写转小写，小写转大写，大小写相差32，小写大
fmt.Printf("大写：%d，小写：%d\n", 'A', 'a')
fmt.Printf("大写转小写：%c\n", 'A'+32)
fmt.Printf("小写转大写：%c\n", 'a'-32)
// '\'以反斜杠开头的字符是转义字符，'\n'代表换行
fmt.Printf("hello Go%c", '\n')
fmt.Printf("hello Go\n")
fmt.Printf("hello shenzhen\n")
}
字符串类型
package main
import "fmt"
func main() {
var name1 string // 声明变量
name1 = "zhouwanchun"
fmt.Println("name1 =", name1)
name2 := "eric" // 自动推导类型
fmt.Printf("name2的类型是%T\n", name2)
// 内置函数，len()可以测字符串的长度，有多少个字符
fmt.Println("len(name1) =", len(name1))
fmt.Println("len(name2) =", len(name2))
}
字符和字符串的区别
package main
import "fmt"
func main() {
var ch byte
// 字符：
// 1、单引号
// 2、字符，往往都只有一个字符，转义字符除外'\n'
ch = 'a'
fmt.Println("ch =", ch)
var str string
// 字符串：
// 1、双引号
// 2、字符串有一个过多个字符组成
// 3、字符串都是隐藏了一个结束符'\0'
str = "a" // 由'a'和'0'组成的一个字符串
fmt.Println("str =", str)
str = "hello Go"
// 只想操作字符串的某个字符，从0开始操作
fmt.Printf("str[0] = %c\n", str[0])
fmt.Printf("str[1] = %c\n", str[1])
}
复数类型
package main
import "fmt"
func main() {
var t1 complex128 // 声明变量
t1 = 2.1 + 3.14i // 赋值
fmt.Println("t1 =", t1)
t2 := 3.3 + 4.4i // 自动推导类型
fmt.Printf("t2 type is %T\n", t2)
// 通过内置函数，取实部和虚部
fmt.Println("real(t2) =", real(t2)) // 取实部
fmt.Println("imag(t2) =", imag(t2)) // 取虚部
}
格式化输出
package main
import "fmt"
func main() {
a := 10
b := "abc"
c := 'a'
d := 3.14
// %T操作变量所属类型
fmt.Printf("%T, %T, %T, %T\n", a, b, c, d)
// %d 整数格式
// %s 字符串格式
// %c 字符个数
// %f 浮点型个数
fmt.Printf("a = %d, b = %s, c = %c, d = %f\n", a, b, c, d)
// %v 自动匹配格式输出
fmt.Printf("a = %v, b = %v, c = %v, d = %v\n", a, b, c, d)
}
输入的使用
package main
import "fmt"
func main() {
var username string // 声明变量
fmt.Printf("请输入你的用户名：")
// 阻塞等待用户的输入
// fmt.Scanf("%d", &username) //别忘了&
fmt.Scan(&username)
var password string
fmt.Printf("请输入你的密码：")
fmt.Scan(&password)
fmt.Println("-------------------------------------")
fmt.Printf("你的用户名是：%s\n", username)
fmt.Println("你的密码是：", password)
}
类型转换
package main
import "fmt"
func main() {
var flag bool
flag = true
fmt.Printf("flag = %t\n", flag)
// bool类型不能转换int
// fmt.Printf("flag = %d\n", int(flag)) // 这种不能转换的类型，叫不兼容类型
// 0就是假，非0就是真
// 整型也不能转换为bool
// flag = bool(1)
var ch byte
ch = 'a' // 字符类型本质上就是整型
var t int
t = int(ch) // 类型转换，把ch的值取出来后，转成int再给t赋值
fmt.Println("t =", t)
}
类型别名
package main
import "fmt"
func main() {
// 给int64起一个别名叫bigint
type bigint int64
var a bigint // 等价于var a int64
fmt.Printf("a type is %T\n", a)
type (
long int64
char byte
)
var b long = 22
var ch char = 'a'
fmt.Println("b =", b)
fmt.Printf("ch = %c\n", ch)
}
运算符
package main
import "fmt"
func main() {
fmt.Println("4 > 3 结果：", 4 > 3)
fmt.Println("4 != 3 结果：", 4 != 3)
fmt.Println("!(4 > 3) 结果：", !(4 > 3))
fmt.Println("!(4 != 3) 结果：", !(4 != 3))
// && 与，并且，左边右边都为真，结果才为真，其它都为假
fmt.Println("true && true 结果：", true && true)
fmt.Println("true && false 结果：", true && false)
// || 或者，左边右边都为假，结果才为假，其它都为真
fmt.Println("true || false 结果：", true || false)
fmt.Println("false || false 结果：", false || false)
a := 22
fmt.Println("0 <= a && a <= 10 结果为：", 0 <= a && a <= 10)
}
if的使用
package main
import "fmt"
func main() {
name := "王思聪"
// if和{就是条件，条件通常都是关系运算符
if name == "王思聪" { // 左括号和if在同一行
fmt.Println("左手一个妹子，右手一个少妇")
}
// if支持1个初始化语句，初始化语句和判断条件以;分隔
if a := 10; a == 9 {
fmt.Println("a == 10")
}
}
if_else_if_else的使用
package main
import "fmt"
func main() {
a := 10
if a == 10 {
fmt.Println("a == 10")
} else {
fmt.Println("a != 10")
}
if b := 10; b == 10 {
fmt.Println("b == 10")
} else {
fmt.Println("b != 10")
}
mm := 35
if mm == 35 {
fmt.Println("风韵尚存呀！哈哈！")
} else if mm < 35 {
fmt.Println("你已经是小熟女了")
} else if mm > 35 {
fmt.Println("你已经是老熟女了")
}
if mm := 40; mm == 35 {
fmt.Println("风韵尚存呀！哈哈！")
} else if mm < 35 {
fmt.Println("你已经是小熟女了")
} else if mm > 35 {
fmt.Println("你已经是老熟女了")
}
}
if_else_if和多个if的区别
package main
import "fmt"
func main() {
// if_else嵌套（推荐这种方式）
mm1 := 35
if mm1 == 35 {
fmt.Println("风韵尚存呀！哈哈！")
} else if mm1 < 35 {
fmt.Println("你已经是小熟女了")
} else if mm1 > 35 {
fmt.Println("你已经是老熟女了")
}
// 多个if判断
mm2 := 40
if mm2 == 35 {
fmt.Println("风韵尚存呀！哈哈！")
}
if mm2 < 35 {
fmt.Println("你已经是小熟女了")
}
if mm2 > 35 {
fmt.Println("你已经是老熟女了")
}
}
switch的使用
package main
import "fmt"
func main() {
var num int
fmt.Printf("请按下电梯楼层：")
fmt.Scan(&num)
switch num { // switch后面写的是变量本身
case 1:
fmt.Println("按下的是1楼")
break // Go语言保留了break关键字，跳出switch语句，不写break默认就包含。
case 2:
fmt.Println("按下的是2楼")
fallthrough // 不跳出switch语句，这条语句后面语句可以无条件执行。
case 3:
fmt.Println("按下的是3楼")
case 4:
fmt.Println("按下的是4楼")
default:
fmt.Println("按下的是xxx楼")
}
}
switch使用的补充
package main
import "fmt"
func main() {
// 支持一个初始化语句，初始化语句和变量本身，以分号分隔
switch num := 4; num { // switch后面写的是变量本身
case 1:
fmt.Println("按下的是1楼")
break // Go语言保留了break关键字，跳出switch语句，不写break默认就包含。
case 2:
fmt.Println("按下的是2楼")
fallthrough // 不跳出switch语句，这条语句后面语句可以无条件执行。
case 3, 4, 5:
fmt.Println("按下的是345楼")
case 6:
fmt.Println("按下的是4楼")
default:
fmt.Println("按下的是xxx楼")
}
score := 85
switch {
case score > 90: // case后面可以放条件
fmt.Println("优秀")
case score > 80:
fmt.Println("良好")
case score > 70:
fmt.Println("一般")
default:
fmt.Println("很差")
}
}
for循环
package main
import "fmt"
func main() {
// for 初始化条件; 判断条件; 条件变化 {
// }
// 计算从1加到100
sum := 0
for i := 1; i <= 100; i++ {
sum = sum + i
}
fmt.Println("sum =", sum)
// 打印1到100的整数
for i := 1; i <= 100; i++ {
fmt.Println(i)
}
}
range的使用
package main
import "fmt"
func main() {
name := "zhouwanchun"
// 通过for打印每个字符
for i := 0; i < len(name); i++ {
fmt.Printf("name[%d]=%c\n", i, name[i])
}
fmt.Println("----------------------")
// range迭代打印每个元素，默认返回2个值: 一个是元素的位置，一个是元素本身
for i, data := range name {
fmt.Printf("name[%d]=%c\n", i, data)
}
fmt.Println("----------------------")
// 第2个返回值，默认丢弃，返回元素的位置（下标）
for i := range name {
fmt.Printf("name[%d]=%c\n", i, name[i])
}
fmt.Println("----------------------")
// 第2个返回值，默认丢弃，返回元素的位置（下标）
for i, _ := range name {
fmt.Printf("name[%d]=%c\n", i, name[i])
}
}
break和continue的区别
package main
import "fmt"
import "time"
func main() {
i := 0
for { // for后面不写任何东西，这个循环条件永远为真，死循环
i++
time.Sleep(time.Second) // 睡1秒
if i == 5 {
// break // 跳出循环，如果嵌套多个循环，跳出最近的那个内循环
continue // 跳过本次循环，下一次继续
}
fmt.Println("i =", i)
}
}
goto的使用
package main
import "fmt"
func main() {
// break is not in a loop, switch, or select
// continue is not in a loop
// goto 可以用在任何地方，但是不能跨函数使用
fmt.Println("111111111111111111111111")
goto End // goto是关键字，End是用户起的名字，它叫标签
fmt.Println("222222222222222222222222")
End:
fmt.Println("333333333333333333333333")
}