Ruby/Hash

Aus Scientia
Wechseln zu: Navigation, Suche

Ein Hash ist eine ungeordnete Sammlung von Schlüssel-Wert-Paaren, mit einem default Wert, der zurückgegeben wird, wenn man einen Schlüssel benutzt, der nicht im Hash existiert.

Allgemein

Die Hash Klasse ist der Array Klasse ziemlich ähnlich. Ein Array ordnet Objekten einen Index zu - man kann ihn sich also als eine nummerierte Liste vorstellen. Man kann dann gucken, unter welcher Nummer, bzw. unter welchem Index was steht. Die Hash Klasse arbeitet anders. Man kann sich anstatt der Liste eine Tabelle mit zwei Spalten vorstellen, wobei die linke Spalte die Überschrift "Schlüssel" oder im Englischen "key" trägt, und die rechte Spalte die Überschrift "Wert" oder, wieder aus dem Englischen, "value".
Man trägt in den Hash Paare a, b ein, wobei das erste Element a der Schlüssel ist (er wird links notiert) und das zweite Element b der Wert (der rechts notiert wird). Man nennt diesen Wert im Paar auch "Wert b unter dem Schlüssel a".

Hier findet man die für RGSS am Häufigsten verwendeten Methoden der Klasse kurz erklärt. Eine vollständige Dokumentation findest Du auf ruby-doc.org. Die Klasse Hash inkludiert das Rubymodul Enumerable, enthält also auch alle Methoden daraus.

Syntax

{ Schlüssel_Ausdruck => Wert_Ausdruck , ... }
{ Schlüssel_Ausdruck , Wert_Ausdruck , ... }
Erzeugt ein neues Hash Objekt, welches jedem Schlüssel ein Wert zuordnet.

Beispiele:

  quadratzahl = { 1 => 1, 2 => 2*2, 3 => 3*3, 4 => 16, 5=>25, 6=> 36, 7 =>49, 8 => 64, 9 => 81, 10 => (10 ** 2) }
  print quadratzahl[2]  #=> 4
  print quadratzahl[10] #=> 100
  print quadratzahl[16] #=> nil ( Im Hash ist kein Element dem Schlüssel 16 zugeordnet, der Schlüssel existiert nicht )
  quadratzahl[16] = 256
  print quadratzahl[16] #=> 256
 
 
  hauptstaedte = { "Deutschland" => "Berlin", "Frankreich" => "Paris", "Italien" => "Rom", "Groß Britanien"=>"London" }
  print hauptstaedte[ "Frankreich" ] #=> Paris
 
 
  beliebig = { :wiki => "Scientia",  42 => 24,  [32,64] => "Scientia",  "Scientia" => 42 }
  print( beliebig[:wiki] ) #=> Scientia
  print( beliebig[ beliebig[ :wiki ] ] ) #=> 42
  print( beliebig[ beliebig[ beliebig[ :wiki ] ] ] ) #=> 24
  beliebig[42] = 2000
  print( beliebig[ beliebig[ beliebig[ :wiki ] ] ] ) #=> 2000

In der Vorstellung, hätte man nun diese Listen:

hauptstaedte
key value
"Deutschland" "Berlin"
"Frankreich" "Paris"
"Italien" "Rom"
"Groß Britanien" "London"
beliebig
key value
:wiki "Scientia"
42 2000
[32,64] "Scientia"
"Scientia" 42

Hash im Vergleich zum Array

Es gibt Situationen, indenen man, obwohl ein Array nutzbar wäre, einen Hash vorzieht und als Schlüssel Ganzzahlen nimmt. Dies ist dann der Fall, wenn die Größe der Indizes in keinem Verhältnis zu ihrer Anzahl steht.
Ein Beispiel, um diese Aussage etwas anschaulicher zu machen: Um im RPG Maker zu speichern, wieviele Items, Waffen und Rüstungen die Heldengruppe im Detail besitzt, speichert man drei Hashs und benutzt als Schlüssel die Item-, Weapon- und Armor-IDs und als Wert die Anzahl des jeweiligen Gegenstandes im Besitz.
Nun kann man fragen, warum man nicht Arrays nimmt - schließlich benutzt man als Schlüssel Ganzzahlen und sie sind bei gleicher Elementanzahl kleiner im Speicher und hier haken wir uns ein! Wenn die Gruppe nur Schwert#14 dreimal besitzt, dann legt der Array 15 Zellen an (0-14) und speichert an Index 14 die Drei. Ein Hash speichert 1 Schlüssel-Wert-Paar { 14=>3 }. Dies macht die Aussage vom Anfang etwas anschaulicher. Wir haben einen relativ großen Index, aber nur wenig Daten. Der Array würde nun größeren, vorerst unnötigen Platz beanspruchen, wobei der Hash hier nur für das was er braucht Platz beansprucht.
Aber denkt nicht, Hashes sind immer die bessere Wahl. Wenn die Anzahl der Indizes in einem guten Verhältnis zu ihrer Größe steht, wir also zum Beispiel zwanzig Indizes zwischen 1 und 30 haben, beansprucht der Array Platz für 31 Referenzen. Der Hash speichert aber 20 Paare, wodurch wir, wenn wir abschätzen können, dass dieser Fall öffter auftritt den Array dem Hash vorziehen.

Methoden

new(default = nil)

Obwohl Hash meistens über die Hash Expression {...} erzeugt werden, kann man ein Objekt der Klasse Hash auch mit Hash.new erzeugen und danach den Hash füllen.
Der Vorteil ist, dass man direkt einen default Wert angeben kann, welcher in einigen Methoden verwendet wird und bei Verwendung der Hash Expression immer auf nil gesetzt wird.
Beispiel:

  my_hash = Hash.new(0)
  my_hash[1] = 15
  my_hash[2] = 4
  print( my_hash[1] ) #=> 15
  print( my_hash[3] ) #=> 0

self[key]

Gibt den Wert unter dem Schlüssel key zurück. Wenn es kein Schlüssel-Wert-Paar mit diesem Schlüssel gibt, wird der default Wert des Hash zurückgegeben (nil, wenn keiner spezifiziert wurde).

self[key]=value

Fügt das Schlüssel-Wert-Paar key,value in den Hash ein.

clear

Entfernt alle Paare aus dem Hash.
Gibt self zurück.

clone

Erzeugt eine Kopie des Hash, mit dem selben Inhalt. Wenn vorher die freeze Methode des Hashobjekt aufgerufen wurde, ist auch die Kopie eingefrohren, also gegen Veränderungen geschützt und wenn für das Objekt singleton Methoden definiert wurden, werden diese auch mitkopiert.

dup

Erzeugt eine Kopie des Hash, mit dem selben Inhalt. Andere Eigenschaften werden nicht mitkopiert (ausgenommen dem default Wert).

delete(key)

Entfernt den Schlüssel key und den Wert unter dem Schlüssel aus dem Hash.
Gibt den zum gelöschten Schlüssel gehörigen Wert zurück, oder nil, falls der Schlüssel nicht im Hash enthalten war.
Diese Methode kann auch in Verbindung mit einem Block aufgerufen werden:
delete(key) {|key| ... }
Wenn der Schlüssel im Hash nicht existiert, wird er dem Block übergeben und das Ergebnis zurückgegeben.

my_hash = { 'A' => 65, 'B' => 66 }
my_hash.delete('B'){|k| print("Im Hash gibt es kein " + k + "!") #=> 66
my_hash.delete('C'){|k| print("Im Hash gibt es kein " + k + "!") #=> Im Hash gibt es kein C!

each {|key, value| ... }

Siehe each_pair.

each_pair {|key, value| ... }

Führt einen Block mit key und value als Parameter für jedes Schlüssel-Wert-Paar im Hash aus.
Beispiel:

my_hash = { "Aluxes" => "ein Schwert",  "Basil" => "ein Ball",  "Hilda"=>"ein paar Buntstifte",  "Gloria"=>"eine Krone" }
my_hash.each_pair{ |hero, item|
  print(hero + "hat" + item + ". " )
}
#=> Aluxes hat ein Schwert. Basil hat ein Ball. Hilda hat ein paar Buntstifte. Gloria hat eine Krone.

Der Rückgabewert ist self, also der Hash selbst.

each_key {|key| ... }

Führt einen Block mit key als Parameter für jedes Schlüssel-Wert-Paar im Hash aus.
Beispiel:

  my_hash = { "Aluxes" => "ein Schwert",  "Basil" => "ein Ball",  "Hilda"=>"ein paar Buntstifte",  "Gloria"=>"eine Krone" }
  print("Im Raum sind: ")
  my_hash.each_key{ |hero|
    print(hero + "  " )
  }
  #=> Im Raum sind: Aluxes  Basil  Hilda  Gloria

Der Rückgabewert ist self, also der Hash selbst.

each_value {|value| ... }

Führt einen Block mit value als Parameter für jedes Schlüssel-Wert-Paar im Hash aus.
Beispiel:

  my_hash = { "Aluxes" => "ein Schwert",  "Basil" => "ein Ball",  "Hilda"=>"ein paar Buntstifte",  "Gloria"=>"eine Krone" }
  print("Unsere Freunde haben: ")
  my_hash.each_value{ |item|
    print(item + "  " )
  }
  #=> Unsere Freunde haben: ein Schwert  ein Ball  ein paar Buntstifte  eine Krone

Der Rückgabewert ist self, also der Hash selbst.

empty?

Gibt true zurück, wenn der Hash leer ist, also keine Paare enthält.

include?(key)

Siehe has_key?(key)

has_key?(key)

Gibt true zurück, wenn der Hash key als Schlüsselelement enthält. Der Vorstellung aus dem Abschnitt Allgemein folgend, also wenn in der linken Spalte irgendwo der angefragte key steht.

has_value?(value)

Gibt true zurück, wenn der Hash value als Wertelement enthält. Der Vorstellung aus dem Abschnitt Allgemein folgend, also wenn in der rechten Spalte irgendwo der angefragte value steht.
Hierfür wird der als Parameter übergebene Wert value mithilfe der Methode == mit allen Wertelementen verglichen.

index(val)

Gibt den Schlüssel zurück, der im Hash zum Wert val gehört. Der Vorstellung aus dem Abschnitt Allgemein folgend, wird in der rechten Tabellenspalte nach val gesucht und dann was in der selben Zeile in der linken Spalte steht zurückgegeben.
Gibt es im Hash kein Schlüssel-Wert-Paar, mit dem Wert val, wird nil zurückgegeben.
Wenn es mehrere Schlüssel-Wert-Paare mit val als Wert gibt, wird irgendeiner der passenden Schlüssel zurückgegeben.

keys

Gibt einen Array mit allen Schlüssel-Elementen des Hash zurück.
Der Vorstellung aus dem Abschnitt Allgemein folgend, also ein Array, der die gesammte linke Spalte der Tabelle enthält.

length

Gibt die Anzahl der Paare im Hash zurück.

size

Tut das Selbe wie length.

values

Gibt einen Array mit allen Wert-Elementen des Hash zurück.
Der Vorstellung aus dem Abschnitt Allgemein folgend, also ein Array, der die gesammte rechte Spalte der Tabelle enthält.

Verwandte Themen