Go 语言快速入门指南：第二篇变量与常量

变量

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

syntax_code1
syntax_code2
syntax_code3

什么是变量

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

可以改变的量，赋值一次还可以随意更改
使用多变，可以一次定义，多次使用

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

package main

import "fmt"

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

hello

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

varhellostringHello 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

十年前，人们叫我:  小王
十年后，人们叫我:  老王

使用海象运算符定义变量

:=

 hello := "Hello World"

:=

hellohellovar

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)
}

变量命名

namex

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)

定义多个变量

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

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 天

无类型常量

stringfloat64

从属待定的常量共有 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

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

代码注释

///**/

// 声明变量
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 中实现常量的方式非常独特。常量不同于变量，常量只存在于编译期，无类型常量可以隐式转换，而类型常量和变量不能，无类型常量视为具有种类，而不是类型。

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

Go 语言快速入门指南：第二篇 变量与常量