Ruby-tablica dwuindeksowa

Zielona szkoła
1

Witam

Mam pytanie odnośnie tablic w języku Ruby posiadających dwa indeksy. Mam następujący kod:

array=[“Pierwszy”, “Drugi”, 3, 4, 5]
array[1,1]=“Trzeci”

Powyższy kod spowoduje przekształcenie tablicy do: [“Pierwszy”, “Trzeci”, 3, 4, 5]

Natomiast jeżeli:

array=[“Pierwszy”, “Drugi”, 3, 4, 5]
array[1,2]=“Trzeci”

tablica w takim wypadku ma elementy: [“Pierwszy”, “Trzeci”, 4, 5]
Dlaczego modyfikując elementy przy użyciu array[1,2], jeden element zostaje skasowany. Przecież modyfikujemy dwa elementy, rozpoczynając od elementu o indeksie 1, czemu więc nie otrzymujemy takiej tablicy:
[“Pierwszy”, “Trzeci”, “Trzeci”, 4, 5]? Z góry dziękuję za odpowiedź.

Pozdrawiam

2

Metoda Array#[]= może przyjmować kilka rodzajów parametrów.
Podstawowe użycie to odwołanie się do pojedyncznego indeksu:

a = [1, 2, 3] a[1] = 5 p a #=> [1, 5, 3]
Używają dwóch parametrów liczbowych [par1, par2] odwołujesz się do podtablicy zaczynającej się na indeksie “par1” i długości “par2”. Można w ten sposób podmienić wybraną część na nowe elementy, np:

[code=ruby]a = [1, 2, 3, 4, 5]
a[1, 3] = “foo”
p a
#=> [1, “foo”, 5] - dlatego, że a[1, 3] zwraca [2, 3, 4]

można także przypisać tablicę, wtedy:

a = [1, 2, 3, 4, 5]
a[1, 3] = [“foo”, “bar”]
p a
#=> [1, “foo”, “bar”, 5][/code]
Trzecim sposobem odwołania jest podanie obiektu zakresu (Range), wtedy wartości krańcowe określają indeksy pól podtablicy:

a = [1, 2, 3, 4, 5] a[2..3] = "foo" p a #=> [1, 2, "foo", 5]
Mam nadzieję, że teraz jest wszystko jasne.

3

Z dokumentacji Array#[].
Wyciąłem fragment, który powinieneś z uwagą przeczytać:

array[start, length]        -> an_array or nil
 array[range]                -> an_array or nil
 array.slice(index)          -> obj      or nil
 array.slice(start, length)  -> an_array or nil
 array.slice(range)          -> an_array or nil

 Element Reference---Returns the element at _index_, or returns a
 subarray starting at _start_ and continuing for _length_ elements,
 or returns a subarray specified by _range_. Negative indices count
 backward from the end of the array (-1 is the last element).
 Returns nil if the index (or starting index) are out of range.

    a = [ "a", "b", "c", "d", "e" ]
    a[2] +  a[0] + a[1]    #=> "cab"
    a[6]                   #=> nil
    a[-3, 3]               #=> [ "c", "d", "e" ]
    # special cases
    a[5]                   #=> nil
    a[5, 1]                #=> []

Po polskiemu: notacja array[i] wyciąga/przypisuje i-ty element tablicy. Notacja array[i,k] wyciąga/przypisuje PODTABLICĘ stworzoną z k elementów licząc od elementu i-tego.
Czyli u ciebie array[1,2] wyciąga lub nadpisuje dwuelementową tablicę od elementu o indeksie 1 - czyli [“Drugi”, 3]. Jeśli przypisałeś temu pojedynczą wartość, a nie tablicę dwuelementową, to nie dziw się że drugi z elementów podtablicy poszedł się … :wink:

4

Radarek mnie ubiegł :frowning:

:wink:

5

Dzięki. Teraz już wszystko jasne :slight_smile:

Pozdrawiam