go基础

变量

var v int
var v string
var v []int
var v [3]int
var v *int
var v map[int]string
var v func()int

自动推导

v := 10
m := make(map[int]string) 

var m1 map[int]string
m1 = make(map[int]string) 

数组

var arr [5]int = [5]int{1,2,3,4,5}
arr := [5]int{1,2,3,4,5}

遍历数组
for k,v := range arr {
	fmt.Println(k,v)
}

数组是值传递，函数参数为数组无法改变值
func change(arr [3]int) {
	arr[0] = 0
}
func main() {
	var arr[3]int = [3]int{1,2,3}
	change(arr);
	fmt.Println(arr)//[1 2 3]
}

切片

切片是原数组的引用
func main() {
	arr := [5]int {1,2,3,4,5}
	//切片
	//slice := arr[1:3] //从下标1开始，不包括结尾
	var slice []int = arr[1:3]
	fmt.Println(slice)

	slice[0] = 9
	fmt.Println(arr)
}

make创建切片
func main() {
	arr := make([]int, 5, 10)//[] len cap
	arr[0] = 1
	arr[1] = 2

	//遍历
	for i := 0; i<len(arr); i++ {
		fmt.Printf("%d ", arr[i])
	}
	fmt.Println()

	for k, v := range arr {
		fmt.Println(k, v)
	}

	fmt.Printf("%d %d\n", len(arr), cap(arr))
}

append 切片增加元素

//增加若干个元素
func main() {
	arr := make([]int, 2)//[] len cap
	arr[0] = 1
	arr[1] = 2

	arr = append(arr, 4, 5, 6)
	fmt.Println(arr)
}

//直接增加一个切片
func main() {
	arr := make([]int, 2)//[] len cap
	
	tmp := []int{1,2,3}

	arr = append(arr, tmp...)
	fmt.Println(arr)
}

copy切片复制

func main() {
	arr1 := []int{1,2,3}
	arr2 := []int{4,5}
	//copy(arr1,arr2)
	//fmt.Println(arr1)//4 5 3 

	copy(arr2,arr1)
	fmt.Println(arr2)//1 2
}

map创建赋值遍历查找删除

func main() {
	m := map[int]string {
		1:"qwe",
		2:"asd",
	}
	m[0] = "qaa"
	for k, v := range m {
		fmt.Println(k, v)
	}
}

func main() {
	//var db map[int]string
	//db = make(map[int]string) 

	//或者 可以声明容量
	db := make(map[int]string, 10) 

	db[0] = "qwe"
	db[1] = "asd"
	db[2] = "zxc"

	//查找
	p, ok := db[4] 
	if ok == false {
		fmt.Println("null key")
	} else {
		fmt.Println("find ", p)
	}
	
	v, ok := db[1]
	if ok {
		fmt.Println(v)
	}

	//删除
	delete(db, 1)

	//遍历
	for k, v := range db {
		fmt.Println(k, v)
	}
}

变长参数

func add(args  ...int)(s int) {
	sum := 0
	for _, v := range args {
		sum += v
	}
	return sum
}
func add2(args []int) (s int) {
	sum := 0
	for _, v := range args {
		sum += v
	}
	return sum
}
func main() {

	fmt.Println(add(1,2,3))
	fmt.Println(add2([]int{1,2,3,3}))
}
//任意类型的参数
func test(args ...interface{}) {
	for _, v := range args {
		fmt.Println(v)
	}
}










func test(args ...interface{}) {
	for _, v := range args {
		fmt.Printf("%v, %T\n", v, v)
	}
	fmt.Println("----")
}

func main() {
	//test(1, "qwe", 1.3)

	args := []interface{}{1, "qwe", 1.3}
	test(args...)

	var a []interface{}
	a = make([]interface{}, 0)
	a = append(a, 1)
	a = append(a, "qwe")
	test(a...)

	var b []interface{} = []interface{}{1, "qwe"}
	test(b...)
}

闭包

func main() {
	f1 := func() (func()) {
		var i int = 1
		return func() {
			fmt.Printf("i=%d\n", i)
		}
	}	
	fmt.Printf("%T -- %T\n", f1, f1())//func()func()  func()
	f1()()

	f2 := func() (func()) {
		var i int = 1
		return func() {
			fmt.Printf("i=%d\n", i)
		}
	}()
	fmt.Printf("%T\n", f2)//func()
	f2()
}


//第2种
func closeure() (func()) {
	var i int =10
	return func() {
		fmt.Println(i)
	}
}

func main() {
	f := closeure()
	fmt.Printf("%T\n", f)//func()
	f()//10
}

defer
一般用于打开文件后紧跟着defer f.Close()

func main() {
	
	defer func() {
		fmt.Println("defer1")
	}()

	defer func() {
		fmt.Println("defer2")
	}()
	
	defer func() {
		fmt.Println("defer3")
	}()
}

[root@localhost work]# go run 1.go 
defer3
defer2
defer1

type起别名

func main() {

	type myint int
	var i myint = 10
	fmt.Println(i)
}

struct结构体

type Student struct {
	id int 
	name string
}

func (s Student)show1() {
	s.name = "test"
	fmt.Println(s)
}
func (s *Student)show2() {
	s.name = "test"
	fmt.Println(s)
}

func main() {
	//初始化
	//s1 := new(Student)
	//s2 := &Student{}
	//s3 := &Student{1, "qwe"}
	//s4 := &Student{name:"asd", id: 2}

	s := Student{1,"QWE"}
	s.show1()
	fmt.Println(s)
	s.show2()
	fmt.Println(s)
}

[root@localhost work]# go run 1.go 
{1 test}
{1 QWE}
&{1 test}
{1 test}


接收者是值类型，不能改变原值
接收者是指针类型，可以修改