golang之变量、常量、自定义类型及运算符、指针
Go语言是一种编译型语言
下载地址：https://studygolang.com/dl
配置GOPATH
GOPATH是一个环境变量，用来表明你写的go项目的存放路径（工作目录）。
变量名：GOPATH 值：G:\go
GOPATH路径最好只设置一个，所有的项目代码都放到GOPATH的src目录下
我在g盘新建一个go的工作目录，在该目录下新建三个目录
bin：用来存放编译后生成的可执行文件
pkg：用来存放编译后生成的归档文件
src：用来存放源码文件
适合企业开发者的Go项目结构
https://www.liwenzhou.com/images/Go/install_go_dev/1550806101915.png
Go开发编辑器
Go采用的是UTF-8编码的文本文件存放源代码，理论上使用任何一款文本编辑器都可以做Go语言开发，这里推荐使用VS Code和Goland。 VS Code是微软开源的编辑器，而Goland是jetbrains出品的付费IDE。
下载地址：https://code.visualstudio.com/Download
第一个go程序
package main // 声明 main 包，表明当前属于哪个包，
// 包内元素共享，大写字母开头的变量可以被外部导入
// go语言，单引号表示字符，双引号表示字符串
import "fmt" // 导入内置 fmt 包
func main(){ // main函数表明该程序是一个可执行程序，是程序执行的入口
// 一个项目只能有一个可执行文件，否则会报错
fmt.Println("Hello World!") // 在终端打印 Hello World!
}
进入对应的目录或者直接右键单击文件，选择在终端打开：
go + 文件路径：
绝对路径：
相对路径：相对的是当前路径
go + 项目路径：
绝对路径：
相对路径：相对的是src
go run main.go # 编译并执行，但不保存编译结果
go build # 编译会生成一个.exe文件，结果放在当前路径下
直接在命令行运行，会打印：Hello World!
go build -o heiheihei.exe # -o可以指定编译后文件的路径和名字
go install
# 编译的是可执行项目：结果放在bin下
# 编译的是非可执行：结果放在pkg下
go fmt # 代码格式化
编译后放到linux执行
# 只需要指定目标操作系统的平台和处理器架构即可：
SET CGO_ENABLED=0 // 禁用CGO
SET GOOS=linux // 目标平台是linux
SET GOARCH=amd64 // 目标处理器架构是amd64
# 然后执行：go build
即可编译成一个二进制文件
如果切换回windows
SET CGO_ENABLED=0
SET GOOS=darwin
SET GOARCH=amd64
go build
注释：
//单行注释
/*
多行注释
所有的功能都是通过导包的形式调用的。
导的包必须使用，不然会报错
*/
一、变量
局部变量定义完之后，一定得使用，否则会报错
// 声明变量：如果声明的变量在后面的代码没有使用会报错
var 变量名 变量类型（int,float64,bool,string）
// 批量声明
var (
a string
b int
c bool
)
// 变量赋值：需要事先声明好
a = "上海"
b = 100
c = true
// 声明与赋值放一起
var x string = "李一桐"
// 字符串拼接
fmt.Printf("%s哈哈哈%d", x, b) //Printf:打印格式化
%s：字符串
%d：整型
%f：浮点型
%b：二进制
%x：十六进制
%o：八进制
//短变量类型：只能在函数内部使用
func main(){
n := 10
m := "你好啊" //函数内部声明局部变量
fmt.Println(n, m)
}
// 类型推导：有时我们在声明变量时，忽略了类型，编译器会根据等号右边的值来推导变量的类型完成初始化
var name = "李一桐"
var age = 24
// 匿名变量
// 先定义一个有返回值的函数
func foo()(string, int){
return "李一桐", 24
}
func main(){
// 调用foo
a, b := foo()
fmt.Println(a, b)
// 如果只需要一个，另一个可以用_，用于接收不用的值
// a, _ := foo()
}
// 不能重复声明同名变量，以下声明会报错
var name = "aaa"
var name = "aaa"
二、常量
常量：内存的读写权限只是可读
// go语言的常量通过 const 关键字来声明
const pi = 3.1415
const e = 2.7182
//声明了这两个常量以后，在整个程序运行期间，它们的值都不能再发生变化了
const a,b,c = 100,false,"xiaoli"
fmt.Println(a,b,c)
// 多个常量可以一起声明：常量组
const (
pi = 3.1415
e = 2.7182
)
// const同时声明多个常量时，如果忽略了值则表示和上面一行的值相同
const (
n1 = 100
n2 //100
n3 //100
)
// iota：枚举，只能在常量的表达式中使用
// 1、iota在const关键字出现时将被重置为0。
// 2、const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义，在定义枚举时很有用。
// 3、iota可以参与运算
// 4、iota的中断和恢复
// 5、多个iota同时使用，单独计数互不影响
const (
n1 = iota //0
n2 //1
n3 //2
n4 //3
)
//使用_跳过某些值
const (
n1 = iota //0
n2 //1
_
n4 //3
)
//iota声明中间插队
const (
n1 = iota //0
n2 = 100 //100，const中每新增一行常量声明将使iota计数一次
n3 = iota //2
n4 //3
)
const n5 = iota //0
//定义数量级 （这里的<<表示左移操作，1<<10表示将1的二进制表示向左移10位，也就是由1变成了10000000000，也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位，也就是由10变成了1000，也就是十进制的8。）
const (
_ = iota
KB = 1 << (10 * iota) // 1<<10 ==> 2的10次方
MB = 1 << (10 * iota) // 1<<20 ==> 1024*1024
GB = 1 << (10 * iota) // 1<<30
TB = 1 << (10 * iota) // 1<<40
PB = 1 << (10 * iota) // 1<<50
)
// 多个iota定义在一行
const (
a, b = iota + 1, iota + 2 //iota=0;a=1,b=2
c, d //iota=1;c=2,d=3
e, f //iota=2;e=3,f=4
)
三、自定义类型
reflect.TypeOf()：打印某个变量的类型
type 自定义类型名 基础类型
// 例：
type id int
var a id = 1
fmt.Println(a,reflect.TypeOf(a))
注意： 自定义类型和基础类型不是一个类型
四、基本运算符
算数运算，逻辑运算，赋值运算，比较运算，位运算，其它运算
1、算术运算符
// 算术运算符的坑
1、变量的类型是确定死的
2、2这样的整型数字会自动转换成浮点型
3、2.0这样的浮点型数字会被自动转换成整型
4、同类型之间才能进行运算
func main(){
a,b := "刘大炮", 24
fmt.Println(b/2.0,reflect.TypeOf(b/2.0)) // 12 int
fmt.Println(2.2/b) // 类型不同，无法计算
var x,y,z int
x=y=z=1 //不支持
fmt.Println(x,y,z) //syntax error: unexpected = at end of statement
}
2、指针
指针就是一个存放了内存地址的变量
*类型：指针类型——变量类型
func main(){
var c = 10.23
fmt.Println(&c) // 0xc000056080
var d = &c
fmt.Println(d, reflect.TypeOf(d)) // 0xc000056080 *float64
fmt.Println(*d) // 10.23
*d += 200
fmt.Println(c) // 210.23
}