Cap. 5 Arrays
Anterior Índice Próximo
Matrizes (Arrays)...
Até agora, nós geralmente temos usados objetos um de cada vez. Neste capítulo nós veremos como
criar uma lista de objetos. Vamos iniciar vendo o tipo de lista mais comum – uma matriz (array).
O que é um Ar r ay?
Um ar r ay é uma coleção sequencial de itens na qual cada item pode ser
indexado.
No Ruby, (difer ente de muitas outr as linguagens) um único Ar r ay pode
conter itens de tipos de dados mistur ados como str ings, inteir os e númer os
de ponto flutuante ou mesmo chamadas de métodos que r etor nem algum
valor :
a1 = [1,'two', 3.0, array_length( a0 ) ]
O pr imeir o item de um ar r ay têm o índice 0, o que significa que o item final
têm um índice igual ao total de itens do ar r ay menos 1. Dado o ar r ay, a1,
mostr ado acima, esta é a for ma de obter os valor es do pr imeir o e último itens:
a1[0] # returns 1st item (at index 0)
a1[3] # returns 4th item (at index 3)
arr ay0.r b
# Ruby Sample program from www.sapphiresteel.com /
www.bitwisemag.com
def array_length( anArray )
return anArray.length
end
a0 = [1,2,3,4,5]
a1 = [1,'two', 3.0, array_length( a0 ) ]
p( a0 )
p( a1 )
puts( "Item index #0 of a1 is #{a1[0]}, item #3 is #{a1[3]}" )
Usando arrays
Nós já usamos arrays algumas vezes – por exemplo, no programa adventure2.rb no capítulo 4 nós
usamos um array para armazenar um mapa de salas (objetos Room):
mymap = Map.new([room1,room2,room3])
Criando Arrays
Em comum com muitas outras linguagens de programação, o Ruby usa os sinais de colchetes []
para delimitar um array. Você pode facilmente criar um array, preenchao com alguns valores
separados por vírgula e atribuaos a uma variável:
arr = ['one','two','three','four']
arr ay1.r b
# Ruby Sample program from www.sapphiresteel.com /
www.bitwisemag.com
arr = ['a', 'b', 'c']
puts(arr[0]) # shows a
puts(arr[1]) # shows b
puts(arr[2]) # shows c
puts(arr[3]) # nil
Como a maioria das outras coisas no Ruby, arrays são objetos. Eles são definidos, como você deve
ter adivinhado, por uma classe Array, assim como as strings, os arrays são indexados a partir de 0.
Você pode referenciar um item em uma matriz colocando o seu índice entre colchetes []. Se o
índice for inválido, nil é retornado:
arr = ['a', 'b', 'c']
puts(arr[0]) # shows ‘a’
puts(arr[1]) # shows ‘b’
Pág. 46
Pequeno Livro do Ruby Cap. 5 Arrays
puts(arr[2]) # shows ‘c’
puts(arr[3]) # nil
arr ay2.r b
# Ruby Sample program from www.sapphiresteel.com /
www.bitwisemag.com
def hello
return "hello world"
end
x = [1+2, hello, `dir`] # array containing an expression, a
methodcall and a string
puts(x.inspect) # Note: if your are not using Windows, you
may need to
# change `dir` to a command that is understood
by your
# operating system
y = %w( this is an array of strings )
puts(y.inspect)
a = Array.new
puts("Array.new : " << a.inspect)
a = Array.new(2)
puts("Array.new(2) : " << a.inspect)
a = Array.new(2,"hello world")
puts(a.inspect)
a = Array.new(2)
a[0]= Array.new(2,'hello')
a[1]= Array.new(2,'world')
puts(a.inspect)
a = [ [1,2,3,4],
[5,6,7,8],
[9,10,11,12],
[13,14,15,16] ]
puts(a.inspect)
a = Array.new([1,2,3])
Pág. 47
Pequeno Livro do Ruby Cap. 5 Arrays
puts(a.inspect)
# Note: in the above example, if you pass an array to new()
without
# putting it in sound brackets, you must leave a space between
# 'new' and the opening square bracket.
# This works:
# a = Array.new [1,2,3]
# This doesn't!
# a = Array.new[1,2,3]
É permitido misturar tipos de dados em um array e até mesmo incluir expressões que produzam
algum valor. Vamos assumir que você já criou este método:
def hello
return "hello world"
end
Você pode agora declarar este array:
x = [1+2, hello, `dir`]
Aqui, o primeiro elemento é um inteiro, 3 (1+2), e o segundo é uma string“hello
world” (retornada pelo método hello criado acima). Se você executar isto no Windows, o terceiro
elemento será uma string contendo a listagem do diretório. Isto devese ao fato que `dir` é uma
string cotada por crase (`) que é executada pelo sistema operacional. O slot final do array é, por
essa razão, preenchido com o valor retornado pelo comando dir que monta a string com nomes de
arquivos. Se você está usando um sistema operacional diferente você deve substituir o comando dir
pelo comando apropriado do seu sistema operacional ( por exemplo no Linux o comando é o `ls` ).
Criando um Array de Nomes de Arquivos: Algumas classes Ruby possuem
métodos que r etor nam ar r ays. Por exemplo, a classe Dir , que é usada par a
executar oper ações em dir etór ios de disco, têm o método entr ies. Passe um nome de
dir etór io par a o método e ele r etor na uma lista de ar quivos em um ar r ay:
Dir.entries( 'C:\\' ) # returns an array of files in C: dir _ar r ay.r b
# Ruby Sample program from www.sapphiresteel.com /
www.bitwisemag.com
Pág. 48
Pequeno Livro do Ruby Cap. 5 Arrays
p( Dir.entries( 'C:\\' ) )
Se você quer criar um array de strings mas não quer chatearse digitando todas as aspas e vírgulas,
um atalho é colocar texto não cotado separado por espaços entre parênteses precedido por %w
como este exemplo:
y = %w( this is an array of strings )
Você pode também criar arrays com o método usual de construção de objetos, new.
Opcionalmente, você pode passar um inteiro para criar um array vazio com um tamanho específico
( no qual cada elemento será igual a nil ), ou você pode passar dois argumentos – o primeiro para
definir o tamanho do array e o segundo para especificar o elemento a colocar em cada índice,
assim:
a = Array.new # an empty array
a = Array.new(2) # [nil,nil]
a = Array.new(2,"hello world") # ["hello world","hello world"]
Arrays Multi-Dimensionais
Para criar arrays multidimensionais, você pode criar um array e então adicionar outros arrays para
os 'slots' deste array. Por exemplo, isto cria um array contendo dois elementos, cada qual é também
um array de dois elementos:
a = Array.new(2)
a[0]= Array.new(2,'hello')
a[1]= Array.new(2,'world')
Ou você poderia aninhar arrays dentro de outro usando os colchetes. Isto cria um array de quatro
arrays, cada qual contém quatro inteiros:
a = [ [1,2,3,4],
[5,6,7,8],
[9,10,11,12],
[13,14,15,16] ]
No código acima, eu coloquei quatro ‘subarrays’ em linhas separadas. Isto não é obrigatório mas
ajuda a tornar clara a estrutura do array multidimensional mostrando cada subarray como se fosse
uma linha, semelhante a linhas em uma planilha de cálculo. Quando tratar de arrays dentro de
Pág. 49
Pequeno Livro do Ruby Cap. 5 Arrays
arrays, é conveniente tratar cada array aninhado como uma linha de um array externo.
arr ay_new.r b
# Ruby Sample program from www.sapphiresteel.com /
www.bitwisemag.com
# all these are ok
arrayob = Array.new([1,2,3])
arrayob = Array.new( [1,2,3] )
arrayob = Array.new [1,2,3]
# but this one isn't
arrayob = Array.new[1,2,3]
p( arrayob )
Você também pode cr iar um objeto Ar r ay passando um ar r ay com um
ar gumento par a o método new. Seja cuidadoso, contudo. É uma
ar timanha do Ruby que, mesmo sendo legítimo passar um ar gumento
ar r ay com ou sem os par ênteses delimitador es, o Ruby consider a um
er r o de sintaxe se você esquecer de deixar um espaço entr e o new e o
pr imeir o colchete – outr a boa r azão par a cr iar o fir me hábito de usar
par ênteses quando passar ar gumentos!
Para alguns exemplos do uso de arrays multidimensionais, carregue o programa multi_array.rb.
Ele começa criando um array, multiarr, contendo dois outros arrays. O primeiro destes arrays está
no índice 0 de multiarr e o segundo está no índice 1:
multiarr = [['one','two','three','four'],[1,2,3,4]]
multi_ar r ay.r b
# Ruby Sample program from www.sapphiresteel.com /
www.bitwisemag.com
# create an array with two subarrays i.e. 2 'rows' each with 4
elements
multiarr = [['one','two','three','four'], # multiarr[0]
[1,2,3,4]] # multiarr[1]
Pág. 50
Pequeno Livro do Ruby Cap. 5 Arrays
# iterate over the elements ('rows') of multiarr
puts( "for i in.. (multidimensional array)" )
for i in multiarr
puts(i.inspect)
end
puts( "\nfor a, b, c, d in.. (multidimensional array)" )
for (a,b,c,d) in multiarr
print("a=#{a}, b=#{b}, c=#{c}, d=#{d}\n" )
end
Iterando sobre Arrays
Você pode acessar os elementos de uma matriz, iterando sobre eles usando um laço for. O laço irá
iterar sobre dois elementos neste exemplo: nomeadamente, os dois subarrays nos índices 0 e 1:
for i in multiarr
puts(i.inspect)
end
Isto mostra:
["one", "two", "three", "four"]
[1, 2, 3, 4]
arr ay_index.r b
# Ruby Sample program from www.sapphiresteel.com /
www.bitwisemag.com
arr = ['h','e','l','l','o',' ','w','o','r','l','d']
# Here we print each char in sequence
print( arr[0,5] )
puts
print( arr[5,5 ] )
puts
print( arr[0..4] )
puts
print( arr[5..1] )
Pág. 51
Pequeno Livro do Ruby Cap. 5 Arrays
puts
# Here we inspect the chars. Notice that we can
# index into an array like this...
# arr[
, ]
# or specify a range like this...
# arr[ .. ]
#
# So these are equivalent:
p( arr[0,5] )
p( arr[0..4] )
Iteradores e laços for: O código dentr o de um laço for é executado par a cada elemento em
uma expr essão. A sintaxe é r esumida assim:
for in do
end
Quando mais de uma var iável é for necida, elas são passadas par a o código inter no do bloco
for ..end da mesma for ma que você passa ar gumentos par a um método. Aqui, por exemplo,
você pode ver (a,b,c,d) como quatr o ar gumentos que são inicializados, a cada volta do laço for ,
pelos quatr o valor es de uma linha de multiar r :
for (a,b,c,d) in multiarr
print("a=#{a}, b=#{b}, c=#{c}, d=#{d}\n" )
end
Indexando Arrays
Você pode indexar a partir do fim de um array usando o sinal de menos (), onde 1 é o índice do
último elemento; e você também pode usar faixas ( valores entre um índice inicial e final separados
por dois sinais de ponto .. ):
arr = ['h','e','l','l','o',' ','w','o','r','l','d']
print( arr[0,5] ) #=> ‘hello’
print( arr[5,5 ] ) #=> ‘world’
Pág. 52
Pequeno Livro do Ruby Cap. 5 Arrays
print( arr[0..4] ) #=> ‘hello’
print( arr[5..1] ) #=> ‘world’
Note que, como as strings, quando fornecido dois inteiros para retornar um número contíguo de
itens de um array, o primeiro inteiro é o índice inicial e o segundo é número de itens (não um
índice):
arr[0,5] # returns 5 chars ["h", "e", "l",
"l", "o"]
ar r ay_index.r b
# Ruby Sample program from www.sapphiresteel.com /
www.bitwisemag.com
arr = []
arr[0] = [0]
arr[1] = ["one"]
arr[3] = ["a", "b", "c"]
p( arr ) # inspect and print arr
arr2 = ['h','e','l','l','o',' ','w','o','r','l','d']
arr2[0] = 'H'
arr2[2,3] = 'L', 'L'
arr2[4..5] = 'O','','W'
arr2[4,4] = 'a','l','d','o'
p( arr2 ) # inspect and print arr2
Você também pode designar índices dentro de um array. Aqui, por exemplo, Eu primeiro criei um
array vazio então coloquei itens nos índices 0, 1 e 3. O slot vazio no índice número 2 será
preenchido com um valor nil:
arr = []
arr[0] = [0]
arr[1] = ["one"]
arr[3] = ["a", "b", "c"]
# arr now contains:
Pág. 53
Pequeno Livro do Ruby Cap. 5 Arrays
# [[0], ["one"], nil, ["a", "b", "c"]]
Uma vez mais, você pode usar índices iniciais e finais, faixas e índices negativos:
arr2 = ['h','e','l','l','o',' ','w','o','r','l','d']
arr2[0] = 'H'
arr2[2,3] = 'L', 'L'
arr2[4..5] = 'O','','W'
arr2[4,4] = 'a','l','d','o'
# arr2 now contains:
# ["H", "e", "L", "L", "O", "", "W", "a", "l", "d", "o"]
Anterior Índice Próximo
-- LeandroNunes - 18 Oct 2006