Hash auf bedingte Weise erstellen

Ich bin mit Ruby, Ruby on Rails 3.0.10 und ich bauen möchte einen hash-key\ - Wert-Paare in einer bedingten Weise. Das heißt, ich hinzufügen möchte, einen Schlüssel und seinen zugehörigen Wert, wenn eine Bedingung gefunden:

hash = {
  :key1 => value1,
  :key2 => value2, # This key2\value2 pair should be added only 'if condition' is 'true'
  :key3 => value3,
  ...
}

Wie kann ich das tun und halten ein "gute" Lesbarkeit für den code? Bin ich "gezwungen" zu verwenden, die merge Methode?

Kommentar zu dem Problem

Wo sind die Schlüssel und Werte kommen? Einen anderen hash? Kommentarautor: Ray Toal

@Ray-Toal - Keine aus einem anderen hash. Ich bin Aufbau einer hash von Grund auf. Kommentarautor: Backo

Tut mir Leid, ich verstehe nicht. Die Daten kommen von irgendwo: ein string, eine andere hash, ein array, oder woanders. Auch wenn Sie "erstellen des hash from scratch" Sie haben die Daten. Schreiben bedingte Einfügungen in einer hash-literal nicht in Ruby; Sie können das löschen nach der Tat mit Chris Jester-Junge - Technik. Kommentarautor: Ray Toal

gibt es nur eine Bedingung, die steuert, alle bedingten Werte? Kommentarautor: Martin DeMello

@backo du meinst, es gibt genau eine bedingte Wert in der gesamten hash? wenn also würde ich nur sagen, legen Sie es am Ende Kommentarautor: Martin DeMello

InformationsquelleAutor der Frage Backo | 2011-09-07

50

Ich lieber tap, wie ich denke, es bietet eine sauberere Lösung als die hier beschriebenen, die von nicht dass irgendwelche hacky löschen von Elementen und durch eine klare Definition des Umfangs, in dem der hash erstellt wird.

Es bedeutet auch, Sie brauchen nicht zu erklären, eine unnötige lokale Variablen, die ich immer hasse.

Falls Sie noch nicht über ihn kommen, bevor tap ist sehr einfach - es ist eine Methode, die auf Object nimmt einen block und immer gibt das Objekt zurück, hieß es weiter. So ist der Aufbau einer hash-bedingt, Sie könnten dies tun:
```
Hash.new.tap do |my_hash|
  my_hash[:x] = 1 if condition_1
  my_hash[:y] = 2 if condition_2
  ...
end
```
Gibt es viele interessante Anwendungen für tap dies ist nur ein.

InformationsquelleAutor der Antwort Russell
20

Einen funktionalen Ansatz:
```
hash = {
  :key1 => 1,
  :key2 => (2 if condition),
  :key3 => 3,
}.reject { |k, v| v.nil? }
```
[Bearbeiten] Ruby-2.4.0 eingeführt Hash#compact, sodass wir jetzt schreiben können hash = { ... }.compact.

InformationsquelleAutor der Antwort tokland
6

Wahrscheinlich am besten, es einfach zu halten, wenn Sie sich Gedanken über die Lesbarkeit:
```
hsh = {}
hsh[:key1] = value1
hsh[:key2] = value2 if condition?
hsh[:key3] = value3
...
```
InformationsquelleAutor der Antwort dwhalen
2

Zuerst bauen Sie Ihre hash folgendermassen:
```
hash = {
  :key1 => value1,
  :key2 => condition ? value2 : :delete_me,
  :key3 => value3
}
```
Dann tun Sie dies nach dem Bau Ihrer hash:
```
hash.delete_if {|_, v| v == :delete_me}
```
Sei denn, Ihr hash ist gefroren oder auf andere Weise unveränderlich, dies würde effektiv nur beibehalten von Werten, die vorhanden sind.

InformationsquelleAutor der Antwort Chris Jester-Young
2

Halten Sie es einfach:
```
hash = {
  :key1 => value1,
  :key3 => value3,
  ...
}
hash[:key2]=value2 if condition
```
Diese Weise haben Sie auch optisch getrennt Ihren speziellen Fall, die möglicherweise unbemerkt, wenn es begraben ist in hash-literalen Zuordnung.

InformationsquelleAutor der Antwort Mladen Jablanović

Benutze ich merge und der ternäre operator für diese situation,

hash = {
  :key1 => value1,
  :key3 => value3,
  ...
}.merge(condition ? {:key2 => value2} : {})

InformationsquelleAutor der Antwort Dave Morse

1

WENN Sie bauen hash aus einer Art von Aufzählbaren Daten, die Sie verwenden können, zu injizieren, zum Beispiel:
```
raw_data.inject({}){ |a,e| a[e.name] = e.value if expr; a }
```
InformationsquelleAutor der Antwort Dmitry Maksimov

Einfach:

hash = {
  :key1 => value1,
  **(condition ? {key2: value2} : {})
}

Hoffe, es hilft!

InformationsquelleAutor der Antwort Dusht

Mithilfe von fetch kann nützlich sein, wenn Sie zuerst ein hash von optionalen Parametern woanders. Schauen Sie auf dieses Beispiel:

def create_watchable_data(attrs = {})
  return WatchableData.new({
    id:             attrs.fetch(:id, '/catalog/titles/breaking_bad_2_737'),
    titles:         attrs.fetch(:titles, ['737']),
    url:            attrs.fetch(:url, 'http://www.netflix.com/shows/breaking_bad/3423432'),
    year:           attrs.fetch(:year, '1993'),
    watchable_type: attrs.fetch(:watchable_type, 'Show'),
    season_title:   attrs.fetch(:season_title, 'Season 2'),
    show_title:     attrs.fetch(:id, 'Breaking Bad')
  })
end

InformationsquelleAutor der Antwort Excalibur

-1

Gleiche Idee wie Chris Jester-Junge, mit einer leichten Lesbarkeit trick
```
def cond(x)
  condition ? x : :delete_me
end

hash = {
  :key1 => value1,
  :key2 => cond(value2),
  :key3 => value3
}
```
und dann nachbearbeiten, entfernen Sie die :delete_me Einträge

InformationsquelleAutor der Antwort Martin DeMello

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.