Constantes du langage Go

Comme le nom " CONSTANTS” sontLa signification implicite est fixe, de même dans les langages de programmation, c'est-à-dire que, une fois la valeur de la constante définie, elle ne peut pas être modifiée. Les constantes peuvent avoir n'importe quel type de données de base, par exemple des constantes entières, des constantes flottantes, des constantes de caractères ou des textes littéraux.

Comment déclarer ?
Les constantes sont déclarées de la même manière que les variables, mais utilisentconst Les mots-clés utilisés comme préfixe pour déclarer des constantes de types spécifiques. Ne pas utiliser:=Déclaration de syntaxe.

package main
import "fmt"
const PI =　3.14
func main() {
　　　　const GFG = "w3codebox"
　　　　fmt.Println("Bonjour", GFG)
　　　　fmt.Println("Heureux", PI, " Jour")
　　　　const Correct= vrai
　　　　fmt.Println("Go règle ?", Correct)
}

Sortie :

Bonjour w3codebox
Heureux　3.14　Jour
Go règle ? vrai

Constantes numériques non typées et typées :
Le fonctionnement des constantes typées fonctionne comme des variables immuables qui ne peuvent interagir qu'avec des types similaires, tandis que le fonctionnement des constantes non typées fonctionne comme des littéraux qui peuvent interagir avec des types similaires. Les constantes peuvent être déclarées avec ou sans type en Go. Les exemples suivants montrent des constantes numériques typées et non typées nommées et non nommées.

const untypedInteger　123
const untypedFloating typed　123.12
const typedInteger int　123
const typedFloatingPoint float64　　=　123.12

Voici la liste des constantes dans le langage Go :

• Constantes numériques (littéraux numériques entiers, constantes flottantes, constantes complexes)

• Littéraux de chaîne

• Constantes booléennes

Constantes numériques :
Les constantes numériques sontvaleurs à haute précision。Go est un langage statique, qui ne permet pas les opérations de mixage de types numériques. Vous ne pouvez pasfloat64ajouter àint，et même ne pas pouvoir ajouterint32ajouter àint。Bien que, écrire1e6 * time.Second oumath.Exp(1)même 1 <<('\ t'+ 2.0) toutes sont valides. Dans Go, les constantes sont différentes des variables, elles se comportent comme des nombres normaux.

Les constantes numériques peuvent être3Types, c'est-à-dire entiers, flottants, complexes

Constantes entières :

• Préfixe spécifiant la base : hexadécimal pour 0x ou 0X, octal pour 0, décimal pour 0.

• Les littéraux numériques entiers peuvent également avoirsuffixerespectivement U (majuscule) et L (majuscule), représentant respectivement les entiers sans signe et les entiers longs.

• Il peut êtredécimal, octal ou hexadécimal.。

• Un int peut stocker au maximum64bits d'entiers, parfois moins.

VoiciConstantes entièresVoici quelques exemples：

85　　　　　　　　　/*　decimal　*/
0213　　　　　　　/*　octal　*/
0x4b　　　　　　　/*　hexadécimal　*/
30　　　　　　　　　/*　int　*/
30u　　　　　　　　/*　unsigned int　*/
30l　　　　　　　　/*　long　*/
30ul　　　　　　　/*　unsigned long　*/
212　　　　　　　　　/*　Légal　*/
215u　　　　　　　　/*　Légal　*/
0xFeeL　　　　　　/*　Légal　*/
078　　　　　　　　　/*　Il est illégal :8n'est pas un chiffre octal　*/
032UU　　　　　　　/*　Il est illégal : ne pas répéter l'extension　*/

Constantes complexes :
Le comportement des constantes complexes est très similaire aux constantes flottantes. Il est une constante entière (ou paramètre)paire ordonnée ou paire réelleet cette constante est séparée par une virgule, et cette paire est encadrée par des parenthèses. La première constante est la partie réelle, la deuxième constante est la partie imaginaire. La constante COMPLEX * 8Utilisez8octetsde l'espace de stockage.

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

Constantes de type flottant :

• Les constantes flottantes ont uneune partie entière, un point décimal, une partie décimale et une partie exponentielle。

• les constantes flottantes peuvent être représentées en format décimal ou exponentiel.

• Bien queEn utilisant le format décimal, il doit y avoir un point décimal, un exposant ou les deux.

• Et en utilisantExponentielLorsqu'ils sont représentés sous forme de chaîne, ils doivent inclure une partie entière, une partie décimale ou les deux.

Voici des exemples de constantes de types flottants :

3.14159　　　　　　　/*　Légal　*/
314159E-5L　　　　/*　Légal　*/
510E　　　　　　　　　　/*　Illégal : exponentiel incomplet　*/
210f　　　　　　　　　　/*　Illégal : pas de décimal ou d'exponentiel　*/
.e55　　　　　　　　　　/*　Illégal : manque d'entier ou de fraction　*/

Littéraux de chaîne

• Go prend en charge deux types de littéraux de chaînes, à savoir "" (style d'quotes doubles) et "" (style d'quotes inversées).

• Les chaînes peuventcascadingpar+et+ =Opérateurs.

• Les chaînes contiennent des caractères similaires à ceux des littéraux de caractères : caractères purs, séquences d'échappement et caractères universels, ce qui est sans type.

• La valeur zéro d'un type de chaîne est une chaîne vide, qui peut être représentée par ou avec des caractères littéraux. " " ''

• En utilisant==, !=et (utilisé pour comparer des types similaires) et autres opérateurs,Type de chaîne comparable

Syntaxe

type _string struct {
　　　　éléments　*byte　//　Octets de base
　　　　len int　　　//Taille des octets
}

Exemples d'expressions littérales de chaînes :
"hello, w3codebox"

"hello, \

w3codebox"

"hello, " "geeks" "forgeeks"

Ici, les trois instructions ci-dessus sont similaires, c'est-à-dire qu'elles n'ont pas de type spécifique.
Exemple :

package main
import "fmt"
func main() {
　　　　const A = "GFG"
　　　　var B = "w3codebox"
　　　　
　　　　//Concaténation des chaînes
　　　　var helloWorld = A+　" "　+　B
　　　　helloWorld　+= "!"
　　　　fmt.Println(helloWorld)　
　　　　
　　　　//Comparaison des chaînes
　　　　fmt.Println(A == "GFG")　　　
　　　　fmt.Println(B < A)　
}

Sortie :

GFG w3codebox!
true
false

Constantes booléennes :
Les constantes booléennes sont similaires aux constantes de chaîne. Elles appliquent les mêmes règles que les constantes de chaîne, la seule différence étant qu'elles possèdent deux constantes non typées true et false.

package main
import "fmt"
const Pi =　3.14
func main() {
　　　　const trueConst = true
　　　　type myBool bool
　　　　var defaultBool = trueConst　　　　　　　//　允許
　　　　var customBool myBool = trueConst　//　允許
　　　　//　　defaultBool = customBool　//　不允許
　　　　fmt.Println(defaultBool)
　　　　fmt.Println(customBool)
}

Sortie :

true
true