这是我参与「第五届青训营」伴学笔记创作活动的第 1 天

常量

这总结了 Go 语言常量的一些知识。

什么是常量？

Go 中的术语常量用于表示固定值，例如

95  
"I love Go" 
67.89

等等。

声明常量

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

package main

import (  
    "fmt"
)

func main() {  
    const a = 50
    fmt.Println(a)
}

在上面的代码中a 是一个常量，它被赋值 50.

声明一组常量

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

package main

import (  
    "fmt"
)

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

}

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

John  
50  
Canada

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

package main

func main() {  
    const a = 55 //allowed
    a = 89 //reassignment not allowed
}

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

package main

import (  
    "math"
)

func main() {  
    var a = math.Sqrt(4)   //allowed
    const b = math.Sqrt(4) //not allowed
}

在上面的程序中，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

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

括在双引号之间的任何值都是 Go 中的字符串常量。例如，"Hello World"``"Sam"这样的字符串都是Go中的常量。

字符串常量属于什么类型？答案是它们是未键入的.

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

const hello = "Hello World"

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

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

package main

import (  
    "fmt"
)

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

}

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

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

const typedhello string = "Hello World"

上面的代码中的类型dhello是字符串类型的常量。

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

package main

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

}

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

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

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

现在我们有一个string类型的变量 defaultName 和另一个 myString 类型的变量 customName。尽管我们知道 myString 是字符串的别名，但 Go 的强类型策略不允许将一种类型的变量分配给另一种类型。因此，不允许赋值 customName = defaultName defaultName，编译器抛出错误 ../prog.go:7:20: cannot use defaultName (type string) as type myString in assignment

布尔常量

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

package main

func main() {  
    const trueConst = true
    type myBool bool
    var defaultBool = trueConst //allowed
    var customBool myBool = trueConst //allowed
    defaultBool = customBool //not allowed
}

上述程序是不言自明的。

数值常量

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

让我们看一些例子来说明问题。

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

在上面的程序中，const a 是untyped，值为 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)

}

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

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

有了这些知识，让我们尝试了解以下程序的工作原理。

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

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

数值表达式

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

package main

import (  
    "fmt"
)

func main() {  
    var a = 5.9 / 8
    fmt.Printf("a's type is %T and value is %v", a, a)
}

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

a's type is float64 and value is 0.7375

这就是所有的内容了，具体介绍了常量的定义、使用。

Go 语言常量的使用 ｜ 青训营笔记

常量