Qualcuno potrebbe spiegare questo strano comportamento di accodamento alle slice golang

Question

Il programma seguente ha un risultato inaspettato.

func main(){ 
    s:=[]int{5} 
    s=append(s,7) 
    s=append(s,9) 
    x:=append(s,11) 
    y:=append(s,12) 
    fmt.Println(s,x,y) 
} 

uscita: [5 7 9] [5 7 9 12] [5 7 9 12]

Perché è l'ultimo elemento di x12?

Answer 1

Una sezione è solo una finestra su parte di un array, non ha una memoria specifica.

Ciò significa che se si dispone di due sezioni sulla stessa parte di un array, entrambe le sezioni devono "contenere" gli stessi valori.

Ecco esattamente ciò che accade qui:

1. Quando si esegue il primo append, si ottiene una nuova fetta di dimensioni 2 su un array di fondo di dimensioni 2.
2. Quando si esegue la prossima append, si ottiene una nuova fetta di dimensioni 3 ma la matrice di fondo è di dimensioni 4 (append di solito assegna più spazio di quello immediatamente necessario in modo che non ha bisogno di allocare ad ogni append) .
3. Ciò significa che il prossimo append non ha bisogno di un nuovo array. Quindi, x e utilizzeranno entrambi lo stesso array sottostante della sezione precedente s. Scrivi 11 e poi 12 nello stesso slot di questo array, anche se ottieni due sezioni diverse (ricorda che sono solo finestre).

È possibile verificare che stampando la capacità della fetta dopo ogni Aggiungi:

fmt.Println(cap(s)) 

Se si desidera avere valori diversi in x e y, si dovrebbe fare un copy, per esempio come questo :

s := []int{5} 
s = append(s, 7) 
s = append(s, 9) 
x := make([]int,len(s)) 
copy(x,s) 
x = append(x, 11) 
y := append(s, 12) 
fmt.Println(s, x, y) 

Un'altra soluzione qui sarebbe stato quello di forzare la capacità della matrice dietro il s fetta essere non superiore alla necessità ed uno (assicurando così le due seguenti appendhanno ad utilizzare un nuovo array):

s := []int{5} 
s = append(s, 7) 
s = append(s, 9) 
s = s[0:len(s):len(s)] 
x := append(s, 11) 
y := append(s, 12) 
fmt.Println(s, x, y) 

Vedi anche Re-slicing slices in Golang

Answer 2

dystroy spiegato molto bene. Mi piace aggiungere una spiegazione visiva al comportamento.

Una sezione è solo un descrittore di un segmento di matrice. Consiste di un puntatore all'array (ptr), alla lunghezza del segmento (len) e alla capacità (cap).

+-----+                
    | ptr |                
    |*Elem|                
    +-----+                
    | len |                
    |int |                
    +-----+                
    | cap |                
    |int |                
    +-----+ 

Quindi, la spiegazione del codice è la seguente;

func main() {               
         +             
         |             
    s := []int{5}  | s -> +-----+         
         | []int | ptr +-----> +---+      
         |  |*int | [1]int| 5 |      
         |  +-----+  +---+      
         |  |len=1|         
         |  |int |         
         |  +-----+         
         |  |cap=1|         
         |  |int |         
         |  +-----+         
         |             
    s = append(s,7)  | s -> +-----+         
         | []int | ptr +-----> +---+---+     
         |  |*int | [2]int| 5 | 7 |     
         |  +-----+  +---+---+     
         |  |len=2|         
         |  |int |         
         |  +-----+         
         |  |cap=2|         
         |  |int |         
         |  +-----+         
         |             
    s = append(s,9)  | s -> +-----+         
         | []int | ptr +-----> +---+---+---+---+   
         |  |*int | [4]int| 5 | 7 | 9 | |   
         |  +-----+  +---+---+---+---+   
         |  |len=3|         
         |  |int |         
         |  +-----+         
         |  |cap=4|         
         |  |int |         
         |  +-----+         
         |             
    x := append(s,11) |   +-------------+-----> +---+---+---+---+ 
         |   |    | [4]int| 5 | 7 | 9 |11 | 
         |   |    |  +---+---+---+---+ 
         | s -> +--+--+ x -> +--+--+      
         | []int | ptr | []int | ptr |      
         |  |*int |  |*int |      
         |  +-----+  +-----+      
         |  |len=3|  |len=4|      
         |  |int |  |int |      
         |  +-----+  +-----+      
         |  |cap=4|  |cap=4|      
         |  |int |  |int |      
         |  +-----+  +-----+      
         |             
    y := append(s,12) |      +-----> +---+---+---+---+ 
         |      | [4]int| 5 | 7 | 9 |12 | 
         |      |  +---+---+---+---+ 
         |      |       
         |   +-------------+-------------+   
         |   |    |    |   
         | s -> +--+--+ x -> +--+--+ y -> +--+--+  
         | []int | ptr | []int | ptr | []int | ptr |  
         |  |*int |  |*int |  |*int |  
         |  +-----+  +-----+  +-----+  
         |  |len=3|  |len=4|  |len=4|  
         |  |int |  |int |  |int |  
         |  +-----+  +-----+  +-----+  
         |  |cap=4|  |cap=4|  |cap=4|  
         |  |int |  |int |  |int |  
         +  +-----+  +-----+  +-----+  
    fmt.Println(s,x,y)              
}