Costanti del linguaggio Go

Come suggerisce il nome “ CONSTANTS” haIl significato implicito è fisso, come in un linguaggio di programmazione, ossia, una volta definito il valore di una costante, non può essere modificato più. Le costanti possono avere qualsiasi tipo di dati fondamentali, come costanti intere, costanti a virgola mobile, costanti di carattere o testi di stringa.

come dichiararle?
Le costanti vengono dichiarate come variabili, ma si utilizzaconst le parole chiave come prefisso per dichiarare costanti con un tipo specifico. Non è possibile utilizzare:=dichiarazione grammaticale。

package　main
import　"fmt"
const PI = 3.14
func　main()　{
　　　　const GFG = "w3codebox"
　　　　fmt.Println("Hello", GFG)
　　　　fmt.Println("Happy", PI, "Day")
　　　　const Correct = true
　　　　fmt.Println("Go rules?", Correct)
}

Output:

Hello w3codebox
Happy 3.14 Day
Go rules? true

Costanti numeriche nontipizzate e tipizzate：
Il funzionamento delle costanti tipizzate è simile a variabili immutabili che possono interagire solo con lo stesso tipo, mentre il funzionamento delle costanti nontipizzate è simile a costanti testuali che possono interagire con tipi simili. In Go è possibile dichiarare costanti con o senza tipo. Esempi di costanti numeriche denominate e non denominate, tipizzate e nontipizzate.

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

Ecco l'elenco delle costanti nel linguaggio Go：

• costanti numeriche (costanti intere, costanti a virgola mobile, costanti complesse)

• litere di stringa

• costanti booleane

costanti numeriche：
le costanti numeriche sonovalori ad alta precisione。Go è un linguaggio di programmazione staticamente tipizzato, che non permette operazioni miste su tipi numerici. Non puoi aggiungerefloat64aggiunto aint， persino non può essereint32添加 到int。虽然，写1e6 * time.Second 或math.Exp（1）甚至 1 <<（'\ t'+ 2.0） 都是合法的。在Go中，常量与变量不同，其行为类似于常规数字。

数值常量可以是3种，即整数，浮点数，复数

整数常量：

• 前缀指定基数：十六进制为0x或0X，八进制为0，十进制为0。

• 整数字面量也可以具有后缀，分别是U（大写）和L（大写）的组合，分别表示无符号和长整数。

• 它可以是十进制，八进制或十六进制常量。

• 一个int最多可以存储64位整数，有时更少。

以下是整数常量的一些示例：

85                         /* 十进制 */
0213                         /* 八进制 */
0x4b                         /* 十六进制 */
30                         /* int */
30u                         /* unsigned int */
30l                         /* long */
30ul                         /* unsigned long */
212                         /* 合法 */
215u                         /* 合法 */
0xFeeL                     /* 合法 */
078                         /* 非法的:8不是八进制数字 */
032UU                     /* 非法的:不能重复后缀 */

复数常量：
复数常量的行为与浮点常量非常相似。它是整数常数（或参数）的有序对 或 实数对，并且该常数用逗号分隔，并且该对包含在括号之间。第一个常数是实部，第二个常数是虚部。复数常量COMPLEX * 8使用8个字节的存储空间。

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

浮动类型常量：

• 浮点型常量具有一个整数部分，一个小数点，一个小数部分和一个指数部分。

• 可以用十进制或指数形式表示浮点常量。

• 虽然用十进制形式表示，必须包含小数点，指数，或两者兼而有之。

• 并且在使用指数在形式表示时，必须包括整数部分，小数部分或两者。

以下是浮点类型常量的示例：

3.14159                     /* 合法 */
314159E-5L                 /* 合法 */
510E                         /* 非合法：不完整的指数 */
210f　/*　Non consentito: manca un numero decimale o esponenziale　*/
.e55　/*　Non consentito: manca un intero o un numero frazionato　*/

Literali di stringa

• Go supporta due tipi di literal di stringa, ovvero "" (stili di virgolette doppie) e "" (stili di virgolette quadre).

• Le stringhe possonocatenazionecon+e+ =Operatore.

• Le stringhe contengono caratteri simili ai literal di carattere: caratteri puri, sequenze di escape e caratteri universalmente definiti, che sono non tipizzati.

• Il valore zero di un tipo di stringa è una stringa vuota, che può essere rappresentata come o con il testo. " " ''

• usando==，！=e operatori come (usati per confrontare lo stesso tipo)等，Tipi di stringa comparabili

Sintassi

type　_string　struct　{
　　　　elements　*byte　//　byte di base
　　　　len　int　//numero di byte
}

Esempio di visualizzazione delle stringhe：
"hello, w3codebox"

"hello, \

w3codebox"

"hello, " "geeks" "forgeeks"

In questo caso, tutte e tre le espressioni sono simili, ovvero non hanno un tipo specifico.
Esempio：

package　main
import　"fmt"
func　main()　{
　　　　const　A= "GFG"
　　　　var　B　=　"w3codebox"
　　　　
　　　　//concatenazione delle stringhe
　　　　var　helloWorld　=　A+ " " + B
　　　　helloWorld += "!"
　　　　fmt.Println(helloWorld)　
　　　　
　　　　//confronto delle stringhe
　　　　fmt.Println(A == "GFG")　　　
　　　　fmt.Println(B < A)　
}

Output:

GFG w3codebox!
true
false

Costanti booleane：
Le costanti booleane sono simili alle costanti di stringa. Applicano le stesse regole delle costanti di stringa, la differenza è che hanno due costanti non tipizzate true e 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)
}

Output:

true
true