goang基础知识小全

1.自动立即回收。
2.更丰富的内置类型。
3.函数多返回值。
4.错误处理。
5.匿名函数和闭包。
6.类型和接口。
7.并发编程。
8.反射。
9.语言交互性。

1）首字符可以是任意的Unicode字符或者下划线
2）剩余字符可以是Unicode字符、下划线、数字
3）字符长度不限

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

Constants:    true  false  iota  nil
Types:    int  int8  int16  int32  int64  
          uint  uint8  uint16  uint32  uint64  uintptr
          float32  float64  complex128  complex64
          bool  byte  rune  string  error
Functions:   make  len  cap  new  append  copy  close  delete
             complex  real  imag
             panic  recover

1）声明在函数内部，是函数的本地值，类似private
2）声明在函数外部，是对当前包可见(包内所有.go文件都可见)的全局值，类似protect
3）声明在函数外部且首字母大写是所有包可见的全局值,类似public

var apiClient
var URLString
var isExist bool
var hasConflict bool
var canManage bool
var allowGitHook bool

const todayNews = "Hello"
// 如果超过了一个常量应该用括号的方法来组织
const (
  systemName = "What"
  sysVal = "dasdsada"
)

const APP_URL = "https://www.baidu.com"

type Scheme string
const (
    HTTP  Scheme = "http"
    HTTPS Scheme = "https"
)

type Reader interface {
    Read(p []byte) (n int, err error)
}
两个函数的接口名综合两个函数名，如:
type WriteFlusher interface {
    Write([]byte) (int, error)
    Flush() error
}
三个以上函数的接口名类似于结构体名，如:
type Car interface {
    Start() 
    Stop()
    Drive()
}

type MainConfig struct {
    Port string `json:"port"`
    Address string `json:"address"`
}
config := MainConfig{"1234", "123.221.134"}

type A struct{}
func (a *A) methodA() {
}
func (a *A) methodB() {
  a.methodA()
}

// 注释一律使用双斜线， 对象暴露的方法
func (*fileDao) AddFile(file *model.File) bool {
  result := db.NewRecord(*file)
  if result {
   db.Create(file)
  }
  return result
}
// 不需要给包外访问的函数如下
func removeCommaAndQuote(content string) string {
  re, _ := regexp.Compile("[\\`\\,]+")
  return strings.TrimSpace(re.ReplaceAllString(content, ""))
}

var 变量名 变量类型

var name string
var age int
var isOk bool

var (
    a string
    b int
    c bool
    d float32
)

var 变量名 类型 = 表达式

var name string = "pprof.cn"
var sex int = 1

var name, sex = "pprof.cn", 1

var name = "pprof.cn"
var sex = 1

package main
import (
    "fmt"
)
// 全局变量m
var m = 100
func main() {
    n := 10
    m := 200 // 此处声明局部变量m
    fmt.Println(m, n)
}

函数外的每个语句都必须以关键字开始（var、const、func等）
:=不能使用在函数外。
_多用于占位，表示忽略值。

const pi = 3.1415
const e = 2.7182

const (
    pi = 3.1415
    e = 2.7182
)

const (
    n1 = 100
    n2
    n3
)

const (
        n1 = iota //0
        n2        //1
        n3        //2
        n4        //3
    )

const (
        n1 = iota //0
        n2        //1
        _
        n4        //3
    )

const (
        n1 = iota //0
        n2 = 100  //100
        n3 = iota //2
        n4        //3
    )
const n5 = iota //0

const (
        _  = iota
        KB = 1 << (10 * iota)
        MB = 1 << (10 * iota)
        GB = 1 << (10 * iota)
        TB = 1 << (10 * iota)
        PB = 1 << (10 * iota)
    )

const (
        a, b = iota + 1, iota + 2 //1,2
        c, d                      //2,3
        e, f                      //3,4
    )

算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符

+ 相加
  - 相减
  * 相乘
  / 相除
  % 求余

==  检查两个值是否相等，如果相等返回 True 否则返回 False。
!=  检查两个值是否不相等，如果不相等返回 True 否则返回 False。
> 检查左边值是否大于右边值，如果是返回 True 否则返回 False。
>=  检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
< 检查左边值是否小于右边值，如果是返回 True 否则返回 False。
<=  检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。

&&  逻辑 AND 运算符。 如果两边的操作数都是 True，则为 True，否则为 False。
|| 逻辑 OR 运算符。 如果两边的操作数有一个 True，则为 True，否则为 False。
! 逻辑 NOT 运算符。 如果条件为 True，则为 False，否则为 True。

& 参与运算的两数各对应的二进位相与。（两位均为1才为1）
  l 参与运算的两数各对应的二进位相或。（两位有一个为1就为1）
  ^ 参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。（两位不一样则为1）
  <<  左移n位就是乘以2的n次方。“a<<b”是把a的各二进位全部左移b位，高位丢弃，低位补0。
  >>  右移n位就是除以2的n次方。“a>>b”是把a的各二进位全部右移b位。

= 简单的赋值运算符，将一个表达式的值赋给一个左值
  +=  相加后再赋值
  -=  相减后再赋值
  *=  相乘后再赋值
  /=  相除后再赋值
  %=  求余后再赋值
  <<= 左移后赋值
  >>= 右移后赋值
  &=  按位与后赋值
  l=  按位或后赋值
  ^=  按位异或后赋值

func Scan(a ...interface{}) (n int, err error)

func Scanf(format string, a ...interface{}) (n int, err error)

func Scanln(a ...interface{}) (n int, err error)

func main() {
  var (
    name    string
    age     int
    married bool
  )
  fmt.Scanln(&name, &age, &married)
  fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
}

张三 19 false
扫描结果 name:张三 age:19 isMale:false

os.Stdin指向标准输入文件/dev/stdin，即os.Stdin是标准输入文件/dev/stdin的指针

func main() {
   reader := bufio.NewReader(os.Stdin) // 从标准输入生成读对象
   fmt.Print("请输入内容：")
   text, _ := reader.ReadString('\n') // 读到换行
   text = strings.TrimSpace(text)
   fmt.Printf("%#v\n", text)
}

func Fscan(r io.Reader, a ...interface{}) (n int, err error)
func Fscanln(r io.Reader, a ...interface{}) (n int, err error)
func Fscanf(r io.Reader, format string, a ...interface{}) (n int, err error)

func Sscan(str string, a ...interface{}) (n int, err error)
func Sscanln(str string, a ...interface{}) (n int, err error)
func Sscanf(str string, format string, a ...interface{}) (n int, err error)

func Print(a ...interface{}) (n int, err error)

func Fprint(w io.Writer, a ...interface{}) (n int, err error)
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)
func Fprintln(w io.Writer, a ...interface{}) (n int, err error)

func Sprint(a ...interface{}) string
func Sprintf(format string, a ...interface{}) string
func Sprintln(a ...interface{}) string

s1 := fmt.Sprint("沙河小王子")
name := "沙河小王子"
age := 18
s2 := fmt.Sprintf("name:%s,age:%d", name, age)
s3 := fmt.Sprintln("沙河小王子")
fmt.Println(s1, s2, s3)

%v  值的默认格式表示
  %+v 类似%v，但输出结构体时会添加字段名
  %#v 值的Go语法表示
  %T  打印值的类型
  %%  百分号

fmt.Printf("%v\n", 100)
  fmt.Printf("%v\n", false)
  o := struct{ name string }{"小王子"}
  fmt.Printf("%v\n", o)
  fmt.Printf("%+v\n", o)
  fmt.Printf("%#v\n", o)
  fmt.Printf("%T\n", o)
  fmt.Printf("100%%\n")

100
false
{小王子}
{name:小王子}
struct { name string }{name:"小王子"}
struct { name string }
100%

%t  true或false

n := 65
fmt.Printf("%b\n", n)
fmt.Printf("%c\n", n)
fmt.Printf("%d\n", n)
fmt.Printf("%o\n", n)
fmt.Printf("%x\n", n)
fmt.Printf("%X\n", n)

1000001
A
65
101
41
41

%b  无小数部分、二进制指数的科学计数法，如-123456p-78
    %e  科学计数法，如-1234.456e+78
    %E  科学计数法，如-1234.456E+78
    %f  有小数部分但无指数部分，如123.456
    %F  等价于%f
    %g  根据实际情况采用%e或%f格式（以获得更简洁、准确的输出）
    %G  根据实际情况采用%E或%F格式（以获得更简洁、准确的输出）

f := 12.34
fmt.Printf("%b\n", f)
fmt.Printf("%e\n", f)
fmt.Printf("%E\n", f)
fmt.Printf("%f\n", f)
fmt.Printf("%g\n", f)
fmt.Printf("%G\n", f)

6946802425218990p-49
1.234000e+01
1.234000E+01
12.340000
12.34
12.34

%s  直接输出字符串或者[]byte
%q  该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示
%x  每个字节用两字符十六进制数表示（使用a-f)
%X  每个字节用两字符十六进制数表示（使用A-F）

s := "小王子"
fmt.Printf("%s\n", s)
fmt.Printf("%q\n", s)
fmt.Printf("%x\n", s)
fmt.Printf("%X\n", s)

小王子
"小王子"
e5b08fe78e8be5ad90
E5B08FE78E8BE5AD90

%p  表示为十六进制，并加上前导的0x

占位符 说明
%f  默认宽度，默认精度
%9f 宽度9，默认精度
%.2f  默认宽度，精度2
%9.2f 宽度9，精度2
%9.f  宽度9，精度0

’+’ 总是输出数值的正负号；对%q（%+q）会生成全部是ASCII字符的输出（通过转义）；
      ’ ‘ 对数值，正数前加空格而负数前加负号；对字符串采用%x或%X时（% x或% X）会给各打印的字节之间加空格
      ’-’ 在输出右边填充空白而不是默认的左边（即从默认的右对齐切换为左对齐）；
      ’#’ 八进制数前加0（%#o），十六进制数前加0x（%#x）或0X（%#X），指针去掉前面的0x（%#p）对%q（%#q），对%U（%#U）会输出空格和单引号括起来的go字面值；
      ‘0’ 使用0而不是空格填充，对于数值类型会把填充的0放在正负号后面；

// 当前程序的包名
package main
// 导入其他包
import . "fmt"
// 常量定义
const PI = 3.14
// 全局变量的声明和赋值
var name = "gopher"
// 一般类型声明
type newType int
// 结构的声明
type gopher struct{}
// 接口的声明
type golang interface{}
// 由main函数作为程序入口点启动
func main() {
    Println("Hello World!")
}

bool
    string
    Numeric Types
    int8,int16,int32,int64,int
    uint8,uint16,uint32,uint64,uint
    float32,float64
    complex64,complex128
    byte
    rune

int8 有符引8位整型(-128到127) 长度:8bit
      int16 有符号16位整型(-32768到32767)
      int32 有符号32位整型(-2147483648到2147483647)
      int64 有符号64位整型(-9223372036854775808到9223372036854775807)
      uint8 无符号8位整型(0到255) 8位都用于表示数值
      uint16 无符号16位整型(O到65535)
      uint32 无符号32位整型(0到4294967295)
      uint64 无符号64位整型(O到18446744073709551615)

float32 IEEE-75432位浮点型数
      float64 lEEE-75464位浮点型数

complex64 32位虚数和实数
      complex128 64位虚数和实数

byte 类似uint8
      rune 类似int32
      uint 32位或64位
    uintptr 无符号整型，用于存放一个指针

var arr [10]int

var arr [10]int 
var arr [10]int = [10]int{1,2,3,4}//（初始化部分元素值，其他值均为0）
arr := [10]int{1,2,3,4}
arr := [10]int{1,2,3,4,6:8}//(6:8 表示下标为6的赋值为8)
arr := [...]int{1,2}
fmt.Println(arr)//[1 2]  //（使用自动类型推导可以根据元素个数创建数组）
fmt.Printf("%T",arr)//[2]int

var a [3][2]int
a = [3][2]int{[2]int{1, 2}, [2]int{3, 4}, [2]int{5, 6}}

import (
  "math/rand"
  "time"
)
rand.Seed(time.Now().UnixNano())
for i:=0;i<10;i++{
  fmt.Println(rand.Intn(123))
}

var s []int

make([]T,size,cap)

a := make([]int, 8,10)

a := make([]int, 8)
a[0] = 1

s1 := []string{"北京", "上海", "深圳"}
    //s1[3] = "广州" //错误的写法会导致编译错误:索引越界
    ss := []string{"武汉","西安","苏州"}
    s1 = append(s1, ss...)//...表示拆开

// 从切片中删除元素
a := []int{30, 31, 32, 33, 34, 35, 36, 37}
//要删除索引为3的元素
a = append(a[:3], a[4:]...)
fmt.Println(a) //[30 31 32 34 35 36 37]

func test111(s []int){
  s=append(s, 4,5,6)
  fmt .Printf( "%p\n",s)//0xc0000c2060
  fmt .Println(s)//[1 2 3 4 5 6]
}
func main(){
  s:=[]int{1,2,3}
  fmt.Printf("%p\n",s)//0xc0000ae090
  test111(s)
  fmt.Println(s)//[1 2 3]
}

s = append(s, 2,3,4)

s := make([]int, 5)
s = append(s, 1, 2, 3)
fmt.Println(s)//[0 0 0 0 0 1 2 3]

b := len(a)

fmt.Println(cap(s))

s1:=[]int{1,2,3,4,5}
s2:=make([]int,5)
copy(s2,s1)
copy(s2,s1[1:3])//如果想拷贝切片中的片段，需要使用截取

for i, v := range s {
     fmt.Println(i, v)
  }

var a = make([]int, 5, 10) //创建切片，长度为5，容量为10
fmt.Println(a)//[0 0 0 0 0]
for i := 0; i < 10; i++ {
  a = append(a, i)
}
fmt.Println(a) //[0 0 0 0 0 0 1 2 3 4 5 6 7 8 9]

map[keyType]valueTye

var  ml map[int]string
m :=make(map[int]string,50)//尽量预估数量，避免动态扩容
n := map[string]int{"赵四": 10}

m := map[int]string{1: "hell", 2: "o", 3: "word"}
value, ok := m[1]
if ok == true {
  fmt.Println("m[1] = ", value)
} else {
  fmt.Println("key不存在")
}

m := map[int]string{1: "hell", 2: "o", 3: "word"}
for k,v:=range m{
  fmt.Println(k,v)
}

m := map[int]string{1: "hell", 2: "o", 3: "word"}
delete(m,1)

func demo(m map[int]string) {
  m[102] = "李四"
  m[103] = "王五"
  delete(m, 101)
}
func main() {
  m := make(map[int]string, 1)
  m[101] = "张三"
  demo(m)
  fmt.Println(m)//map[102:李四 103:王五]
}

var arr [20]byte
for i := 0; i < len(arr); i++ {
  fmt.Scanf("%c", &arr[i])
}
m := make(map[byte]int)
for i := 0; i < len(arr); i++ {
  m[arr[i]] ++
}
for k, v := range m {
  if v > 0 {
   fmt.Printf("%c %d\n", k, v)
  }
}

rand.Seed(time.Now().UnixNano())
var scoreMap = make(map[string]int, 200)
for i := 0; i < 100; i++ {
  key := fmt.Sprintf("stu%02d", i)  //生成stu开头的字符串
  value := rand.Intn(100)      //生成0~99的随机整数
  scoreMap[key] = value
}
fmt.Println(scoreMap)
//取出map中的所有key存入切片keys
var keys = make([]string, 0, 280)
for key := range scoreMap {
  keys = append(keys, key)
}
//对切片进行排序
sort.Strings(keys)
//按照排序后的key遍历map
for _,key := range keys {
  fmt.Println(key, scoreMap[key])
}

type Student struct{
id int
name string
}

type Student struct{
  id int
  name,sex string
}
func main(){
  var s Student
  s.name="张三"
  s.id = 1
  s.sex="男"
  var s1 Student = Student{1,"李四"}
  s2:=Student{id:10,name:"李四"}
}

//类构造函数初始化：约定成俗，用new开头
type person struct {
  name string
  age  int
}
//类似构造函数 返回值是结构体 
func newPerson(name string, age int) person {
  return person{
   name: name,
   age:  age,
  }
}
//类似构造函数 返回值是指针
func newPerson2(name string, age int) *person {
  return &person{
   name: name,
   age:  age,
  }
}
p1 := newPerson("张三", 18)
p2 := newPerson2("李四", 9000)
fmt.Println(p1, p2)//{张三 18} &{李四 9000}

s2:=Student{id:10,name:"李四"}
s3 :=s2

s3 :=s2
fmt.Println(s2==s3)//true

var ss [8]Student
ss[0].id=1
ss[0].name = "王五"
var ss []Student//切片

var s5 []Student
s5 = append(s5,Student{10,"赵四"})

m := make(map[int]Student)
m[101] = Student{101, "张三"}
m[102] = Student{102, "李四"}

m := make(map[int][]Student)
m[101] = append(m[101],Student{101, "张"}
          ,Student{102, "王五"})
m[101] = append(m[101],Student{103, "李四"})
fmt.Println(len(m[101]))//3
fmt.Println(m[101])//[{101 张三} {102 王五} {103 李四}]

func test123( student Student){
  student.name= "李逵"
}
func main() {
  stu:=Student{101,"宋江"}
  test123(stu)
  fmt.Println(stu)//{101 宋江}
}

p1 := new(Student)
p1.name = "张三"  //go语言语法糖，会转化成下面那种格式
(*p1).id = 123
fmt.Println(p1)//&{123 张三}
var p2 = &Student{
  name: "李四",
  id:  111,
}
fmt.Println(p2)//&{111 李四}
var p3 = &Student{
  1234,
  "王五",
}
fmt.Println(p3)//&{1234 王五}

//匿名结构体
var s struct {
  name string
  age  int
}

type x struct {
  a int8 // 8bit 一》1byte
  b int8
  c int8
}
func main() {
  m := x{
   a: int8(18),
   b: int8(20),
   c: int8(30),
  }
  fmt.Printf("%p\n", &(m.a))
  fmt.Printf("%p\n", &(m.b))
  fmt.Printf("%p\n", &(m.c))
}

type people struct {
  string
  int
}
func main() {
  var p = people{"张三", 11}
  fmt.Println(p.string)//张三
  fmt.Println(p.int)//11
  fmt.Println(p)//{张三 11}
}

type people struct {
  name string
  age  int
  addr address
}
type address struct {
  province string
  city   string
}
func main() {
  var p = people{
   "张三",
   11,
   address{
     "湖北",
     "武汉",
   }}
  fmt.Println(p) //{张三 11 {湖北 武汉}}
}

type people struct {
  name string
  age  int
  address//将结构体写成匿名嵌套形式，就可以将结构体内的成员当成本结构体的成员直接访问
}
type address struct {
  province string
  city   string
}
func main() {
  var p = people{
   "张三",
   11,
   address{
     "湖北",
     "武汉",
   }}
  fmt.Println(p.province) //湖北 先在自己结构体找这个字段,找不到就去匿名嵌套的结构体中查找该字段
  fmt.Println(p) //{张三 11 {湖北 武汉}}
}

//动物的结构体（模拟动物类）
type animal struct {
  name string
}
//给animal结构体实现一个移动的方法
func (a animal) move() {
  fmt.Printf("%s在动!\n", a.name)
}
//狗的结构体（模拟狗类）
type dog struct {
  id uint8
  animal //anima拥有的方法，dog也有了
}
//给dog结构体实现一个汪汪汪的方法
func (d dog) wang() {
  fmt.Printf("%s叫：汪汪汪\n", d.name)
}
func main() {
  var d = dog{
   1,
   animal{
     "小李子",
   },
  }
  fmt.Println(d.id) //1
  fmt.Println(d.name) //小李子
  fmt.Println(d)    //{1 {小李子}}
  d.move()       //小李子在动!
  d.wang()       //小李子叫：汪汪汪
}

type people1 struct {
  name string
  age  int
  address1//将结构体写成匿名嵌套形式，就可以将结构体内的成员当成本结构体的成员直接访问
}
type address1 struct {
  province string
  city   string
}
func main() {
  var p = people1{
   name: "张单",
   age:  18,
   address1: address1{
     "山东",
     "菏泽",
   },
  }
  fmt.Println(p)//{张单 18 {山东 菏泽}}
  marshal,err := json.Marshal(p)
  fmt.Printf("%#v\n",string(marshal))//"{}"
  fmt.Println(string(marshal))//{}
  fmt.Println(marshal)//[123 125]
  fmt.Println(err)//<nil>
}

type people1 struct {
  Name string
  Age  int
  address1//将结构体写成匿名嵌套形式，就可以将结构体内的成员当成本结构体的成员直接访问
}
type address1 struct {
  Province string
  city   string
}
func main() {
  var p = people1{
   Name: "张单",
   Age:  18,
   address1: address1{
     "山东",
     "菏泽",
   },
  }
  fmt.Println(p)//{张单 18 {山东 菏泽}}
  marshal,err := json.Marshal(p)
  fmt.Printf("%#v\n",string(marshal))//"{\"Name\":\"张单\",\"Age\":18,\"Province\":\"山东\"}"
  fmt.Println(string(marshal))//{"Name":"张单","Age":18,"Province":"山东"}
  fmt.Println(marshal)//[123 34 78 97 109 101 34 58 34 229 188 160 229 141 149 34 44 34 65 103 101 34 58 49 56 44 34 80 114 111 118 105 110 99 101 34 58 34 229 177 177 228 184 156 34 125]
  fmt.Println(err)//<nil>
}

type people1 struct {
  Name string `json:"name" db:"name" xml:"name" ini:"name"`
  Age  int `json:"age"`
  address1//将结构体写成匿名嵌套形式，就可以将结构体内的成员当成本结构体的成员直接访问
}
type address1 struct {
  Province string `json:"province"`
  City   string `json:"city"`
}
func main() {
  var p = people1{
   Name: "张单",
   Age:  18,
   address1: address1{
     "山东",
     "菏泽",
   },
  }
  fmt.Println(p)//{张单 18 {山东 菏泽}}
  marshal,err := json.Marshal(p)
  fmt.Printf("%#v\n",string(marshal))//"{\"name\":\"张单\",\"age\":18,\"province\":\"山东\",\"city\":\"菏泽\"}"
  fmt.Println(string(marshal))//{"name":"张单","age":18,"province":"山东","city":"菏泽"}
  fmt.Println(marshal)//[123 34 110 97 109 101 34 58 34 229 188 160 229 141 149 34 44 34 97 103 101 34 58 49 56 44 34 112 114 111 118 105 110 99 101 34 58 34 229 177 177 228 184 156 34 44 34 99 105 116 121 34 58 34 232 143 143 230 179 189 34 125]
  fmt.Println(err)//<nil>
}

type people1 struct {
  Name   string `json:"name" db:"name" xml:"name" ini:"name"`
  Age    int   `json:"age" `
  address1 `:"address_1"` //将结构体写成匿名嵌套形式，就可以将结构体内的成员当成本结构体的成员直接访问
}
type address1 struct {
  Province string `json:"province"`
  City   string `json:"city"`
}
func main() {
  str :=`{"name":"张单","age":18,"province":"山东","city":"菏泽"}`
  var p people1
  json.Unmarshal([]byte(str),&p)
  fmt.Println(p)//{张单 18 {山东 菏泽}}
  fmt.Printf("%#v\n",p)//main.people1{Name:"张单", Age:18, address1:main.address1{Province:"山东", City:"菏泽"}}
}

type student struct {
  id    int
  name  string
  score  [3]int
}
func main() {
  arr := []student{student{101, "小明", [3]int{100, 99, 88}},
   student{102, "小红", [3]int{88, 56, 83}},
   student{103, "小刚", [3]int{18, 57, 81}},
   student{104, "小强", [3]int{48, 66, 93}},
   student{105, "小花", [3]int{98, 50, 89}}}
  //五名学生
  for i := 0; i < len(arr); i++ {
   //三门成绩
   sum := 0
   for j := 0; j < len(arr[1].score); j++ {
     sum += arr[i].score[j]
   }
   fmt.Printf("第%d名学生\t总成绩为:%d\t平均成绩:%d\n", i+1, sum, sum/len(arr[i].score))
  }
}

* ：取值运算符（也可以用于定义指针类型）
    & ：取地址运算符（与变量一起用时）

var p *int//声明了一个指针默认值为nil (空指针 值为0)指向了内存地址编号为0的空间
//*p =100 0- 255为系统占用不允许用户进行读写操作 空指针是不能直接赋值的
var a int
p =&a
*p =555 // 可以通过指针间接修改变星对应的内存空间
fmt.Println(*p)

指针变量 = new（数据类型）

var p *int
p = new (int)//与定义的类型必须一至
*p =555 // 可以通过指针间接修改变星对应的内存空
fmt.Println(*p)

func CallUserCenter(name string, age int, gender string) (detail *User, err error) {
 detail, err = NewUserUsecase().Create(name, age, gender)
 if err != nil {
  return
 }
 return
}

func CallUserCenter(name string, age int, gender string, args ...interface{}) (detail *User, err error) {
 if len(args) == 0 {
  detail, err = NewUserUsecase().Create(name, age, gender)
 } else {
  detail, err = NewUserUsecase().Create(name, age, gender, args[0])
 }
 if err != nil {
  return
 }
 return
}

switch匹配成功后就不会执行其他的case，如果我们需要无条件的强制执行后面的case，需要使用fallthrough关键字。

func (recevier type) methodName（参数列表） (返回值列表){
    方法体
    return 返回值
}

a 参数列表：表示方法的输入。
b recevier type: 表示这个方法和 type 这个类型进行绑定，或者说该方法作用于 type 类型。
c receiver type: type 可以是结构体，也可以其它的自定义类型。
d receiver: 就是 type 类型的一个变量(实例)。比如：Person 结构体的一个变量(实例)。
e 返回值列表: 表示返回的值，可以有多个。
f 方法主体: 表示为了实现某一功能代码块。
g return 语句不是必须的。

type  接口名称 interface {
    method1(参数列表) 返回值列表
    method2(参数列表) 返回值列表
    ...
    methodn(参数列表) 返回值列表
}

type stringer interface{ 
   string()string
} 
type tester interface{ 
   stringer               // 嵌入其他接口 
   test() 
}

对变量进行初始化
检查/修复程序的状态
注册
运行一次计算

初始化导入的包（递归导入）
对包块中声明的变量进行计算和分配初始值
执行包中的init函数

0. 当前go源文件中， 每一个被Import的包， 按其在源文件中出现顺序初始化。
1. 如果当前包有多个init在不同的源文件中， 则按源文件名以字典序从小到大排序，小的先被执行到， 同一包且同一源文件中的init,则按其出现在文件中的先后顺序依次初始化； 
    当前包的package level变量常量也遵循这个规则； 
    其实准确来说，应是按提交给编译器的源文件名顺序为准，只是在提交编译器之前， go命令行工具对源文件名按字典序排序了。
2. init只可以由go runtine自已调用， 我们在代码中不可以显示调用，也不可以被引用，如赋给a function variable。
3. 包A 引入包B , 包B又引入包C, 则包的初始化顺序为： C -> B -> A
4. 引入包，必须避免死循环，如 A 引 B , B引C, C引A.
5. 一个包被其它多个包引入，如A -> B ->C 和 H -> I -> C , C被其它包引了2次， 但是注意包C只被初始化一次。
6. 另一个大原则， 被依赖的总是先被初始化，当然呀。
7. main包总是被最后一个初始化，这很好理解，因为它总是依赖别的包。

$ go
...
    build            compile packages and dependencies
    clean            remove object files
    doc              show documentation for package or symbol
    env              print Go environment information
    fmt              run gofmt on package sources
    get              download and install packages and dependencies
    install          compile and install packages and dependencies
    list             list packages
    run              compile and run Go program
    test             test packages
    version          print Go version
    vet              run go tool vet on packages
Use "go help [command]" for more information about a command.
...

go help get

go get -u "github.com/VictoriaMetrics/fastcache"

go env -w GOPROXY="https://goproxy.com,direct"

# cd yky-sys-backend/cmd/bidengine
# go list -json -m
{
        "Path": "github.com/Project/test",
        "Main": true,
        "Dir": "/data/test",
        "GoMod": "/data/test/go.mod",
        "GoVersion": "1.15"
}
# 进入到.go文件的目录下，可以把文件依赖打印出来
go list -m -json

go tool addr2line binary

go tool asm [flags] file

-B note
    Add an ELF_NT_GNU_BUILD_ID note when using ELF.
    The value should start with 0x and be an even number of hex digits.
-D address
    Set data segment address.
-E entry
    Set entry symbol name.
-H type
    Set executable format type.
    The default format is inferred from GOOS and GOARCH.
    On Windows, -H windowsgui writes a "GUI binary" instead of a "console binary."
-I interpreter
    Set the ELF dynamic linker to use.
-L dir1 -L dir2
    Search for imported packages in dir1, dir2, etc,
    after consulting $GOROOT/pkg/$GOOS_$GOARCH.
-R quantum
    Set address rounding quantum.
-T address
    Set text segment address.
-V
    Print linker version and exit.

# 列出了所有复杂度大于20的函数
gocyclo -over 20 $(ls -d */ | grep -v vendor)
# 列出最复杂的5个
gocyclo -top 5 $(ls -d */ | grep -v vendor)

find . -type d -not -path "./vendor/*" | xargs deadcode

find . -name "*.go" -not -path "./vendor/*" -not -path ".git/*" -print | xargs gotype -a

find . -type f -not -path "./vendor/*" -print | xargs misspell

# 安装：
go install honnef.co/go/tools/cmd/staticcheck@latest
# 使用：
staticcheck main.go

https://blog.51cto.com/u_13919520/3152161
https://blog.csdn.net/qq_52648173/article/details/124653298
https://blog.csdn.net/z318913/article/details/123005086
https://blog.csdn.net/mocoll/article/details/119427874
https://www.jb51.net/article/255592.htm
https://blog.csdn.net/m0_54130475/article/details/125586782
https://blog.csdn.net/chengqiuming/article/details/115915109
https://www.jianshu.com/p/b62adfaaefc3
https://golang.google.cn/cmd/go/
https://mp.weixin.qq.com/s?__biz=MzI2NDU4OTExOQ==&mid=2247540970&idx=1&sn=2df664485056860e6af54e6120414734&chksm=eaa83abadddfb3ac301e1a1766f7bdc4ce3c2edd0029279ece81c6abe85fcd639a8559be4192&scene=27
https://blog.csdn.net/htyu_0203_39/article/details/50948193
https://blog.csdn.net/zhuxinquan61/article/details/73712251