-
只有 package main 的文件才可以编译成可执行文件，其他包编译后不是可执行文件，但是可以被其他文件调用
自己文件测试的时候，也要写 package main 才可以运行，否则提示
cannot run non-main package
-
一个文件夹下面很多文件 ，但是只能有一个 main 函数，而且他们的包名要一样，同一个 包名下的文件里的东西，可以直接使用 而不需要导入包的操作
（其他函数也不能重名 ？在不同文件？）
-
main () 函数永远没有参数，没有返回值
-
go 里面 不强制使用
；当然你想用也可以啦（其实是编译的时候，会自动给每行加个；的） 。 另外 一行多句可以用；连接(但是 所有语言都不推荐这样写) -
如果一个包里的函数或者变量想让其他包调用，那么他的名字 首字母要大写（相当于java public, 否则就是私有地 无法调用）
-
如果要go build main_package 生成可执行文件
那么 go build 后面要指定 （相对于当前 gopath 的src 的位置）xx/.../main(package main 的目录即可)
-
go build -o 文件路径 main包
指定产生可执行文件的位置
如果不指定则默认放在当前 命令行左边的目录下
比如 gopath> go build -o bin/xx.exe mainpackage
-
go run xx (直接run 的时候如果依赖其他文件，需要都写上[xx..])
go build 模块目录 则会自动搜索当前模块的文件，打包为一个独立的可执行文件
-
同一个包内的变量函数 都是可以共享的，只有不同包才有 公开和私有变量的概念
比如 main 包下面 a.go 声明 了 cc 变量， 那么 main 包下面的 b.go 就可以直接使用 cc 。但是 如果 b.go 不属于 main 包，那就汇报错（除非 cc 声明为 Cc 也就是公开变量）
-
因为编译型语言 ，在函数外面不能有执行语句
但是声明并且初始化是可以的 例如 var xx int = 5
但是 在程序文件函数之外的全局变量 不能先声明后赋值
var xx int
xx = 5 // 报错 non-declaration statement outside function body
这也就解释了 为什么 ：= 只能写在函数内 因为 ：= 就是 上面两行的缩写。
-
使用 引入包的别名 相当于 python imoprt xx as xx
import {
new_package_name “xx/xx/xxpackagename”
}
然后直接使用 new_package_name 而不用 xxpackagename
经常出现在 包的名字重复 或者太长等不友好的时候使用
-
每个源文件 都可以有一个 init 初始化函数
package add
func init(){
your code
}
每个源文件都可以自定一个 init ,他会在这个文件被使用之前，最后执行 init 函数
main 导入了 add 包 add 倒入了 test 包。那么tets 的 init 最先执行，其次是 add 最后是 main包
-
使用 _ 别名 ，导入包只初始化，不用 这样不会报错
package main
import （
"add"
）
如果不用 add 就会报错了
但是如果add 里面有我们需要的初始化的内容，想要 init 执行一下
那就需要这样
import （
_ "add"
）
给导入的包 用 _ 别名代替，这样不使用也不会报错了。
-
批量声明或者引入包这些操作，可以用 （[...]）简洁操作多个变量或者导入包
-
值类型
基本数据类型：int float bool string 数组和struct （通常在栈中分配内存）
-
引用类型
指针 slice(切片) map（字典） chan（管道） （通常在 堆中分配内存）
-
其实 可变类型 都是传入的地址
可以理解为一个特殊的指针，声明参数的时候 并没有 带* ,传入的时候也没有 & 符号。简化了 这个操作过程
-
局部变量就是在 { 里面的} if for 里面都是局部变量
-
浮点数没有直接 float 的类型 只有 float32 64
但是 整形就有 int 直接写的（这个一般是 四个字节的） 其实和 int32 差不多，但是确实是不同的整形
-
其实函数的参数都是复制了一份
不同的是 对于值类型，形参直接存储值copy，而引用类型，形参存储的是引用 地址的cpoy
-
一个字符(存储会转化为 整数) 类型为 byte(单引号，输出需要格式化 %c) 字符串是 string 类型
-
字符串 为
" "也可以是 ``
后者相当于 多行字符串 \n 等转移字符串原样输出。
-
关于 fmt 的输入输出 fmt 包
其实 fmt 里面有很多io 操作的
fmt 地址 ：https://golang.org/pkg/fmt/#Print
func Errorf(format string, a ...interface{}) 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 Fscan(r io.Reader, a ...interface{}) (n int, err error)
func Fscanf(r io.Reader, format string, a ...interface{}) (n int, err error)
func Fscanln(r io.Reader, a ...interface{}) (n int, err error)
func Print(a ...interface{}) (n int, err error)
func Printf(format string, a ...interface{}) (n int, err error)
func Println(a ...interface{}) (n int, err error)
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 Sprint(a ...interface{}) string
func Sprintf(format string, a ...interface{}) string
func Sprintln(a ...interface{}) string
func Sscan(str string, a ...interface{}) (n int, err error)
func Sscanf(str string, format string, a ...interface{}) (n int, err error)
func Sscanln(str string, a ...interface{}) (n int, err error)
简单说说 Print Println Printf 的区别：
从他们函数定义来说： Print Println 接收可变参数 （Println 会在末尾多输出 \n），而Printf 第一个是占位字符串，后面是 可变参数(可变参数个数要和第一个参数占位符一一对应)还有 Sprint 和 Print 区别 ：返回值不一样 带S 开头的，会有字符串返回（原来是输出到控制台的，现在直接返回给调用者,控制台不在输出了）
-
go 函数不支持重载，一个包里面不能有重复 函数名
-
函数也可以定义为一种类型
例如 type func_type func (int, int) int func_type 就是一种类型（两个int 参数，一个返回int 类型的函数类型）任何满足这个结构的函数都可以属于这个类型，你也可以当做普通类型来声明一个变量
-
函数返回值可以直命名
例如 func (int, int) int { xx := 1 return xx}
也可以直接 func (int, int) (xx int) {xx := 1 return}
(第二种，直接制定了 返回变量，所以 return 后面就不需制定了)
-
函数可变参数
func xx(args...int) int {
}
格式固定 ... 连接可变参数名和 类型， 这个和 python * 类似
函数里面 用 args[index] 来取出每个可变 参数的值
-
defer 关键字 吧语句 压入栈
func xx() {
a := 1
defer fmt.Printf("a is %d", a)
a = 100
fmt.Printf("a is %d", a)
}
func main(){
xx()
}
>> a is 100 a is 1
defer 会先把当前标记的语句放到函数最后执行，但是 ，现在会立即把u哦
有变量值固定住，放到堆栈。（有点进程加 py finally 的感觉）
多个 defer 语句遵循 后写的先执行。
-
label 不止可以使用 goto 跳转
其他的break continue 也是可以的
-
使用 new 或 make 给变量分配内存
new 为 值类型分配内存（返回的是指针） make为 可变类型分配内存
-
数组申明时，不加长度就是一个切片slice
var a [] int (slice切片，引用 类型，使用时候，必须通过make 分配内存才可以使用)
var b [2] int 数组值类型
切片和普通数组的区别就是，切片传给函数，函数内部可以该变切片的值到外面。
-
字符串也是一个数组
其实字符串底层是 bytes 类型元素的数组
比如py 常见的 字符串可以切片，同样 go 也可以
var a = "aabb"
b := a[0:3]
b就是 aab 了 （但现在 b底层是一个 bytes 类型的切片了）
-
字典 map 类型
ps 例如 slice map 这些 ，如果不直接赋值初始化，后面就要用 make 初始化，否则无法使用
-
普通类型也可以添加自定义方法
普通结构体，当然可以绑定他自己的方法，只要上面一个方法在它前面，加上它所属于的结构体的类型，它就属于这个结构体，这个已经讲过了。
其实你也可以把函数绑定在普通的类型上，比如像下面这样：
func (a int) get() {
fmt.Print(a)
}
var a = 2
a.get()
>> 2
太灵活 了
-
go 的结构体继承通过结构体类型的字段实现
通过在结构体里面写其他结构体类型的匿名字段，实现继承那个结构体里面的东西
