├── Prazer, Ruby.doc ├── README.mkdn ├── trabalhando-com-datas.mkdn ├── trabalhando-com-hashes.mkdn ├── trabalhando-com-strings.mkdn └── trabalhando-com-array.mkdn /Prazer, Ruby.doc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/albertoleal/prazer--ruby/HEAD/Prazer, Ruby.doc -------------------------------------------------------------------------------- /README.mkdn: -------------------------------------------------------------------------------- 1 | ## Prazer, Ruby 2 | 3 | # O que é? 4 | Tudo começou com a idéia de pegar meus resumos pessoais de estudos e transformá-los em uma série de posts sobre Ruby, no meu blog. Percebi, então, que seria mais interessante tentar fazer uma espécie de apostila, junto com a comunidade, para aqueles que estão chegando na linguagem e não encontram muito material em Português. 5 | 6 | # Dúvidas e Sugestões? 7 | Dúvidas e sugestões podem ser enviadas diretamente para mim. 8 | 9 | #Bibliografia 10 | Como citado, tudo o que está aqui é baseado nos meus resumos. Abaixo, listo os livros que li sobre Ruby: 11 | - The Ruby Way, Second Edition: Solutions and Techniques in Ruby Programming (2nd Edition) 12 | by Hal Fulton (Author) 13 | 14 | - The Ruby Programming Language 15 | by David Flanagan (Author), Yukihiro Matsumoto (Author) 16 | 17 | -------------------------------------------------------------------------------- /trabalhando-com-datas.mkdn: -------------------------------------------------------------------------------- 1 | # Trabalhando com Datas 2 | 3 | É muito simples obter a hora e data atual com Ruby, para isso basta criar um objeto do tipo Time (ou chamando o método new ou now): 4 | 5 | hora_atual = Time.new 6 | hora_atual = Time.now 7 | 8 | Para trabalhar com datas/horas no passado e no futuro, podemos utilizar o método mktime da classe Time: 9 | 10 | mk = Time.mktime(2009,12,23,9,34,23) # Wed Dec 23 09:34:23 -0200 2009 11 | 12 | ## Alguns métodos interessantes 13 | 14 | mon ou month - Retorna o mês do ano 15 | 16 | time = Time.now 17 | puts time.mon 18 | puts time.month 19 | 20 | yday - Retorna um inteiro representanto o dia do ano 21 | 22 | time = Time.now 23 | puts time.yday 24 | 25 | wday - Retorna o dia da semana 26 | 27 | time = Time.now 28 | puts time.wday 29 | 30 | Existe uma outra forma de se recuperar o dia da semana: 31 | 32 | time = Time.now 33 | array_time = time.to_a 34 | puts array_time[6] 35 | -------------------------------------------------------------------------------- /trabalhando-com-hashes.mkdn: -------------------------------------------------------------------------------- 1 | # Trabalhando com Hashes 2 | 3 | Hashes são conhecidos como arrays associativos. Mas então, o que difere Arrays de Hashes? 4 | Arrays são estruturas que criam associações entre um índice e um valor. E, os hashes são semelhantes, mas possuem algumas diferenças, tais como: 5 | - Os índices dos arrays são inteiros, já os índices dos hashes, é permitido ter uma string como índice. 6 | - Arrays são ordenados, e hashes não. 7 | 8 | ## Criando um hash 9 | Assim como fazemos com o Array, para criar um Hash, utilizamos o método []: 10 | 11 | h1 = Hash.[](1=>“casa”,2=>”carro”,3=>”comida”) 12 | h2 = Hash[1=>“casa”,2=>”carro”,3=>”comida”] 13 | h3 = Hash[“casa” => 1,”carro” => 2,”comida” => 3] 14 | h4 = {1=>“casa”,2=>”carro”,3=>”comida”} 15 | h5 = {“casa” => 1,”carro” => 2,”comida” => 3} 16 | 17 | Existe também o método new, o qual aceita um parâmetro para indicar o valor default. Esse valor default não quer dizer que é o valor armazenado dentro do Hash, mas sim, o valor que é retornado ao invés quando o valor é nulo, caso o elemento solicitado seja nulo. 18 | 19 | h1 = Hash.new 20 | h2 = Hash.new(10) 21 | h3 = Hash.new(“casa” => 1) 22 | h3.inspect #{} 23 | puts h3[3] # “casa” 24 | 25 | Outra forma de se definir um valor default para o hash é chamando o método default: 26 | 27 | h1 = Hash.new(“valor_default”) 28 | puts h1[9]; # valor_default 29 | h1.default = “outro_valor” 30 | puts h1[9]; # outro_valor 31 | 32 | ## Acessando e Adicionando valores a um Hash 33 | 34 | Assim como a classe Array, a classe Hash possui os métodos [] e []= para adicionar elementos ao Hash. Se você olhar na api, verá um método store, ele é apenas um alias para o método []= 35 | 36 | nb = Hash.new 37 | nb[‘imovel’] = “casa” 38 | nb.[]=(“imovel”,”casa”) 39 | nb.store(“imovel”,”casa”) 40 | h1.default = “outro_valor” 41 | puts h1[9]; # outro_valor 42 | 43 | Uma maneira de se acessar um elemento dentro do hash é através do método fetch, passando como parâmetro o nome do índice desejado. Este método possui , ainda, um segundo parâmetro. Ele é utilizado, opcionalmente, para setar um valor a ser retornado, caso o elemento solicitado não seja encontrado, evitando IndexError: 44 | 45 | nb = {“imovel” => “casa”, “carro” => “gol”} 46 | nb.fetch ‘imovel’ # casa 47 | nb.fetch ‘xpto’ # IndexError 48 | nb.fetch ‘xpto’, "alô" # alô 49 | 50 | ## Deletando Elementos em um Hash 51 | 52 | clear - Utilizado para deletar todos os elementos do hash 53 | delete - Utilizado para deletar um índice-valor específico 54 | delete_if - Utilizado para deletar um índice-valor, quando o bloco retorna true. 55 | shift - Utilizado para deletar o primeiro índice-valor encontrado 56 | 57 | nb = {“imovel” => “casa”, “carro” => “gol”} 58 | nb.clear 59 | nb.delete(“carro”) 60 | nb.delete_if{|k,v| v == “gol”} 61 | nb.shift 62 | 63 | ## Iterando um Hash 64 | 65 | A classe Hash possui alguns métodos para fazer iteração em seus elementos. Vejamos alguns: 66 | 67 | nb = {“imovel” => “casa”, “carro” => “gol”} 68 | nb.each{|k,v| puts ”Chave: #{k}, Valor: #{v}} 69 | nb.each_key{|k| puts ”Chave: #{k}} 70 | nb.each_value{|v| puts ”Valor: #{v}} 71 | 72 | ## Alguns métodos interessantes 73 | 74 | invert - utilizado para inverter o par chave-valor 75 | 76 | nb = {“imovel” => “casa”, “carro” => “gol”} 77 | nb.invert # “ casa” => “ imovel”, “gol” => “ carro”} 78 | 79 | has_key? , member?, key?, include? - utilizado para verificar se a chave informada está contida no hash 80 | 81 | nb = {“imovel” => “casa”, “carro” => “gol”} 82 | nb.has_key? “imovel” # true 83 | nb.member? “gol” # false 84 | 85 | length ou size - Retornar o tamanho do hash 86 | 87 | nb = {“imovel” => “casa”, “carro” => “gol”} 88 | nb.length #2 89 | 90 | empty? - retorna true ou false, se o hash está vazio ou não 91 | 92 | nb = {“imovel” => “casa”, “carro” => “gol”} 93 | nb.empty? #false 94 | 95 | to_a - converte o hash para array 96 | 97 | nb = {“imovel” => “casa”, “carro” => “gol”} 98 | nb.to_a # [“imovel”, ”casa”, “carro”, ”gol”] 99 | 100 | keys - converte apenas as chaves para array 101 | 102 | nb = {“imovel” => “casa”, “carro” => “gol”} 103 | nb.keys # [“imovel”,“carro”] 104 | 105 | values - converte apenas os valores para array 106 | 107 | nb = {“imovel” => “casa”, “carro” => “gol”} 108 | nb.values # [“casa”,“gol”] 109 | 110 | values_at - retornar uma array contendo os valores para as chaves passadas 111 | 112 | nb = {“imovel” => “casa”, “carro” => “gol”} 113 | nb.values_at(“carro”,”imovel”) # [“gol”, ”casa”] 114 | -------------------------------------------------------------------------------- /trabalhando-com-strings.mkdn: -------------------------------------------------------------------------------- 1 | # Trabalhando com Strings 2 | 3 | ## Sendo uma string 4 | 5 | String é basicamente uma sequência de caracteres. Essencialmente, existem duas formas de se criar uma objeto string em ruby: utilizando aspas simples ou aspas duplas. Existe uma sutil diferença entre essas duas abordagens. 6 | 7 | Quando criamos uma string utilizando aspas simples estamos forçando que ela seja impresa exatamente da forma como foi escrita. E, se for necessário incluir uma ou mais aspas simples no texto, é preciso escapar (\). 8 | 9 | Por outro lado, se criar uma string utilizando aspas duplas é permitido utilizar de um artifício, que veremos mais a frente, chamado interpolação. Além de poder usufruir de outros caracteres de escape, como: \n,\t e outros. 10 | 11 | s1 = "Isso é uma string" 12 | s2 = 'Isso, também, é uma string' 13 | s3 = %q[Mais uma forma de se criar uma string] # 'Mais uma forma de se criar uma string' 14 | s4 = %Q[Outra forma de se criar uma string] # "Outra forma de se criar uma string" 15 | 16 | * Nota: Repare que quando utilizamos %q, aspas simples é utilizada, enquanto que %Q utiliza aspas duplas 17 | 18 | ## Substituição de strings 19 | 20 | Para alterar trechos de uma string, utiliza-se os métodos gsub e sub. 21 | O método sub altera apenas a primeira ocorrência encontrada para o padrão informado para substituição, por exemplo: 22 | 23 | str = "prazer ruby e ruby on rails" 24 | str.sub(/ruby/, "xxx") #"prazer xxx e ruby on rails" 25 | 26 | Agora, já o método gsub faz a substituição em todas as ocorrências encontradas: 27 | 28 | str = "prazer ruby e ruby on rails" 29 | str.sub(/ruby/, "xxx") #"prazer xxx e xxx on rails" 30 | 31 | ## Pesquisando Strings 32 | 33 | Para retirar uma substring de uma string, basta informar o índice e a quantidade de caracteres que deseja obter a partir daquele índice: 34 | 35 | str = "Prazer, Ruby on Rails" 36 | str[8,4] # “Ruby” 37 | 38 | Juntamente com o código acima, ou melhor, antes de utilizá-lo, pode ser interessante pesquisar de ante-mão qual a posição da palavra “Ruby”, para então recuperá-la. Caso não se saiba qual é a posição em que a palavra se encontra, pode-se fazer uma chamada ao método index ou rindex: 39 | 40 | str.index(/ruby/) #nil 41 | 42 | O código acima não retorna nada, visto que a palavra procurada não existe dentro da string. O que quer dizer que nossa busca está procurando apenas pela palavra em caixa baixa. Portanto, para torná-la não case-sensitive, adicionamos a letra “i” ao final de nossa expressão regular: 43 | 44 | str.index(/ruby/i) #8 45 | 46 | Existe, ainda, o método scan. Utiliza-se tal método passando um padrão a ser pesquisado, via regex. O retorno é um array com o resultado encontrado: 47 | 48 | str.scan(/\w/) # ["P", "r", "a", "z", "e", "r", "R", "u", "b", "y", "o", "n", "R", "a", "i", "l", "s"] 49 | str.scan(/\w+/) # ["Prazer", "Ruby", "on", "Rails"] 50 | 51 | ## Interpolação 52 | 53 | Ao construir uma string, muitas vezes desejamos adicionar valores de variáveis ao longo da expressão. Para não ter que ficar concatenando sempre que isso for necessário, utiliza-se da interpolação. A notação utilizada para tal tarefa é #{}. Basta adicionarmos o nome da nossa variável dentro da notação para que ela seja impressa. Mas, para isso, a string deve ser construída com aspas duplas, caso contrário, tanto a notação quanto o nome da variável, contida dentro da mesma, serão exibidos literalmente. 54 | 55 | minha_variavel = “Rails” 56 | str = "Prazer, Ruby on #{minha_variavel}" # “Prazer, Ruby on Rails” 57 | str = 'Prazer, Ruby on #{minha_variavel}' # ‘Prazer, Ruby on #{minha_variavel}’ 58 | 59 | ## Alguns métodos interessantes 60 | 61 | length ou size - Retorna o tamanho da string. 62 | 63 | str = “Prazer, Ruby” 64 | puts str.length 65 | puts str.size 66 | 67 | each_byte - utilizado para percorrer byte a byte. 68 | 69 | str = “Prazer, Ruby” 70 | str.each_byte { |c| puts c } 71 | 72 | split - retorna um array de acorda com o critério passado. 73 | 74 | str = “Prazer, Ruby” 75 | str.split #[“Prazer,”, “Ruby”] 76 | str.split(“,”) #[“Prazer”, “Ruby”] 77 | 78 | ljust, rjust, center - Formatar uma string 79 | 80 | str = “Prazer, Ruby” 81 | str.ljust(20) # "Prazer, Ruby " 82 | str.rjust(20) # " Prazer, Ruby" 83 | str.center(20) # " Prazer, Ruby " 84 | 85 | upcase - Deixar todas as letras maiúsculas 86 | downcase - Deixar todas as letras minúsculas 87 | capitalize - Deixar a primeira letra em maiúscula 88 | swapcase - Inverte as letras, ou seja, as maiúsculas ficam minúsculas e vice-versa 89 | 90 | str = “Prazer, Ruby” 91 | str.downcase 92 | str.upcase 93 | str.capitalize 94 | str.swapcase 95 | 96 | strip - utilizado para remover espaços no início e no final da string 97 | ltrip - utilizado para remover espaços no início da string 98 | rtrip - utilizado para remover espaços no final da string 99 | 100 | str = “ Prazer, Ruby ” 101 | str.strip # "Prazer, Ruby on Rails" 102 | str.ltrip # "Prazer, Ruby on Rails " 103 | str.rtrip # " Prazer, Ruby on Rails" 104 | 105 | squeeze - Remove caracteres duplicados (Apenas se os caracteres estiverem “juntos”) 106 | 107 | str = “Prazer, RRuby” 108 | str.squeeze # "Prazer, Ruby" 109 | 110 | ## Invertendo uma String 111 | 112 | Para inverter uma string, utilize o método reverse: 113 | 114 | str = “Prazer, Ruby” 115 | str.reverse # "ybuR ,rezarP" 116 | 117 | Se, ao invés de inverter as letras, você desejar inverter as palavras: 118 | 119 | str = "Prazer, Ruby" 120 | str.split(“ ”).reverse.join(“ ”) # "Ruby Prazer," 121 | 122 | O que acontece no exemplo acima é que o que está sendo invertido é a ordem dos elementos contidos no array :-) 123 | 124 | ## Convertendo String em Inteiro 125 | 126 | Existem duas formas de se converter uma string em um inteiro. Ou você utiliza os métodos da classe kernel (Interger e/ou Float) ou os métodos da classe String (to_i e/ou to_f). 127 | 128 | Mas, vale lembrar que, para que os métodos funcionem o valor da variável deve representar um valor numérico. Caso contrário, o valor retornado será 0(zero) ou erro: 129 | 130 | num = “um” 131 | num = Interger(num) # ArgumentError 132 | num = num.to_i # 0 133 | num = num.to_f # 0.0 134 | 135 | * Nota: Se o valor da variável começar com um número, mesmo o restante sendo string, os métodos to_i e to_f convertem os números iniciais: 136 | 137 | num = “123um” 138 | num = Interger(num) # ArgumentError 139 | num = num.to_i # 123 140 | num = num.to_f # 123 141 | 142 | ## Tamanho de String 143 | 144 | Para contar a quantidade de caracteres em uma string, utilize o método size : 145 | 146 | num = “Tamanho da String” 147 | puts num.size # 17 148 | 149 | Você pode, também, contar a ocorrência de determinada palavra ou expressão: 150 | 151 | num = “Tamanho da String” 152 | puts num.count(“a”) # 3 153 | -------------------------------------------------------------------------------- /trabalhando-com-array.mkdn: -------------------------------------------------------------------------------- 1 | # Trabalhando com Array 2 | 3 | Assim como em outras linguagens de programação, array no ruby é indexado por inteiros e começa com o número 0(zero). 4 | 5 | Assim como em PHP, por exemplo, array no ruby é dinâmico, ou seja, não é necessário informar qual o tamanho, apesar de ser permitido. Mesmo que o tamanho inicial seja informado na sua criação, ele pode aumentar, sem que seja feita quaisquer alteração no código da aplicação. 6 | 7 | Diferente de quando trabalhamos com coleções, em Java, é possível armazenar diversos tipos de objetos em um único array em ruby. Aliás, não se armazena o objeto propriamente dito, e sim um ponteiro, uma referência para acessá-lo. A menos que o objeto seja imediato, por exemplo, um objeto da classe Fixnum. 8 | 9 | ## Criando e inicializando um array 10 | 11 | Em ruby, existem diversas maneiras de se criar/inicializar um array. Vamos ver algumas dessas: 12 | a1 = ["a","b","c","d","e"] 13 | a2 = Array.[]("a","b","c","d","e") 14 | a3 = Array["a","b","c","d","e"] 15 | a4 = Array.new 16 | a5 = Array.new(5) 17 | a6 = Array.new(3,"OLA MUNDO") 18 | a7 = %w{a b c d e} 19 | 20 | 21 | Tudo parece legal e auto-explicativo, mas algumas pessoas estranham a última expressão. Mas, vai se acostumando pois está é uma das formas mais utilizadas :-) 22 | 23 | Temos 3 formas de se criar um array quando utilizamos o método new: 24 | 25 | * Sem parâmetro 26 | * Com 1 parâmetro (tamanho inicial do array a ser criado). 27 | * Com 2 parâmetros. O primeiro parâmetro refere-se ao tamanho inicial a ser criado e o segundo parâmetro ao valor inicial de cada posição. No caso do exemplo acima, a6 será igual a: ["Ola mundo", "Ola mundo", "Ola mundo"]. 28 | 29 | Se você foi esperto o suficiente, deve ter notado que eu falei que objetos não são armazenados diretamente em um array, o que existe são ponteiros para o mesmo objeto, com exeção de valores imediatos, como objetos da classe Fixnum. Então, o que você acha que acontece quando indicamos um valor inicial para cada posição no array, e, logo em seguida alteramos o valor deste objeto: Todos os objetos serão atualizados? 30 | 31 | Pense um pouco nisso.... 32 | 33 | Acertou se você falou que todas as posições serão trocadas. Como seja definido um valor default no momento da criação do array, ruby cria apenas um objeto e faz com que todas as posições referenciem o mesmo objeto. Veja o código abaixo, que ilustra isso: 34 | a6 = Array.new(3,"OLA MUNDO") #=> ["OLA MUNDO","OLA MUNDO","OLA MUNDO"] 35 | a6[0].downcase! # [" ola mundo"," ola mundo"," ola mundo"] 36 | 37 | 38 | Mas, então, qual o objetivo de se criar um array de N posições e iniciá-las com um valor default? Calma! Existe uma forma de contornar esse comportamente, digamos, estranho. Basta usar um bloco, e cada posição referenciará um objeto diferente. Quando utilizamos um bloco, estamos dizendo ao ruby para criar um objeto para cada posição: 39 | a6 = Array.new(3) { "OLA MUNDO" } #=> ["OLA MUNDO","OLA MUNDO","OLA MUNDO"] 40 | a6[0].downcase! #=> ["ola mundo","OLA MUNDO","OLA MUNDO"] 41 | 42 | 43 | Quando um array cresce e um novo elemento é adicionado, o valor default é nil: 44 | array = Array.new 45 | array[0] = "Alberto" 46 | array[5] = "Leal" #=> ["Alberto", nil,nil,nil,nil, "Leal"] 47 | 48 | 49 | ## Acessando e Atribuindo Elementos 50 | 51 | Para acessar algum elemento em um array, basta informar o índice ao método [ ] da classe Array: 52 | array = [1,2,3,4,5,6,7,8,9] 53 | primeiro_elemento = array[0] 54 | terceiro_elemento = array[2] 55 | 56 | 57 | Calma lá, [] é um método?! Sim. Tudo em ruby é um objeto. Caso você queira comprovar isso, basta executar o seguinte comando no irb: Array.methods e você encontrará o []. 58 | 59 | Existe, ainda, uma outra opção, basta informar o índice ao método at: 60 | array = [1,2,3,4,5,6,7,8,9] 61 | primeiro_elemento = array.at(0) 62 | terceiro_elemento = array.at(2) 63 | 64 | 65 | * Nota: Se você optar por utilizar o método "at", os parenteses são opcionais. Você pode chamar assim: array.at 2. 66 | 67 | Para ambos os métodos, [] e at, temos a opção de informar um inteiro negativo. Dessa forma, a contagem de posições para acessar o elemento será feita da direita para a esquerda. Por exemplo: 68 | array = [1,2,3,4,5,6,7,8,9] 69 | primeiro_elemento = array[-2] 70 | terceiro_elemento = array.at(-3) 71 | 72 | 73 | Se desejar recuperar apenas alguns índices do array, basta informar as posições desejadas como segundo parâmetro para o método [].Exemplo: 74 | array = [1,2,3,4,5,6,7,8,9] 75 | primeiro_elemento = array[0..2] 76 | 77 | 78 | O método slice é um atalho para o método [], portanto: 79 | 80 | primeiro_elemento = array[-2] 81 | 82 | é o mesmo que: 83 | 84 | primeiro_elemento = array.slice(-2) 85 | 86 | 87 | Mas, cuidado ao utilizá-lo desta maneira. Particularmente, eu não recomendo, pois o método slice tem como objetivo remover o elemento solicitado e retorná-lo. Mas, neste caso, como estamos utilizando o slice e não o método slice!, com (!)exclamação, o objeto original - array - não está sofrendo mudanças. Evite utilizar slice para recuperar um elemento de um array. 88 | 89 | Caso você queira recuperar várias posições, existe o método values_at: 90 | array = [1,2,3,4,5,6,7,8,9] 91 | result = array.values_at(0,2,4) #=> 1,3,5 92 | result2 = array.values_at(0..2,4) #=> 1,2,3,5 93 | 94 | 95 | ## Tamanho de um Array 96 | Dois métodos são bastante usados quando é desejável obter o tamanho de um array: 97 | 98 | * length - possui um alias size 99 | * nitems - desconsidera posições nulas (nil) 100 | array = [1,2,3,4,5,6,7,8,9, nil, 10] 101 | puts array.length #=> 11 102 | puts array.size #=> 11 103 | puts array.nitems #=> 10 104 | 105 | 106 | * Se quiser visualizar o conteúdo de um array, utilize o método inspect. 107 | 108 | ## Comparando arrays 109 | 110 | Para comparar arrays, utilizamos o método <=>. Esse método retorna -1 quando o objeto do lado esquerdo da operação é menor do que o lado direito, 0 quando os objetos são iguais e 1 quando o objeto do lado direito é menor do que o do lado esquerdo. 111 | 112 | Quando comparamos arrays, os elementos são comparados um a um, posição a posição. Assim que a primeira comparação falha, isto é, quando os objetos não são iguais, a comparação chega ao fim.Vejamos um exemplo: 113 | b1 = [1,2,3,4,5] 114 | b2 = [1,2,4,1,1] 115 | re = b1 <=> b2 # -1 116 | 117 | 118 | Quando é feita a comparação na posição 2, é constatado que b1 é menor do que b2, mesmo que todo o resto de b2 seja menor do que b1. 119 | 120 | Quando os elementos dos arrays são iguais, então a comparação retorna 0. Por outro lado, se os arrays possuem tamanhos diferentes, mas seus elementos são iguais até o momento da desigualdade de tamanho, o array que possuir um tamanho maior é considerado maior. 121 | c1 = [1,2,3,4,5] 122 | c2 = [1,2,3,4,5,6,7] 123 | re = c1 <=> c2 # -1 124 | 125 | 126 | Falei anteriormente que, é permitido armazenar diferente tipos de objetos dentro de um mesmo array. Então, o que aconteceria se tentarmos comparar arrays, onde elementos de diferentes tipos tivessem de ser comparados? 127 | 128 | Nesse caso, haverá um erro, ArgummentError! 129 | d1 = [1,2,3,4,5] 130 | d2 = [1,2,”nb”,4,5] 131 | if d1 > d2 132 | puts "não aconteceu o erro" 133 | end 134 | ArgumentError: comparison of Array with Array failed 135 | from (irb):60:in `>' 136 | from (irb):60 137 | 138 | 139 | Entretando, se for comparado arrays de diferentes tamanhos, e o "elemento estranho" estiver em uma posição superior, ou seja, que não será necessário fazer a comparação, não há nenhum problema 140 | d1 = [1,2,3,4,5] 141 | d2 = [1,2,3,4,5,"nb"] 142 | if d1 > d2 143 | print "não aconteceu o erro" 144 | end 145 | 146 | 147 | * Nota: Para fazer comparações utilizando os métodos >, <, >=, <= é necessário definí-los via duck typing na classe Array, ou fazer com que a classe inclua o módulo Comparable, o que seria melhor: 148 | 149 | class Array 150 | include Comparable 151 | end 152 | 153 | 154 | ## Ordenando um Array 155 | array = %w{e h b g k l k h s a} 156 | ordenado = array.sort 157 | 158 | 159 | O exemplo acima é completamente auto-explicativo. A classe Array possui um método sort, responsável por fazer a ordenação do array, sem maiores esforços. O mesmo vale para array de números: 160 | array = %w{1 6 2 5 74 52 44 23 12 9 } 161 | ordenado = array.sort 162 | # ["1", "12", "2", "23", "44", "5", "52", "6", "74", "9"] 163 | 164 | 165 | Uai, isso aí não está ordenado não!! Lembra quando eu falei sobre comparações de elementos em um array, e que ele compara o primeiro elemento e vê se é maior e coisa e tal?! Pois então, neste caso, a linguagem não está tratando o elemento por si só como um objeto como inteiro. Para atingir o resultado desejado - que é ordenar os números - faça com que os elementos sejam comparados como sendo um objeto da classe Fixnum, e não como se fosse um objeto da classe String (Quando utilizamso %w{} os elementos são tratados como String): 166 | array = %w{1 6 2 5 74 52 44 23 12 9 } 167 | array.sort {|x,y| x.to_i <=> y.to_i } 168 | # ["1", "2", "5", "6", "9", "12", "23", "44", "52", "74"] 169 | 170 | 171 | Existe a possibilidade de definir a forma como os elementos serão comparados. Para isso, basta passar um bloco para o método sort: 172 | numeros = %w{1 2 4 3 5 6} 173 | ordenados = numeros.sort {|a,b| b <=> a} #[6,5,4,3,2,1] 174 | 175 | 176 | ## Recuperando elementos a partir de um critério 177 | 178 | * detect == find - Recupera um elemento a partir do critério informado. 179 | * find_all == select - Recupera todos os elementos encontrados para o critério informado. 180 | * grep - Recupera todos os elementos encontrados para o pattern passado. 181 | * reject - Retira os elementos do array. 182 | numeros = [1, 2, 3, 4, 5, 6] 183 | numeros.detect { |elem| elem % 2 == 0 } # 2 184 | numeros.select { |elem| elem % 2 == 0 } # 2, 4, 6 185 | numeros.grep(2..4) # 2, 3, 4 186 | numeros.reject { |elem| elem % 2 == 0 } # 1, 3, 5 187 | 188 | 189 | ## Mapeando um Array 190 | 191 | * Ao utilizar os métodos map ou collect, os elementos são "retirados" do array, porém o objeto original(numeros) não sofre nenhuma mudança, ou seja, seu contéudo continua lá. Somente se você utilizar (!)exclamação é que o objeto original será modificado. Está já é a segunda vez que falamos que métodos que terminam com ! modificam o estado original do objeto. Isso é do ruby, portanto grave isso ;) 192 | numeros = %w[1, 2, 3, 4, 5, 6] 193 | numeros.map! { |elem| puts elem } 194 | puts numeros 195 | numeros = %w[1, 2, 3, 4, 5, 6] 196 | numeros.collect! { |elem| puts elem } 197 | puts numeros 198 | 199 | 200 | ## Removendo elementos de um array 201 | 202 | * Repare que, quando iniciamos o nosso array utilizando %w, todos os elementos inseridos são do tipo string. Com isso, quando utilizamos o método compact! não funciona da forma como esperamos, que seria remover todos os elementos nulos do array: 203 | numeros = %w[1, 2, nil, 3, 4, nil, nil, 5, 6] #nil será tratado como String. 204 | numeros.compact! 205 | puts numeros #["1,","2,", "nil,", "3,", "4,", "nil,", "nil,", "5,", "6"] 206 | numeros = [1, 2, nil, 3, 4, nil, nil, 5, 6] 207 | numeros.compact! 208 | puts numeros # [1, 2, 3, 4, 5, 6] 209 | 210 | 211 | Caso você saiba o índice do elemento a ser deletado, utilize o método delete_at: 212 | numeros = [1, 2, nil, 3, 4, nil, nil, 5, 6] 213 | numeros.delete_at(4) #parenteses não é obrigatório 214 | 215 | 216 | Mas, se você não sabe o índice e sabe o valor que deseja deletar do array, então utilize o método delete (esse método retorna nil quando não encontra a expressão informada): 217 | palavras = %w[revista rails ruby Java perl] 218 | palavras.delete("perl") 219 | 220 | 221 | * Nota: Se houver mais de uma entrada para a palavra a ser excluída, todas as ocorrências serão removidas. 222 | 223 | Se desejar fazer alguma validação antes de excluir algo do array, então utilize o método delete_if. Com ele, todos os elementos serão passados para bloco. Caso a condição contida dentro do bloco seja satisfeita, o elemento é deletado: 224 | palavras = %w[revista rails ruby Java perl] 225 | palavras.delete_if{|palavra| palavra.length ## 5} 226 | 227 | 228 | Quando se estiver trabalhando com pilhas e filas no ruby, pode ser necessário excluir o primeiro e/ou o último elemento do array. Para tais tarefas, existem os métodos shift e pop , respectivamente. 229 | numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 230 | numeros.pop 231 | numeros.shift 232 | 233 | 234 | Quer apagar todo o array? Utilize o método clear: 235 | numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 236 | numeros.clear 237 | 238 | 239 | ## Concatenando e Acionando valores a Arrays 240 | 241 | Para adicionar valores a um array, utilize o operador append "<<" 242 | 243 | Para adicionar um array ao outro, literalmente, ou seja, não apenas os valores, mas o array, utilize os métodos unshift e push para adicionar o array no início e no fim, respectivamente. 244 | array = %w[1 2 3 4 5] # => ["1", "2", "3", "4", "5"] 245 | array.unshift("a", "b") # => ["a", "b", "1", "2", "3", "4", "5"] 246 | array.push("c", "d") # => ["a", "b", "1", "2", "3", "4", "5", "c", "d"] 247 | 248 | 249 | Agora, para somar o conteúdo de dois ou mais arrays, utilize o método + ou += ou concat. Mas, tenha em mente que os métodos += e << criam uma nova instância da classe. 250 | o = [1,2,3,4] 251 | i = [3,4,5,6] 252 | puts o.object_id #74025330 253 | o += i 254 | puts o.object_id #74057480 255 | 256 | 257 | ## Iterando em um Array 258 | 259 | Muitas são as formas de se iterar um array. Vejamos algumas: 260 | numeros = [1,2,3,4] 261 | numeros.each { |num| puts num } 262 | numeros.collect { |num| puts num } 263 | 264 | 265 | Se desejar percorrer apenas pelo índice, utilize o método each_index 266 | 267 | ## Adicionando delimitadores 268 | 269 | Às vezes desejamos adicionar delimitadores entre os elementos contidos em um array para exibí-los para o usuário, por exemplo. Para tal tarefa, existe o método join. 270 | numeros = [1,2,3,4] 271 | numeros.join() #=> 1234 272 | numeros.join("-") #=> 1-2-3-4 273 | 274 | 275 | ## Removendo elementos duplicados 276 | 277 | Você pode usar o método uniq: 278 | numeros = [1,2,3,4,2,3,8,9,7] 279 | numeros.uniq # [1, 2, 3, 4, 8, 9, 7] 280 | 281 | --------------------------------------------------------------------------------