go学习笔记

1.go数据类型

2.声明变量

var 声明可以不加类型但是必须初始化，不初始化就要声明变量类型；
：=的用法：

3.常量

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
const identifier [type] = value
你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

显式类型定义： const b string = “abc”
隐式类型定义： const b = “abc”

常量的枚举：
const (
Unknown = 0
Female = 1
Male = 2
)

Go 没有三目运算符，所以不支持 ?: 形式的条件判断。

4.函数

Go 语言函数定义格式如下：

5.占位符的使用

6.go指针

指针和c语言里面的一样，就是一种存储空间地址值的一个变量类型
他的声明，赋值，访问看下图：

指针数组：数据类型为指针的数组

指针作为函数参数
在这之前要对比 * 和 & 区别
& 是取地址符号 , 即取得某个变量的地址 , 如 ; &a

• 在后面加指针变量，表示取出(访问)该地址存储的值
  用于声明是指针变量，后面加数据类型，例如int,表示int型指针

go没有while只有for

第一种 只是用作循环问题
1.和java的for一样用


2.像java的while一样用

第二种：和range关键字一起用遍历数组，map等

go语法的左上角和右上角两点

`` 语法 理解为不转译字符串的意思，可以json yaml 等一起使用。

主要使用在结构体里面，

1. -：不要解析这个字段

2. omitempty：当字段为空（默认值）时，不要解析这个字段。比如false、0、nil、长度为 0 的 array，map，slice，string

3.FieldName：当解析 json 的时候，使用这个名字

参考：添加链接描述

package main

import (
    "encoding/json"
    "fmt"
)

type Student struct {
    StudentId      string `json:"sid"`
    StudentName    string `json:"sname"`
    StudentClass   string `json:"class"`
    StudentTeacher string `json:"teacher"`
}

type StudentNoJson struct {
    StudentId      string
    StudentName    string
    StudentClass   string
    StudentTeacher string
}

type StudentWithOption struct {
StudentId      string //默认使用原定义中的值
StudentName    string `json:"sname"`// 解析（encode/decode） 的时候，使用 `sname`，而不是 `Field`
StudentClass   string `json:"class,omitempty"`// 解析的时候使用 `class`，如果值为空，就忽略它
StudentTeacher string `json:"-"`// 解析的时候忽略该字段。默认情况下会解析这个字段，因为它是大写字母开头
}

func main() {
    //NO.1 with json struct tag
    s := &Student{StudentId: "1", StudentName: "fengxm", StudentClass: "0903", StudentTeacher: "feng"}
    jsonString, _ := json.Marshal(s)

    fmt.Println(string(jsonString))
    //{"sid":"1","sname":"fengxm","class":"0903","teacher":"feng"}
    newStudent := new(Student)
    json.Unmarshal(jsonString, newStudent)
    fmt.Println(newStudent)
    //&{1 fengxm 0903 feng}
    //Unmarshal 是怎么找到结构体中对应的值呢？比如给定一个 JSON key Filed，它是这样查找的：
    // 首先查找 tag 名字（关于 JSON tag 的解释参看下一节）为 Field 的字段
    // 然后查找名字为 Field 的字段
    // 最后再找名字为 FiElD 等大小写不敏感的匹配字段。
    // 如果都没有找到，就直接忽略这个 key，也不会报错。这对于要从众多数据中只选择部分来使用非常方便。

    //NO.2 without json struct tag
    so := &StudentNoJson{StudentId: "1", StudentName: "fengxm", StudentClass: "0903", StudentTeacher: "feng"}
    jsonStringO, _ := json.Marshal(so)

    fmt.Println(string(jsonStringO))
    //{"StudentId":"1","StudentName":"fengxm","StudentClass":"0903","StudentTeacher":"feng"}

    //NO.3 StudentWithOption
    studentWO := new(StudentWithOption)
    js, _ := json.Marshal(studentWO)

    fmt.Println(string(js))
    //{"StudentId":"","sname":""}

    studentWO2 := &StudentWithOption{StudentId: "1", StudentName: "fengxm", StudentClass: "0903", StudentTeacher: "feng"}
    js2, _ := json.Marshal(studentWO2)

    fmt.Println(string(js2))
    //{"StudentId":"1","sname":"fengxm","class":"0903"}
}

接口interface要写一个结构体去实现它

interface是一组method的组合，我们通过interface来定义对象的一组行为

通道数据类型通常用于和并发goroutine一起使用，<-箭头方向表示数据流向

通道（channel）是用来传递数据的一个数据结构。

通道可用于两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。操作符 <- 用于指定通道的方向，发送或接收。如果未指定方向，则为双向通道。

通道类型创建：
声明一个通道很简单，我们使用chan关键字即可，通道在使用前必须先创建：

ch := make(chan int)

使用注意：默认情况下，通道是不带缓冲区的。发送端发送数据，同时必须有接收端相应的接收数据。

go函数调用参数地址问题

自定义参数类型对象变量传入前后地址不一样，无法改变赋值变量内容，切片，map函数调用传入默认是指针类型

type User struct {
	Id int
	Name string
}

type ID int64
type IntArray []int

func px(arr []string,u *User,sl []User,m map[int]string)  {
	//sort.Sort(arr)
	u.Name=""
	fmt.Println("px函数中u1地址-",&u.Id)
	sl[0].Name=""
	sort.Strings(arr)
	m[1]=""
}
func px2(arr []string,u User,sl []User)  {
	//sort.Sort(arr)
	fmt.Println("px2函数中u2地址-",&u.Id)
	u.Name=""
	sl[0].Name=""
	sort.Strings(arr)

}
func main()  {
	ss:=[]string{"aaa","cccc","bb"}
	u1:=User{
		Id:1,
		Name:"xiaoxioa",
	}
	u2:=User{
		Id:1,
		Name:"xiaoxioa",
	}
	sll:=[]User{
		{
			Id:2,
			Name:"da",
		},
		{
			Id:3,
			Name:"ca",
		},
	}
	k:=1
	fmt.Println(&k)
	mm:=map[int]string{1:"map值"}
	px(ss,&u1,sll,mm)
	px2(ss,u2,sll)
	fmt.Println(u1)
	fmt.Println("主函数中u2地址-和u2值-",&u2.Id,u2)
	fmt.Println("主函数中u1地址-和u2值-",&u1.Id,u2)
	fmt.Println(sll)
	fmt.Println("map："+mm[1])
	fmt.Println(320168%16)