行者花雕 / 待分类 / go:内置函数 | 闭包 | 数组 | 切片 | 排...

分享

   

go:内置函数 | 闭包 | 数组 | 切片 | 排序 | map | 锁

2020-06-07  行者花雕
内置函数
1.close: 主要是用来关闭channel
2.len:用来求长度,比如string、array、slice、map、channel
3.new与make都是用来分配内存
	new用来分配值类型,如int、string,返回的是指针
	make用来分配引用类型,如chan、map、slice
	new创建的指针指向变量,make进行变量的初始化
	
4.append用来追加元素到数组、slice中
5.panie和recover,用来做错误处理

闭包
1。一个函数和与其相关的饮用环境组合而成的实体
	package main

	import "fmt"
	func Addr() func(int) int {
		var x int
		return func(d int) int {
			x +=d
			return x
		}
	}
	func main() {
		f := Addr()
		fmt.Println(f(1))
		fmt.Println(f(100))
		fmt.Println(f(1000))
	}

数组

1.数组:
	是同一种数据类型的固定长度的序列
2.数组定义
	var a [len]int
3.长度是数据类型的一部分,因此,var a[5] int和var a[10] int是不同类型
4.数据可以通过下标进行访问,下标是从0开始,最后一个元素的下标为len-1
5.访问越界,如果下标在数组合法范围之外,则触发访问越界,会panic
6.数组的初始化
	a.var age() [5]int = [5] int{1,2,3,4,5}
	b.var age() = [5]int{1,2,3,4,5}
	c.var age = [...]int {1,2,3,4,5}
	d.var str = [5]string{3:"hello world",4:"tom"}
7.多维数组
	a.var age [5][3]int
	b.var f [2][3]int = [...][3]int{{1,2,3},{4,5,6}}

切片

1.切片,切片是数组的一个引用,因此切片是引用类型
2.切片的长度可以改变,因此,切片是一个可变数组
3.切片遍历方式和数组一样,可以用len()求长度
4.cap可以求出slice最大的容量,0<=len(slice) <=cap(array),其中arrayshi slice引用的数组
5.切片的定义
	var 变量名 []类型,比如 var str []string    var arr []int
6.切片的初始化:
	var slice []int = arr[start:end] 
	var slice []int = arr[0:end] 简写为 var slice []int = arr[:]
	var slice []int = arr[start:len(arr)]简写为var slice[]int = arr[start:]
	var slice []int = arr[0,len(arr)]简写为 var slice[]int = arr[:]
7.通过make创建切片
	var slice []type = make([]type,len)
	slice := make([]type,len)
	slice := make([]type,len,cap)
8.用append内置函数操作切片
	slice = append(slice,10)
	var a = []int {1,2,3}
	var b = []int {4,5,6}
	a = append(a,b...)
9.切片拷贝
	s1 := []int{1,2,3,4,5}
	s2 := make([]int,10)
	copy(s2,s1) // copy不会扩容,append会。
	s3 := []int{1,2,3}
	s3 = append(s3,s2...)
	s3 = append(s3,4,5,6)
10.字符串改字符
	s := "hello world"
	s1 := []rune(s) //[]byte(s)
	s1[0] = '0'
	str := string(s1)
	
排序
1.sort.Ints()对证书进行排序
2.sort.String对字符和窜进行排序
3.sort.Float64s对浮点型进行排序
4.sort.SearchInte(a []int,b int)从数组a中查找b。前提是a有序
5.sort.SearchFloats(a []float64,b float64)从数组a中查找b。前提是a有序
7.sort.SearchStrings(a []string,b string)从数组a中查找b。前提是a有序





map
1.key-value的数据结构,又叫字典或关联数组
	a.声明
		var map1 map[keytype]valuetype
		var a map[string]string
		var a map[string]int
		var a map[int]string
		var a map[string]map[string]string
		//声明不会分配内存,初始化需要make
	

锁

1.互斥锁
	sync.Mutex
	var lock sync.Mutex
	func test() {
		var a map[int]int
		a = make(map[int]int)
		a[7] = 10
		a[5] = 10
		a[3] = 10
		a[1] = 10
		for i :=0;i<3;i++{
			go func(b map[int]int){
				lock.Lock()
				b[8] = rand.Intn(100)
				lock.Unlock()
			}(a)
			lock.Lock()
			fmt.Println(a)
			lock.Unlock()
			time.sleep(time.Second)
		} 
	}
2.读写锁
	var mu sync.RWMutex
	go build -race 目录 检测代码是否有冲突

  

    本站是提供个人知识管理的网络存储空间,所有内容均由用户发布,不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息,谨防诈骗。如发现有害或侵权内容,请点击一键举报。

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多
    喜欢该文的人也喜欢 更多

    ×
    ×

    ¥.00

    微信或支付宝扫码支付:

    开通即同意《个图VIP服务协议》

    全部>>