package main
​
import (
    "encoding/json"
    "fmt"
)
​
// 自定义类型
type myint int
​
// 自定义类型+自定义方法
func (m myint) add(n myint) myint {
    return m + n
}
​
// 类型别名
type myint2 = int
​
// 结构体
type person struct {
    name string
    age  int
}
​
// 结构体 匿名字段 类型必须唯一
type person2 struct {
    string
    int
}
type person22 struct {
    name2 string
    age2  int
}
​
// 结构体 里面有切片 map 结构体
type person3 struct {
    name    string
    age     int
    hobbies []string
    books   map[string]int
    attr    person
    //匿名结构体 嵌套 相当于继承person22的属性包括方法
    person2
    person22
}
​
// 结构体转json 里面的字段必须大写 因为私有属性不能json化
type Person4 struct {
    //struct tag 自定义json key
    Name string `json:"name"`
    Age  int    `json:"age"`
}
​
// 结构体的方法
func (p person) sayHello() {
    fmt.Printf("Hello, my name is %s, I am %d years old.\n", p.name, p.age)
}
​
// 结构体指针修改值
func (p *person) sayHello2(name string, age int) {
    p.name = name
    p.age = age
}
func main() {
    a := 10
    b := &a //指针变量 *int 指针类型
    //%p 打印变量的地址  &a 取a的地址 *b 取指针b指向的值
    fmt.Printf("a的值是：%d,类型是：%T,地址是：%p,b的值是：%v,类型是：%T,地址是：%p,b指向的值是：%d\n", a, a, &a, b, b, &b, *b)
    *b = 20 //修改指针指向的值
    fmt.Printf("a的值是：%d,类型是：%T,地址是：%p,b的值是：%v,类型是：%T,地址是：%p,b指向的值是：%d\n", a, a, &a, b, b, &b, *b)
    //引用数据类型 声明需要分配内存
    //new()函数 得到指针变量
    zz := new(int)   //声明指针变量 指向int类型 分配内存
    zz2 := new(bool) //声明指针变量 指向bool类型 分配内存
    fmt.Printf("zz的值是：%v,类型是：%T,对应值：%v,zz2的值是：%v,类型是：%T,对应值：%v\n", zz, zz, *zz, zz2, zz2, *zz2)
    //make()函数 用于创建切片、map、通道内存创建
    s := make([]int, 5) //创建切片 长度为5
    fmt.Printf("s的值是：%v,类型是：%T,地址是：%p\n", s, s, &s)
    m := make(map[string]int) //创建map
    fmt.Printf("m的值是：%v,类型是：%T,地址是：%p\n", m, m, &m)
    c := make(chan int) //创建通道
    fmt.Printf("c的值是：%v,类型是：%T,地址是：%p\n", c, c, &c)
    //自定义类型
    mi := myint(10)
    fmt.Printf("mi的值是：%v,类型是：%T\n", mi, mi)
    //调用自定义方法
    rmi := mi.add(20)
    fmt.Printf("rmi的值是：%v,类型是：%T\n", rmi, rmi)
    //类型别名
    mi2 := myint2(20)
    fmt.Printf("mi2的值是：%v,类型是：%T\n", mi2, mi2)
    //结构体
    p := person{"Tom", 20}
    fmt.Printf("p的值是：%v,类型是：%T\n", p, p)
    //%#v 打印变量的详细信息
    fmt.Printf("p的值是：%#v,类型是：%T\n", p, p)
    p2 := new(person) //声明指针变量 指向person类型 分配内存
    p2.name = "Jerry"
    p2.age = 25
    fmt.Printf("p2的值是：%#v,类型是：%T\n", p2, p2)
    p3 := &person{"Lily", 30} //声明指针变量 指向person类型 分配内存
    fmt.Printf("p3的值是：%#v,类型是：%T\n", p3, p3)
    p3.age = 35 //修改指针指向的值
    fmt.Printf("p3的值是：%#v,类型是：%T\n", p3, p3)
    p4 := person{name: "Mary", age: 40}
    fmt.Printf("p4的值是：%#v,类型是：%T\n", p4, p4)
    p5 := &person{name: "Lucy", age: 45}
    fmt.Printf("p5的值是：%#v,类型是：%T\n", p5, p5)
    //不指定变量 则使用默认值
    p6 := person{name: "Lucy"}
    fmt.Printf("p6的值是：%#v,类型是：%T\n", p6, p6)
    //调用结构体的方法
    p4.sayHello()
    //修改结构体指针指向的值
    p4.sayHello2("Mary2", 50)
    fmt.Printf("p4的值是：%#v,类型是：%T\n", p4, p4)
    p7 := person3{name: "Tom", age: 20, hobbies: []string{"reading", "swimming", "running"}, books: map[string]int{"book1": 100, "book2": 200}, attr: person{name: "Jerry", age: 25}, person2: person2{"person2", 100}, person22: person22{name2: "person22", age2: 100}}
    fmt.Printf("p7的值是：%#v,类型是：%T\n", p7, p7)
    var p8 person3
    p8.name = "Tom"
    p8.age = 25
    p8.hobbies = make([]string, 3)
    p8.hobbies[0] = "reading"
    p8.hobbies[1] = "swimming"
    p8.hobbies[2] = "running"
    p8.books = make(map[string]int)
    p8.books["book1"] = 100
    p8.books["book2"] = 200
    p8.attr.name = "Jerry"
    p8.attr.age = 25
    p8.person2.string = "person2"
    p8.person2.int = 100
    //匿名变量 名字唯一 可以直接赋值; 名字重复 先赋值外层变量,同级都有就回报错
    p8.name2 = "person22"
    p8.age2 = 100
    fmt.Printf("p8的值是：%#v,类型是：%T\n", p8, p8)
    person4 := Person4{Name: "Tom", Age: 20}
    fmt.Printf("person4的值是：%#v,类型是：%T\n", person4, person4)
    //结构体转json 返回字节数组
    j, _ := json.Marshal(person4)
    //string()函数 字节数组转字符串
    jsonstr := string(j)
    fmt.Println(jsonstr)
    var p9 Person4
    //json字符串转结构体 第一个参数是json字符串的字节切片  第二个参数是结构体指针
    err := json.Unmarshal([]byte(jsonstr), &p9)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Printf("p9的值是：%#v,类型是：%T\n", p9, p9)
}
​

延伸阅读

golang使用gorm 操作数据库

golang连接数据库 增删改查以及事物

学习golang(九)

学习golang(三)

学习golang(十一)