Comment utiliser les constantes dans Golang

Qu'est-ce que Constant ou Const dans Golang ? Voici ce que vous devez savoir sur l’utilisation des constantes dans Go .

Comme son nom l’indique, constant signifie fixe. Il en va de même dans les langages de programmation : une fois la valeur d’une constante définie, elle ne peut plus être modifiée. Il peut y avoir n'importe quel type de données de base de constante comme une constante entière, une constante dynamique, une constante de caractère ou une chaîne.

Comment déclarer : les constantes sont déclarées comme des variables, mais utilisez le mot-clé const comme préfixe pour déclarer des constantes avec un type de données spécifique. Les constantes ne peuvent pas être déclarées à l’aide de la syntaxe « : = ».

Par exemple:

package main

import "fmt"

const PI = 3.14

func main() 
{
	const GFG = "Quantrimang"
	fmt.Println("Hello", GFG)

	fmt.Println("Happy", PI, "Day")

	const Correct= true
	fmt.Println("Go rules?", Correct)
}

Résultat:

Hello Quantrimang
Happy 3.14 Day
Go rules? true

Choses à savoir sur les constantes dans Golang

Constantes numériques sans type et avec type

Les constantes typées se comportent comme des variables immuables qui ne peuvent interagir qu'avec les mêmes types, et les constantes sans type se comportent comme des constantes littérales qui peuvent interagir avec des types similaires. Les constantes peuvent être déclarées avec ou sans type dans Go. Les exemples suivants montrent des constantes numériques typées et non typées, nommées et sans nom.

const untypedInteger          = 123
const untypedFloating          = 123.12

const typedInteger  int             = 123
const typedFloatingPoint   float64  = 123.12

Voici la liste des constantes du langage Go :

• Constantes (constantes entières, constantes dynamiques, constantes complexes)
• Chaîne de caractères
• constante booléenne

Constante numérique

Les constantes numériques sont des valeurs de haute précision. Étant donné que Go est un langage typé statiquement, il n’autorise pas les opérations qui combinent des types numériques. Vous ne pouvez pas ajouter float64à int, ni même int32à int. Cependant, il est toujours valable d'écrire 1e6*time.Secondou math.Exp(1)ou même 1<>. En Go, les constantes, contrairement aux variables, se comportent comme des nombres normaux.

Les constantes numériques sont de trois types :

1. entier
2. virgule flottante
3. complexe

Constante entière :

• Le préfixe spécifie la base : 0x ou 0X pour hexadécimal, 0 pour octal et rien pour décimal.
• Un littéral entier peut également avoir un suffixe qui est une combinaison de U (majuscule) et L (minuscule), pour non signé et long respectivement.
• Il peut s'agir d'une constante décimale, octale ou hexadécimale.
• Un int peut stocker jusqu'à un entier de 64 bits et parfois moins.

Voici quelques exemples de constantes entières :

85 /* thập phân */
0213 /* bát phân */
0x4b /* thập lục phân */
30 /* int */
30u /* unsigned int */
30l /* long */
30ul /* unsigned long */
212 /* Hợp lệ */
215u /* Hợp lệ */
0xFeeL /* Hợp lệ */
078 /* Không hợp lệ: 8 không phải là chữ số bát phân */
032UU /* Không hợp lệ: không thể lặp lại hậu tố */

Constantes complexes :

Les constantes complexes fonctionnent de manière très similaire aux constantes à virgule flottante. Il s'agit d'une paire ordonnée ou d'une paire réelle de constantes entières (ou paramètres). Les constantes sont séparées par des virgules et les paires de nombres sont placées entre parenthèses. La première constante est la partie réelle et la deuxième constante est la partie imaginaire. Une constante complexe, COMPLEX*8, utilise 8 octets de stockage.

Par exemple:

(0.0, 0.0) (-123.456E+30, 987.654E-29)

Constante de type dynamique :

• Les constantes de nombres réels ont une partie entière, une partie décimale, une partie fractionnaire et une partie exposant.
• Peut être représenté comme une constante réelle sous forme décimale ou exponentielle.
• Lorsqu'il est exprimé sous forme décimale, il doit inclure un point décimal, un exposant ou les deux.
• Et lorsqu'elle est exprimée sous forme exponentielle, elle doit inclure une partie entière, une partie fractionnaire ou les deux.

Par exemple:

3.14159 /* Hợp lệ */
314159E-5L /* Hợp lệ */
510E /* Không hợp lệ: số mũ không đầy đủ */
210f /* Không hợp lệ: không có số thập phân hoặc số mũ */
.e55 /* Không hợp lệ: thiếu số nguyên hoặc phân số */

Chaîne de caractères

• Go prend en charge deux types de littéraux de chaîne, à savoir ” ”(style guillemets doubles) et ‘ ‘(style guillemets inversés).
• Les chaînes peuvent être concaténées avec les opérateurs +et +=.
• Les chaînes contiennent des caractères similaires aux caractères littéraux : caractères simples, séquences d'échappement et caractères universels. Et c'est un personnage sans style.
• La valeur zéro des types de chaîne est la chaîne vide, qui peut être représentée par ” ”ou ”dans des littéraux.
• Tous les types de chaînes peuvent être comparés à l'aide d'opérateurs tels que ==, !=et (pour comparer des types similaires)

Syntaxe:

kiểu _string struct {
các phần tử *byte // các byte cơ bản
len int // số byte
}

Par exemple:

"hello, quantrimang" 

"hello, \ 

quantrimang" 

"hello, " "quan" "trimang" 

Ici, les trois énoncés sont identiques, c'est-à-dire qu'ils n'ont pas de type spécifique.

Par exemple:

package main

import "fmt"

func main()
{
	const A = "GFG"
	var B = "GeeksforGeeks"
	
	// Chuỗi Concat.
	var helloWorld = A+ " " + B
	helloWorld += "!"
	fmt.Println(helloWorld) 
	
	// Chuỗi so sánh.
	fmt.Println(A == "GFG") 
	fmt.Println(B < a)="">

Résultat:

GFG Quantrimang!
true
false

Complexité temporelle : O(1)
Espace auxiliaire : O(1)

constante booléenne

Les constantes booléennes sont similaires aux constantes de chaîne. Il applique les mêmes règles que les constantes de chaîne. La seule différence est qu'il possède deux const sans type trueet false.

package main

import "fmt"

const Pi = 3.14

func main() 
{
	const trueConst = true
	
	// Định nghĩa kiểu bằng từ khóa type
	type myBool bool 
	var defaultBool = trueConst // được phép
	var customBool myBool = trueConst // được phép
	
	// defaultBool = customBool // không được phép
	fmt.Println(defaultBool)
	fmt.Println(customBool) 
}

Résultat:

true
true

Complexité temporelle : O(1)
Espace auxiliaire : O(1)

Constantes dans Go : Go possède des constantes de type caractère, chaîne, booléenne et numérique. Const déclare une valeur constante. Une instruction constpeut se produire lorsqu'il y a une variable et ainsi, effectuer des opérations arithmétiques sans aucune précision fixe.

// Minh họa hằng số bằng cách dùng go.
package main

import (
	"fmt"
	"math"
)

const s string = "Quantrimang"

func main() {
	fmt.Println(s)

	const n = 5

	const d = 3e10 / n
	fmt.Println(d)

	fmt.Println(int64(d))

	fmt.Println(math.Sin(n))
}

Résultat:

Quantrimang
6e+09
6000000000
-0.9589242746631385

Complexité temporelle : O(1)
Espace auxiliaire : O(1)

Si vous souhaitez définir plusieurs constantes à la fois, vous pouvez le faire en utilisant un bloc de parenthèses comme indiqué ci-dessous.

package main

import "fmt"

const (
	GFG	 = "Quantrimang"
	Correct = true
	Pi	 = 3.14
)

// Hàm chính
func main() {

	fmt.Println("value of GFG : ", GFG)

	fmt.Println("value of Correct : ", Correct)

	fmt.Println("value of Pi : ", Pi)
}

Résultat:

value of GFG :  Quantrimang
value of Correct :  true
value of Pi :  3.14