Que fait l'astérisque dans " Go"

* attaché à un type de (*string) indique un pointeur vers le type.

* attaché à une variable dans une affectation de (*v = ...) indique une indirects d'affectation. Autrement dit, Modifiez la valeur pointée par la variable.

* attaché à une variable ou une expression (*v) indique un déréférencement de pointeur. C'est-à-dire, prenez la valeur sur laquelle pointe la variable.

& attaché à une variable ou une expression (&v) indique une référence. Autrement dit, créez un pointeur sur la valeur de la variable ou sur le terrain.

Aller lang des Adresses, des Pointeurs et Types:

s := "hello"      // type string
t := "bye"        // type string
u := 44           // type int
v := [2]int{1, 2} // type array 

Toutes ces variables Go ont une adresse. Même les variables de type "pointeur" ont des adresses. La distinction est que les types de chaînes contiennent des valeurs de chaîne, les types int contiennent des valeurs entières et les types de pointeurs contiennent des adresses.

& == évaluer pour répondre, ou penser "voici mon adresse afin que vous sachiez où me trouver"

// make p type pointer (to string only) and assign value to address of s
var p *string = &s // type *string
// or
q := &s // shorthand, same deal

* == pointeur de déréférence ,ou pensez " passer l'action à l'adresse qui est ma valeur"

*p = "ciao"   // change s, not p, the value of p remains the address of s

// j := *s    // error, s is not a pointer type, no address to redirect action to
// p = "ciao" // error, can't change to type string

p = &t        // change p, now points to address of t
//p = &u      // error, can't change to type *int

// make r type pointer (to pointer [to string]) and assign value to address of p
var r **string = &p // shorthand: r := &p

w := (  r == &p) // (  r evaluates to address of p) w = true
w =  ( *r == p ) // ( *r evaluates to value of p [address of t]) w = true
w =  (**r == t ) // (**r evaluates to value of t) w = true

// make n type pointer (to string) and assign value to address of t (deref'd p)
n := &*p
o := *&t // meaningless flip-flop, same as: o := t

// point y to array v
y := &v
z := (*y)[0] // dereference y, get first value of element, assign to z (z == 1)

Allez jouer ici: http://play.golang.org/p/u3sPpYLfz7

Je ne sais pas aller, mais basé sur la syntaxe, il semble que c'est similaire à C - c'est un pointeur. C'est similaire à une référence, mais de niveau inférieur et plus puissant. Il contient l'adresse mémoire de l'objet en question. &a obtient l'adresse mémoire d'une variable et *a la déréfère, obtenant la valeur à l'adresse mémoire.

En outre, le * dans la déclaration signifie qu'il s'agit d'un pointeur.

Donc oui, c'est comme en PHP en ce que la valeur de s est modifiée car p et &s pointez sur le même bloc de mémoire.

Le caractère * est utilisé pour définir un pointeur en C et en Go. Au lieu d'une valeur réelle, la variable a plutôt une adresse à l'emplacement d'une valeur. Le & opérateur est utilisé pour prendre l'adresse d'un objet.

Voilà comment je le vois. Un phrasé différent pourrait aider quelqu'un à mieux le comprendre (vous pouvez copier coller ce code et examiner la sortie):

package main

import (
    "fmt"
)

func main() {
    // declare a variable of type "int" with the default value "0"
    var y int

    // print the value of y "0"
    fmt.Println(y)

    // print the address of y, something like "0xc42008c0a0"
    fmt.Println(&y)

    // declare a variable of type "int pointer"
    // x may only hold addresses to variables of type "int"
    var x *int

    // y may not simply be assigned to x, like "x = y", because that 
    // would raise an error, since x is of type "int pointer", 
    // but y is of type "int"

    // assign address of y "0xc42008c0a0" as value to x
    x = &y

    // print the value of x "0xc42008c0a0" which is also the address of y
    fmt.Println(x)

    // print the address of x, something like "0xc420030028" 
    // (x and y have different addresses, obviously)
    fmt.Println(&x)

    // x is of type "int pointer" and holds an address to a variable of 
    // type "int" that holds the value "0", something like x -> y -> 0;
    // print the value of y "0" via x (dereference)
    fmt.Println(*x)

    // change the value of y via x
    *x = 1; /* same as */ y = 1

    // print value of y "1"
    fmt.Println(y); /* same as */ fmt.Println(*x)
}