二、Go语言内置变量类型

复数类型

func euler() {
    c := 3 + 4i
    fmt.Println(cmplx.Abs(c))
}

iota 常量生成器

func enum_funcation() {
    const (
        //普通枚举类型
        cpp=iota
        java
        javascript
        python
    )
    fmt.Println(cpp,java,javascript,python)
    //输出:
    //0 1 2 3

func enum_funcation() {
    const (
        //偏移自增值枚举类型
        b = 1 << (10*iota)
        b1
        b2
        b3
    )
    fmt.Println(b,b1,b2,b3)

二、Go语言变量

Go语言是编译强类型语言，因此变量（variable）是有明确类型的，编译器也会检查变量类型的正确性。

声明变量

声明变量使用关键字var开头,name是变量名,后置变量类型，行尾无须分号。

var 变量名 类型名

需要注意的是，Go语言和其他编程语言不同，它在声明变量时将变量的类型放在变量的名称之后。这样做的好处就是可以避免像C语言中那样含糊不清的声明形式，例如：int a, b; 。其中只有 a 是指针而 b 不是。如果你想要这两个变量都是指针，则需要将它们分开书写。而在 Go 中，则可以和轻松地将它们都声明为指针类型：`var a, b int`

下面是Go语言变量声明的例子

package main
import "fmt"
//变量声明
var  name string
var age int
var sex string
func main() {
    //使用全局变量
    fmt.Println(name) //" "
    fmt.Println(age) //0
    fmt.Println(sex) //" "
}

当一个变量被声明之后，Go语言编译器自动赋予它该类型的的零值:int为0，float为0.0，bool为false，string为空字符串指针为nil等。这样的好处是省下了我们为变量赋初值的时间，在Go语言中所有的内存都是经过初始化的。

声明变量并初始化

我们可以在声明变量的同时赋予它一个初始值，这个过程我们称为变量的初始化。

var 变量名 类型 = 值,表达式,函数

下面是Go语言声明变量并初始化的例子

package main
import "fmt"
func main() {
    //声明变量并赋初值
    var language string="Go语言"
    var birthTime  int=2009
    //单行声明多个变量，并且赋值多个变量
    var a,b int=10,22
    fmt.Println(language) //Go语言
    fmt.Println(birthTime) //2009
    fmt.Println(a,b) //10,22
}

注意: Go语言中已声明的变量必须使用! a declared but not used
上面代码中，100 和 int 同为 int 类型，int 可以认为是冗余信息，因此可以进一步简化初始化的写法。

编译器推导类型

在声明变量并初始化的基础上，将类型int省略后，编译器会自动根据=右值推导变量的类型。

var brithTime = 100

下面的例子，编译器会自动根据=右值推导变量类型并完成初始化赋值。

package main
import "fmt"
func main() {
    //编译器推导类型
    var name = "Go语言"
    var birthTime = 2009
    var a, b, c = 10, 3.5, false
    fmt.Println("变量name的类型:", reflect.TypeOf(name))           //string
    fmt.Println("变量birthTime的类型:", reflect.TypeOf(birthTime)) //int
    fmt.Printf("变量a,b,c的类型：%T %T %T\n", a, b, c)              //int，float64，bool
    fmt.Println(name, birthTime, a, b, c) //Go语言 2009 10 3.5 false
}

在Go语言中变量的声明还有一种更为精简的写法，例如：

brithTime := 100

如果变量brithTime已经被声明过，再次使用:=时编译器会报错，例子如下

//声明变量
var name string
//再次声明并赋值 
name := "Go语言"
//报错no new variables on left side of :=

批量声明变量

每行都用var关键字声明变量比较繁琐，Go语言提供了一种省略var批量声明变量的方法。

package main
import "fmt"
//批量声明变量
var (
    name string
    age int
    sex string
)
func main() {
    //使用全局变量
    fmt.Println(name) //" "
    fmt.Println(age) //0
    fmt.Println(sex) //" "
}

强制类型转换

Golang的类型转换和C/C++ Java等编译型语言的类型转换还是有一定区别的，在Go语言不存在隐式类型转换，因此所有的类型转换都必须显式的声明：

int main()
{
    int a=5;
    float b=3.5;
    printf("%f",a*b);//17.5
}

这样的C代码不会报错，C编译器会隐式的将变量a转换为float类型，但是在Go语言中必须显式类型转换

三、Go语言常量

声明常量

Go语言中的常量使用关键字 const定义，用于存储不变的数据，常量是在编译时被创建，并且只能是布尔型、数字型（整数型、浮点型和复数）和字符串型。

与C/C++的常量定义方式稍微不同，在Go语言中定义常量的同时必须赋予它一个初始值

//报错 Missing value in const declaration
const str1 string
//不报错 显式定义
const str1 string = "Go语言"
//不报错 隐式定义
const str2 = "Go语言"

在上述代码例子中，你可以将类型省略(隐式定义)，因为Go编译器可以根据=右值来推断其类型。

显式类型定义：const str1 string = “Go语言”
隐式类型定义：const str2 = “Go语言”

批量声明常量

和var声明变量一样，可以批量声明多个常量，例子如下：

//批量声明常量(显式)
const (
    a int     = 10
    b float32 = 3.5
    c bool    = false
)
//批量声明常量(隐式)
const (
    a = 10
    b = 3.5
    c = false
)

特殊常量iota

特殊常量iota只能用在const语句中，


const a = iota
const b = iota
fmt.Println(a,b)//0 0

总结

需要注意的是，简短模式（short variable declaration）有以下限制：

定义变量，同时初始化赋值。
不能提供数据类型。
只能用在函数内部。
使用var关键字定义变量可以放在包内或者函数内
使用var()批量定义变量
两种编译器自动推导类型var 变量名和:=

Golang 从入门到进阶

Go语言变量和常量