Aller aux bases du langage-constantes

Qu'est-ce qu'une constante ?

Les constantes sont utilisées dans le langage Go pour représenter des valeurs fixes, par exemple :

95
"I love Go"
67.89

Déclarer des constantes

Le mot-clé const est utilisé pour déclarer une constante. en langage Go :

package main

import (
    "fmt"
)

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

Execute ^[1]

Le code ci-dessus déclare la constante a et lui attribue une valeur de 50.

Déclarer un ensemble de variables

Le langage Go fournit une syntaxe pour déclarer un ensemble de constantes dans un seul bloc d'instructions. Jetons un coup d'œil à l'exemple :

package main

import (
    "fmt"
)

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

}

Execute ^[2].

Le code ci-dessus, nous avons déclaré un ensemble de constantes : nom, âge et pays, et le résultat de l'exécution est :

John
50
Canada

Les constantes, comme leur nom l'indique, sont fixes et ne peuvent pas être réaffectées à d'autres valeurs après déclaration. Dans le code suivant, nous essayons d'attribuer à nouveau la valeur 89 à la constante a. Cela n'est pas autorisé car a est une constante et le compilateur signalera une erreur qui ne peut pas être attribuée à a.

package main

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

Exécution^[3]

La valeur d'une constante doit être déterminée au moment de la compilation, par conséquent, la valeur renvoyée par un appel de fonction ne peut pas être affectée à une constante, car l'appel de fonction se produit au moment de l'exécution .

package main

import (
    "math"
)

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

Execute ^[4]

Dans le code ci-dessus, a est une variable, elle peut donc être initialisée par la valeur de retour de la fonction math.Sqrt(4).

b 是常量，它的值在编译时就需要确定，而函数 math.Sqrt(4) 的返回值在运行时确定，所以编译会报错：

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

字符串常量、类型确定常量和无类型常量

Go 语言里面，使用双引号括起来来的任何值表示字符串常量，例如："Hello World", "Sam" 等。

字符串常量属于什么类型呢？答案是类型不确定。

const hello = "Hello World"

上面的代码，没有为常量 hello 指定类型。

Go 是强类型语言，所有变量的类型都是明确的。

下面的代码，将无类型的常量 n 赋值给变量 name 的机制是怎样的呢？

package main

import (
    "fmt"
)

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

}

执行^[5]

未定义类型的常量被使用时，会根据上下文来获得相关类型。

例如上面代码的第 9 行，编译器会自动推断常量 n 的类型为 string。

那有没有创建指定类型的常量呢？

当然是有的，比如下面这样：

const typedhello string = "Hello World"

typedhello 是 string 类型的常量。

Go 是强类型语言，不同类型之间相互赋值时不允许的。我们看下这个例子：

package main

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

}

执行^[6]

上面的代码，我们创建了变量 defaultName 并赋值为常量 Sam，因为 Sam 的默认类型为 string，所以变量 defaultName 的类型也是 string。

接着下一行代码，使用关键字 type 创建了新的类型 myString，底层类型是 string。

接着我们创建了 myString 类型的变量 customName，并将常量 Sam 赋值给它。因为 Sam 未指定类型，所以可以用它给任意字符串变量赋值。

现在变量 defaultName 的类型是 string，变量 customName 的类型是 myString，尽管两者的底层类型相同，但还是不允许相互赋值，所以最后一行代码会编译报错：

./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
}

执行^[7]

大家可以自行分析上面的代码。

数值常量

数值常量包括整型、浮点和复数，数值常量有一些特别的地方，一起看下：

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

执行^[8]

看上面的代码，a 是无类型的常量，值为 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)

}

执行^[9]

上面的代码，每个变量的类型取决于各自赋值的常量，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 表示的数值是比较通用的，它可以表示整型、浮点数甚至是不带虚数的复数，因此它可以分配给任何兼容的类型。常量的类型可以认为是根据上下文动态生成的。比如，var intVar int = a 场景中 a 是 int，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 is %v", a, a)
}

执行^[10]

上面的代码中，在语法上，5.9 表示 float、8 表示 int，尽管如此，5.9/8 依然是允许的，因为它们都是数值常量。相除的结果是 0.7375，float 类型，因此变量 a 的类型是浮点数。

程序输出：

a's type is float64 and value is 0.7375

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!