Comment puis-je convertir des clés de hachage pour les noms de méthode?

C'est mon hash:

tempData = {"a" => 100, "here" => 200, "c" => "hello"}

J'ai besoin d'accéder aux clés de hachage comme une méthode comme:

tempData.a #100
tempData.here # 200

Quel est le problème avec la normale de l'accesseur?
nous pouvons accéder à la façon traditionnelle, je suis juste curieux de savoir à ce sujet 🙂

InformationsquelleAutor Sreeraj | 2011-06-21

ruby

87

Vous pourriez juste envelopper de votre hachage dans un OpenStruct:
```
require 'ostruct'
tempData = {"a" => 100, "here" => 200, "c" => "hello"}
os = OpenStruct.new tempData
os.a #=> 100
os.here #=> 200
```
Si vous avez vraiment vraiment voulu, vous pouvez également singe-patch le Hash classe, mais je vous le déconseille qu':
```
class Hash
  def method_missing(m, *args, &blk)
    fetch(m) { fetch(m.to_s) { super } }
  end
end

tempData = {"a" => 100, "here" => 200, "c" => "hello"}
tempData.a #=> 100
```
Mise à jour: Dans mon personnels de la bibliothèque d'extensions j'ai ajouté un Dièse#to_ostruct méthode. Ce sera de manière récursive convertir un hachage dans un OpenStruct y compris tous imbriqués les tables de hachage.
- Un excellent travail.....
- Je voudrais ajouter que la deuxième solution est bien si vous définir une nouvelle classe, plutôt que de remplacer le noyau de Hachage de la classe.
- c'est fondamentalement ce qui OpenStruct est en train de faire
- Un post intéressant, qui fait la même chose, mais a besoin d'écrire une petite classe..
- Merci pour le lien. Si vous lisez les commentaires, vous verrez que les postes", l'auteur dit que OpenStruct gère l'ensemble de sa mise en œuvre initiale, mais pas imbriquée hachages que la version qu'il a posté dans les commentaires.
- r le droit..j'ai utilisé sa version de imbriquée de hachage, dans un projet où il y avait un sérialisé colonne (qui convertit un ensemble de hachage en Ruby)et le besoin pour mon Rails de éléments de formulaire ayant (objet, méthode) de la syntaxe..
InformationsquelleAutor Michael Kohl
10

Il y a une autre façon de le faire.

JSON.parse(tempData.to_json, object_class: OpenStruct)

qui donnera objet
#<OpenStruct a=100, here=200, c="hello">

De cette façon imbriquée hash aussi seront convertis en OpenStruct Object
```
tempData = {a: { b: { c: 3}}, foo: 200, msg: 'test msg'}
obj = JSON.parse(tempData.to_json, object_class: OpenStruct)
```
Maintenant nous sommes en mesure d'appeler
```
obj.a.b.c # 3
obj.foo # 200
obj.msg # 'test msg'
```
Espère que cela aidera quelqu'un.

InformationsquelleAutor Engr. Hasanuzzaman Sumon
6

Sinon, si c'est juste un petit script, il peut être plus commode de simplement étendre Hash lui-même
```
class Hash
  def method_missing sym,*
    fetch(sym){fetch(sym.to_s){super}}
  end
end
```
method_missing est une méthode magique qui est appelée à chaque fois que votre code tente d'appeler une méthode qui n'existe pas. Ruby va intercepter l'échec d'appel au moment de l'exécution et de vous permettre de gérer votre programme peut récupérer gracieusement. La mise en œuvre ci-dessus tente d'accéder à la valeur de hachage en utilisant le nom de la méthode comme un symbole, l'un avec le nom de méthode comme une chaîne de caractères, et finalement échoue avec Ruby intégré dans la méthode d'erreur manquant.
NB pour un script plus complexe, où l'ajout de ce comportement pourrait le briser d'autres tiers gemmes, vous pouvez également utiliser un module
et de l'étendre de chaque instance
```
module H
  def method_missing sym,*
    fetch(sym){fetch(sym.to_s){super}}
  end
end

the = { answer: 42 }
the.extend(H)
the.answer # => 42
```
et pour plus de commodité, vous pouvez même se propager le module vers le bas pour
imbriqués les hachages
```
module H
  def method_missing sym,*
    r = fetch(sym){fetch(sym.to_s){super}}
    Hash === r ? r.extend(H) : r
  end
end 

the = { answer: { is: 42 } }
the.extend(H)
the.answer.is # => 42
```
InformationsquelleAutor akuhn
2

Si le hachage est à l'intérieur d'un module, vous pouvez définir des méthodes sur ce module (ou classe) de manière dynamique à l'aide de define_method. Par exemple:
```
module Version
  module_function

  HASH = { 
    major: 1,
    minor: 2,
    patch: 3,
  }

  HASH.each do |name, value|
    define_method(name) do
      return value
    end
  end
end
```
Cela permettra de définir un Version module avec major, minor, et patch méthodes qui retournent des 1, 2, et 3, respectivement.

InformationsquelleAutor sferik

vous pouvez étendre la classe Hash de la manière suivante.

class Hash
      # return nil whenever the key doesn't exist
      def method_missing(m, *opts)
        if self.has_key?(m.to_s)
          return self[m.to_s]
        elsif self.has_key?(m.to_sym)
          return self[m.to_sym]
        end
        return nil

        # comment out above line and replace with line below if you want to return an error
        # super
      end
end

InformationsquelleAutor lsu_guy

Vous devez vous connecter pour publier un commentaire.