第五篇常量

常量

什么是常量

在Go中constant这个术词是用来表示固定值的，例如：

95
"I LOVE YOU"
777.66

等等。

声明一个常量

声明常量是使用关键字const，下面我们看一个例子，是如何声明一个常量的。

package main

import (
	"fmt"
)

func main() {

	const a = 50
	fmt.Println(a)
}

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

声明一组常量

在这里有也是有方法通过使用一个语句来声明一组变量。下面就提供了声明一组变量的语法。

package main

import (
	"fmt"
)

func main() {

	const (
		name = "zhangsan"
		age = 50
		contry = "china"
	)
	fmt.Println(name)
	fmt.Println(age)
	fmt.Println(contry)

}

在上面的程序中，我们声明了3个常量name,age和contry。下面就是程序的输出.

zhangsan
50
china

常量，就像它的名字一样，就不可以再重新给它赋予其他的值。在下面的程序中，我们试着将另外一个值89赋予a。但这样是不允许的，因为a是一个常量。所以这个程序将会编译失败，并报错cannot assign to a (declared const)。

package main

func main() {

	const a = 55  // 允许
	a = 89  // 重新给一个常量赋值是不允许的
}

常量的值是在编译的时候就已经知道了的。因此，不能使用函数调用返回的值作为常量值，因为函数调用是在程序运行的时候发生的。

package main

import (
	"math"
)

func main() {

	var a = math.Sqrt(4)  // 允许
	const b = math.Sqrt(4)  // 不允许
}

在上面的程序中，a是一个变量，可以使用函数的返回值作为它的值。但b是一个常量，它的值需要在编译的时候就确定下来。而函数math.Sqrt(4)只有在运行的时候才会求值，因此const b=math.Sqrt(4)在编译的时候就会发生错误。

const initializer math.Sqrt(4) is not a constant

字符串常量，有类型和无类型的常量

Go的字符串常量的值是由两个引起括起来的。例如，一些字符串"Hello World","Sam"在Go中都是常量。

那么，字符串常量是属于什么类型的呢？答案就是，无类型的！

一个字符串常量，就像"Hello World"就没有任何类型之说.

const hello = "Hello World"

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

Go是一种强类型语言。所有的变量都需要有一个显式的类型。在下面的程序中，当无类型的常量n赋值给一个变量name时，这个程序是怎么工作的呢？

package main

import (
	"fmt"
)

func main() {

	const n = "zhangsan"
	var name = n
	fmt.Printf("type %T value %v", name,name)
}

答案就是无类型常量是有一个默认的关联类型的，当且仅当一行代码需要时，它们才会提供。在语句var name = n中，name需要一个类型，所以它从字符串常量n取的默认的类型string。

那是否有一种方式创建一个有类型常量呢？答案是肯定的，下面的代码就是创建了一个有类型的常量。

const typedhello string = "hello world"

typedhello在上面的代码中是一个string类型的常量

Go是一种强类型语言，变量赋值给多个类型是不允许的。我们看看下面的程序就知道是咋回事。

package main

func main() {

	var defaultName = "Sam"
	type myString string
	var customName myString = "Sam"
	customName = defaultName
}

在上面的代码中，我们首先创建了一个变量defaultName，并且赋值了一个常量Sam。常量sam的默认类型是string，所以经过赋值后，defaultName的类型就是string.

在下一行代码，我们创建了string的别名一个新的类型myString。

然后，我们创建了一个myString类型的变量customName，并给它赋值常量sam,因为sam是无类型的，它可以赋值给任何字符串变量(string)。因此，这个赋值是允许的，而customName的类型就是myString。

现在我们有一个string类型的变量defaultName和另外一个myString类型的变量customName，即使我们知道myString是string的别名，但是Go的强类型策略不允许一个类型的变量赋值另外一种类型。因此，赋值语句 customName = defaultName是不允许的，编译时也会跑出错误，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 // 允许
	var customBool myBool = trueConst  //允许
	defaultBool = customBool  // 不允许，default是bool类型，customBool是自定义的myBool类型
}

上面的程序要表达的是不言而喻的。

数值常量

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

让我们看一些例子来弄清楚它。

package main

import(
	"fmt"
)
func main() {

	const a = 50
	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赋予其他不同类型的变量将会怎么样？,答案就在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, c's type is %T, c's type is %T",i,f,c)
}

在上面的常量中，每个变量的类型取决于数值常量的语法。根据语法，5是一个整数，5.6是浮点数，5+6i是复数。执行上面的程序，将会输出：

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

根据这个知识点，让我们尝试理解下面的程序是怎么运行的。

package main

import(
	"fmt"
)
func main() {

	const a = 50
	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的语法是泛型的。它可以表示浮点型、整型、甚至复数非虚拟部分数值。所以它可以赋值给任何可兼容的类型。这些常量的默认类型可以看作是取决于上下文而动态生成的。var intVar int = a需要a作为整型，所以它就成为一个整型的常量。var complex64Var complex64 = a需要a作为一个复数数值，所以它就是一个复数常量。相当整洁的。

数字表达式

数值常量是可以在表达式中随意混合和搭配的，只有当它们赋值给一个变量才需要类型，或者在代码中其他要求需要类型的地方。

package main

import(
	"fmt"
)
func main() {

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

在上面的程序中，5.9在语法中是浮点型(float)，8在语法是整型(integer)，尽管如此，5.9/8依然是允许的，因为这两都是数值常量。这个除法的结果0.7375是float的，因此，变量a的类型是浮点型(float)，下面是程序的输出。

a's type is float64 and value id 0.7375

以上就是本篇的全部，感谢阅读，这是我第一次翻译，难免会有翻译不当的地方，如果有什么反馈和评论，欢迎提出来！

原文地址： https://golangbot.com/constants/

posted on 2021-12-28 21:25 swong 阅读(76) 评论(0) 收藏举报

刷新页面返回顶部

导航

第五篇 常量

常量