Nuove funzionalità in Ruby 2.3 e 2.4
È utile rimanere al passo con le nuove funzionalità linguistiche che aiuteranno il tuo gioco di golf. Ce ne sono alcuni fantastici negli ultimi rubini.
Ruby 2.3
L'operatore di navigazione sicura: &.
Quando si chiama un metodo che potrebbe restituire nilma si desidera concatenare chiamate di metodo aggiuntive in caso contrario, si sprecano byte gestendo il nilcaso:
arr = ["zero", "one", "two"]
x = arr[5].size
# => NoMethodError: undefined method `size' for nil:NilClass
x = arr[5].size rescue 0
# => 0
L '"operatore di navigazione sicuro" interrompe la catena di chiamate di metodo se uno ritorna nile ritorna nilper l'intera espressione:
x = arr[5]&.size || 0
# => 0
Array#dig & Hash#dig
Accesso diretto agli elementi nidificati, con un bel nome breve:
o = { foo: [{ bar: ["baz", "qux"] }] }
o.dig(:foo, 0, :bar, 1) # => "qux"
Restituisce nilse raggiunge un vicolo cieco:
o.dig(:foo, 99, :bar, 1) # => nil
Enumerable#grep_v
L'inverso di — Enumerable#greprestituisce tutti gli elementi che non corrispondono all'argomento dato (confrontato con ===). Ad esempio grep, se viene fornito un blocco, viene restituito il risultato.
(1..10).grep_v 2..5 # => [1, 6, 7, 8, 9, 10]
(1..10).grep_v(2..5){|v|v*2} # => [2, 12, 14, 16, 18, 20]
Hash#to_proc
Restituisce un Proc che restituisce il valore per la chiave fornita, che può essere molto utile:
h = { N: 0, E: 1, S: 2, W: 3 }
%i[N N E S E S W].map(&h)
# => [0, 0, 1, 2, 1, 2, 3]
Ruby 2.4
Ruby 2.4 non è ancora uscito, ma lo sarà presto e ha alcune piccole funzionalità. (Quando verrà rilasciato aggiornerò questo post con alcuni collegamenti ai documenti.) Ho imparato la maggior parte di questi in questo fantastico post sul blog .
Enumerable#sum
Non più arr.reduce(:+). Ora puoi semplicemente farlo arr.sum. Prende un argomento facoltativo sul valore iniziale, il cui valore predefinito è 0 per gli elementi numerici ( [].sum == 0). Per altri tipi dovrai fornire un valore iniziale. Accetta anche un blocco che verrà applicato a ciascun elemento prima dell'aggiunta:
[[1, 10], [2, 20], [3, 30]].sum {|a,b| a + b }
# => 66
Integer#digits
Ciò restituisce una matrice di cifre di un numero nell'ordine di significatività minimo-massimo:
123.digits # => [3, 2, 1]
Rispetto, diciamo, 123.to_s.chars.map(&:to_i).reverseè abbastanza carino.
Come bonus, prende un argomento radix opzionale:
a = 0x7b.digits(16) # => [11, 7]
a.map{|d|"%x"%d} # => ["b", "7"]
Comparable#clamp
Fa quello che dice sulla scatola:
v = 15
v.clamp(10, 20) # => 15
v.clamp(0, 10) # => 10
v.clamp(20, 30) # => 20
Dal momento che è in Comparable puoi usarlo con qualsiasi classe che include Comparable, ad esempio:
?~.clamp(?A, ?Z) # => "Z"
String#unpack1
Un risparmio di 2 byte su .unpack(...)[0]:
"👻💩".unpack(?U) # => [128123]
"👻💩".unpack(?U)[0] # => 128123
"👻💩".unpack1(?U) # => 128123
Argomento di precisione per Numeric#ceil, flooretruncate
Math::E.ceil(1) # => 2.8
Math::E.floor(1) # => 2.7
(-Math::E).truncate(1) # => -2.7
Assegnazione multipla in condizionali
Ciò genera un errore nelle versioni precedenti di Ruby, ma è consentito in 2.4.
(a,b=1,2) ? "yes" : "no" # => "yes"
(a,b=nil) ? "yes" : "no" # => "no"