Go语言学习第2关

1. Slice

package main

import "fmt"

func main() {
    
    
	var arr2 [3]int
	fmt.Printf("%v %T\n",arr2,arr2)
	//不指定长度就是切片声明
	var arr1 []int //不推荐
	fmt.Printf("%v %T\n",arr1,arr1)
	var arr3 = []int{
    
    1,2,3}
	fmt.Println(arr3)

	var arr4 []int
	fmt.Println(arr4 == nil) //声明切片但不扩容则默认值为nil

	//切片循环遍历
	var arr0 = []string{
    
    "java","go","c"}
	for _,v := range arr0{
    
    
		fmt.Println(v)
	}

	//基于数组定义切片 同理可以基于切片进行切片
	a := [5]int{
    
    1,2,3,4,5}
	b := a[:] //获取其所有值
	fmt.Printf("%T",b)
	//长度与容量 容量是从第一个元素开始数到底层数组末尾的个数
	s := []int{
    
    1,2,3,4,5,6}
	fmt.Printf("length %d capacity %d\n",len(s),cap(s))
	ss := s[2:]
	fmt.Printf("length %d capacity %d\n",len(ss),cap(ss))

	//make函数创建切片
	var slice1 = make([]int,4,8) //[0 0 0 0]
	slice1[1] = 5
	fmt.Println(slice1)
	//golang不能通过下标给切片扩容
	slice1 = append(slice1, 99,88,77)
	fmt.Println(slice1)
	//append另外的切片
	slice2 := make([]int,3,3)
	slice2[0]=10
	slice1 = append(slice1, slice2...)
	fmt.Println(slice1)

	//复制切片 使用copy函数使副本不受影响
	sliceA := []int{
    
    5,6,7,8}
	sliceB := make([]int,4,4)
	copy(sliceB,sliceA)
	fmt.Println(sliceA,sliceB)
	//删除切片
	sliceA = append(sliceA[:1],sliceA[2:]... ) //删除第2个元素
	fmt.Println(sliceA)
	//排序 sort包 用到再看就ok
}

2. Map

package main

import (
	"fmt"
	"strings"
)

func main(){
    
    
	userinfo := make(map[string]string)
	userinfo["name"] = "zhangsan"
	userinfo["age"] ="20"
	fmt.Println(userinfo)

	var userinfo2 = map[string]string{
    
    
		"name":"wangwu",
		"age":"30",
	}
	fmt.Println(userinfo2)

	//map类型的切片
	user := make([]map[string]string,3,3)
	fmt.Println(user[0]) //map不初始化的值也是nil

	if user[0] == nil{
    
    
		user[0] = make(map[string]string)
		user[0]["name"] = "dou"
		user[0]["age"] = "21" 
	}
	if user[1] == nil{
    
    
		user[1] = make(map[string]string)
		user[1]["name"] = "qi"
		user[1]["age"] = "22" 
	}
	fmt.Println(user)
	
	//值为切片的map
	p := make(map[string][]string)
	p["hobby"] = []string{
    
    
		"eat",
		"sleep",
	}
	p["work"] = []string{
    
    
		"go",
		"solidity",
	}
	fmt.Println(p)

	//e.g. 统计一个句子中单词出现次数
	var str = "how do you do"
	slice := strings.Split(str," ")
	fmt.Println(slice)
	var Map = make(map[string]int)
	for _,v := range slice{
    
    
		Map[v]++
	}
	fmt.Println(Map)
}

3. func–part1

package main

import "fmt"
import "sort"

//标准形式
func sum(x int, y int) int {
    
    
	return x + y
}

//可变参数x是一个切片 若要和固定参数结合使用把固定参数放前面
func sumN(x ...int) int {
    
    
	var sum int
	for _, v := range x {
    
    
		sum += v
	}
	return sum
}

//多返回值
func cal(x, y int) (int, int) {
    
    
	sum := x + y
	sub := x - y
	return sum, sub
}

//封装函数实现切片的排序
func sortS(slice []int) []int {
    
    
	for i := 0; i < len(slice); i++ {
    
    
		for j := i + 1; j < len(slice); j++ {
    
    
			if slice[i] > slice[j] {
    
    
				temp := slice[i]
				slice[i] = slice[j]
				slice[j] = temp
			}
		}
	}
	return slice
}

//实现map对象按key排序
func sortMap(m map[string]string) string {
    
    
	var sliceKey []string
	for k, _ := range m {
    
    
		sliceKey = append(sliceKey, k)
	}
	sort.Strings(sliceKey)
	var str string
	for _, v := range sliceKey {
    
    
		str += fmt.Sprintf("%v=>%v\t", v, m[v])
	}
	return str
}

//自定义函数类型
type calc func(int, int) int

func add(x, y int) int {
    
    
	return x + y
}

//函数作为参数
func calcPro(x, y int, op func(int, int) int) int {
    
    
	return op(x, y)
}

//函数作为返回值
type calType func(int,int) int

func do(o string) calType {
    
    
	switch o {
    
    
	case "*":
		return func(x, y int) int {
    
    
			return x * y
		}
	default:
		return nil
	}
}

func main() {
    
    
	sum := sum(4, 5)
	fmt.Println(sum)
	sumN := sumN(1, 2, 3, 4, 5)
	fmt.Println(sumN)

	fmt.Println(sortS([]int{
    
    2, 6, 3, 9, 4}))
	m1 := map[string]string{
    
    
		"user":   "hi",
		"age":    "20",
		"gender": "man",
	}
	fmt.Println(sortMap(m1))

	var c calc
	c = add
	d := add
	fmt.Printf("%T %T\n", c, d) //main.calc func(int, int) int

	//匿名函数
	j := calcPro(3, 4, func(i1, i2 int) int {
    
    
		return i1 * i2
	})
	fmt.Println(j)

	e := do("*")
	fmt.Println(e(9,9))
}

3. func–part02

package main

import "fmt"

//函数递归
func fn1(n int) {
    
    
	if n > 0 {
    
    
		//fmt.Println(n) 10 9 8 7 ... 1
		n--
		fn1(n)
		fmt.Println(n) // 0 1 2 3 ... 9
	}
}
func sum(n int) int {
    
    
	if n > 1 {
    
    
		return n + sum(n-1)
	} else {
    
    
		return 1
	}
}

/*
闭包:函数里嵌套一个函数 返回其中的函数
i是局部变量不污染全局 但会常驻内存
*/
func adder() func() int{
    
    
	var i = 10
	return func() int{
    
    
		return i+1
	}
}
//defer 延迟处理
func main() {
    
    
	fn1(10)
	fmt.Println(sum(10))

	fmt.Println(1)
	defer fmt.Println(2)
	defer fmt.Println(3)
}