Ir a la versión de velocidad de gramática básica (3) - variable, declaración constante

declaración de variables`var`

En el lenguaje Go, las variables se declaran mediante palabras clave var. Su sintaxis básica es var name type = valuedonde namees el nombre de la variable, typees el tipo de la variable y valuees el valor inicial de la variable (opcional). A continuación introduciremos algunos conceptos y casos relacionados con la declaración de variables.

variable local:

Una variable local es una variable declarada dentro de una función cuyo alcance se limita a la función en la que se declara. Solo se puede acceder a ellas dentro de la función, otras funciones no pueden acceder directamente a estas variables. Por ejemplo:
```
func foo() {
    var x int = 10
    fmt.Println(x) // 输出：10
}

func main() {
    // 无法访问变量x
    foo()
}
```
Variables del paquete:

Las variables de paquete son variables declaradas fuera de una función, dentro de un paquete, y se puede acceder a ellas en cualquier función dentro del paquete completo. Estas variables son visibles a nivel de paquete. Por ejemplo:
```
package main

import "fmt"

var x int = 10

func foo() {
    fmt.Println(x) // 输出：10
}

func main() {
    foo()
    fmt.Println(x) // 输出：10
}
```
Declaración de bloque:

En el lenguaje Go, se puede usar una declaración de bloque para definir un conjunto de variables. Las declaraciones de bloque son una forma compacta de declarar varias variables juntas. Por ejemplo:
```
func foo() {
    var (
        x int = 10
        y int = 20
        z int = 30
    )
    fmt.Println(x, y, z) // 输出：10 20 30
}
```
Control de acceso:

En el lenguaje Go, la accesibilidad de una variable está determinada por el caso de la primera letra de su nombre. Si la primera letra del nombre de la variable está en mayúscula, significa que se puede acceder a la variable fuera del paquete; si la primera letra del nombre de la variable está en minúscula, significa que solo se puede acceder a la variable dentro del paquete.
Tipo de inferencia:

El lenguaje Go admite la inferencia de tipos, es decir, el tipo de una variable se puede inferir automáticamente en función de su valor inicial sin especificar explícitamente el tipo. Por ejemplo:
```
func main() {
    var x = 10       // 类型推断为int
    var y = "hello"  // 类型推断为string
    var z = 3.14    // 类型推断为float64
}
```

declaración de variables`:=`

En el lenguaje Go, también existe una forma simplificada de declarar variables, utilizando :=operadores, también conocidos como declaraciones de variables cortas. Este método solo se puede usar para variables locales, es decir, dentro del método, no para variables de paquete o variables globales:

Inferencia de tipo: :=al declarar una variable, el lenguaje Go inferirá automáticamente su tipo en función del valor inicial de la variable. Los enteros se deducen como int, los flotantes se deducen como float64. Por lo tanto, si desea declarar otros tipos de valores, aún necesita usar varuna declaración explícita.
Sintaxis simplificada: :=El operador es una sintaxis simplificada que completa el proceso de declaración e inicialización de variables al mismo tiempo. No es necesario especificar explícitamente el tipo de la variable, el compilador realizará la inferencia de tipos en función del valor inicial.

Aquí hay un :=ejemplo usando la declaración de variables locales:

func main() {
    x := 10 // 类型推断为int
    y := 3.14 // 类型推断为float64
    z := "hello" // 类型推断为string
    fmt.Println(x, y, z)
}

在上述例子中，变量x被推断为int类型，变量y被推断为float64类型，变量z被推断为string类型。需要注意的是，:=操作符只能用于局部变量的声明。如果要声明包级变量或全局变量，仍需使用var关键字进行显式声明。

变量声明易错点

在代码中声明了变量但未使用，这可能会导致编译错误。为了避免这种情况，建议只声明需要使用的变量，或者使用匿名变量。
在变量声明时，如果初始值的类型与变量声明的类型不匹配，会导致编译错误。确保变量的初始值与声明的类型相匹配，或者使用类型转换来进行匹配。
在同一个作用域下（如函数内部），变量名不能重复声明。如果在同一作用域内重复声明变量，会导致编译错误。确保变量名在同一作用域内是唯一的。

常量声明 const

与变量不同，常量是不可变的值，常用于定义程序运行期间保持不变的值。常量的声明方式与变量类似，只需用const替代var关键字，在定义常量时必须进行赋值。

常量只能存储以下数据类型之一：

布尔型
数字型（整数型、浮点型和复数）
字符串型

当使用未指定类型的常量时，其类型会根据上下文进行推断。换句话说，未定义类型的常量会根据需要自动获取相关类型。

var n int
f(n + 5)    // 无类型的数字型常量 “5” 它的类型在这里变成了 int

常量使用规范

常量的值必须是能够在编译时就能确定的；你可以在其赋值表达式中涉及计算过程，但是所有用于计算的值必须在编译期间就能获得。

正确的做法：const c1 = 2/3
错误的做法：const c2 = getNumber() // 引发构建错误: getNumber() used as value

因为在编译期间自定义函数均属于未知，因此无法用于常量的赋值，但内置函数可以使用，如：len()。

数字型的常量是没有大小和符号的，并且可以使用任何精度而不会导致溢出：

const Ln2 = 0.693147180559945309417232121458176568075500134360255254120680009
const Log2E = 1/Ln2 // this is a precise reciprocal
const Billion = 1e9 // float constant
const hardEight = (1 << 100) >> 97

这里的 << 表示左移操作，1 << 10 表示将 1 的二进制表示向左移 10 位，也就是由 1 变成了 10000000000，也就是十进制的 1024。同理 2<<2 表示将 2 的二进制表示向左移 2 位，也就是由 10 变成了 1000 ，也就是十进制的 8。

常量也允许使用并行赋值的形式：

const beef, two, c = "eat", 2, "veg"

const Monday, Tuesday, Wednesday, Thursday, Friday, Saturday = 1, 2, 3, 4, 5, 6

const (
    Monday, Tuesday, Wednesday = 1, 2, 3
    Thursday, Friday, Saturday = 4, 5, 6
)

const 同时声明多个常量时，如果省略了值则表示和上面一行的值相同。例如：

const (
    n1 = 100
    n2
    n3
)

上面示例中，常量n1、n2、n3的值都是100。