Constantes del lenguaje Go

Como indica el nombre “ CONSTANTS” seLa intención implícita es fija, también en los lenguajes de programación, es decir, una vez que se define el valor de la constante, no se puede modificar. Las constantes pueden tener cualquier tipo de datos básicos, como constantes enteras, constantes de punto flotante, constantes de caracteres o cadenas literales.

¿Cómo se declara?
Las constantes se declaran de la misma manera que las variables, pero se utilizanconst Los identificadores de palabra clave se utilizan como prefijo para declarar constantes con tipos específicos. No se puede usar:=Declaración de sintaxis.

package main
import "fmt"
const PI =　3.14
func main() {
　　　　const GFG = "w3codebox"
　　　　fmt.Println("Hola", GFG)
　　　　fmt.Println("Feliz", PI, "Día")
　　　　const Correct= true
　　　　fmt.Println("Go rules?", Correct)
}

Salida:

Hola w3codebox
Feliz　3.14　Día
¿Reglas de Go? true

Constantes numéricas no tipificadas y tipificadas:
El funcionamiento de las constantes tipificadas es como variables inmutables que solo pueden operar con tipos idénticos, mientras que el funcionamiento de las constantes no tipificadas es como literals que pueden operar con tipos similares. En Go se pueden declarar constantes con o sin tipo. A continuación se muestra un ejemplo de constantes numéricas tipificadas y no tipificadas nombradas y no nombradas.

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

A continuación se muestra la lista de constantes en el lenguaje Go:

• Constantes numéricas (constantes enteras, constantes de coma flotante, constantes complejas)

• Literales de cadena

• Constantes booleanas

Constantes numéricas:
Las constantes numéricas sonvalores de alta precisión。Go es un lenguaje de tipo estático, que no permite operaciones mezcladas entre tipos de números. No se puedefloat64agregar aintincluso no se puede agregarint32agregar aint。Aunque, escribir1e6 * time.Second omath.Exp（1）incluso 1 <<（'\ t'+ 2.0） todos son válidos. En Go, las constantes son diferentes de las variables, y su comportamiento es similar a los números digitales comunes.

Las constantes numéricas pueden ser3tipos, es decir, enteros, coma flotante, complejos

Constantes enteras:

• prefijo que especifica la base: hexadecimal es 0x o 0X, octal es 0, decimal es 0.

• La literal de entero también puede tenersufijoque son combinaciones de U (mayúscula) y L (mayúscula), que representan entero sin signo y entero largo, respectivamente.

• puede serconstantes decimales, octales o hexadecimales.

• Un int puede almacenar hasta64enteros de bits, a veces incluso menos.

A continuación se muestraLas constantes enterasAlgunos ejemplos：

85　　　　　　　　　/*　decimal　*/
0213　　　　　　　/*　octal　*/
0x4b　　　　　　　/*　hexadecimal　*/
30　　　　　　　　　/*　int　*/
30u　　　　　　　　/*　unsigned int　*/
30l　　　　　　　　/*　long　*/
30ul　　　　　　　/*　unsigned long　*/
212　　　　　　　　　/*　Válido　*/
215u　　　　　　　　/*　Válido　*/
0xFeeL　　　　　　/*　Válido　*/
078　　　　　　　　　/*　Ilegal:8no es un dígito octal　*/
032UU　　　　　　　/*　Ilegal: no se puede repetir el sufijo　*/

Constantes complejas:
El comportamiento de la constante compleja es muy similar a la constante de coma flotante. Es un constante entera (o parámetro) depar ordenado o par de números realesy la constante se separa por comas, y el par se encierra entre paréntesis. La primera constante es la parte real, y la segunda constante es la parte imaginaria. La constante compleja COMPLEX * 8utiliza8bytesespacio de almacenamiento.

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

Constantes de tipo flotante:

• Las constantes de coma flotante tienen unauna parte entera, un punto decimal, una parte decimal y una parte exponencial.

• pueden representarse las constantes de coma flotante en forma decimal o exponencial.

• AunquePara representar en forma decimal, debe incluir el punto decimal, el exponente o ambos.

• Y al usarExponenteAl representar en forma, debe incluir la parte entera, la parte decimal o ambas.

A continuación se presentan ejemplos de constantes de tipo flotante:

3.14159　　　　　　　/*　Válido　*/
314159E-5L　　　　/*　Válido　*/
510E　　　　　　　　　　/*　Ilegal: exponente incompleto　*/
210f　　　　　　　　　　/*　Ilegal: no hay decimal o exponente　*/
.e55　　　　　　　　　　/*　Ilegal: falta entero o fracción　*/

Literales de cadena

• Go admite dos tipos de literales de cadena, es decir, "" (estilo de comillas dobles) y "" (estilo de comillas invertidas).

• Las cadenas puedenCascadaCon+Y+ =Operadores.

• Las cadenas contienen caracteres similares a los literales de caracteres: caracteres puros, secuencias de escape y caracteres universales, estos son de tipo no tipizado.

• El valor cero de un tipo de cadena es una cadena en blanco, que se puede representar como o con texto. " " ''

• Utilizando==, !=y (para comparar tipos iguales) operadores como,Tipos de cadenas comparables

Sintaxis

type _string struct {
　　　　elementos　*byte　//　Bajo nivel
　　　　len int　　　//Tamaño de bytes
}

Ejemplo de visualización de texto de cadena:
"hello, w3codebox"

"hello, \

w3codebox"

"hello, " "geeks" "forgeeks"

Aquí, todas las tres declaraciones anteriores son similares, es decir, no tienen un tipo específico.
Ejemplo:

package main
import "fmt"
func main() {
　　　　const A = "GFG"
　　　　var B = "w3codebox"
　　　　
　　　　//Conexión de cadenas
　　　　var helloWorld = A+　" "　+　B
　　　　helloWorld　+= "!"
　　　　fmt.Println(helloWorld)　
　　　　
　　　　//Comparación de cadenas
　　　　fmt.Println(A == "GFG")　　　
　　　　fmt.Println(B < A)　
}

Salida:

GFG w3codebox!
true
false

Constantes booleanas:
Las constantes booleanas son similares a las constantes de cadena. Aplican las mismas reglas que las constantes de cadena, la diferencia radica en que tienen dos constantes no tipizadas true y 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)
}

Salida:

true
true