Variável do Linguagem Go

Programas típicos usam vários valores, que podem mudar durante a execução.

Por exemploprograma que executa algumas operações com valores fornecidos pelo usuário. Um valor fornecido pelo usuário pode ser diferente do valor fornecido por outro usuário. Portanto, é necessário usar variáveis, pois outros usuários podem não usar o mesmo valor. Quando um usuário inserir um novo valor que será usado no processo de operação, ele pode ser armazenado temporariamente na memória de acesso aleatório do computador. Esses valores são diferentes em diferentes partes da memória, portanto, esse outro termo é conhecido comoVariável. A variável é um marcador de posição para informações que podem ser alteradas durante a execução. Além disso, a variável permite que se recupere e se processe informações armazenadas.

VariávelRegras de nomeação:

O nome da variável deve começar com uma letra ou sublinhado (_). E o nome pode conter os caracteres "a".-z" ou "A-Z" ou o número 0-9e o caractere " _".

Geeks, geeks, _geeks23　　//Variável válida
123Geeks,　23geeks　　　　　　//　Variável ilegal

O nome da variável não deve começar com um número.

234geeks　　//Variável ilegal

Os nomes de variáveis diferenciam maiúsculas e minúsculas.

geeks e Geeks são duas variáveis diferentes

palavra-chave não pode ser usada como nome de variável.

O comprimento do nome da variável não tem limite, mas é recomendado usar apenas4até15o comprimento ideal de um nome de variável.

Declaração de variável

No idioma Go, as variáveis são criadas de duas maneiras diferentes:

(I) Uso da palavra-chave var:No idioma Go, as variáveis são declaradas usando tipos específicosvarpalavra-chave criada, que está associada ao nome da variável e atribui a ela um valor inicial.

Sintaxe:

var variable_name type = expression

Ponto importante:

Na sintaxe acima,Tipo (type) ou=A expressão pode ser removida, mas não pode ser removida simultaneamente das duas declarações de variável.

Se você remover o tipo, o tipo da variável é determinado pela inicialização do valor da expressão.

//Conceito de variável
package main
import "fmt"
func main() {
　　　　//Declaração e inicialização de variáveis
　　　　//Tipo explícito
　　　　var myvariable1　=　20
　　　　var myvariable2　= "w3codebox"
　　　　var myvariable3　=　34.80
　　　　//　Exibir o valor e o
　　　　//　Tipo das variáveis
　　　　fmt.Printf("myvariable1o valor é:　%d\n",　myvariable1)
　　　　fmt.Printf("myvariable1o tipo é: :　%T\n",　myvariable1)
　　　　fmt.Printf("myvariable2o valor é:　%s\n",　myvariable2)
　　　　fmt.Printf("myvariable2o tipo é: :　%T\n",　myvariable2)
　　　　fmt.Printf("myvariable3o valor é:　%f\n",　myvariable3)
　　　　fmt.Printf("myvariable3o tipo é: :　%T\n",　myvariable3)
}

saída:

myvariable1o valor é: :　20
myvariable1o tipo é: : int
myvariable2o valor é: : w3codebox
myvariable2o tipo é: : string
myvariable3o valor é: :　34.800000
myvariable3o tipo é: float64

Se você remover a expressão, o tipo da variável é zero, o número é zero, o valor booleano é false, e a string é""interfaces e tipos de referência são nil. Portanto,No idioma Go, não há o conceito de variável não inicializada.

package main
import "fmt"
func main() {
　　　　//A declaração e inicialização de variáveis não usam expressões
　　　　var myvariable1　int
　　　　var myvariable2　string
　　　　var myvariable3　float64
　　　　//Exibir variável com valor 0
　　　　fmt.Printf("myvariable1o valor é:　%d\n",　myvariable1)
　　　　fmt.Printf("myvariable2o valor é:　%d\n",　myvariable2)
　　　　fmt.Printf("myvariable3o valor é:　%d\n",　myvariable3)
}

saída:

myvariable1Seu valor é: 0
myvariable2Seu valor é: !d(string=)
myvariable3Seu valor é: !d(float64=0)

Se usar o tipo, pode declarar múltiplas variáveis do mesmo tipo em uma única declaração.

package main
import "fmt"
func main() {
　　　　//　Declarar e inicializar múltiplas variáveis do mesmo tipo em uma linha.
　　　　var myvariable1,　myvariable2,　myvariable3　int =　2,　454,　67
　　　　//　Exibir o valor da variável
　　　　fmt.Printf("myvariable1o valor é:　%d\n",　myvariable1)
　　　　fmt.Printf("myvariable2o valor é:　%d\n",　myvariable2)
　　　　fmt.Printf("myvariable3o valor é:　%d\n",　myvariable3)
}

saída:

myvariable1o valor é: :　2
myvariable2o valor é: :　454
myvariable3o valor é: :　67

Se você remover o tipo, pode declarar múltiplas variáveis de tipos diferentes em uma única declaração. O tipo da variável é determinado pelo valor de inicialização.

package main
import "fmt"
func main() {
　　　　//várias variáveis de diferentes tipos
　　　　//declarar e inicializar em uma única linha
　　　　var myvariable1,　myvariable2,　myvariable3　=　2, "GFG",　67.56
　　　　//　imprimir o valor e o tipo da variável
　　　　fmt.Printf("myvariable1o valor é:　%d\n",　myvariable1)
　　　　fmt.Printf("myvariable1o tipo é: :　%T\n",　myvariable1)
　　　　fmt.Printf("\nmyvariable2o valor é:　%s\n",　myvariable2)
　　　　fmt.Printf("myvariable2o tipo é: :　%T\n",　myvariable2)
　　　　fmt.Printf("\nmyvariable3o valor é:　%f\n",　myvariable3)
　　　　fmt.Printf("myvariable3o tipo é: :　%T\n",　myvariable3)
}

saída:

myvariable1o valor é: :　2
myvariable1o tipo é: : int
myvariable2Seu valor é: GFG
myvariable2o tipo é: : string
myvariable3o valor é: :　67.560000
myvariable3o tipo é: float64

Chamadas de função que retornam múltiplos valores permitem que você inicialize um grupo de variáveis.

Por exemplo:

//aqui, a função os.Open retorna um
//a variável i no arquivo e um erro
//na variável j
var i, j = os.Open(name)

(II) Uso da declaração de variável curta: Use a declaração de variável curtapara declarar e inicializar variáveis locais dentro de uma função.

Sintaxe:

variable_name:= expression

Atenção:Não use：=e=confusão entre：= é declaração, enquanto = é atribuição.

Ponto importante:

No texto acima, o tipo da variável é determinado pelo tipo da expressão.

package main
import "fmt"
func main() {
　　　　//　usar declarações de variáveis curtas
　　　　myvariable1　:=　39
　　　　myvariable2　:= "oldtoolbag.com"
　　　　myvariable3　:=　34.67
　　　　//　imprimir o valor e o tipo da variável
　　　　fmt.Printf("myvariable1o valor é:　%d\n",　myvariable1)
　　　　fmt.Printf("myvariable1o tipo é: :　%T\n",　myvariable1)
　　　　fmt.Printf("\nmyvariable2o valor é:　%s\n",　myvariable2)
　　　　fmt.Printf("myvariable2o tipo é: :　%T\n",　myvariable2)
　　　　fmt.Printf("\nmyvariable3o valor é:　%f\n",　myvariable3)
　　　　fmt.Printf("myvariable3o tipo é: :　%T\n",　myvariable3)
}

saída:

myvariable1o valor é: :　39
myvariable1o tipo é: : int
myvariable2o valor é: : oldtoolbag.com
myvariable2o tipo é: : string
myvariable3o valor é: :　34.670000
myvariable3o tipo é: float64

devido à sua concisão e flexibilidade, a maioria das variáveis locais são declaradas e inicializadas usando declarações de variáveis curtas.

a declaração var de variáveis é usada para variáveis locais que precisam de tipos explícitos diferentes dos itens de inicialização de valor ou para aqueles cujo valor será alocado mais tarde e cujo valor inicial não importa.

usar declarações de variáveis curtas, é possível declarar várias variáveis em uma única declaração.

package main
import "fmt"
func main() {
　　　　//declarar e inicializar variáveis em uma única linha
　　　　//usar declarações de variáveis curtas
　　　　//várias variáveis do mesmo tipo
　　　　myvariable1,　myvariable2,　myvariable3　:=　800,　34.7,　56.9
　　　　//　imprimir o valor e o tipo da variável
　　　　fmt.Printf("myvariable1o valor é:　%d\n",　myvariable1)
　　　　fmt.Printf("myvariable1o tipo é: :　%T\n",　myvariable1)
　　　　fmt.Printf("\nmyvariable2o valor é:　%f\n",　myvariable2)
　　　　fmt.Printf("myvariable2o tipo é: :　%T\n",　myvariable2)
　　　　fmt.Printf("\nmyvariable3o valor é:　%f\n",　myvariable3)
　　　　fmt.Printf("myvariable3o tipo é: :　%T\n",　myvariable3)
}

saída:

myvariable1o valor é: :　800
myvariable1o tipo é: : int
myvariable2o valor é: :　34.700000
myvariable2o tipo é: float64
myvariable3o valor é: :　56.900000
myvariable3o tipo é: float64

na declaração curta de variáveis, permite que chamadas de funções que retornam múltiplos valores inicializem um conjunto de variáveis.

//aqui, a função os.Open retorna um
//a variável i no arquivo e um erro
//na variável j
i, j := os.Open(name)

a declaração de variável curta é válida apenas para aqueles variáveis que já foram declarados no mesmo bloco de sintaxe, como uma atribuição. Variáveis declaradas em bloco externo serão ignoradas. Como mostrado no exemplo a seguir, pelo menos uma dessas variáveis é uma nova variável.

package main
import "fmt"
func main() {
　　　　//usar declarações de variáveis curtas
　　　　//aqui, a ação da declaração de variável curta
　　　　//como myvar2atribuição de variáveis
　　　　//porque o mesmo variável existe no mesmo bloco
　　　　//portanto myvar2o valor de45mude para100
　　　　myvar1,　myvar2　:=　39,　45
　　　　myvar3,　myvar2　:=　45,　100
　　　　//se você tentar executar a linha de comentário
　　　　//então o compilador dará um erro, porque
　　　　//esses variáveis já estão definidas, por exemplo
　　　　//　myvar1，myvar2：=　43，47
　　　　//　myvar2：=　200
　　　　//　imprimir o valor da variável
　　　　fmt.Printf("myvar1　e myvar2　o valor:　%d　%d\n",　myvar1,　myvar2)
　　　　fmt.Printf("myvar3　e myvar2　o valor:　%d　%d\n",　myvar3,　myvar2)
}

saída:

myvar1　e myvar2　o valor:　39　100
myvar3　e myvar2　o valor:　45　100

usar declarações de variáveis curtas, é possível declarar várias variáveis de diferentes tipos em uma única declaração. O tipo dessas variáveis é determinado pela expressão.

package main
import "fmt"
func main() {
　　　　//declarar e inicializar em uma única linha
　　　　//usar declarações de variáveis curtas
　　　　//várias variáveis de diferentes tipos
　　　　myvariable1,　myvariable2,　myvariable3　:=　800, "w3codebox",　47.56
　　　　//　imprimir o valor e o tipo da variável
　　　　fmt.Printf("myvariable1o valor é:　%d\n",　myvariable1)
　　　　fmt.Printf("myvariable1o tipo é: :　%T\n",　myvariable1)
　　　　fmt.Printf("\nmyvariable2o valor é:　%s\n",　myvariable2)
　　　　fmt.Printf("myvariable2o tipo é: :　%T\n",　myvariable2)
　　　　fmt.Printf("\nmyvariable3o valor é:　%f\n",　myvariable3)
　　　　fmt.Printf("myvariable3o tipo é: :　%T\n",　myvariable3)
}

saída:

myvariable1o valor é: :　800
myvariable1o tipo é: : int
myvariable2o valor é: : w3codebox
myvariable2o tipo é: : string
myvariable3o valor é: :　47.560000
myvariable3o tipo é: float64