Golang教程:(五)常量

前端之家收集整理的这篇文章主要介绍了Golang教程:(五)常量前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

原文:https://golangbot.com/constants/

这是本Golang系列教程的第五篇。

定义常量

常量(constant)表示固定的值,比如:5-89"I love Go"67.89 等等。

考虑如下程序:

var a int = 50  
var b string = "I love Go"

上面的程序中, a 和 b 分别被赋值为常量 50"I love Go"。关键字 const 用于指示常量,如 50"I love Go"。在上面的代码中,尽管没有使用关键字 const 修饰 50"I love Go",但它们在Go的内部表示为常量。(译者注:像 50"I love Go" 这样的值称为字面值(literal)常量,它们的值即为它们本身,是无法被改变的。

关键字 const 修饰的名字为常量,不能被重新赋予任何值。 因此下面的程序会报错:cannot assign to a

package main

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

常量的值必须在编译期间确定。因此不能将函数的返回值赋给常量,因为函数调用发生在运行期。

package main

import (  
    "fmt"
    "math"
)

func main() {  
    fmt.Println("Hello,playground")
    var a = math.Sqrt(4)//allowed
    const b = math.Sqrt(4)//not allowed
}

在上面的程序中,a 是一个变量因此可以被赋值为函数 math.Sqrt(4)调用结果。(我们将在单独的教程中更详细的讨论函数)。而 b 是一个常量,它的值必须在编译期间确定,但是函数 math.Sqrt(4)调用结果只能在运行时被计算出来,因此在编译 const b = math.Sqrt(4) 时将会报错:error main.go:11: const initializer math.Sqrt(4) is not a constant.

字符串常量

字符串常量最简单的常量,通过了解字符串常量可以更好的理解常量的概念。

在Go中任何用双引号(")括起来的值都是字符串常量,比如 "Hello World""Sam" 都是字符串常量。

字符串常量是什么类型呢?答案是 无类型(untyped)

"Hello World" 这样的字符串没有任何类型。

const hello = "Hello World"

上面的代码"Hello World" 赋给一个名为 hello 的常量。那么现在常量 hello 是不是就有了类型?答案是:No。hello 仍然没有类型。

下面的代码中,变量 name 被赋值为一个无类型的常量 "Sam",它是如何工作的呢?

package main

import (  
    "fmt"
)

func main() {  
    fmt.Println("Hello,playground")
    var name = "Sam"  // 译者注:这里编译器需要推导出 name 的类型,
                      // 那么它是如何从无类型的常量 "Sam" 中获取类型的呢?
    fmt.Printf("type %T value %v",name,name)

}

答案是无类型常量有一个默认的类型,当且仅当代码中需要无类型常量提供类型时,它才会提供该默认类型。在语句 var name = "Sam" 中,name需要一个类型,因此它从常量 "Sam"获取其默认类型:string。

译者注:这里可以理解为常量是无类型的,但是在需要类型的场合,编译器会根据常量的值和上下文将常量转换为相应的类型。

有没有办法创建一个有类型(typed)的常量?答案是:Yes。下面的代码创建了一个有类型常量。

const typedhello string = "Hello World"

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

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,它是 string 的别名。

译者注:可以通过 type NewType Type 的语法来创建一个新的类型。类似 C 语言的 typedef 。

接着我们创建了一个名为 customNamemyString 类型的变量,并将常量 "Sam" 赋给它。因为常量 "Sam" 是无类型的所以可以将它赋值给任何字符串变量。因此这个赋值是合法的,customName 的类型是 myString

现在我们有两个变量:string 类型的 defaultNamemyString 类型的 customName。尽管我们知道 myStringstring 的一个别名,但是Go的强类型机制不允许将一个类型的变量赋值给另一个类型的变量。因此, customName = defaultName 这个赋值是不允许的,编译器会报错:main.go:10: cannot use defaultName (type string) as type myString in assignment

布尔常量

布尔常量与字符串常量(在概念上)没有区别。布尔常量只包含两个值:truefalse。字符串常量的规则也同样适用于布尔常量,这里不再赘述。下面的代码解释了布尔常量:

package main

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

上面的程序很好理解,这里就不过多解释了。

数值常量

数值常量(Numeric constants)包括整数,浮点数以及复数常量。数值常量有一些微妙之处。

让我们看一些例子使事情变得明朗。

package main

import (  
    "fmt"
)

func main() {  
    fmt.Println("Hello,playground")
    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 是无类型的,值为 5你也许想知道 a 的默认类型是什么?如果它有默认类型,那么它是怎么赋值给其他类型的变量的? 答案在于使用 a 时的上下文。我们暂时放下这两个问题,先来看下面的程序:

package main

import (  
    "fmt"
)

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

在上面的程序中,所有变量的类型都是由数值常量决定的。在语法上看,5 在是一个整数,5.6 是一个浮点数, 5 + 6i 是一个复数。运行上面的程序,输出为:i's type int,f's type float64,c's type complex128

译者注:编译器可以根据字面值常量的表现形式来确定它的默认类型,比如 5.6 表现为浮点数,因此它的默认类型为 float64 ,而 "Sam" 表现为字符串,因此它的默认类型为 stirng

现在应该很清楚下面的程序是如何工作的了:

package main

import (  
    "fmt"
)

func main() {  
    fmt.Println("Hello,complex64Var)
}

在这个程序中,a 的值是 5 并且 a 在语法上是泛化的(它既可以表示浮点数 5.0,也可以表示整数 5,甚至可以表示没有虚部的复数 5 + 0i),因此 a 可以赋值给任何与之类型兼容的变量。像 a 这种数值常量的默认类型可以想象成是通过上下文动态生成的。var intVar int = a 要求 a 是一个 int,那么 a 就变成一个 int 常量。var complex64Var complex64 = a 要求 a 是一个 complex64,那么 a 就变成一个 complex64 常量。这很容易理解:)

数值表达式

数值常量可以在表达式中自由的混合和匹配,仅当将它们赋值给变量或者在代码中明确需要类型的时候,才需要他们的类型。

package main

import (  
    "fmt"
)

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

在上面的程序中,语法上 5.9 是一个浮点数,8 是一个整数。因为它们都是数值常量,因此 5.9/8 是合法的。相除的结果为 0.7375,是一个浮点数。因此变量 a 的类型为浮点型。上面的程序输出为:a's type float64 value 0.7375


常量的介绍到此结束。

目录
上一篇Golang教程:(四)类型
下一篇Golang教程:(六)函数

原文链接:https://www.f2er.com/go/188238.html

猜你在找的Go相关文章