Variables del lenguaje Go

Un programa típico utiliza varios valores, que pueden cambiar durante la ejecución.

Por ejemplo, un programa que realiza ciertas operaciones con los valores de entrada del usuario. Un valor de entrada de un usuario puede ser diferente al de otro usuario. Por lo tanto, se necesita usar variables, ya que otros usuarios pueden no usar el mismo valor. Cuando un usuario ingresa un nuevo valor que se utilizará durante el proceso de operación, estos valores pueden almacenarse temporalmente en la memoria de acceso aleatorio del ordenador, estos valores son diferentes en la ejecución de esta parte de la memoria, por lo que se denomina con otro términoVariable. Una variable es un marcador de posición para información que se puede cambiar en tiempo de ejecución. Además, las variables permiten recuperar y procesar información almacenada.

VariableReglas de nombramiento:

El nombre de la variable debe comenzar con una letra o guión bajo (_). Además, el nombre puede contener las letras “a”.-z" o " A-Z" o el número 0-9y el carácter " _".

Geeks, geeks, _geeks23　　//Variable válida
123Geeks,　23geeks　　　　　　//　Variable ilegal

El nombre de la variable no debe comenzar con un número.

234geeks　　//Variable ilegal

Los nombres de variable distinguen entre mayúsculas y minúsculas.

geeks y Geeks son dos variables diferentes

La palabra clave no se permite como nombre de variable.

La longitud del nombre de la variable no tiene límite, pero se recomienda utilizar4a15La longitud óptima de un nombre de variable es

Declaración de variables

En el lenguaje Go, las variables se crean de dos formas diferentes:

(I) Uso de la palabra clave var:En el lenguaje Go, las variables se utilizan con tipos específicosvarLa palabra clave crea, que se asocia con el nombre de la variable y le asigna un valor inicial.

Sintaxis:

var variable_name type = expression

Puntos importantes:

En la sintaxis anterior,Tipo (type) o=Se puede eliminar la expresión, pero no ambas en la declaración de la variable.

Si se elimina el tipo, el tipo de la variable se determina por el valor de inicialización de la expresión.

//El concepto de variable
package main
import "fmt"
func main() {
　　　　//Declaración e inicialización de variables
　　　　//Tipo explícito
　　　　var myvariable1　=　20
　　　　var myvariable2　= "w3codebox"
　　　　var myvariable3　=　34.80
　　　　//　Mostrar el valor y el
　　　　//　El tipo de las variables
　　　　fmt.Printf("mivariable1su valor es: %d\n", mivariable1)
　　　　fmt.Printf("mivariable1su tipo es: %T\n", mivariable1)
　　　　fmt.Printf("mivariable2su valor es: %s\n", mivariable2)
　　　　fmt.Printf("mivariable2su tipo es: %T\n", mivariable2)
　　　　fmt.Printf("mivariable3su valor es: %f\n", mivariable3)
　　　　fmt.Printf("mivariable3su tipo es: %T\n", mivariable3)
}

Salida:

mivariable1su valor es:　20
mivariable1su tipo es: int
mivariable2su valor es: w3codebox
mivariable2su tipo es: string
mivariable3su valor es:　34.800000
mivariable3El tipo es: float64

Si se elimina la expresión, el tipo de la variable es cero, el número es cero, el valor booleano es falso, y la cadena es""ni los tipos de interfaz y referencia son nil. Por lo tanto,En el lenguaje Go no existe el concepto de variable no inicializada.

package main
import "fmt"
func main() {
　　　　//La declaración y la inicialización de variables no utilizan expresiones
　　　　var myvariable1　int
　　　　var myvariable2　string
　　　　var myvariable3　float64
　　　　//Mostrar variable de valor 0
　　　　fmt.Printf("mivariable1su valor es: %d\n", mivariable1)
　　　　fmt.Printf("mivariable2su valor es: %d\n", mivariable2)
　　　　fmt.Printf("mivariable3su valor es: %d\n", mivariable3)
}

Salida:

mivariable1El valor es: 0
mivariable2El valor es: !d(string=)
mivariable3El valor es: !d(float64=0)

Si se utiliza el tipo, se pueden declarar múltiples variables del mismo tipo en una sola declaración.

package main
import "fmt"
func main() {
　　　　//　Declarar e inicializar múltiples variables del mismo tipo en una línea.
　　　　var myvariable1, mivariable2, mivariable3　int =　2,　454,　67
　　　　//　Mostrar el valor de la variable
　　　　fmt.Printf("mivariable1su valor es: %d\n", mivariable1)
　　　　fmt.Printf("mivariable2su valor es: %d\n", mivariable2)
　　　　fmt.Printf("mivariable3su valor es: %d\n", mivariable3)
}

Salida:

mivariable1su valor es:　2
mivariable2su valor es:　454
mivariable3su valor es:　67

Si se elimina el tipo, se pueden declarar múltiples variables de diferentes tipos en una sola declaración. El tipo de la variable se determina por el valor de inicialización.

package main
import "fmt"
func main() {
　　　　//varias variables de diferentes tipos
　　　　//declarar e inicializar en una sola línea
　　　　var myvariable1, mivariable2, mivariable3　=　2, "GFG",　67.56
　　　　//　imprimir el valor y el tipo de la variable
　　　　fmt.Printf("mivariable1su valor es: %d\n", mivariable1)
　　　　fmt.Printf("mivariable1su tipo es: %T\n", mivariable1)
　　　　fmt.Printf("\nmivariable2su valor es: %s\n", mivariable2)
　　　　fmt.Printf("mivariable2su tipo es: %T\n", mivariable2)
　　　　fmt.Printf("\nmivariable3su valor es: %f\n", mivariable3)
　　　　fmt.Printf("mivariable3su tipo es: %T\n", mivariable3)
}

Salida:

mivariable1su valor es:　2
mivariable1su tipo es: int
mivariable2El valor es: GFG
mivariable2su tipo es: string
mivariable3su valor es:　67.560000
mivariable3El tipo es: float64

La llamada a una función que devuelve múltiples valores le permite inicializar un grupo de variables.

Por ejemplo:

//aquí, la función os.Open devuelve un
//un variable en el archivo i y un error
//en la variable j
var i, j = os.Open(name)

(II) Uso de declaración de variables cortas: Utilice la declaración de variables cortaspara declarar y inicializar variables locales dentro de una función.

Sintaxis:

variable_name:=expression

Nota:No utilice:=y=se confunden entre sí, porque:= es una declaración, mientras que = es una asignación.

Puntos importantes:

En la expresión anterior, el tipo de la variable se determina por el tipo de la expresión.

package main
import "fmt"
func main() {
　　　　//　usar declaraciones de variables cortas
　　　　mivariable1　:=　39
　　　　mivariable2　:= "oldtoolbag.com"
　　　　mivariable3　:=　34.67
　　　　//　imprimir el valor y el tipo de la variable
　　　　fmt.Printf("mivariable1su valor es: %d\n", mivariable1)
　　　　fmt.Printf("mivariable1su tipo es: %T\n", mivariable1)
　　　　fmt.Printf("\nmivariable2su valor es: %s\n", mivariable2)
　　　　fmt.Printf("mivariable2su tipo es: %T\n", mivariable2)
　　　　fmt.Printf("\nmivariable3su valor es: %f\n", mivariable3)
　　　　fmt.Printf("mivariable3su tipo es: %T\n", mivariable3)
}

Salida:

mivariable1su valor es:　39
mivariable1su tipo es: int
mivariable2su valor es: oldtoolbag.com
mivariable2su tipo es: string
mivariable3su valor es:　34.670000
mivariable3El tipo es: float64

debido a su brevedad y flexibilidad, la mayoría de las variables locales se declaran e inicializan usando declaraciones de variables cortas.

la declaración var de variables se usa para aquellos variables que necesitan un tipo explícito diferente de la expresión de inicialización o para aquellos variables cuyos valores se asignarán más tarde y cuyos valores iniciales no son importantes.

usar declaraciones de variables cortas, se pueden declarar múltiples variables en una sola declaración.

package main
import "fmt"
func main() {
　　　　//declarar e inicializar variables en una sola línea
　　　　//usar declaraciones de variables cortas
　　　　//varias variables del mismo tipo
　　　　mivariable1, mivariable2, mivariable3　:=　800,　34.7,　56.9
　　　　//　imprimir el valor y el tipo de la variable
　　　　fmt.Printf("mivariable1su valor es: %d\n", mivariable1)
　　　　fmt.Printf("mivariable1su tipo es: %T\n", mivariable1)
　　　　fmt.Printf("\nmivariable2su valor es: %f\n", mivariable2)
　　　　fmt.Printf("mivariable2su tipo es: %T\n", mivariable2)
　　　　fmt.Printf("\nmivariable3su valor es: %f\n", mivariable3)
　　　　fmt.Printf("mivariable3su tipo es: %T\n", mivariable3)
}

Salida:

mivariable1su valor es:　800
mivariable1su tipo es: int
mivariable2su valor es:　34.700000
mivariable2El tipo es: float64
mivariable3su valor es:　56.900000
mivariable3El tipo es: float64

en la declaración de variables cortas, se permite que las llamadas a funciones que devuelvan múltiples valores inicialicen un grupo de variables.

//aquí, la función os.Open devuelve un
//un variable en el archivo i y un error
//en la variable j
i, j := os.Open(name)

las declaraciones de variables cortas solo actúan como asignaciones para aquellos variables que ya se han declarado en el mismo bloque de sintaxis. Los variables declarados en bloques externos se ignoran. Como se muestra en el siguiente ejemplo, al menos una de estas variables es nueva.

package main
import "fmt"
func main() {
　　　　//usar declaraciones de variables cortas
　　　　//aquí, la acción de declaración de variables cortas
　　　　//como mivar2asignación de variables
　　　　//porque el mismo variable existe en el mismo bloque
　　　　//por lo que mivar2su valor de45cambiar a100
　　　　mivar1, mivar2　:=　39,　45
　　　　mivar3, mivar2　:=　45,　100
　　　　//si intenta ejecutar una línea de comentario
　　　　//luego el compilador dará un error porque
　　　　//estos variables ya están definidos, por ejemplo
　　　　//　mivar1, mivar2:=　43,47
　　　　//　mivar2:=　200
　　　　//　imprimir el valor de la variable
　　　　fmt.Printf("mivar1　y mivar2　su valor: %d %d\n", mivar1, mivar2)
　　　　fmt.Printf("mivar3　y mivar2　su valor: %d %d\n", mivar3, mivar2)
}

Salida:

mivar1　y mivar2　su valor:　39　100
mivar3　y mivar2　su valor:　45　100

Al usar declaraciones de variables cortas, se pueden declarar múltiples variables de diferentes tipos en una sola declaración. El tipo de estas variables se determina por la expresión.

package main
import "fmt"
func main() {
　　　　//declarar e inicializar en una sola línea
　　　　//usar declaraciones de variables cortas
　　　　//varias variables de diferentes tipos
　　　　mivariable1, mivariable2, mivariable3　:=　800, "w3codebox　47.56
　　　　//　imprimir el valor y el tipo de la variable
　　　　fmt.Printf("mivariable1su valor es: %d\n", mivariable1)
　　　　fmt.Printf("mivariable1su tipo es: %T\n", mivariable1)
　　　　fmt.Printf("\nmivariable2su valor es: %s\n", mivariable2)
　　　　fmt.Printf("mivariable2su tipo es: %T\n", mivariable2)
　　　　fmt.Printf("\nmivariable3su valor es: %f\n", mivariable3)
　　　　fmt.Printf("mivariable3su tipo es: %T\n", mivariable3)
}

Salida:

mivariable1su valor es:　800
mivariable1su tipo es: int
mivariable2su valor es: w3codebox
mivariable2su tipo es: string
mivariable3su valor es:　47.560000
mivariable3El tipo es: float64