变量

Go 语言不再像 C 和 Java 那样使用分号 “;” 作为程序语句的结尾。我们可以直接使用如下语法规则：

syntax_code1
syntax_code2
syntax_code3
复制代码

什么是变量

变量可以从两个角度来理解：

1. 可以改变的量，赋值一次还可以随意更改

2. 使用多变，可以一次定义，多次使用

变量是指一个包含部分已知或未知数值或信息（即一个值）的存储地址，变量一般具有特定类型和关联名称。

package main

import "fmt"

func main() {
    var hello string = "Hello World~"
    fmt.Println("Hello, World!")
    fmt.Println(hello)
}
复制代码

如上面的代码， hello 就是一个变量。

我们来拆解这变量是如何来的：

在 Go 语言中，定义变量使用 var 关键字，然后定义变量名如 hello 和类型 string ，最后给这个变量指定一个值 Hello World~ 。

所以：变量 = 变量名+类型+值。

用 var 关键字开头，基本格式如下：

var myvariable data_type，紧接后面跟上你想定义的变量名，最后加上变量的数据类型，最后再给变量赋值，如下面的代码：

package main

import "fmt"

func main() {
    var x int
    var y int
    x = 1014
    y = 2021
    fmt.Println("x + y = ", x+y)
}
复制代码

变量修改

当定义了一个变量，赋值给一个值之后，还可以对这个变量进行修改，比如：

package main

import "fmt"

func main() {
    var nickName string
    nickName = "小王"
    fmt.Println("十年前，人们叫我: ", nickName)
    // After 10 years
    nickName = "老王"
    fmt.Println("十年后，人们叫我: ", nickName)
}
复制代码

同样的变量名 nickName ，在程序中使用两次，代码运行结果：

十年前，人们叫我:  小王
十年后，人们叫我:  老王
复制代码

使用海象运算符定义变量

什么是海象运算符( The Walrus Operator )。因为 := 很像海象——眼睛小，长着两枚长长的牙，所以这种方式叫做海象运算符，是不是很形象。

Go 语言为了方便程序员定义变量，支持使用这种海象运算符的变量命名方式，如：  hello := "Hello World" 。

不难发现，在 :=  之前并没有在程序中指定变量类型。因为我们不需要指定该类型， Go 编译器能够根据变量值推断类型，然后分配给这个变量。

例如，变量 hello 就正在分配一个字符串字面量， 变量 hello 就是字符串类型。另外，编译器可以也用 var 语句进行变量类型推导。

hello1 := "Hello World"            // 海象运算符进行的变量类型推导
var hello2 = "Hello World"    // var 关键字进行变量类型推导
复制代码

可以利用 Go 的变量编写一个简单的数学相加计算，代码如下：

package main

import "fmt"

func main() {

    x := 1024
    y := 2021

    fmt.Println("x + y = ", x+y)
}
复制代码

变量命名

正确命名变量是软件开发的一个重要部分。 名称必须以字母开头，并且可以包含字母、数字或  _（下划线）符号。 Go 编译器不关心您命名变量的名称，但是最好让变量命名描述清楚，比如名字选择 name ，比命名为 x 更好。

x := "三多"
fmt.Println("My cat's name is:", x)

name := "柚子"
fmt.Println("The other cat's name is:", name)
复制代码

更改为：

catName := "三多"
fmt.Println("My cat's name is:", catName)
复制代码

推荐一个帮助程序员命名的网站：unbug.github.io/codelf/ ，比如我们想命名 name，可以搜索看看其他程序员如何命名 name 相关的变量名。

定义多个变量

Go 提供了定义多个变量的简写方式：

var (
  a = 3
  b = 4
  c = 5
)
复制代码

常量

什么是常量

常量就是不变的量，恒定的量。Go 当然支持常量。常量的本质其实也属于基本类型，如布尔型、字符串或数字。

常量可以保证在编译阶段就计算出表达式的值，并不需要等到运行时，从而使得编译器可以在任何时候就知道这个值。

常量的创建方式与创建变量的结构相同，但我们使用 const 关键字代替 var 关键字：

package main

import "fmt"

func main() {
    const hello string = "Hello World"
    fmt.Printlb(x)
}
复制代码

如果我们更改一个常量的话，比如这样：

const hello string = "Say Hello to you"
hello = "Hello, Bro"
复制代码

会在编辑器中得到这样的错误，“不能给 hello 赋值（声明了常量）”：

Variables\main.go:6:8: cannot assign to hello (declared const)
复制代码

常量是在程序中复用而不用每次都重新写的好方法。 例如 math 包中的圆周率 Pi 和自然常数 E 被定义为一个常数。

fmt.Println(math.E)
// 结果为：2.718281828459045
复制代码

既然，我们提到了圆周率，不如来写一个程序计算一下圆的面积和周长：

package main

import (
    "fmt"
    "math"
)

func main() {
    const (
        hello string  = "Hello,"
        pi    float64 = math.Pi
    )
    var (
        name string
        r    float64
    )
    fmt.Print("Enter your name: ")
    fmt.Scanf("%s", &name)
    fmt.Println(hello + name)
    fmt.Print("让我们来学习圆，请输入圆的半径: ")
    fmt.Scanf("%f", &r)
    fmt.Printf("半径为%f的圆周长: %f\n", r, 2*pi*r)
    fmt.Printf("半径为%f的圆面积: %f", r, pi*r*r)
}
复制代码

在终端中运行一下代码，如下结果：

$ go run main.go
Enter your name: Yuzhou1su
Hello,Yuzhou1su
让我们来学习圆，请输入圆的半径: 3
半径为3.000000的圆周长: 18.849556
半径为3.000000的圆面积: 28.274334
复制代码

定义多个常量

跟定义多个变量一样，使用关键字 const 后跟括号，每个常量都定义在单独行上。

const (
        hello string  = "Hello,"
        pi    float64 = math.Pi
    )
复制代码

常量生成器 iota

常量的声明可以使用常量生成器 iota，可以创建一系列相关的值，而不用逐个值显式写出。

在 iota 中，从 0 开始取值，逐个加 1，例如定义一星期，从 Sunday 开始，其值为 0。

package main

import "fmt"

type Weekday int

const (
    Sunday Weekday = iota
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
)

func main() {
    fmt.Printf("Sunday 是一周的第 %d 天\n", Sunday)
    fmt.Printf("Monday 是一周的第 %d 天\n", Monday)
    fmt.Printf("Tuesday 是一周的第 %d 天\n", Tuesday)
    fmt.Printf("Wednesday 是一周的第 %d 天\n", Wednesday)
    fmt.Printf("Thursday 是一周的第 %d 天\n", Thursday)
    fmt.Printf("Friday 是一周的第 %d 天\n", Friday)
    fmt.Printf("Saturday 是一周的第 %d 天", Saturday)
}
复制代码

运行结果：

$ go run main.go
Sunday 是一周的第 0 天
Monday 是一周的第 1 天
Tuesday 是一周的第 2 天
Wednesday 是一周的第 3 天
Thursday 是一周的第 4 天
Friday 是一周的第 5 天
Saturday 是一周的第 6 天
复制代码

无类型常量

Go 的常量有一些特别之处，上面我们定义的常量都是基本数据类型，如 string 或 float64，但许多常量并不从属于某一具体类型。编译器将这些从属类型待定的常量表示成某些值，这些值比基本类型的数字精度更高，且算数精度高于原生的机器精度。

从属待定的常量共有 6 种：

• 无类型 布尔

• 无类型 整数

• 无类型 文字符号

• 无类型 浮点数

• 无类型 复数

• 无类型字符串

const (
        deadbeef = 0xdeadbeef        // 无类型整数，值为 3735928559
        a        = uint32(deadbeef)  // uint32, 值为 3735928559
        b        = float32(deadbeef) // float32, 值为 3735928576(向上取整)
        c        = float64(deadbeef) // float64, 值为 3735928559
        d        = int32(deadbeef)   //  编译错误：溢出，int32无法容纳常量值
        e        = float64(1e309)    // 编译错误：溢出，float64,无法容纳常量值
        f        = uint(-1)          // 编译错误：溢出，uint 无法容纳常量值
)

// consts\main.go:31:19: constant 3735928559 overflows int32
// consts\main.go:32:21: constant 1e+309 overflows float64
// consts\main.go:33:18: constant -1 overflows uint
复制代码

借助于推迟确定从属类型，无类型常量不仅能维持更高的精度，与类型已确定的常量相比，它们还能写出更多表达式而无需转换类型。

代码注释

go 语言的代码注释和 c 语言一样，使用单行注释 // 和多行注释 /**/ 的格式，在代码中适当的增加注释方便自己和他人阅读，写注释其实也是写代码前的一个总体设计。

// 声明变量
var a int
var str string
var b, c float64

// 给变量赋值
a = 20
str = "Hello World!"
b, c = 7.14, 9.14

/* 打印变量 */
fmt.Println("value of a = ", a)
fmt.Println("var of str = ", str)
fmt.Println("var of b = ", b)
fmt.Println("var of c = ", c)
复制代码

总结

又到了本篇文章的总结部分。

变量是可以改变的，变量有自己的类型和名字，可以使用 var 关键字声明一个变量，或者使用短文本的海象运算符 := 来定义一个变量，变量可以隐式转换，编译器会自动推断该变量的类型，变量命名最好使用有意义方便知道大家知道其功能的名字。

常量是一种创建命名标识符的方法，该标识符的值永远不会改变。它们还为语言提供了难以置信的灵活性。在 Go 中实现常量的方式非常独特。常量不同于变量，常量只存在于编译期，无类型常量可以隐式转换，而类型常量和变量不能，无类型常量视为具有种类，而不是类型。

下一篇我们将进入真实世界的逻辑控制，体会真正的编程乐趣！