Comment puis-je récupérer plusieurs valeurs de hachage à la fois?

Qu'est ce qu'une version plus courte de cette?:

from = hash.fetch(:from)
to = hash.fetch(:to)
name = hash.fetch(:name)
# etc

Note le fetch, je veux lever une erreur si la clé n'existe pas.

Il doit être plus courte version de celui-ci, comme:

from, to, name = hash.fetch(:from, :to, :name) # <-- imaginary won't work

C'est OK pour utilisons si nécessaire.

L'un d'important et de non sollicité question est. À quoi voulez-vous de les réaffecter les valeurs de hachage à vars?
Je ne peut pas analyser votre commentaire ci-dessus.
Pourquoi voulez-vous faire from = hash.fetch(:from); to = hash.fetch(:to);... au lieu d'utiliser hash[:from]?
C'est une question générale qui a trop différents cas d'utilisation de mentionner, tout comme il y a parfois une nécessité pour éviter l'échec silencieux en utilisant fetch au lieu de [], il y a parfois besoin de l'aide d'une extraction de la version de values_at.

InformationsquelleAutor Dmytrii Nagirniak | 2013-07-15

89

Utiliser Hachage du values_at méthode:
```
from, to, name = hash.values_at(:from, :to, :name)
```
Ce sera le retour de nil pour toutes les clés qui n'existent pas dans la table de hachage.
- Cela ne satisfait pas à l'exigence de l'OP.
- Lisez la question par vous-même.
- Il n'y a pas une telle méthode qui vous permettra d'extraire plusieurs touches et railse des exceptions pour ceux qui manquent. L'une des raisons est peut-être - lorsqu'une exception doit être soulevée, lorsque la clé est inexistante (il peut laisser des variables non assignées pour d'autres touches) ou après la récupération de toutes les clés? Il est facile de l'ajouter à vérifier par vous-même et je ne vois vraiment aucune raison pourquoi insister sur la collecte d'exception ici.
- insister sur la collecte d'exception ici" - parce que les clés DOIVENT être présents. "lorsqu'une exception doit être soulevée, lorsque la clé est inexistante (il peut laisser des variables non assignées pour d'autres touches)" - oui, que serait un congé non attribuées à la variable dans le cas d'une normale fetch trop.
- oui, mais pourquoi ne pas simplement utiliser raise MyException if hsh_values.include? nil
- parce que dans les cas où la clé n'existe pas, tout ce qui ne serait pas faire n'importe quoi.
InformationsquelleAutor Dylan Markow
23

Ruby 2.3 introduit finalement le fetch_values méthode pour les hachages carrément obtient ceci:
```
{a: 1, b: 2}.fetch_values(:a, :b)
# => [1, 2]
{a: 1, b: 2}.fetch_values(:a, :c)
# => KeyError: key not found: :c
```
InformationsquelleAutor matthew.tuck

hash = {from: :foo, to: :bar, name: :buz}

[:from, :to, :name].map{|sym| hash.fetch(sym)}
# => [:foo, :bar, :buz]
[:frog, :to, :name].map{|sym| hash.fetch(sym)}
# => KeyError

InformationsquelleAutor sawa

2
```
my_array = {from: 'Jamaica', to: 'St. Martin'}.values_at(:from, :to, :name)
my_array.keys.any? {|key| element.nil?} && raise || my_array
```
Cela va générer une erreur, comme vous l'avez demandé
```
 my_array = {from: 'Jamaica', to: 'St. Martin', name: 'George'}.values_at(:from, :to, :name)
 my_array.keys.any? {|key| element.nil?} && raise || my_array
```
Ce sera le retour de la matrice.

Mais OP demandé à défaut sur une clé manquante...
```
class MissingKeyError < StandardError
end
my_hash = {from: 'Jamaica', to: 'St. Martin', name: 'George'}
my_array = my_hash.values_at(:from, :to, :name)
my_hash.keys.to_a == [:from, :to, :name] or raise MissingKeyError
my_hash = {from: 'Jamaica', to: 'St. Martin'}
my_array = my_hash.values_at(:from, :to, :name)
my_hash.keys.to_a == [:from, :to, :name] or raise MissingKeyError
```
- ` my_array.tout? {|élément| élément.néant?} && soulever " serait incorrect parce qu'une clé peut exister avec un nil valeur.
- Vous êtes correct. J'ai vérifié la valeur plutôt que de la clé. Je vais modifier pour la clé.
- keys.to_a == [:from, :to, :name] est incorrect. La commande sera question ici, mais les clés de Hachage ont pas d'ordre particulier devrait être d'au moins keys.to_a - [:from, :to, :name] == []. Dans l'ensemble, c'est juste plus d'efforts que ça vaut la peine.
- Et si vous faites la soustraction et la clé n'existe simplement pas vous avez encore jusqu'à la fin avec un tableau vide, si ce n'est pas bon non plus. Donc correspondant à un tableau vide ne sera pas dire que la clé a été nécessairement là. Raté.
InformationsquelleAutor vgoff
1

Vous pourriez initialiser votre hash avec une valeur par défaut de KeyError objet. Ceci renvoie une instance de KeyError si la clé que vous essayez d'extraire n'est pas présent. Tout ce que vous devez faire est de vérifier son (de la valeur) de la classe et de l'élever si ses un KeyError.
```
hash = Hash.new(KeyError.new("key not found"))
```
Nous allons ajouter quelques données à ce hachage
```
hash[:a], hash[:b], hash[:c] = "Foo", "Bar", nil
```
Enfin regarder à l'valeurs et de déclencher une erreur si la clé ne trouve pas
```
hash.values_at(:a,:b,:c,:d).each {|v| raise v if v.class == KeyError}
```
Cela permettra de lever une exception si et seulement si la clé n'est pas présente. Il va pas se plaindre dans le cas où vous avez une clé avec nil valeur.
- Je n'ai pas de contrôle sur la façon dont la valeur de Hachage est créé. Donc je vais devoir recréer/copier tout simplement d'utiliser un "spécial" de la valeur comme un marqueur de non-clé.
InformationsquelleAutor saihgala

La chose la plus simple que je voudrais aller serait

from, to, name = [:from, :to, :name].map {|key| hash.fetch(key)}

Alternativement, si vous souhaitez utiliser values_at, vous pouvez utiliser un Hash avec une valeur par défaut de bloc:

hash=Hash.new {|h, k| raise KeyError.new("key not found: #{k.inspect}") }
# ... populate hash
from, to, name = hash.values_at(:from, :to, :name) # raises KeyError on missing key

Ou, si vous êtes si incliné, le singe-patch Hash

class ::Hash
  def fetch_all(*args)
    args.map {|key| fetch(key)}
  end
end
from, to, name = hash.fetch_all :from, :to, :name

Comment est-ce différent du mien?
évidemment, il affecte les résultats LOL 🙂

InformationsquelleAutor Alistair A. Israel

Vous devez vous connecter pour publier un commentaire.