Go学习笔记

go是一门编译型语言，运行效率高，开发高效，部署简单。语言层面支持并发，易于运用多核处理器实现并发。

go的使用场景：
go常被用于：服务器编程如：处理日志，数据打包，虚拟机处理，文件系统等；还用于分布式系统，数据库代理器，中间件；网络编程，web应用，API应用等；云平台应用如：docker，k8s

 

go常用命令：
go version  //查看go版本
go get：动态获取远程包（需 提前安装 git或hg）
go run：编译并运行go源码文件
go build：用于编译(源码文件，代码包，依赖包)；检查是否有编译错误
go fmt：格式化源码（部分IDE在保存时自动调用）
go install：编译包文件并编译整个程序
go test：运行测试文件
go doc：查看文档（CHM手册）
go mod: 依赖管理

操作案例：
go build .   //构建当前项目
go build test.go  //会生成一个test.exe(win系统下)
go run test.go
go get github/xxxxxx

Go常用关键字：
通过 import 关键字来导入其它非 main 包
通过 const 关键字来进行常量的定义
通过在函数体外部使用 var 关键字来进行全局变量的声明与赋值
通过 type 关键字来进行结构(struct)或接口(interface)的声明
通过 func 关键字来进行函数的声明

go的注释：
// ：单行注释
/* */：多行注释

GO的结构实例：
package main
import "fmt"
const VERSION1 ="V1.1"
const VERSION2 string ="V1.1"
var myName1="zhang san"
var myName2 string ="zhang san"
type diyType int  //一般类型声明，这里diyType可看做int的别名，但也不能与int类型数值进行混合运算
type Mystruct struct { //定义结构体

}
type Iperson interface { //声明一个接口

}
func Myfunc(){//声明一个函数
    fmt.Println("myfunc")
}
func main(){
    Myfunc();
    fmt.Println("hello go!")
}

GO语言Package：
package是基本的分发单位；每个go文件开头都要有package的声明；如果要生成go的可执行文件，必须有main的package，且该包下必须有main函数；同一个路径下只能存在一个package，一个package可拆分成多个源文件

GO的import：导入源码所依赖的package；不得导入没有使用的包，会报错。
import原理：一个源代码包含多个包时会按照顺序导入；
如果当前文件导入了a包，而a包中又导入了b包，那么先初始化b包中的变量，常量和init函数，然后初始化a包中的常量，变量，init函数，最后初始化当前包中的常量，变量，init函数
如果一个包被导入多次则只会被导入一次

格式如下：
import (
    "fmt"
    "time"
)

import的其他用法：
import aa "fmt"
//给fmt包定义别名，以后使用的时候用别名访问里面的方法：例如：aa.Println()

import . "fmt"
//用点后这个包里面的所有方法使用的时候不用加前缀。例如fmt.Println()简写为Println()

import _ "xxx"
//用这个标识的包，只会初始化该包的常量，变量，以及init方法。不能通过包名调取其他方法

 

GO的数据类型：

//var i byte =8 //unsafe.Sizeof输出结果1，表示1个字节，共8位
//var i uint8=8 //unsafe.Sizeof输出结果1，表示1个字节，共8位

//var i int32=1 //unsafe.Sizeof输出结果4，表示4个字节,共32位
//var i rune=8 //unsafe.Sizeof输出结果4，表示4个字节,共32位

//var i int=1; //这个类型会根据操作系统位数而定，64位系统就是8字节，32位系统就是4个字节
//var i uint=1; //这个类型会根据操作系统位数而定，64位系统就是8字节，32位系统就是4个字节

//var i float32 =1.2 //unsafe.Sizeof输出结果4，表示4个字节,共32位
//var i float64 =1.2 //unsafe.Sizeof输出结果8，表示8个字节,共64位

//var i complex64 =1.2 //unsafe.Sizeof输出结果8，表示8个字节,共64位
var i complex128 =1.2 //unsafe.Sizeof输出结果16，表示16个字节,共128位
//fmt.Println(unsafe.Sizeof(i))

//var b bool=false //布尔类型的值只能是true或false，不能是其他值
//fmt.Println(b)

GO的派生类型：
指针类型，数组类型，结构化类型，Channel类型，函数类型，切片类型，接口类型，Map类型

GO类型默认值与别名：
布尔类型的默认值是false，string类型的默认值是空字符串，值类型默认值是0(包括：整形，浮点型，复数类型，其他类型)

别名实例：type aaa int   //声明aaa为int的别名，注意两种类型不能混合计算

 

GO语言的变量，常量

分组声明:
var(
i int
name string
)

 

go变量实例：

package main

import "fmt"
import "reflect"

var a int
var b int =345
var(
    c string="kkk"
    d int
)
var f,g int=1,2

func main() {
    l,m:=11,22
    var h,i="hhh",55
    var(
        e int=5
    )
    g,k := 55,"kk" //不能放在函数体外,在函数外部var不能省
    n,_,o:=111,222,"aaa"
    /*相关变量打印代码忽略*/
}

go变量类型判断fmt.Println(reflect.TypeOf(b))

 

GO类型转换

go语言中的类型转换必须是显示的，并且类型转换两种类型必须相互兼容才行。

package main

import "fmt"
import "reflect"

func main() {
    var a int=3
    b:=float32(a)
    fmt.Println(b)
    fmt.Println(reflect.TypeOf(b))
    
    var c float32=3.01
    d:=int32(c)
    fmt.Println(d)
    fmt.Println(reflect.TypeOf(d))
}

首字母大写的变量是公共变量，首字母小写的是私有变量