Go语言常量介绍

什么是常量？

常量是在编程语言中，通过名字可以访问的一个数据，里面存储的数据在程序运行时不能修改。Go 语言的常量关键字是 const，常量的数值在编译阶段就已经确定。

Go 语言中常量的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

声明一个常量

关键字const用于声明常量。让我们通过示例看看如何声明常量。

package main

import (  
    "fmt"
)

func main() {  
    const a = 50
    fmt.Println(a)
}
1
2
3
4
5
6
7
8
9
10

Run in playground

上面的代码中a是一个常量，并被赋值为50。

声明一组常量

还有另一种语法可以使用单个语句定义一组常量。下面提供了使用此语法定义一组常量的示例。

package main

import (  
    "fmt"
)

func main() {  
    const (
        name = "John"
        age = 50
        country = "Canada"
    )
    fmt.Println(name)
    fmt.Println(age)
    fmt.Println(country)

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Run in playground

在上面的程序中，我们声明了 3 个常量name、age和country。上面的程序打印出，

John  
50  
Canada  
1
2
3

顾名思义，常量不能再次重新分配给任何其他值。在下面的程序中，我们尝试为 分配另一个89值a。这是不允许的，因为a是一个常数。该程序将无法运行，并出现编译错误无法分配给.

package main

func main() {  
    const a = 55
    a = 89 
}
1
2
3
4
5
6

Run in playground

**常量的值应该在编译时已知。**因此，它不能分配给函数调用返回的值，因为函数调用发生在运行时。

package main

import (  
    "math"
)

func main() {  
    var a = math.Sqrt(4)   
    //不被允许
    const b = math.Sqrt(4) 
}
1
2
3
4
5
6
7
8
9
10
11

Run in playground

在上面的程序中，a是一个变量，因此可以将其分配给函数的结果math.Sqrt(4)

b是一个常量，b 的值需要在编译时知道。该函数math.Sqrt(4)仅在运行时评估，因此const b = math.Sqrt(4)无法编译并出现错误

./prog.go:9:8: const initializer math.Sqrt(4) is not a constant
1

字符串常量、类型化和非类型化常量

任何用双引号括起来的值都是 Go 中的字符串常量。例如，像"Hello World",这样的字符串在 Go 中都是常量。

字符串常量属于什么类型？答案是它们是无类型的。

像“Hello World”这样的字符串常量没有任何类型。

const hello = "Hello World"  
1

在上面的代码行中，常量hello没有类型。

Go 是一种强类型语言。所有变量都需要显式类型。
以下将变量分配name 给无类型常量的程序如何工作？

package main

import (  
    "fmt"
)

func main() {  
    const n = "Sam"
    var name = n
    fmt.Printf("type %T value %v", name, name)

}
1
2
3
4
5
6
7
8
9
10
11
12

Run in playground

答案是非类型化常量具有与之关联的默认类型，并且当且仅当一行代码需要它时，它们才会提供它。在第 8 行的语句 var name = n 中，name 需要一个类型，它从字符串常量 n 的默认类型（字符串）获取它*。*

有没有办法创建类型常量？答案是肯定的。以下代码创建一个类型化常量。

const typedhello string = "Hello World"  
1

上面代码中的typedhello是一个字符串类型的常量。

Go 是一种强类型语言。不允许在分配期间混合类型。让我们借助一个程序看看这意味着什么。

package main

func main() {  
        var defaultName = "Sam" 
        type myString string
        var customName myString = "Sam" 
        customName = defaultName

}
1
2
3
4
5
6
7
8
9

Run in playground

在上面的代码中，我们首先创建一个变量并将其分配给常量。常量 Sam 的默认类型是字符串，因此赋值后 defaultName 的类型是字符串。

在下一行中，我们创建一个新类型myString，它是字符串的别名。

然后我们创建一个customName类型变量myString并将常量Sam分配给它。由于常量Sam是无类型的，因此可以将其分配给任何string变量。因此，该分配被允许并customName获得类型myString。

现在我们有一个类型的变量和另一个类型的变量。尽管我们知道 myString 是字符串的别名，但 Go 的强类型策略不允许将一种类型的变量分配给另一种类型。因此，不允许赋值 customName = defaultName，编译器抛出错误 ./prog.go：7：20：不能在赋值中使用 defaultName（类型字符串）作为 myString 类型defaultName``string``customName``myString

布尔常量

布尔常量与字符串常量没有什么不同。它们是两个无类型常量true和false。字符串常量的相同规则也适用于布尔值，因此我们不会在这里重复它们。下面是一个解释布尔常量的简单程序。

package main

func main() {  
    const trueConst = true
    type myBool bool
    var defaultBool = trueConst 
    var customBool myBool = trueConst 
    defaultBool = customBool 
}
1
2
3
4
5
6
7
8
9

Run in playground

上面的程序是不言自明的。

数字常量

数字常量包括整数、浮点数和复数常量。数字常量有一些微妙之处。

让我们看一些例子来使事情变得清楚。

package main

import (  
    "fmt"
)

func main() {  
    const a = 5
    var intVar int = a
    var int32Var int32 = a
    var float64Var float64 = a
    var complex64Var complex64 = a
    fmt.Println("intVar",intVar, "\nint32Var", int32Var, "\nfloat64Var", float64Var, "\ncomplex64Var",complex64Var)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Run in playground

在上面的程序中， consta是一个值5。您可能想知道 a 的默认类型是什么，如果它确实有，我们如何将它分配给不同类型的变量。答案在于 a的语法。下面的程序会让事情变得更清楚。

package main

import (  
    "fmt"
)

func main() {  
    var i = 5
    var f = 5.6
    var c = 5 + 6i
    fmt.Printf("i's type is %T, f's type is %T, c's type is %T", i, f, c)

}
1
2
3
4
5
6
7
8
9
10
11
12
13

Run in playground

在上面的程序中，每个变量的类型由数字常量的语法确定。从语法上看， 5是整数，5.6是浮点数，从语法上看， 5 + 6i是复数。当上面的程序运行时，它会打印

i's type is int, f's type is float64, c's type is complex128  
1

有了这些知识，让我们尝试了解下面的程序是如何工作的。

package main

import (  
    "fmt"
)

func main() {  
    const a = 5
    var intVar int = a
    var int32Var int32 = a
    var float64Var float64 = a
    var complex64Var complex64 = a
    fmt.Println("intVar",intVar, "\nint32Var", int32Var, "\nfloat64Var", float64Var, "\ncomplex64Var",complex64Var)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Run in playground

在上面的程序中，a 的值是5。它可以表示浮点数、整数甚至没有虚部的复数。因此，可以将其分配给任何兼容类型。这些类型的常量的默认类型可以被认为是根据上下文动态生成的。 需要是 int，所以它成为一个常量。 需要是一个复数，因此它成为一个复常数。相当整洁的

intVar 5 
int32Var 5 
float64Var 5 
complex64Var (5+0i)
1
2
3
4

数字表达式

数字常量可以在表达式中自由混合和匹配，并且仅当将它们分配给变量或在需要类型的代码中的任何位置使用时才需要类型。

package main

import (  
    "fmt"
)

func main() {  
    var a = 5.9 / 8
    fmt.Printf("a's type is %T and value is %v", a, a)
}
1
2
3
4
5
6
7
8
9
10

Run in playground

在上面的程序中， 是语法上的浮点数，语法上的是整数。尽管如此，还是允许的，因为两者都是数字常量。除法的结果是 0.7375 是 a，因此变量 a 的类型为 float。程序的输出是

a's type is float64 and value is 0.7375  
1

上一教程 Go语言基本类型简介
下一教程 Go语言函数和包介绍