Go: Tableaux de tableaux, tableaux de tranches, tranches de tableaux et tranches de tranches

Question

Essayer de m'instruire et trouver difficile de trouver des exemples, et mon cerveau est déjà dans un nœud. Très incertain sur 3 et 4 et ont besoin d'aide pour faire 5 travaux.

package main 
import "fmt" 

func main() { 
    println("0. Array:") 
    var a = [...]int{4,5,6,7,8,9} //assign 
    fmt.Println(a,"\n") 

    println("1. Slice:") 
    var as []int 
    as = a[:] //assign 
    fmt.Println(as,"\n") 

    println("2. Array of arrays:") 
    var b [4][len(a)]int 
    for i:= range b { //assign 
     b[i]=a 
    } 
    fmt.Println(b,"\n") 

    println("3. Array of slices:") 
    var d [len(b)][]int 
    for i:= range b { // assign 
     d[i] = b[i][:] //does this really work? 
    } 
    fmt.Println(d,"\n") 

    println("4. Slice of arrays:") 
    var c [][len(a)]int 
    c = b[:][:] // assign, does this really work? 
    fmt.Println(c,"\n") 

    println("5. Slice of slices:") 
    var e [][]int 
// e = c // ??? 
    fmt.Println(e,"\n") 
} 

Answer 1

La partie 3 fonctionne.

La partie 4 contient un inutile [:].

println("4. Slice of arrays:") 
var c [][len(a)]int 
c = b[:] // one [:], not two 
fmt.Println(c, "\n") 

b[:] est évalué comme étant une tranche dans laquelle chaque élément est un [len(a)]int. Si vous ajoutez un autre [:], vous coupez la tranche à nouveau. Puisque pour toute tranche s, s[:] == s, c'est un non op.

La partie 5, vous pouvez découper votre tableau de tranches.

println("5. Slice of slices:") 
var e [][]int 
e = d[:] 
fmt.Println(e, "\n") 

J'ai posté un exemple complet à http://play.golang.org/p/WDvJXFiAFe.

Answer 2

La réponse à "ça marche vraiment?" Cela dépend de ce que vous attendez. Considérons cet exemple à http://play.golang.org/p/7Z5hKioTI_

package main 

import "fmt" 

func main() { 
    fmt.Println("0. Array:") 
    var a = [...]int{4, 5, 6, 7, 8, 9} //assign 
    fmt.Println(a, "\n") 

    fmt.Println("1. Slice:") 
    var as []int 
    as = a[:] //assign 
    fmt.Println(as, "\n") 

    fmt.Println("new slice:") 
    ns := make([]int, len(a)) 
    copy(ns, a[:]) 
    fmt.Print(ns, "\n\n") 

    fmt.Println("modifying array...") 
    a[0] = 10 
    fmt.Print("array is now:\n", a, "\n\n") 
    fmt.Print("slice is now:\n", as, "\n\n") 
    fmt.Print("new slice is still:\n", ns, "\n") 
} 

Il montre comment les tranches ont un tableau sous-jacent, et que les exemples dans votre OP faire des tranches en utilisant le même tableau sous-jacent. Si vous souhaitez que les tranches aient un contenu indépendant, vous devez créer de nouvelles coupes et copier les données. (Ou il y a des trucs avec append ...)

également comme une note de côté, println envoie des données à stderr pas stdout, et les formats certains types de données différemment fmt.Println. Pour éviter toute confusion, il est préférable de continuer à utiliser fmt.Println.