Comment retourner une partie d’un tableau dans Ruby?

Avec une liste en Python, je peux en retourner une partie en utilisant le code suivant:

foo = [1,2,3,4,5,6] bar = [10,20,30,40,50,60] half = len(foo) / 2 foobar = foo[:half] + bar[half:] 

Comme Ruby fait tout dans les tableaux, je me demande s’il y a quelque chose de similaire.

Oui, Ruby a une syntaxe de découpage de tableaux très similaire à Python. Voici la documentation de ri pour la méthode d’indexation du tableau:

 --------------------------------------------------------------- Array#[] array[index] -> obj or nil 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[1, 2] #=> [ "b", "c" ] a[1..3] #=> [ "b", "c", "d" ] a[4..7] #=> [ "e" ] a[6..10] #=> nil a[-3, 3] #=> [ "c", "d", "e" ] # special cases a[5] #=> nil a[5, 1] #=> [] a[5..10] #=> [] 

Si vous voulez diviser / couper le tableau sur un index i,

 arr = arr.drop(i) > arr = [1,2,3,4,5] => [1, 2, 3, 4, 5] > arr.drop(2) => [3, 4, 5] 

Vous pouvez utiliser slice () pour cela:

 >> foo = [1,2,3,4,5,6] => [1, 2, 3, 4, 5, 6] >> bar = [10,20,30,40,50,60] => [10, 20, 30, 40, 50, 60] >> half = foo.length / 2 => 3 >> foobar = foo.slice(0, half) + bar.slice(half, foo.length) => [1, 2, 3, 40, 50, 60] 

Au fait, les «listes» Python sont, à ma connaissance, simplement mises en œuvre de manière dynamic. L’insertion au début est dans O (n), l’insertion à la fin est amortie O (1), l’access aléatoire est O (1).

une autre façon est d’utiliser la méthode de la gamme

 foo = [1,2,3,4,5,6] bar = [10,20,30,40,50,60] a = foo[0...3] b = bar[3...6] print a + b => [1, 2, 3, 40, 50 , 60] 

J’aime les gammes pour cela:

 def first_half(list) list[0...(list.length / 2)] end def last_half(list) list[(list.length / 2)..list.length] end 

Cependant, faites très attention à savoir si le noeud final est inclus dans votre plage. Cela devient critique sur une liste de longueurs impaires où vous devez choisir où vous allez casser le milieu. Sinon, vous finirez par compter le double élément.

L’exemple ci-dessus mettra systématiquement l’élément intermédiaire dans la dernière moitié.

vous pouvez aussi écrire quelque chose comme ça

 foo = [1,2,3,4,5,6,7] bar = [10,20,30,40,50,60,70] half = foo.length / 2 foobar = (foo.first half) + (bar.drop half) => [1, 2, 3, 40, 50, 60, 70]