go语言学习第一天

1.基本知识

1.go语言以包作为管理单位，每个文件必须申明包，程序必须有一个main包

2.语句结尾没有分号

3.一个文件夹只能有一个main函数

4.命令行（处理一个文件夹下只能有一个main函数问题）：

            go build xxx.go     编译go代码，生成一个可执行程序

            xxx.exe       运行程序

            go run xxx.go       不生成可执行程序，直接运行

5.导入的包必须被使用，变量也必须使用

2.变量

1.声明格式   var  变量名  类型

2.只是声明，没有初始化的变量，默认值为0

func main() { 
	var a,b int
	var c int=20
    var d float64
	a=10
	fmt.Println(a,b,c,d)
}

结果：10 0 20

3.自动推导类型，必须初始化，通过初始化的值确定类型（常用）

_匿名变量，丢弃数据不处理，_匿名变量配合函数返回值使用，才有优势

func main() {
	aa, bb :=10,20
	fmt.Println(aa,bb)
	aa, bb = bb,aa
	fmt.Println(aa,bb)
	aa, _ = bb,aa
	fmt.Println(aa,bb)
}

结果：

10 20
20 10
10 10

例：

func main() {
	var d int
	_, d, _ = test()
	fmt.Println(d)
}
func test()(a,b,c int)  {
	return 1,2,3
}

结果：2

3.常量

const a int  = 10
const b  = 20 

4.多个变量定义

var (
    a int
	b float64
)
a,b = 1,2.5
fmt.Println(a,b)

const  (
	i int =30
	j  = 6.26
)
fmt.Println(i,j)

结果：

1 2.5
30 6.26

5.枚举类型

1.iota常量自动生成器，每个一行，自动累加1，给常量赋值时使用

2.iota遇到const，重置为0

3.可以只写一个iots，如果是同一行，值都一样

例：

const  (
	a = iota
	b  = iota
)
fmt.Println(a,b)
const c  = iota
fmt.Println(c)
const  (
	d = iota
	e
)
fmt.Println(d,e)
const  (
	f = iota
	g,h = iota,iota
)
fmt.Println(f,g,h)

结果：

0 1
0
0 1
0 1 1

6.复数类型，并取实部和虚部

var a complex128
a = 1.5+5.9i
fmt.Println(a)
fmt.Println(real(a),imag(a))

结果：

(1.5+5.9i)
1.5 5.9

7.控制台输入

var a int
//fmt.Scanf("%d",&a)
fmt.Scan(&a)
fmt.Println(a)

8.类型转换

bool类型不能转换为int，整型也不能转换为bool类型

var a byte
a = 'a'
t := int(a)
fmt.Println(t)

结果：97

9.类型别名

type personInt int64
var  x personInt  = 23
fmt.Println(x)

type (
	myint int
	mystr string
)

总结：int64类型改名为personInt

          int改名为myint

10.if

s := "aa"
if s== "aa" {
	fmt.Println("aaaaaaa");
}

if c:=11; c== 10 {
	fmt.Println("等于10");
}else if c<10 {
	fmt.Println("小于10");
}else if c>10 {
	fmt.Println("大于10");
}

11.switch

num :=3
switch num {
case 1:
	fmt.Println("等于1")
    //break go语言保留了break关键字，跳出switch循环，可以不写，默认包含
case 2:
	fmt.Println("等于2")
case 3:
	fmt.Println("等于3")
case 4:
	fmt.Println("等于4")
default:
	fmt.Println("不知道")
}

fallthrough用法：

num :=1
switch num {
case 1:
	fmt.Println("等于1")
	fallthrough //不跳出switch循环，后面的语句无条件执行
case 2:
	fmt.Println("等于2")
default:
	fmt.Println("不知道")
}

结果：

等于1
等于2

num :=1
switch {
case num > 1:
	fmt.Println("大于1")
case num < 1:
	fmt.Println("小于1")
default:
	fmt.Println("不知道")
}

12.for循环

num :=5
for i :=1;i<num ;i++  {
	fmt.Println(i)
}

str :="abc"
for i :=0;i<len(str) ;i++  {
	fmt.Println(str[i])
}
fmt.Println("================")
//迭代打印每个元素，默认返回两个值，一个是元素的位置，一个是元素本身
for i,data :=range str {
	fmt.Println(i,data)
}

fmt.Println("================")
//丢弃某个返回值
//或写法为
//for i :=range str {
for i,_ :=range str {
	fmt.Println(i,str[i])
}

结果：

97
98
99
================
0 97
1 98
2 99
================
0 97
1 98
2 99

13.break和continue

break可用于for，switch，select，而continue仅能用于for循环

14.goto

goto可以用在任何地方，但是不能跨函数使用，跳转到End标签，并从标签处执行代码

fmt.Println("111111111")

goto End //goto是关键字，End是用户起的名字，叫标签
fmt.Println("222222222222")

End:
fmt.Println("3333333333")

结果：

111111111
3333333333