go语言上手｜青训营笔记这是我参与「第三届青训营 -后端场」笔记创作活动的的第1篇笔记包含golang标识符，关键

这是我参与「第三届青训营 -后端场」笔记创作活动的的第1篇笔记

如何编写golang代码

代码组织

go应用使用包和模块来组织代码，包对应文件系统就是文件夹，模块就是.go的go源文件。一个包中会有多个模块，或者多个子包。

go项目管理工具

早期用gopath管理项目，不方便而且容易出错。现在用gomod或者一些第三方模块

实现步骤

创建项目
初始化项目
创建包
创建模块
相互调用

golang标识符，关键字，命名规则

标识符

给变量常量函数方法结构体数组切片接口起名的字

标识符的组成

标识符有数字字母下划线组成
只能以字母下划线开头
区分大小写

golang变量

声明之后必须使用

var identifier type

var：声明变量的关键词

identifier：变量的名称

type：变量的状态

func main() {
    var name string
    fmt.Printf("name: %v\n", name)

    var(
        age int
        married bool
    )

    age = 120
    married = true
    fmt.Printf("age: %v\n", age)
    fmt.Printf("married: %v\n", married)

}

变量的初始化：

func main() {

    var name string ="老张"
    var site string ="www.qq.com"
    var age int = 20

}

类型的判断

func main() {

    //类型的推断
    var name="tom"
    var age=20
    var b = true
    
    fmt.Printf("name: %v\n", name)
    fmt.Printf("age: %v\n", age)
    fmt.Printf("b: %v\n", b)

}

初始化多个变量

func main() {

    var name,site,age = "老张" ,"www.qq.com",30
    fmt.Printf("name: %v\n", name)
    fmt.Printf("site: %v\n", site)
    fmt.Printf("age: %v\n", age)

}

func main() {

    //短变量申明
    name:= "tom"
    age:="20"
    b:=true

    fmt.Printf("name: %v\n", name)
    fmt.Printf("age: %v\n", age)
    fmt.Printf("b: %v\n", b)

}

匿名变量：

func getNameAndAge()(string,int){
    return "tom",20
}


func main() {

    name,age :=getNameAndAge()
    fmt.Printf("name: %v\n", name)
    fmt.Printf("age: %v\n", age)

}

go语言的常量

编译阶段确定，程序运行是无法改变该值

const constantName [type] = value

实例：

    const PI float64 =3.14
    const PI2 = 3.1415
    fmt.Printf("PI: %v\n", PI)

    const(
        a = 100
        b = 200
    )

    const w,h =200,300

iota

iota比较特殊，可以被认为是一个可被编译器修改的常量，默认值是0，每调用一次加一。遇到const关键字是被重置为0

实例：

func main() {

    const (
        a1 = iota  //0
        a2 = iota  //1
        a3 = iota  //2
    )

    fmt.Printf("a1: %v\n", a1)
    fmt.Printf("a2: %v\n", a2)
    fmt.Printf("a3: %v\n", a3)

}

跳过：

func main() {
    const (
        a1 = iota  //0
        _  //1
        a3 = iota  //2
    )
}

中间插队的情况：


func main() {

    const (
        a1 = iota  //0
        a2 = 100
        a3 = iota  //2
    )


}

函数的使用

func add2(n int){
    n+=2     //无法修改成功   传入的是一个拷贝
}

func add2ptr(n *int){
    *n+=2       //需要用指针传
}


func main() {
    n:=5
    add2(n)
    fmt.Println(n)
    add2ptr(&n)
    fmt.Println(n)
}

结构体的使用

type user struct {
    name     string
    password string
}

func main() {
    a := user{name: "zhang", password: "123456"}
    b := user{name: "zhangzheng", password: "123456"}
    c := user{name: "jisoo"}
    c.password = "123456" //依然可以用变量.属性的格式 对变量进行复制和使用

    var d user
    d.name = "zhangzheng"
    d.password = "123456"

    fmt.Println(a, b, c, d)
    fmt.Println(checkPassword(a,"123456"))
    fmt.Println(checkPassword2(&a,"123456"))
    fmt.Println()


    d.resetPassword("zhagnzhegn")
    fmt.Printf("d: %v\n", d)

}



func checkPassword(u user,password string)bool{
    return u.password==password
}

func checkPassword2(u *user,password string) bool {     //传入指针可以对属性进行修改 而且避免了大结构体的拷贝
    return u.password==password
}


//结构体的方法  类似于类成员函数
func (u user) checkPassword3(password string) bool{
    return u.password==password
}

func (u *user) resetPassword(password string){
    u.password=password
}

go语言上手 ｜ 青训营笔记