Aller variables linguistiques

Variable de mathématiques, langages informatiques peuvent être stockés ou les résultats calculés peuvent être représentés valeur abstraction. Les variables peuvent être accessibles via le nom de la variable.

noms de variables Go de langue se composent de lettres, de chiffres, de soulignement, dont la première lettre est pas numérique.

La forme générale d'une variable est déclarée en utilisant le mot-clé var:

var identifier type

déclaration de variable

Tout d'abord, préciser le type de variable, la déclaration si la cession, utilisez la valeur par défaut.

var v_name v_type
v_name = value

Le second, basé sur la valeur de l'auto-détermination des types de variables.

var v_name = value

Troisièmement, en omettant var, Note: Variable = gauche ne doit pas être déclarée en place, sinon il fera une erreur du compilateur.

v_name := value

// 例如
var a int = 10
var b = 10
c : = 10

Des exemples sont les suivants:

package main
var a = "w3cschool本教程"
var b string = "w3cschool.cc"
var c bool

func main(){
    println(a, b, c)
}

Les exemples ci-dessus la mise en œuvre des résultats:

w3cschool本教程 w3cschool.cc false

déclaration multivariée

//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 //和python很像,不需要显示声明类型，自动推断

vname1, vname2, vname3 := v1, v2, v3 //出现在:=左侧的变量不应该是已经被声明过的，否则会导致编译错误


// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

Des exemples sont les suivants:

package main

var x, y int
var (  // 这种因式分解关键字的写法一般用于声明全局变量
    a int
    b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"

//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"

func main(){
    g, h := 123, "hello"
    println(x, y, a, b, c, d, e, f, g, h)
}

Les exemples ci-dessus la mise en œuvre des résultats:

0 0 0 false 1 2 123 hello 123 hello

types de valeurs et types de référence

Tous comme int, float, bool et chaîne de ces types de base sont tous les types de valeur, l'utilisation de ces types de variables directement à la valeur stockée dans la mémoire:

Lorsque vous utilisez le signe égal = lorsque la valeur d'une variable est affectée à une autre variable, tels que: j = i , est en fait la valeur de la mémoire , je vais être une copie:

Vous pouvez obtenir l'adresse mémoire de la variable i & i, par exemple: 0xf840000040 (chaque adresse peut être différente). La valeur stockée type de valeur variable de la pile.

Adresse de la mémoire varie en fonction de la machine, ou même le même programme sur différentes machines après l'exécution aura des adresses de mémoire différentes. Parce que chaque machine peut avoir une mise en page de mémoire différente, et une affectation de position peut varier.

Plus de données complexes nécessite souvent l'utilisation de plusieurs mots, ces données sont généralement stockées en utilisant un type de référence.

Une variable de type référence r1 r1 est la valeur stockée dans l'adresse de mémoire où le (numérique), ou la position de l'adresse de mémoire du premier mot est situé.

L'adresse de mémoire est appelé un pointeur qui était en fait il y a un autre un mot.

En référence à une pluralité de types de mot pointeur peut être dans des adresses de mémoire contigus (mise en page de mémoire est continue), qui est un calcul de la forme la plus efficace du stockage; ceux-ci peuvent également être stockés dans des mots de mémoire dispersés, chacun un mot indique où l'adresse de mémoire de mot suivant.

Lorsque l'instruction d'affectation r2 = r1, seules les références (adresse) est copiée.

Si la valeur r1 est modifiée, alors la valeur de toutes les citations sera modifié à un point, dans ce cas, r2 également être affectée.

Forme courte, utilisez le: = opérateur d'affectation

Nous savons que vous pouvez automatiquement déduire le type d'une variable est initialisée par la variable système est omis, la déclaration écrite sur le mot-clé déclaration var est en fait un peu redondant, donc nous pouvons être les abrégés comme: = 50 ou b: = false.

a et b (types int et bool) sera automatiquement déduit compilateur.

Ceci est la forme préférée de l'utilisation des variables, mais il ne peut être utilisé dans le corps de la fonction, il ne peut pas être utilisé pour confirmer à l'affectation à des variables globales. Utilisez les opérateurs: = peuvent efficacement créer une nouvelle variable appelée déclaration d'initialisation.

Précautions

Si le même bloc de code, on ne peut pas réutiliser le même nom pour une déclaration d'initialisation variable, par exemple: a: = 20 est pas autorisé, le compilateur affichera une erreur aucune nouvelle variable sur le côté gauche de: =, mais un = 20 est possible, car il est à la même variable est affectée une nouvelle valeur.

Si vous l'utilisez avant de définir la variable d'un, vous obtiendrez une erreur de compilation undefined: a.

Si vous déclarez une variable locale, mais pas utilisé dans le même bloc de code en elle, vous obtiendrez une erreur de compilation, comme l'exemple suivant qui variable a:

func main() {
   var a string = "abc"
   fmt.Println("hello, world")
}

Essayez de compiler ce code va obtenir l'erreura déclaré et non utilisé.

En outre, pour donner une simple affectation est pas assez, cette valeur doit être utilisé, donc l'utilisation

fmt.Println("hello, world", a)

Il va supprimer les erreurs.

Mais les variables globales sont déclarées mais non autorisés à utiliser.

Plusieurs variables du même type peuvent être déclarées sur la même ligne, telles que:

var a, b, c int

Plusieurs variables peuvent être attribuées à la même ligne, telles que:

a, b, c = 5, 7, "abc"

La ligne ci-dessus suppose que les variables a, b et c ont été déclarés, sinon il doit être utilisé de cette façon:

a, b, c := 5, 7, "abc"

Ces valeurs sont à droite dans le même ordre attribué à la variable de gauche, de sorte qu'une valeur de 5, la valeur b est de 7, la valeur de c est "abc".

Cette affectation est appelée parallèle ou simultanément.

Si vous voulez échanger les valeurs de deux variables, vous pouvez simplement utiliser a, b = b, a.

_ identificateur vide est également utilisé des valeurs mis au rebut, tels que la valeur de 5: _, b = 5, 7 a été abandonnée.

_ En fait une variable d'écriture seule, vous ne pouvez pas obtenir sa valeur. Allez faire cela parce que la langue dans laquelle vous devez utiliser toutes les variables sont déclarées, mais parfois, vous ne devez pas utiliser toutes les valeurs de retour à partir d'une fonction obtenue.

Affectation parallèle est également utilisé en fonction des valeurs de retour multiples de retour, tels que val et erreur err est ici simultanément obtenus en appelant la fonction Func1: val, err = Func1 (var1).