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

}