[box class=windowbg1]
Índice das aulas básicas
- Aula 1 - Introdução (http://centrorpg.com/index.php?topic=198.0)
- Aula 2 - Objetos (http://centrorpg.com/index.php?topic=205.0)
- Aula 3 - Operações (http://centrorpg.com/index.php?topic=1218.0)
- Aula 4 - Condições (http://centrorpg.com/index.php?topic=2504.0)
- Aula 5 - Repetição (http://centrorpg.com/index.php?topic=2870.0)
- Aula 6 - Arrays (http://centrorpg.com/index.php?topic=523.0)
- Aula 7 - Hashes (http://centrorpg.com/index.php?topic=589.0)
[/box]
[box class=windowbg1]Índice das aulas avançadas
- Aula 8 - Superclasses e instâncias (http://centrorpg.com/aulas-para-rgss/superclasse-herancas-e-instancias/)
[/box]
[box class=windowbg1]Índice das aulas de algoritmos
- Aula 1 - Sort (http://centrorpg.com/aulas-para-rgss/algoritmo-1-otrs-gt-sort/)
- Aula 2 - Busca (http://centrorpg.com/aulas-para-rgss/algoritmo-2-busca/)
- Aula 3 - Recursividade (http://centrorpg.com/aulas-para-rgss/recursividade/)
[/box]
[box class=windowbg2]Mega Aula de Arrays
[/box]
[box class=catbg4]Introdução
[/box]
[box class=catbg3]Arrays, uma das ferramentas mais uteis e utilizadas pelos programadores, por sua facilidade, rapidez, é uma ferramenta poderosíssima.
As arrays são basicamente vetores e comparados a tal, a razão disso é porque arrays são um conjunto de valores. Basicamente as arrays criam espaços em que podem ser preenchidos por valores de variáveis no caso todas aquelas já aprendidas, Integer, Float, String...
Fiz uma imagem bem malfeita no paint xD, mas será possível entender melhor o que acontece.
Se eu criar uma array com 5 espaços, no caso 5 valores, no Ruby podendo fazer da seguinte maneira.
minharray = Array.new(5)
Eu teria esse caso
(http://i.imgur.com/B001q.png)
5 espaços em branco, todos com o valor nil, que seria nulo.
No caso eu posso manipular os "espaços" criados pelas arrays, exatamente do mesmo modo que manipulo as variáveis, no caso se eu quiser que o terceiro "espaço" tenha o valor 7, eu poderia simplesmente fazer o seguinte.
minhaarray[2] = 7 # Lembrando que começa do 0 a contagem.
Que deixaria o mostrado anterior assim.
(http://i.imgur.com/U0cGI.png)
As arrays são um recurso muito especial, diferente de declarar diferentes variáveis, declarando elas como array, é possível aumentar a interatividade entre eles, organiza-los e encontra-los mais facilmente, também possibilitando criar laços de repetição para facilitar e optimizar o código.
Utilizando 2 vetores, basicamente 2 arrays é possível também criar uma matriz,como podem ver na foto seguinte(esse imaginei que ficaria muito mal feito no paint, então peguei a primeira imagem do google :).
(http://www.caelum.com.br/apostila-java-orientacao-objetos/um-pouco-de-arrays/referencia_matriz_quadrada.png)
Para quem percebeu, as arrays vão além de simples valores, e devem ser visualizadas como algo que sai de apenas um valor, para algo que pode ir de simples linhas, para mapas completos aonde eu posso encontrar facilmente cada valor nas arrays, e manipula-las entre si.
Certo, chega de teoria, vamos a parte pratica!
[/box]
[box class=catbg4]Arrays
[/box]
[box class=catbg3] Para se declarar uma variável como array no Ruby
variavel = Array.new
ou
variavel = []
Nesses 2 casos, é declarado uma array com valor em branco, ou seja ele já é visto como uma array, porém não tem índice nem valores embutidos nele.
variavel = Array.new(n)
Nesse caso é declarado uma array com tamanho n, e todos os valores dentro dessa array tem valor nil, exemplo:
variavel = Array.new(3)
Será criado a seguinte array
[nil, nil, nil]
Também é possível facilmente preencher toda a nova array com um dado valor, por exemplo.
variavel = Array.new(4, "a")
Será criado a seguinte array
["a", "a", "a", "a"]
A array também permite ser criado os valores dentro de um laço, ou seja caso eu pretenda criar uma array que tenha seus valores diretamente ligado a seu índice(índice é a posição dos valores dentro de uma array, sendo que o primeiro valor tem índice 0, o segundo tem índice 1, e assim por diante)
variavel = Array.new(4) {|a| a *= 2}
Esse laço por exemplo criaria uma array com tamanho 4, e que seus valores internos sejam 2 vezes o valor de seu índice, o código acima criaria essa array.
[0, 2, 4, 6]
Caso eu declare um índice fora da Array com algum valor, todos os espaços entre o último índice e o índice que eu criei serão automaticamente preenchidos por nil, exemplo com a array acima.
variavel[6] = 3
deixaria a array da seguinte maneira
[0, 2, 4, 6, nil, nil, 3]
[/box]
[box class=catbg4]Manipulando as arrays
[/box]
[box class=catbg3]Essa é a parte que é interessante sobre as arrays, o modo como podem ser facilmente manipulados e a interligação entre os valores dentro de uma array.
Você pode facilmente criar laços para criar e manipular valores em uma array, exemplo:
minhaarray = Array.new
for n in 0...5
minhaarray[n] = n * n
end
Que criaria uma array da seguinte maneira
[0, 1, 4, 9, 16]
Existem milhares de modos de colocar e criar arrays com laços diferentes.[/box]
[box class=catbg]Intersecção e união
[/box]
[box class=catbg3]Intersecção são os valores idênticos contidos em todas as arrays, exemplo:
[1, 4, 5, 6] & [2, 4, 7] == [4]
União são os valores contidos em todas as arrays, exemplo:
[1, 4, 5, 6] | [2, 4, 7] == [1, 4, 5, 6, 2, 7][/box]
[box class=catbg]Operações matemáticas
[/box]
[box class=catbg3]Adição:
[1, 2, 4, 5] + [2, 4, 6] == [1, 2, 4, 5, 2, 4, 6]
Subtração:
[1, 2, 4, 4, 4, 5] - [4, 1] == [2, 5]
Multiplicação:
[1, 2, 3] * 2 == [1, 2, 3, 1, 2, 3]
Igualdade:
[1, 2, 3, 3] == [2, 1, 3, 3] # false
[1, 2, 3] == [1, 2, 3] # true[/box]
[box class=catbg]Retorno de valores
[/box]
[box class=catbg3]
Size:
array.size ou array.length retorna q quantidade de índices ou tamanho da array.
[1, 2, 3, 4].size == 4
[1, 2, 3, 4].length == 4
Count:
pode ser usado como o size/length
array.count
[1, 2, 3, 4].count == 4
pode ser usado para contar certos valores em uma array
array.count(n)
[1, 2, 2, 4].count(2) == 2
pode ser usado com estruturas condicionais
array.count{|n| condição} aonde n é o índice
[1, 2, 2, 3].count{|n| n >= 2} == 3
Index:
array.index(n) retorna a posição daquele valor dentro da array
[1, 2, 3, 4].index(4) == 3
array.index{|n| block} retorna a posição daquele valor dentro da array de acordo com o bloco condicional.
[1, 2, 3, 4].index{|n| n > 1} == 1
Reparem que ele retorna o primeiro valor que atinge a condição.
First e Last:
array.first retorna o primeiro objeto da array
[1, 2, 3, 4].first == 1
array.last retorna o último objeto da array
[1, 2, 3, 4].last == 4
Include:
array.include?(n) verifica se o objeto n está incluso na array.
[1, 2, 3, 4].include?(2) == true
[1, 2, 3, 4].include?(5) == false
empty:
retorna true se a array estiver vazia.
[].empty == true
[1].empty == false
rindex:
mesma coisa que o index, mas ao invés de retornar o primeiro valor igual, retorna o último.
array.rindex(n)
[1, 2, 2, 2, 3].rindex(2) == 3
[/box]
[box class=catbg]Manipulando a Array
[/box]
Importante sobre as arrays, é de costume que os comandos utilizados nas arrays que terminam com exclamação "!", mudam a array permanentemente, então comandos que tem o mesmo nome porém um sem e outro com exclamação, pode-se deduzir que o sem exclamação retorna o valor, porém não modifica a array e o com modifica a array para o novo valor.
[box class=catbg3]
push:
Empurra um valor no último índice da array
[1, 2, 3, 4].push(5) == [1, 2, 3, 4, 5]
Também pode ser escrito da seguinte maneira
[1, 2, 3, 4] << 5 == [1, 2, 3, 4, 5]
rotate e rotate!:
rotaciona a array, podendo ser positivo ou negativo, lembrando do que foi dito anteriormente sobre a exclamação.
[1, 2, 3, 4].rotate(1) == [4, 1, 2, 3] # porém a array continua com [1, 2, 3, 4] e retorna o novo valor
[1, 2, 3, 4].rotate!(- 2) == [3, 4, 1, 2] # porém a array antiga terá o novo valor
reverse e reverse!:
reposiciona os valores da array no sentido contrário
[1, 2, 3, 4].reverse == [4, 3, 2, 1] # porém a array continua com [1, 2, 3, 4] e retorna o novo valor
[1, 2, 3, 4].reverse! == [4, 3, 2, 1] # porém a array antiga terá o novo valor
delete:
retorna se tem tal valor e o deleta da array.
a = [1, 2, 3, 4]
a.delete(4) # retorna 4
a.delete(5) # retorna nil
a == [1, 2, 3]
shift:
muito semelhante ao delete, porém ao invés dos valores, ele é pego o primeiro valor da array
a = [1, 2, 3, 4]
a.shift # retorna 1
a == [2, 3, 4]
ou então n primeiros valores
a = [1, 2, 3, 4]
a.shift(2) # retorna 1, 2
a == [3, 4]
shuffle e shuffle!:
randomiza as posições dos objetos em uma array
[1, 2, 3, 4].shuffle == [3, 2, 4, 1] # porém a array continua com [1, 2, 3, 4] e retorna o novo valor
[1, 2, 3, 4].shuffle! == [4, 1, 3, 2] # porém a array antiga terá o novo valor
sort e sort!:
reposiciona os valores da array em ordem crescente, ordem númerica para float/integer e ordem alfabética para strings
["c", "a", "d"].sort == ["a", "c", "d"] # porém a array continua com ["c", "a", "d"] e retorna o novo valor
[4, 3, 1, 2].sort! == [1, 2, 3, 4] # porém a array antiga terá o novo valor
take:
retorna os primeiros n valores da array.
["c", "a", "d"].take(2) == ["c", "a"]
unshift:
semelhante ao push, porém ele empurra objetos ns primeiras posições, e reorganiza os seguintes objetos para que o novo tome seu lugar.
[1, 2, 3, 4, 5].unshift(0) == [0, 1, 2, 3, 4, 5]
fill:
preenche a array de tamanho n com um dado valor
[1, 2, 3, 4, 5].fill(0) == [0, 0, 0, 0, 0]
ou com um bloco
[1, 2, 3, 4, 5].fill{|n| n * n} == [0, 1, 4, 9, 16]
compact e compact!:
retira os valores nil de uma array
[1, nil, nil, 2, 3, 4].compact == [1, 2, 3, 4] # porém a array continua com [1, nil, nil, 2, 3, 4] e retorna o novo valor
[1, nil, nil, 2, 3, 4].compact! == [1, 2, 3, 4] # porém a array antiga terá o novo valor
[/box]
[box class=catbg4]Considerações finais
[/box]
Os comandos aqui escritos sobre as arrays são apenas uma parte, tentei escrever os principais e mais utilizados, Aqui tem uma lista mais completa dos métodos, e é aonde eu uso como colinha para me lembrar dos que eu esqueço ou não conheço (também utilizado para poder montar essa aula).
http://www.ruby-doc.org/core-1.9.3/Array.html
Boa sorte nos estudos :D
Tive bastante dificuldade pra entender sobre as arrays, mas acho que deu pra pegar, mas tenho duas duvidas:
na ultimas aulas, varias vezes eu via colocarem a class dentro de uma variável e então usando essa variável para chamar um metodo:
class Classe
def metodo
end
end
variavel = Classe.new
variavel.metodo
essa penúltima linha do código seria a criação de uma array contendo a class como valor?
e sobre o laço:
variavel = Array.new(4) {|a| a *= 2}
O fato do a estar dentro dos || significa que a = índice?
Creio que sejam minha únicas duvidas por enquanto em relação as arrays.
Citação de: Akugam online 12/01/2017 às 16:01
Tive bastante dificuldade pra entender sobre as arrays, mas acho que deu pra pegar, mas tenho duas duvidas:
na ultimas aulas, varias vezes eu via colocarem a class dentro de uma variável e então usando essa variável para chamar um metodo:
class Classe
def metodo
end
end
variavel = Classe.new
variavel.metodo
essa penúltima linha do código seria a criação de uma array contendo a class como valor?
Eu não sei Ruby, mas estudo Java, então
acho que posso explicar:
Não, não é. A penúltima linha é a criação de um objeto da class Classe. É uma variável de referência. Não é uma array.
Opa é o que o Nandikki falou :ok:
Só complementando, isso tem a ver com as estruturas de objetos que o Ruby usa que é comum em praticamente todas linguagens orientadas a objetos.
Dou uma explicada bem por cima nas aulas mais avançadas,
http://centrorpg.com/index.php?topic=6630.0
porém saber como funciona é necessário um estudo maior sobre programação, então de momento essa aula acima já vai ajudar a entender melhor.