Go : Map, Structures et Références

Pierre-Etienne Moreau

Map

Map : déclaration et initialisation

• Déclaration :�var m map[keyType]valueType�
• Initialisation : �// Initialisation avec make

myMap := make(map[string]int)

// Initialisation littérale

myMap := map[string]int{}

// exemple avec des valeurs

myMap := map[string]int{"a": 1, "b": 2, "c": 3}

Map : ajout et accès

• Ajouter des éléments à une Map
• map[key] = value pour ajouter des éléments.
• Exemple : m["clé1"] = 10
• Accéder aux éléments d'une Map
• valeur := map[key] pour accéder à une valeur.
• Exemple : v := m["clé1"] (v vaudra 10)
• Vérifier l'existence d'une clé
• valeur, ok := map[key] pour vérifier si une clé existe.
• v, ok := m["clé1"] (v vaudra 10 et ok sera true)
• v, ok := m["clé2"] (v vaudra 0 et ok sera false).

Map : cardinalité et parcours

• Parcours des éléments
• for key, value := range m { … }�
• len(m) : nombre d'entrées

Clé

• une clé doit être de "type comparable"

map keys may be of any type that is comparable. The language spec defines this precisely, but in short, comparable types are:

• boolean, numeric, string, pointer, channel, and interface types, and structs or arrays that contain only those types.
• Notably absent from the list are slices, maps, and functions; these types cannot be compared using ==, and may not be used as map keys.

Structures

Structures

type Vertex struct {

X, Y int

}

func main() {

v := Vertex{3, 4} // v est alloué dans la pile

fmt.Println(v)

}

En Go tout se fait par valeur

func main() {

v := Vertex{3, 4} // v est alloué dans la pile

c := v // c est alloué dans la pile, v est copié

c.X = 0

fmt.Println(v)

}

Mais il y a aussi des pointeurs

func main() {

v := Vertex{3, 4}

c := &v

c.X = 0 // meme chose que (*c).X = 0

fmt.Println(v)

}

https://go.dev/tour/moretypes/1

Points importants à comprendre

Les struct sont passés par valeur

https://go.dev/tour/methods/4

Passage par valeur et copies

type Vertex struct {

X, Y float64

}

func (v Vertex) Move(dx,dy float64) Vertex {

v.X += dx

v.Y += dy

return v

}

func main() {

v := Vertex{3, 4}

w := v.Move(1,2)

fmt.Println(v,w)

}

Passage par référence

func (v *Vertex) Move2(dx,dy float64) Vertex {

v.X += dx

v.Y += dy

return *v

}

func main() {

v := Vertex{3, 4}

w := v.Move(1,2)

fmt.Println(v,w)

}

​

voir :

https://www.ardanlabs.com/blog/2017/06/design-philosophy-on-data-and-semantics.html

Inclusion de structures

https://go.dev/ref/spec (selectors)

Les reference types sont passés par référence

slice

map

channel

interface

function types

Retour sur la portée des variables

la portée d'une variable est le bloc dans lequel elle est définie

mais une variable peut être redéfinie (shadowing) :

func main() {

var x = 10

{

fmt.Println(x) // 10

var x = 5

fmt.Println(x) // 5

}

fmt.Println(x) // 10

}

Danger : multiple assignment

func main() {

x := 10

{

x, y := 5, 20 // /!\ x est redéfini

fmt.Println(x, y)

}

fmt.Println(x)

}