Variabili del Linguaggio Go

Altri argomenti vari di Golang

Programmi tipici utilizzano vari valori, che possono cambiare durante l'esecuzione.Ad esempioVariabile. La variabile è un segnaposto per informazioni che possono essere modificate durante l'esecuzione. E le variabili permettono di recuperare e trattare le informazioni memorizzate. Programmi che eseguono operazioni su valori di input utente. Un valore di input utente può essere diverso da un altro valore di input utente. Pertanto, è necessario utilizzare variabili perché altri utenti potrebbero non utilizzare lo stesso valore. Quando un utente inserisce un nuovo valore che verrà utilizzato durante l'operazione, questi valori possono essere temporaneamente memorizzati nella memoria di accesso casuale del computer, questi valori sono diversi durante l'esecuzione di questa parte della memoria, quindi questo termine è noto anche come

VariabileRegole di nomi:

Il nome della variabile deve iniziare con una lettera o un trattino basso (_). E può contenere lettere 'a-z' o 'A-Z' o numeri 0-9, nonché il carattere '_'.

Geeks, geeks, _geeks23　　//Variabile valida
123Geeks, 23geeks　　　　　　　　//Variabile non valida

Il nome della variabile non dovrebbe iniziare con un numero.

234geeks　　//Variabile non valida

Il nome della variabile distingue tra maiuscole e minuscole.

geeks e Geeks sono due variabili diverse

La parola chiave non può essere utilizzata come nome di variabile.

La lunghezza del nome della variabile non ha limiti, ma si consiglia di utilizzare una lunghezza ottimale tra 4 e 15 lettere.

Dichiarazione delle variabili

In Go, le variabili vengono create in due modi diversi:

（一）Utilizzo della parola chiave var:In Go, le variabili sono utilizzate con tipi specificivarCreata da una parola chiave, che è associata al nome della variabile e le assegna un valore iniziale.

语法：

var　nome_variabile　type　=　espressione

重要事项：

Nella grammatica sopra menzionata,Tipo (type) o=L'espressione può essere eliminata, ma non possono essere eliminate due dichiarazioni di variabili contemporaneamente.

Se il tipo è stato eliminato, il tipo della variabile è determinato dalla valore dell'espressione inizializzata.

//变量的概念
package main
import "fmt"
func main() {
　　　　//声明变量和初始化
　　　　// Tipo esplicito
　　　　var myvariable1 = 20
　　　　var myvariable2 = "w3codebox"
　　　　var myvariable3 = 34.80
　　　　// Visualizza il valore e il
　　　　// Tipo delle variabili
　　　　fmt.Printf("Il valore di myvariable1 è: %d\n", myvariable1)
　　　　fmt.Printf("Il tipo di myvariable1 è: %T\n", myvariable1)
　　　　fmt.Printf("Il valore di myvariable2 è: %s\n", myvariable2)
　　　　fmt.Printf("Il tipo di myvariable2 è: %T\n", myvariable2)
　　　　fmt.Printf("Il valore di myvariable3 è: %f\n", myvariable3)
　　　　fmt.Printf("Il tipo di myvariable3 è: %T\n", myvariable3)
}

Output:

Il valore di myvariable1 è: 20
Il tipo di myvariable1 è: int
Il valore di myvariable2 è: w3codebox
Il tipo di myvariable2 è: string
Il valore di myvariable3 è: 34.800000
Il tipo di myvariable3 è: float64

Se si elimina l'espressione, il tipo della variabile è zero, il numero è zero, il valore booleano è false, la stringa è""e i tipi di interfaccia e riferimento sono nil. Pertanto,In Go non esiste il concetto di variabile non inizializzata.

package main
import "fmt"
func main() {
　　　　// Dichiarazione e inizializzazione delle variabili senza espressione
　　　　var myvariable1 int
　　　　var myvariable2 string
　　　　var myvariable3 float64
　　　　// Visualizzazione del valore 0 di una variabile
　　　　fmt.Printf("Il valore di myvariable1 è: %d\n", myvariable1)
　　　　fmt.Printf("Il valore di myvariable2 è: %d\n", myvariable2)
　　　　fmt.Printf("Il valore di myvariable3 è: %d\n", myvariable3)
}

Output:

Il valore di myvariable1 è: 0
Il valore di myvariable2 è: %!d(string=)
Il valore di myvariable3 è: %!d(float64=0)

Se si utilizza il tipo, è possibile dichiarare più variabili dello stesso tipo in una singola dichiarazione.

package main
import "fmt"
func main() {
　　　　// Dichiarazione e inizializzazione di più variabili dello stesso tipo in una riga
　　　　var myvariable1, myvariable2, myvariable3 int = 2, 454, 67
　　　　// Output del valore della variabile
　　　　fmt.Printf("Il valore di myvariable1 è: %d\n", myvariable1)
　　　　fmt.Printf("Il valore di myvariable2 è: %d\n", myvariable2)
　　　　fmt.Printf("Il valore di myvariable3 è: %d\n", myvariable3)
}

Output:

Il valore di myvariable1 è: 2
Il valore di myvariable2 è: 454
Il valore di myvariable3 è: 67

Se si elimina il tipo, è possibile dichiarare più variabili di diversi tipi in una singola dichiarazione. Il tipo della variabile è determinato dal valore di inizializzazione.

package main
import "fmt"
func main() {
　　　　// Variabili di diversi tipi
　　　　// Dichiarazione e inizializzazione in una singola riga
　　　　var myvariable1, myvariable2, myvariable3 = 2, "GFG", 67.56
　　　　// Stampa valore e tipo delle variabili
　　　　fmt.Printf("Il valore di myvariable1 è: %d\n", myvariable1)
　　　　fmt.Printf("Il tipo di myvariable1 è: %T\n", myvariable1)
　　　　fmt.Printf("\nIl valore di myvariable2 è: %s\n", myvariable2)
　　　　fmt.Printf("Il tipo di myvariable2 è: %T\n", myvariable2)
　　　　fmt.Printf("\nIl valore di myvariable3 è: %f\n", myvariable3)
　　　　fmt.Printf("Il tipo di myvariable3 è: %T\n", myvariable3)
}

Output:

Il valore di myvariable1 è: 2
Il tipo di myvariable1 è: int
Il valore di myvariable2 è: GFG
Il tipo di myvariable2 è: string
Il valore di myvariable3 è: 67.560000
Il tipo di myvariable3 è: float64

返回多个值的调用函数允许您初始化一组变量。

例如：

//这里，os.Open函数返回一个
//文件中的i变量和一个错误
//在j变量中
var　i,　j　=　os.Open(name)

（二）使用短变量声明：使用短变量声明来声明在函数中声明和初始化的局部变量。

语法：

variable_name:=　expression

注意：请不要在：=和=之间混淆，因为：= 是声明，而 = 是赋值。

重要事项：

在上面的表达式中，变量的类型由表达式的类型确定。

package main
import "fmt"
func main() {
　　　　//　使用短变量声明
　　　　myvariable1　:=　39
　　　　myvariable2　:=　"oldtoolbag.com"
　　　　myvariable3　:=　34.67
　　　　// Stampa valore e tipo delle variabili
　　　　fmt.Printf("Il valore di myvariable1 è: %d\n", myvariable1)
　　　　fmt.Printf("Il tipo di myvariable1 è: %T\n", myvariable1)
　　　　fmt.Printf("\nIl valore di myvariable2 è: %s\n", myvariable2)
　　　　fmt.Printf("Il tipo di myvariable2 è: %T\n", myvariable2)
　　　　fmt.Printf("\nIl valore di myvariable3 è: %f\n", myvariable3)
　　　　fmt.Printf("Il tipo di myvariable3 è: %T\n", myvariable3)
}

Output:

myvariable1的值是　:　39
Il tipo di myvariable1 è: int
myvariable2的值是　:　oldtoolbag.com
Il tipo di myvariable2 è: string
myvariable3的值是　:　34.670000
Il tipo di myvariable3 è: float64

由于它们的简洁性和灵活性，大多数局部变量都是使用短变量声明来声明和初始化的。

变量的var声明用于那些需要与初始值设定项表达式不同的显式类型的局部变量，或用于其值稍后分配且初始值不重要的那些变量。

使用短变量声明，可以在单个声明中声明多个变量。

package main
import "fmt"
func main() {
　　　　//在单行中声明和初始化变量
　　　　// Dichiarazione di variabili brevi
　　　　//多个相同类型的变量
　　　　myvariable1,　myvariable2,　myvariable3　:=　800,　34.7,　56.9
　　　　// Stampa valore e tipo delle variabili
　　　　fmt.Printf("Il valore di myvariable1 è: %d\n", myvariable1)
　　　　fmt.Printf("Il tipo di myvariable1 è: %T\n", myvariable1)
　　　　fmt.Printf("\nmyvariable2的值是　:　%f\n",　myvariable2)
　　　　fmt.Printf("Il tipo di myvariable2 è: %T\n", myvariable2)
　　　　fmt.Printf("\nIl valore di myvariable3 è: %f\n", myvariable3)
　　　　fmt.Printf("Il tipo di myvariable3 è: %T\n", myvariable3)
}

Output:

Il valore di myvariable1 è: 800
Il tipo di myvariable1 è: int
myvariable2的值是　:　34.700000
myvariable2的类型是　:　float64
myvariable3的值是　:　56.900000
Il tipo di myvariable3 è: float64

在简短的变量声明中，允许返回多个值的调用函数初始化一组变量。

//这里，os.Open函数返回一个
//文件中的i变量和一个错误
//在j变量中
i,　j　:=　os.Open(name)

简短的变量声明仅当对于已在同一语法块中声明的那些变量起作用时，才像赋值一样。在外部块中声明的变量将被忽略。如下面的示例所示，这两个变量中至少有一个是新变量。

package main
import "fmt"
func main() {
　　　　// Dichiarazione di variabili brevi
　　　　//这里，短变量声明动作
　　　　//作为myvar2变量的赋值
　　　　//因为相同的变量存在于同一块中
　　　　//因此myvar2的值从45更改为100
　　　　myvar1,　myvar2　:=　39,　45
　　　　myvar3, myvar2 := 45, 100
　　　　// Se tenti di eseguire una riga di commento
　　　　// Il compilatore darà un errore perché
　　　　// Queste variabili sono già definite, ad esempio
　　　　// myvar1, myvar2 := 43, 47
　　　　// myvar2 := 200
　　　　// Stampa valore delle variabili
　　　　fmt.Printf("Il valore di myvar1 e myvar2: %d %d\n", myvar1, myvar2)
　　　　fmt.Printf("Il valore di myvar3 e myvar2: %d %d\n", myvar3, myvar2)
}

Output:

Il valore di myvar1 e myvar2: 39 100
Il valore di myvar3 e myvar2: 45 100

L'uso della dichiarazione di variabili brevi permette di dichiarare più variabili di diversi tipi in una singola dichiarazione. Il tipo delle variabili è determinato dall'espressione.

package main
import "fmt"
func main() {
　　　　// Dichiarazione e inizializzazione in una singola riga
　　　　// Dichiarazione di variabili brevi
　　　　// Variabili di diversi tipi
　　　　myvariable1, myvariable2, myvariable3 := 800, "w3codebox", 47.56
　　　　// Stampa valore e tipo delle variabili
　　　　fmt.Printf("Il valore di myvariable1 è: %d\n", myvariable1)
　　　　fmt.Printf("Il tipo di myvariable1 è: %T\n", myvariable1)
　　　　fmt.Printf("\nIl valore di myvariable2 è: %s\n", myvariable2)
　　　　fmt.Printf("Il tipo di myvariable2 è: %T\n", myvariable2)
　　　　fmt.Printf("\nIl valore di myvariable3 è: %f\n", myvariable3)
　　　　fmt.Printf("Il tipo di myvariable3 è: %T\n", myvariable3)
}

Output:

Il valore di myvariable1 è: 800
Il tipo di myvariable1 è: int
Il valore di myvariable2 è: w3codebox
Il tipo di myvariable2 è: string
Il valore di myvariable3 è: 47.560000
Il tipo di myvariable3 è: float64