Eba! Saiu o Ruby 1.8.3! Algumas coisas novas apareceram:

A opção -W: -W0 para não mostrar os warnings, -W1 para nível normal e -W2 para nível detalhado. -w é igual a -W2.

warning.rb
----------
MyConst = "teste"
MyConst = "teste de novo"

ruby warning.rb
[taq@~/code/ruby]ruby warning.rb
warning.rb:2: warning: already initialized constant MyConst
[taq@~/code/ruby]ruby -W0 warning.rb

Notação %W, similar a %w, mas permite interpolação:

[taq@~/code/ruby]irb
irb(main):001:0> v = "1.8.3"
=> "1.8.3"
irb(main):002:0> %w(new notation #{v})
=> ["new", "notation", "\#{v}"]
irb(main):003:0> %W(new notation #{v})
=> ["new", "notation", "1.8.3"]
irb(main):004:0> 

Símbolos seguem o mesmo esquema:

[taq@~/code/ruby]irb
irb(main):001:0> v = "1.8.3"
=> "1.8.3"
irb(main):002:0> s1 = :"symbol"
=> :symbol
irb(main):003:0> s2 = :"symbol_#{v}"
=> :"symbol_1.8.3"
irb(main):004:0> s1
=> :symbol
irb(main):005:0> s1.class
=> Symbol
irb(main):006:0> s2      
=> :"symbol_1.8.3"
irb(main):007:0> s2.class
=> Symbol
irb(main):008:0> 

Arrays podem receber blocos para preencher seus valores, quando especificado o seu tamanho (ou no método fill):

[taq@~/code/ruby]irb
irb(main):001:0> Array.new(10) {|n| n+1}
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
irb(main):002:0> 

O método to_i de String agora aceita a base para conversão, e quando for zero, pega a base especificada:

[taq@~/code/ruby]irb
irb(main):001:0> "101".to_i(10)
=> 101
irb(main):002:0> "101".to_i(2)
=> 5
irb(main):003:0> "101".to_i(8)
=> 65
irb(main):004:0> "101".to_i(16)
=> 257
irb(main):005:0> "101".to_i(0)
=> 101
irb(main):006:0> "0b101".to_i(0)
=> 5
irb(main):007:0> "0101".to_i(0)
=> 65
irb(main):008:0> "0x101".to_i(0)
=> 257

Adicionado Array.transpose:

[taq@~/code/ruby]irb
irb(main):001:0> a = [[1,2],[3,4],[5,6]]
=> [[1, 2], [3, 4], [5, 6]]
irb(main):002:0> a.transpose
=> [[1, 3, 5], [2, 4, 6]]

Adicionado Array.fetch, que retorna o elemento do array, se não encontrado, retorna o segundo parâmetro ou o retorno da execução do bloco:

[taq@~/code/ruby]irb
irb(main):001:0> a = [11,22,33,44]
=> [11, 22, 33, 44]
irb(main):002:0> a.fetch(1)
=> 22
irb(main):003:0> a.fetch(4)
IndexError: index 4 out of array
        from (irb):3:in `fetch'
        from (irb):3
        from :0
irb(main):004:0> a.fetch(4,"inexistente")
=> "inexistente"
irb(main):005:0> a.fetch(4) {|v| "inexistente: indice #{v}"}
=> "inexistente: indice 4"

Adicionado Array.insert, que insere o(s) elemento(s) antes do índice especificado:

[taq@~/code/ruby]irb
irb(main):001:0> a = %w(um dois cinco)
=> ["um", "dois", "cinco"]
irb(main):002:0> a.insert(2,"tres","quatro")
=> ["um", "dois", "tres", "quatro", "cinco"]

Adicionado String.insert, que insere outra String índice especificado. Aqui tem um fato curioso que é um método destrutivo mas sem o sinal de ! na frente (ou seja, insert!). A discussão sobre isso pode ser vista aqui.

Um pouco do texto: "I think I'm following matz ideas when I named it to be 'insert' instead of 'insert!'. And the reasoning is that currently the methods are not named with exclamation mark (!) if
1) the name clearly indicates the receiving object is going to change and/or
2) there's no corresponding method with implicit dup."

Parece que o Matz concordou com isso, então aí está o método destrutivo sem o !:

[taq@~/code/ruby]irb
irb(main):001:0> s = "Ruby 1.8.3"
=> "Ruby 1.8.3"
irb(main):002:0> s.insert(5,"versao ")
=> "Ruby versao 1.8.3"
irb(main):003:0> s
=> "Ruby versao 1.8.3"

Adicionados String.lstrip e String.rstrip que removem espaços à esquerda e à direita, correspondentemente:

[taq@~/code/ruby]irb
irb(main):001:0> s1 = "    hello " 
=> "    hello "
irb(main):002:0> s2 = "world!    "
=> "world!    "
irb(main):003:0> puts "#{s1.lstrip}#{s2.rstrip}"
hello world!

Adicionados String.match(pattern), que converte pattern em uma Regexp (se já não for uma) e invoca o método match:

[taq@~/code/ruby]irb
irb(main):001:0> "abc123".match("[0-9]{1,3}")
=> #
irb(main):002:0> "abc123".match("[0-9]{1,3}")[0]
=> "123"

Adicionado Symbol.all_symbols. Se o ObjectSpace não lista os símbolos, agora temos um jeito de dar uma olhada neles. :-)

[taq@~/code/ruby]irb
irb(main):001:0> s = :zabumba
=> :zabumba
irb(main):002:0> Symbol.all_symbols.select {|s| s.to_s[0].chr=='z'}
=> [:zone, :"zero?", :zip, :zabumba]

Adicionado Range.step:

[taq@~/code/ruby]irb
irb(main):001:0> r = (0..10)
=> 0..10
irb(main):002:0> r.step(2) {|v| puts v}
0
2
4
6
8
10

E MUITAS outras mudanças! Verifiquem o arquivo <source>/doc/NEWS

Comentários

Comentários fechados.

Sem nenhum comentário.