go二次学习基础（2）

package main

import "fmt"

/*
	golang 数组 ：把同一类元素放在一起的集合

	定义：1.[元素长度]元素类型{元素一, 元素二}  元素长度可以不填写 用...代替
		 2. var a = new([长度]类型) a[i] = value

	func 1.len() 长度
		 2.cap() 容量 在数组中一般是对等的

	数组遍历{
		for i := 0; i < len(arr); i++ { }
		for k,v := range arr {}
	}

	多纬数组
		er := [几个数组][数组个数]数组类型{value}
*/

/*
	golang slice 切片是数组的一部分
	取值
		cl := a[:]  // 取a所有数据
		cl = a[0:2] // 前闭后开原则 可以取到前面 取不到后面
		cl = a[:2]  // 从开始取到指定位置 不包含指定位置
		cl = a[2:]  // 从指定位置取到最后
	增加
		cl = append(cl, 5) // append之后和原数组没有关系了
	copy()
		将后面切片拷贝到前面的切片 会覆盖
		copy(cl, cl1)
		copy(cl[3:4], cl1) 可以将后面数据复制到前面指定位置
	创建切片
		var a []int
		b := make([]int, 4) // var和make的区别是 var声明出来的是空的 make声明的是有默认值的
*/

/*
	golang map 类似于其他语言的字典或者哈希表 表现位 key-value
	声明
		var m map[string]string   m = map[string]string{}
		m := map[string]string{}
		m = make(map[string]string)
		m := map[int]interface{}{}  声明一个空接口就可以实现存储各种value类型数据
	删除
		delete(变量名, key)
	长度
		len() 拥有多少元素
	取值
		m[key]
		for k, v := range m { }

*/

/*
	golang func
	func funcname(input ...params)(output ...params) {
		func logic
		return output type params
	}

	return return返回值已经声明不可以在函数内部重复 返回值如果不写，go会找到函数内部的返回值名称并返回

	匿名函数{
		ret := func(msg string) {
			fmt.Println(msg)
		}
		ret("hello world")
		fmt.Println("")
	}

	不定向参数
	func funcname(param1,param2 ...string) {} //不定向参数必须最后一位 传入的是一个切片
	传入切片时可以使用不定向传参方式{
		sli := []string{"1", "2", "3"}
		funcname(data1, sli...)

	}

	自执行函数{
		(func(){
			fmt.Println("我不需要调用即可执行，从声明那一刻我就自己执行了")
		})()
	}

	闭包函数 ：函数返回一个函数就叫闭包函数
	{
		func mo()func(int){
			return func(num int) {
				// 我和外层函数返回类型（函数）一样一样的
			}
		}
		调用 mo()(4)
	}

	延迟调用函数
		defer
*/

/*
	golang 指针和地址 :指针指向变量原始内存地址 *声明指针 &取地址
	定义{
		var a *int
		var a string = "i'm point"   p := &a  // := 隐式声明指针
	}
	赋值{
		*a = 123
		var b int
		b = *a
	}
	取值{
		*a
	}

	数组指针{
		arr := [5]string{"1", "2", "3", "4", "5"}
		arrP = *[5]string
		arrP = &arr
	}

	指针数组{
		var arrpP *[5]string // 五个指针组成的数组
	}
*/

/*
	golang struct 结构体 : 可以存储多个不同数据类型的数据类型
	声明{
		type structName struct {
			dataName dataType
			dataName dataType
			...
		}
	}

	使用{
		1: var fx Lfx   // 可以用fx. 来调用fx里面的数据类型 来赋值 改变 ...
		2: var fx Lfx{data...}
		3: fx := new(Lfx)
	}

	获取数据{
		使用.即可使用类型里面的数据
	}

	结构体指针{
		声明{
			var fxp *Lfx
		}
		注意{
			*fxp.Name 会报错 因为有可能.的优先级比*高 加括号即可 (*fxp).Name
		}
	}

	结构体和其他类型的区别{
		可以挂载：(l *Lfx)Song(name string)(ret string)
	}
*/

/*
	golang interface  接口是一类规范 是某些方法的集合
	interface在go里面实现了范型{
		范型：例：函数中用接口代替不确定类型 func MyFun(a interface{}) {}
	}

	goroutine 在调用一个方法的前面加上go就是goroutine 它会让方法异步执行 相当于协程
	声明{
		go funcName()
	}

	协程管理器{
		var wg sync.WaitGroup
		wg.Add(1)
		go Run(&wg)
		wg.Wait()
		// 在函数中传递参数 *sync.WaitGroup  函数内部用wg.Done()来中止协程
	}

	channel 是goroutine之间的通讯桥梁
	定义{
		1: c := make(chan int,1)   // 有缓冲区
		2: c := make(chan int)     // 无缓冲区
		3: var readc <-chan int = c // 可读
		4: var write chan<- int = c // 可写
		5:
	}
	关闭{
		close(c) //当不需要存储数据的时候需要关闭
		当使用for range取值的时候 可以先close掉chan
	}
	select {
		select {
			case <-c: //多个条件符合则随机执行
		}
	}

*/

func main() {
	c := make(chan int)
	var readc <-chan int = c
	var writec chan<- int = c

	go SetChan(writec)
	GetChan(readc)
}

func SetChan(writec chan<- int) {
	for i:=0; i<10; i++ {
		fmt.Println("i'm set func ")
		writec<- i
	}
}

func GetChan(readc <-chan int) {
	for i:=0; i<10; i++ {
		fmt.Printf("i'm get func i'm get %d \n", <-readc)
	}
}