Co to jest konstrukcja Groovy i jak działa ta składnia?

Question

Wpadłem na coś dziwnego podczas przeprowadzania testów opartych na danych w Groovy. Jeśli to ma znaczenie, jest to test Spocka.

Oto sposób, myślę, że listy mają działać:

def list = [[1, 2, 3], 
       [4, 5, 6], 
       [7, 8, 9]] 

    println list[0] 

produkuje:

[1, 2, 3] 

przypadkowo zrobił coś takiego:

def whut = [[1, 2, 3] 
       [4, 5, 6] 
       [7, 8, 9]] 

    println whut[0] 
    println whut 

który wyjścia:

[null, null, null] 
[[null, null, null]] 

OK, widzę, że Groovy nie lubił deklaracji bez przecinków - ale kompiluje, więc co to jest?

Oto, co naprawdę rzuca mi o tej składni:

def inputz = [ 
      [1, 0.631226308, 0.631226308, 0.631226308, 1, 0, 0.240426243] 
      [1, 0.312284518, 0.312284518, 0.312284518, 1, 1, 1   ] 
      [3, 0.823506476, 0.31230335, 0.631237191, 1, 1, 0   ] 
      [4, 0.934875788, 0.486395986, 0.66732053, 3, 2, 0.927654169] 
      [4, 0.699869773, 0.234328294, 0.424739329, 3, 3, 1   ] 
    ] 

    println inputz[0] 
    println inputz 

daje następujące:

[0.631226308, 1, 1, 1, 1, 1, 1] 
[[0.631226308, 1, 1, 1, 1, 1, 1]] 

Jestem kompletnie zagubiony tutaj - co jest Groovy konstrukt tworzę i dlaczego czy wyprowadza te pozornie przypadkowe wartości z moich list?

Dzięki, a jeśli pomyślisz o bardziej opisowej nazwie mojego pytania, zmienię to.

Answer 1

Więc

def whut = [[1, 2, 3] 
      [4, 5, 6] 
      [7, 8, 9]] 

Tworzy listę [1,2,3], dostęp do elementów 4, 5 i 6 (które nie istnieją), aby dać Ci listę trzech wartości null, a następnie uzyskuje dostęp elementowi 7,8 i 9 ta lista null (również trzy null są zwrócone)

następnie zawija tej listy trzech null na liście

tego przykładu:

[1, 0.631226308, 0.631226308, 0.631226308, 1, 0, 0.240426243] 
[1, 0.312284518, 0.312284518, 0.312284518, 1, 1, 1   ] 
.... 

to wiercenia w dół do:

[1, 0.631226308, 0.631226308, 0.631226308, 1, 0, 0.240426243] 
[1, 0, 0, 0, 1, 1, 1] 

Aby dać 1st, 0TH, 0TH, 0TH, 1, 1 i 1, a kończy się z

[0.631226308, 1, 1, 1, 0.631226308, 0.631226308, 0.631226308] 

tak dalej i tak dalej.

Answer 2

Złamanie to w dół do mniejszych przykład (w groovysh):

> [[1,2][3,4]] 
===> [[null, null]] 

Ale nie potrzebujemy dodatkowej tablicy, więc możemy rozpakować to:

> [1,2][3,4] 
===> [null, null] 

To jest rzeczywiście rodzaj indeksowania listy, który zwykle wygląda tak:

> [1,2][1] 
===> 2 

Ale jeśli indeksujemy koniec tablicy:

> [1,2][2] 
===> null 

Okazuje się, Groovy podpory krojenie w ramach tej składni (patrz http://groovy-lang.org/groovy-dev-kit.html#Collections-Slicingwiththesubscriptoperator po więcej przykładów), więc możemy zrobić:

> [1,2,3][2,0] 
===> [3, 1] 

Aby uzyskać 3rd elementu następuje przez pierwszy element.

Ale Łącząc te dwa fakty:

> [1,2][3,4] 
===> [null, null] 

Jesteśmy indeksowanie poza końcem tablicy ponownie, ale z plasterkiem, dając nam dwie wartości null.