Nouvelles fonctionnalités de Ruby 2.3 et 2.4
Il est bon de rester au courant des nouvelles fonctionnalités linguistiques qui aideront votre jeu de golf. Il y a quelques grands dans les derniers rubis.
Ruby 2.3
L'opérateur de navigation sécurisé: &.
Lorsque vous appelez une méthode susceptible de renvoyer, nilmais que vous souhaitez enchaîner des appels de méthode supplémentaires, vous perdez des octets qui gèrent le nilcas:
arr = ["zero", "one", "two"]
x = arr[5].size
# => NoMethodError: undefined method `size' for nil:NilClass
x = arr[5].size rescue 0
# => 0
"L'opérateur de navigation sûr" arrête la chaîne d'appels de méthode si on retourne nilet retourne nilpour toute l'expression:
x = arr[5]&.size || 0
# => 0
Array#dig Et Hash#dig
Accès profond aux éléments imbriqués, avec un joli nom court:
o = { foo: [{ bar: ["baz", "qux"] }] }
o.dig(:foo, 0, :bar, 1) # => "qux"
Renvoie nils'il frappe dans une impasse:
o.dig(:foo, 99, :bar, 1) # => nil
Enumerable#grep_v
L'inverse de - Enumerable#greprenvoie tous les éléments qui ne correspondent pas à l'argument donné (par rapport à ===). Comme grepsi un bloc est donné, le résultat est retourné à la place.
(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
Retourne un Proc qui donne la valeur de la clé donnée, ce qui peut être très pratique:
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 n'est pas encore sorti, mais il le sera bientôt et a quelques fonctionnalités intéressantes. (Quand il sera publié, je mettrai à jour ce billet avec quelques liens vers la documentation.) J'ai découvert la plupart de ces informations dans ce blog .
Enumerable#sum
Pas plus arr.reduce(:+). Vous pouvez maintenant faire juste arr.sum. Il prend un argument optionnel de valeur initiale, dont la valeur par défaut est 0 pour Numeric elements ( [].sum == 0). Pour les autres types, vous devez fournir une valeur initiale. Il accepte également un bloc qui sera appliqué à chaque élément avant addition:
[[1, 10], [2, 20], [3, 30]].sum {|a,b| a + b }
# => 66
Integer#digits
Ceci retourne un tableau de chiffres d'un nombre dans l'ordre d'importance le moins élevé:
123.digits # => [3, 2, 1]
Par rapport à, disons, 123.to_s.chars.map(&:to_i).reversec'est plutôt sympa.
En prime, il faut un argument optionnel radix:
a = 0x7b.digits(16) # => [11, 7]
a.map{|d|"%x"%d} # => ["b", "7"]
Comparable#clamp
Fait ce qu'il dit sur la boîte:
v = 15
v.clamp(10, 20) # => 15
v.clamp(0, 10) # => 10
v.clamp(20, 30) # => 20
Comme il est dans Comparable, vous pouvez l’utiliser avec n’importe quelle classe incluant Comparable, par exemple:
?~.clamp(?A, ?Z) # => "Z"
String#unpack1
Une économie de 2 octets sur .unpack(...)[0]:
"👻💩".unpack(?U) # => [128123]
"👻💩".unpack(?U)[0] # => 128123
"👻💩".unpack1(?U) # => 128123
Argument de précision pour Numeric#ceil, floorettruncate
Math::E.ceil(1) # => 2.8
Math::E.floor(1) # => 2.7
(-Math::E).truncate(1) # => -2.7
Affectation multiple dans les conditions
Cela soulève une erreur dans les versions précédentes de Ruby, mais est autorisé dans la version 2.4.
(a,b=1,2) ? "yes" : "no" # => "yes"
(a,b=nil) ? "yes" : "no" # => "no"