Constantes-Ir Idioma

Como sugiere el nombre CONSTANTES significa fijo, en los lenguajes de programación también es lo mismo, es decir, una vez que se define el valor de la constante, no se puede modificar más. Puede haber cualquier tipo de datos básicos de constantes como una constante entera, una constante flotante, una constante de carácter o una string literal. 

Cómo declarar: las constantes se declaran como variables pero al usar una palabra clave const como prefijo para declarar una constante con un tipo específico. No se puede declarar usando la sintaxis  » =» .

Ejemplo: 

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

Producción: 

Hello GeeksforGeeks
Happy 3.14 Day
Go rules? true

Constantes numéricas sin tipo y con tipo: 
las constantes con tipo funcionan como variables inmutables que pueden interoperar solo con el mismo tipo y las constantes sin tipo funcionan como literales que pueden interoperar con tipos similares. Las constantes se pueden declarar con o sin un tipo en Go. El siguiente es el ejemplo que muestra constantes numéricas con tipo y sin tipo que tienen nombre y sin nombre. 

const untypedInteger          = 123
const untypedFloating          = 123.12

const typedInteger  int             = 123
const typedFloatingPoint   float64  = 123.12

La siguiente es una lista de constantes en Go Language: 

• Constante numérica (constante entera, constante flotante, constante compleja)
• Literales de string
• constante booleana

Constante numérica:  las constantes numéricas son valores de alta precisión . As Go es un lenguaje de tipado estático que no permite operaciones que mezclen tipos numéricos. No puede agregar un float64 a un int , o incluso un int32 a un int . Aunque, es legal escribir 1e6*time.Second o math.Exp(1) o incluso 1<<(‘\t’+2.0) . En Go, las constantes, a diferencia de las variables, se comportan como números regulares. 

La constante numérica puede ser de 3 tipos:

1.  entero
2. punto flotante
3. complejo 

Constante entera: 

• Un prefijo especifica la base o raíz: 0x o 0X para hexadecimal, 0 para octal y nada para decimal.
• Un literal entero también puede tener un sufijo que es una combinación de U (mayúscula) y L (mayúscula), para sin signo y largo, respectivamente
• Puede ser una constante decimal, octal o hexadecimal .
• Un int puede almacenar como máximo un número entero de 64 bits y, a veces, menos.

Los siguientes son algunos ejemplos de constantes enteras: 

85         /* decimal */
0213       /* octal */
0x4b       /* hexadecimal */
30         /* int */
30u        /* unsigned int */
30l        /* long */
30ul       /* unsigned long */
212         /* Legal */
215u        /* Legal */
0xFeeL      /* Legal */
078         /* Illegal: 8 is not an octal digit */
032UU       /* Illegal: cannot repeat a suffix */

Constante compleja: las constantes 
complejas se comportan de forma muy parecida a las constantes de coma flotante. Es un par ordenado o un par real de constantes enteras (o parámetros) y las constantes están separadas por una coma, y ​​el par está entre paréntesis. La primera constante es la parte real y la segunda es la parte imaginaria. Una constante compleja, COMPLEX*8, utiliza 8 bytes de almacenamiento. 
Ejemplo: 

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

Constante de tipo flotante: 

• Una constante de tipo flotante tiene una parte entera, un punto decimal, una parte fraccionaria y una parte exponencial .
• Se puede representar como una constante flotante en forma decimal o exponencial.
• Al representar usando la forma decimal, debe incluir el punto decimal, el exponente o ambos.
• Y al representar usando la forma exponencial , debe incluir la parte entera, la parte fraccionaria o ambas.

Los siguientes son ejemplos de constantes de tipo flotante: 

3.14159       /* Legal */
314159E-5L    /* Legal */
510E          /* Illegal: incomplete exponent */
210f          /* Illegal: no decimal or exponent */
.e55          /* Illegal: missing integer or fraction */

Literales de string 

• Go admite dos tipos de strings literales, es decir, el ” ” (estilo de comillas dobles) y el ‘ ‘ (comillas invertidas).
• Las strings se pueden concatenar con los operadores + y += .
• Una string contiene caracteres que son similares a los caracteres literales: caracteres sin formato, secuencias de escape y caracteres universales. Y esto es sin tipo.
• Los valores cero de los tipos de string son strings en blanco, que se pueden representar con ” ” o ” en literal.
• Todos los tipos de string son comparables mediante el uso de operadores como ==, != y (para comparar los mismos tipos)

Sintaxis:

type _string struct {
    elements *byte // underlying bytes
    len      int   // number of bytes
}

Ejemplo para mostrar literales de string: 

"hello, geeksforgeeks" 

"hello, \ 

geeksforgeeks" 

"hello, " "geeks" "forgeeks" 

Aquí, las tres declaraciones anteriores son similares, es decir, no tienen ningún tipo en particular. 

Ejemplo: 

package main
 
import "fmt"
 
func main()
{
    const A = "GFG"
    var B = "GeeksforGeeks"
     
    // Concat strings.
    var helloWorld = A+ " " + B
    helloWorld += "!"
    fmt.Println(helloWorld)
     
    // Compare strings.
    fmt.Println(A == "GFG")  
    fmt.Println(B < A)
}

Producción: 

GFG GeeksforGeeks!
true
false

Constante booleana:  las constantes booleanas son similares a las constantes de string. Aplica las mismas reglas que la constante de string. La diferencia es solo que tiene dos constantes sin tipo verdadero y falso. 

package main
 
import "fmt"
 
const Pi = 3.14
 
func main()
{
    const trueConst = true
     
    // Type definition using type keyword
    type myBool bool   
    var defaultBool = trueConst // allowed
    var customBool myBool = trueConst // allowed
     
    //  defaultBool = customBool // not allowed
    fmt.Println(defaultBool)
    fmt.Println(customBool)  
}

Producción: 

true
true

Constante en Go: Go tiene constantes de caracteres, strings, booleanos y valores numéricos. Const declara un valor constante. Una declaración const puede ocurrir donde hay var can y, por lo tanto, realiza operaciones aritméticas sin ninguna precisión fija.

// Const demonstration using go.
package main
 
import (
    "fmt"
    "math"
)
 
const s string = "GeeksForGeeks"
 
func main() {
    fmt.Println(s)
 
    const n = 5
 
    const d = 3e10 / n
    fmt.Println(d)
 
    fmt.Println(int64(d))
 
    fmt.Println(math.Sin(n))
}

Producción:

GeeksForGeeks
6e+09
6000000000
-0.9589242746631385