GO学习

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

func main() {
	//数组 同一个类型的集合
	var id [50]int
	//操作数组通过下标从0开始到len()-1
	for i := 0;i<len(id) ;i++  {
		id[i] =i+1
		fmt.Printf("id[%d]=%dn",i,id[i])

	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

func main() {

	//定义一个数组  [10]int和[5]int是不同类型
	//[数字],数字作为数组元素个数
	//注意:定义数组是  指定的数组元素个数必须是常量
	var a  [10]int
	var b  [5]int
	fmt.Printf("len(a)=%d,len(b)=%dn",len(a),len(b))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import "fmt"

func main() {
	//声明定义同时腐赋值 :初始化
	//1全部初始化

	var a [5]int  =[5]int{1,2,3,4,5}
	fmt.Println("a=",a)

	b :=[5]int{1,2,3,4,5}
	fmt.Println("b=",b)

	//2部分初始化  没有初始化的元素  自动赋值为0
	c := [5]int{1,2,3}
	fmt.Println("c=",c)

	//3指定某个元素初始化
	d :=[5]int{2:10,4:30}
	fmt.Println("d=",d)
}

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

import "fmt"

func main() {
	//支持比较  只支持==或者 !=,比较是不是每一个元素都一样,2个数组比较,数组类型要一样
	a := [5]int{1,2,3,4,5}
	b := [5]int{1,2,3,4,5}
	c := [5]int{2,3,4}

	fmt.Println("a==b",a==b)
	fmt.Println("a==c",a==c)

	//同类型的数组可以赋值
	var d [5]int

	d=a
	fmt.Println("d=",d)

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

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

func main() {

	//设置种子,只需要一次
	//如果种子参数一样,每次运行程序产生的随机数都一样

	rand.Seed(time.Now().UnixNano()) //以当前系统时间作为种子参数

	for i :=0;i<5 ;i++  {
		//产生随机数
		//fmt.Println("rand=",rand.Int()) //随机很大的数
		fmt.Println("rand=",rand.Intn(100)) //限制在100内的数
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main

import "fmt"

//数组做函数参数,它是值传递
//实参数组的每个元素给形参数组拷贝一份
//形参的数组是实参数组的复制品
func modify(a [5]int) {
	a[0] =666
	fmt.Println("modify a =",a)


}

func main() {
	//初始化
	a :=[5]int{1,2,3,4,5}
	//数组传递过去
	modify(a)

	fmt.Println("main a =",a)

}

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

import "fmt"

//p指向实现数组a,它是指向数组,是数组指针
//*p代表指针所指向的内存 就是参数a
func modify1(p *[5]int) {
	(*p)[0] =666
	fmt.Println("modify *a=",*p)

}

func main() {
	//初始化
	a :=[5]int{1,2,3,4,5}

	//地址传递
	modify1(&a)

	fmt.Println("main:a =",a)
}

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

import "fmt"

func main() {

	//自动推到类型 同时初始化
	s1 := []int{1,2,3,4}
	fmt.Println("s1=",s1)

	//借助make函数,格式make(切片类型,长度,容量)
	s2 :=make([]int,5,10)
	fmt.Printf("len=%d,cap=%dn",len(s2),cap(s2))
	//没有指定容量,容量和长度一样
	s3 :=make([]int,5)
	fmt.Printf("len=%d,cap=%dn",len(s3),cap(s3))

}

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
30
31
32
33
package main

import "fmt"

func main() {
	//定义一个变量 ,类型为map[int]string

	var m map[int]string
	fmt.Println("m=",m)

	//map只有长度len没有容量cap
	fmt.Println("len = ",len(m))


	//可以通过make创建
	m1 :=make(map[int]string)
	fmt.Println("m1=",m1)
	fmt.Println("len = ",len(m1))

	//可以通过make创建,可以指定长度,知识指定了容量,但是里面却一个数据都没有
	m3 :=make(map[int]string,10)
	m3[1] ="外星人1"
	m3[2] ="外星人2"
	m3[3] ="外星人3"
	m3[4] ="外星人4"
	fmt.Println("m3=",m3)
	//初始化
	//键值是唯一的
	m4 := map[int]string{1:"外星人11",2:"外星人112"}
	fmt.Println("m4=",m4)

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

func main() {
	m1 :=map[int]string{1:"lisi",2:"wangwu"}
	//赋值 如果已经存在的key值,修改内容
	fmt.Println("m1 = ",m1)
	m1[1] ="zhaoliu"
	fmt.Println("m1 = ",m1)
	//追加
	m1[3]="hello"
	fmt.Println("m1=",m1)
}

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
package main

import "fmt"

func main() {

	m := map[int]string{1:"lisi",2:"wangwu",3:"hello"}
	//第一个返回值为key,第二个返回值为value,遍历结果是无序的

	for key,value :=range m {
		fmt.Printf("%d====> %sn",key,value)

	}
	//如何判断一个key值是否存在
	//第一个返回值为key所对应的value,第二个返回值为key是否存在的条件,存在ok为true

	value ,ok := m[0]
	if ok ==true {
		fmt.Printf("m[%s]",value)
	}else {
		fmt.Println("key不存在")
	}

}

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

import "fmt"

func main() {
	m :=map[int]string{1:"lisi",2:"zhaoliu",3:"hello"}
	fmt.Println("m=",m)
	//删除key为1的内容
	delete(m,1)
	fmt.Println("m=",m)
}

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

import "fmt"

func test12(m map[int]string)  {
	delete(m,2)

}
func main() {

	m :=map[int]string{1:"lisi",2:"wangwu",3:"zhaoliu"}
	//在函数内部删除某个key
	test12(m)
	fmt.Println("m=",m)
}

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
package main

import "fmt"

//定义一个结构体类型

type Student struct {
	id int
	name string
	sex string
	age int
	addr string
}

func main() {

	//顺序初始化,每个成员必须初始化

	var s1 Student  =Student{1,"hello","男",18,"USA"}

	fmt.Println("s1 =",s1)

	//指定成员初始化,没有初始化的成员,自动赋值为0
	s2 :=Student{name:"lisi",sex:"男",addr:"Chain"}
	fmt.Println("s2=",s2)


}

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
package main

import "fmt"

//定义一个结构体

type Students struct {

	id int
	name string
	sex string
	age int
	addr string

}

func main() {
	//定义一个结构体普通变量
	var s  Students
	//操作成员,需要使用(.)运算符
	s.id = 1
	s.name="hello"
	s.sex = "男"
	s.age = 18
	s.addr = "sz"
	fmt.Println("s= ",s)

}

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package main

import "fmt"

//定义一个结构体

type Student1 struct {

	id int
	name string
	sex string
	age int
	addr string

}

func main() {
	//指针有合法指向后,才操作成员
	//先定义一个普通结构变量
	var s  Student1

	//在定义一个指针变量,保存s的地址
	var p  *Student1
	p = &s

	//通过指针操作成员  p1.id 和(*p1).id完全等价,只能使用.
	p.id =1
	p.name ="hello"
	p.sex = "男"
	p.age = 18
	p.addr = "sz"

	fmt.Println("p=",p)

	//2通过new申请一个结构体
	p1 := new(Student1)

	p1.id =1
	p1.name ="hello"
	p1.sex = "男"
	p1.age = 18
	p1.addr = "sz"

	fmt.Println("p1=",p1)

}