#私藏项目实操分享# Go 语言入门很简单 -- 4. 常量

Posted 2021-11-21 宇宙之一粟

常量

上节，我们讲到​​变量​​，这节我来看看常量，常量就是不变的量，恒定的量。

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"

会得到这样的提示：

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, Bro"
    const pi float64 = math.Pi
    r := 3.0

    fmt.Println(hello)
    fmt.Println("半径为3的圆周长:", 2*pi*r)
    fmt.Println("半径为3的圆面积:", pi*r*r)
    fmt.Println("半径为3的圆面积:", pi*math.Pow(r, 2))
}

运行后，得到结果如下：

Hello, Bro
半径为3的圆周长: 18.84955592153876
半径为3的圆面积: 28.274333882308138
半径为3的圆面积: 28.274333882308138

定义多个变量

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

var (
  a = 3
  b = 4
  c = 5
)

使用关键字 var（或 const）后跟括号，每个变量都定义在单独行上。

Demo

package main

import (
    "fmt"
    "math"
)

func main() {

    const hello string = "Hello,"
    const 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: Rain
Hello,Rain
让我们来学习圆，请输入圆的半径: 4
半径为4.000000的圆周长: 25.132741
半径为4.000000的圆面积: 50.265482

常量生成器 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 37
以上是关于#私藏项目实操分享# Go 语言入门很简单 -- 4. 常量的主要内容，如果未能解决你的问题，请参考以下文章
 
 #私藏项目实操分享#Go 语言入门很简单：Go 如何面向对象
 Go 语言入门很简单 -- Go 语言解析JSON #私藏项目实操分享#
 #私藏项目实操分享# Go 语言入门很简单 -- 4. 常量
 Go 语言入门很简单 -- 7. Go Slices #私藏项目实操分享#
 Go 语言入门很简单 -- 8. Go Maps #私藏项目实操分享#
 跟着动画学 Go 数据结构之 Go 实现栈#私藏项目实操分享#