Go 常用语法总结

Go 常用语法总结

1.字符串修改

s2 := "白萝卜" //修改字符串
s3 := []rune(s2) //rune为utf8类型主要用于汉字等
s3[0] = '红'//单独字符修改
fmt.Println(s3)//把rune切片强悍强制转换成字符串
//单独字符'h'为int32类型
//字符串为string类型

2. for

for _, c := range s{
    //_返回的是索引，c返回字符
}

3.数组定义

var a [3]string = [3]string{"nihao", "jhj", "ir"} 
var q [3]int = [3]int{1, 2, 3}
var r [3]int = [3]int{1, 2}

q := [3]int{1, 2, 3}

a := [2]int{1, 2}
b := [...]int{1, 2}
c := [2]int{1, 3}
fmt.Println(a == b, a == c, b == c)

4.多维切片

// 声明一个二维整型切片并赋值
slice := [][]int{{10}, {100, 200}}
// 为第一个切片追加值为 20 的元素
slice[0] = append(slice[0], 20)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x9vvtYLe-1582596052042)(H:\笔记\This is day01.assets\image-20200219101548016.png)]

5.MAP && sync.map

var mapLit map[string]int //声明map
S：=make(map[string]int)
S["hello"] = 1
for i,j := range S{
    fmt.Println(i,j)
}
delete(S,"hello")
 
var scene sync.Map
    // 将键值对保存到sync.Map
   
scene.Store("greece", 97)    
scene.Store("london", 100)    
scene.Store("egypt", 200)
    // 从sync.Map中根据键取值
fmt.Println(scene.Load("london"))
scene.Delete("london")
scene.Range(func(k, v interface{}) bool {} //遍历map中所有值

6.list 列表(链表)

//列表声明
import	"container/list"
l := list.new()
	l := list.New()
	l.PushBack("hello")
	l.PushFront("nihao")
	e := l.PushBack("...")
	l.InsertAfter("1", e)
	l.InsertBefore("2", e)
	for i := l.Front(); i != nil; i = i.Next() {
		fmt.Println(i.Value)
	}

7.NIL

nil 是 map、slice、pointer、channel、func、interface 的零值

8. new&&make

8.1 new

type stu struct{
    name string 
    age int 
}
s := new(stu)
s.name  = "hello"
fmt.Println(s.name)
fmt.Println(s) // 输出位 &("hello",0)
// new(类型)输出位指针/地址

8.2 make

注意：make 函数只用于 map，slice 和 channel，并且不返回指针。如果想要获得一个显式的指针，可以使用 new 函数进行分配，或者显式地使用一个变量的地址。

9.字符串切割

// 字符串按照空格进行切割得到切片
s3 := "how do you do"
s4 := strings.split(s3," ")
//判断出字符串中字符的出现数量
m1 := make(map[string]int)
for _,k := range s4 {
    if _,h := m1[k] ; !h {
        m1[k] = 1;
    }else{
        m1[k]++
    }
}
// 保存在map中
//

10. make() 函数构造切片

a := make([]int, 2)
b := make([]int, 2, 10)

11. 回文测试

	s5 := "a你好好你a"
	r := make([]rune, 0, len(s5))  //rune相当于int32
	for _, c := range s5 {
		r = append(r, c)
	}
	fmt.Println(len(r))   //len(s5)为14字节，所以将s5切片保存，即为6
	fmt.Println(r)
	fmt.Println(s5)
	for u := 0; u < len(r)/2; u++ {
		if r[u] != r[len(r)-1-u] {
			fmt.Println("不是会问")
			return
		}
	}
	fmt.Println("是胡文")
}

12. 函数可变参数&&命名返回值

func f5(title string,y ...int)int{ // y ...int 是一组可变参数 int类型的切片
    fmt.Println(y)
    return 1
}
f5("hello",1,2,3,4,5,6,7,8)

func f6(x,y int)(sum int){ //sum已经声明
    sum = x+y
    return 
}                   

13. defer

//延迟执行，放入延迟调用栈
defer fmt.Println("hello") // 依次入栈。函数退出前执行多个执行 按照LIFO顺序延迟执行
defer fmt.Println("hi")

go语言中 return不是原子操作，而是分为两步操作，第一步为返回值赋值，第二部为defer，第三步为RET返回

14. 作用域

全局变量
局部变量
块作用域变量，只在块内使用

15. 匿名函数

   func(data int) {
        fmt.Println("hello", data)
    }(100)

16. time()

func test() {
    start := time.Now() // 获取当前时间
    sum := 0
    for i := 0; i < 100000000; i++ {
        sum++
    }
    elapsed := time.Now().Sub(start)
    elapsed := time.Since(start)
    
    fmt.Println("该函数执行完成耗时：", elapsed)

17. 结构体

(1)实例化初始化

type Point struct {
    X int
    Y int
}
var p Point   //实例化
p.X = 10
p.Y = 20

add := new(Point) //指针类型
add.X = 10
add.Y = 20
//在Go语言中，访问结构体指针的成员变量时可以继续使用.，这是因为Go语言为了方便开发者访问结构体指针的成员变量，使用了语法糖（Syntactic sugar）技术，将 ins.Name 形式转换为 (*ins).Name。

ins := &Point{} //取结构体地址实例化
ins.X = 10
ins.Y = 20

//最广泛地的实例化方式

func newCommand(name string, varref *int, comment string) *Command {
    return &Command{
        Name:    name,
        Var:     varref,
        Comment: comment,
    }
}

cmd = newCommand(
    "version",
    &version,
    "show version",
)