go基础语法（爬坑）

go结构体命名和变量命名不冲突

package main

import "fmt"

type user struct {
   name string
   age  int
   sex  bool
}

type admin struct {
   user       user
   priviledge int
}

func main() {
   admin := admin{
       user{"张三", 10, false},
       1,
   }
   fmt.Printf("%v",admin)
}

变量通过type别名后不能转换类型

import "fmt"

type Duration int64 
func main()  {
    var dur Duration
    dur = int64(1000)
    fmt.Print(dur)
}

方法中对象值传递和引用传递都可以 但注意两者区别 值传递并不会改变原对象的属性

package main

import "fmt"

type Person struct {
    name string
    age int
}
func main()  {
    xiaoming := Person{
        "小明",
            10,
    }
    xiaoming.say("Hello World")
    fmt.Printf("%v",xiaoming)
}

func(person *Person) say(word string)  {
    fmt.Printf("%v",word)
    person.age++
}

接口传入时 执行方向 方法接收者类型和方法调用者类型应该一致

package main

import "fmt"

type notifier interface {
    notify()
}

type user1 struct {
    name  string
    email string
}

func (u *user1) notify() {
    fmt.Printf("Hello,%s %s", u.name, u.email)
}

func main() {
    xiaoming := user1{
        "xiaoming",
        "admin@xiaoming.com",
    }
    xiaoming.notify()
    sentNotify(&xiaoming)
}

func sentNotify(u notifier)  {
        u.notify()
}

包引入中如果定义类型名为小写 在引入该包的其他包中无法使用该类型 如果为大写则可以使用该类型 跨包的结构体的属性也遵循这一规则

go语言中协程之间对全局变量的修改不会同步 必须引入原子性sync/atomic函数或者mux锁进行解决

return中运算与defer的顺序

先执行defer后的运算，再执行return中的运算，最后执行defer内的运算

package main

import "fmt"

func add(x, y int) (z int) {
    defer func() {
        z += 100
        fmt.Println(z)
    }()
    z = x + y
    fmt.Println(z)
    return z + 200
}

func main() {
    fmt.Println(add(1, 2))
}