Programmierung in Ruby

Der Leitfaden der Pragmatischen Programmierer
class Hash
Parent: Object
Version: 1.6

Index:

[ ] new == [ ] [ ]= clear default default= delete delete_if each each_key each_pair each_Wert empty? fetch has_key? has_value? include? index indexes indices invert key? keys length member? rehash reject reject! replace shift size sort store to_a to_s update value? values

Ein Hash ist eine Sammlung von Schlüssel-Wert-Paaren. Es ist ähnlich einem Array mit der Ausnahme, dass die Indizierung mit beliebigen Schlüsseln jedes Objekttyps, nicht nur Ganzzahlen, erfolgt. Die Reihenfolge, in der ein Hash nach Schlüssel oder nach Wert durchlaufen wird ist beliebig und wird in der Regel nicht die Einfüge-Reihenfolge.

Hashes haben einen Standardwert, der zurückgegeben wird, wenn auf Schlüssel zugegriffen wird, die nicht im Hash existieren. Dieser Wert ist standardmässig nil.
mixins
Enumerable: collect, detect, each_with_index, entries, find, find_all, grep, include?, map, max, member?, min, reject, select, sort, to_a

class methods
[ ] Hash[ [key => Wert]* ] -> einHash

Erstellt ein neues Hash, das mit den übergebenen Objekten gefüllt ist. Equivalent zum Literal { key, Wert, ... }. Schlüssel und Werte treten in Paaren auf, so dass eine gerade Anzahl von Argumenten eingegeben werden muss.

Hash["a", 100, "b", 200] » {"a"=>100, "b"=>200}
Hash["a" => 100, "b" => 200] » {"a"=>100, "b"=>200}
{ "a" => 100, "b" => 200 } » {"a"=>100, "b"=>200}

new Hash.new( einObjekt=nil ) -> einHash

Gibt ein neues, leeres Hash zurück. Wenn einObjekt spezifiziert ist, wird dieses als default Wert verwendet.

h = Hash.new("Go Fish")
h["a"] = 100
h["b"] = 200
h["a"] » 100
h["c"] » "Go Fish"

instance methods
== hsh == einAnderesHash-> true oder false

Gleichheitsoperator---Zwei Hashs sind gleich, wenn jedes dieselbe Anzahl von Elementen enthält und jedes Schlüssel-Wert-Paar im Sinne von Object#== einem korrespondierenden Paar im anderen Hash gleicht.

h1 = { "a" => 1, "c" => 2 }
h2 = { "a" => 1, "c" => 2, 7 => 35 }
h3 = { "a" => 1, "c" => 2, 7 => 35 }
h4 = { "a" => 1, "d" => 2, "f" => 35 }
h1 == h2 » false
h2 == h3 » true
h3 == h4 » false

[ ] hsh[ einSchluessel ] -> einWert

Elementreferenz---Gibt das Objekt einWert zurück, das unter dem Objekt einSchluessel im Hash gespeichert ist. Der default Wert wird zurückgegeben, wenn kein anderes Objekt gefunden wird.

h = { "a" => 100, "b" => 200 }
h["a"] » 100
h["c"] » nil

[ ]= hsh[ einSchluessel ] = einWert-> einWert

Elementzuweisungsoperator---Weist das Objekt einWert demjenigen Hash-Feld mit dem Schlüsselwert einSchluessel zu. einSchluessel sollte seinen Wert nicht verändern, während es als Schlüssel benutzt wird (ein als Schlüsselwert übergebener String wird dupliziert und eingefroren).

h = { "a" => 100, "b" => 200 }
h["a"] = 9
h["c"] = 4
h » {"a"=>9, "b"=>200, "c"=>4}

clear hsh.clear -> hsh

Entfernt alle Schlüssel-Wert-Paare aus hsh.

h = { "a" => 100, "b" => 200 } » {"a"=>100, "b"=>200}
h.clear » {}

default hsh.default -> einObjekt

Gibt den "default Wert" zurück---d.h. denjenigen Wert, der für einen nichtexistenten Schlüssel im Hash zurückgegeben wird. Der Standardwert ist nil. Siehe auch Hash#default=.

default= hsh.default = einObjekt-> hsh

Setzt den "default Wert"---d.h. denjenigen Wert, der für einen nichtexistenten Schlüssel im Hash zurückgegeben wird. Der Standardwert ist nil.

h = { "a" => 100, "b" => 200 }
h.default = "Go fish"
h["a"] » 100
h["z"] » "Go fish"

delete hsh.delete( einSchluessel ) -> einWert
hsh.delete( einSchluessel ) {| einSchluessel | block }

-> einWert

Entfernt ein Schlüssel-Wert-Paar aus hsh, dessen Schlüssel gleich einSchluessel ist, und gibt dieses zurück. Wenn der Schlüssel nicht gefunden wird, gibt die Methode den default Wert zurück. Falls der optionale Code-Block definiert ist und der Schlüssel nicht auffindbar ist, wird einSchluessel dort verarbeite und das Ergebnis zurückgegeben.

h = { "a" => 100, "b" => 200 }
h.delete("a") » 100
h.delete("z") » nil
h.delete("z") { |el| "#{el} not found" } » "z not found"

delete_if hsh.delete_if {| key, Wert | block }

-> hsh

Löscht jedes Schlüssel-Wert-Paar aus hsh für das der Code-Block in block das Ergebnis true liefert.

h = { "a" => 100, "b" => 200, "c" => 300 }
h.delete_if {|key, Wert| key >= "b" } » {"a"=>100}

each hsh.each {| key, Wert | block }-> hsh

Ruft den Code-Block block für jeden Schlüssel in hsh unter Übergabe von Schlüssel und Wert als Parameter einmal auf. 

h = { "a" => 100, "b" => 200 }
h.each {|key, Wert| print key, " is ", Wert, "\n" }
ergibt:
a is 100
b is 200

each_key hsh.each_key {| key | block }-> hsh

Ruft den Code-Block block für jeden Schlüssel in hsh, unter Übergabe des Schlüssels als Parameter einmal auf. 

h = { "a" => 100, "b" => 200 }
h.each_key {|key| puts key }
produces:
a
b

each_pair hsh.each_pair {| key, Wert | block }-> hsh

Synonym für Hash#each.

each_Wert hsh.each_Wert {| Wert | block }-> hsh

Ruft den Code-Block block für jeden Schlüssel in hsh unter Übergabe des Wertes als Parameter einmal auf. 

h = { "a" => 100, "b" => 200 }
h.each_Wert {|Wert| puts Wert }
produces:
100
200

empty? hsh.empty? -> true oder false

Gibt true zurück, wenn hsh kein Schlüssel-Wert-Paar enthält.

{}.empty? » true

fetch hsh.fetch( einSchluessel[, einDefObjekt] ) -> einObjekt
hsh.fetch( einSchluessel ) {| einSchluessel | block }

-> einObjekt

Gibt den zum angegebenen Schlüssel gehörigen Wert aus dem Hash zurück. Falls der Schlüssel nicht auffindbar ist, bestehen mehrere Optionen: Wenn kein weiteres Argument übergeben wurde, wird eine IndexError Exception geworfen; wenn einDefObjekt angegeben wurde, wird dieses zurückgegeben; wenn der optionale Code-Block übergeben wurde, wird dieser ausgeführt und dessen Ergebnis zurückgegeben.

h = { "a" => 100, "b" => 200 }
h.fetch("a") » 100
h.fetch("z", "go fish") » "go fish"
h.fetch("z") { |el| "go fish, #{el}"} » "go fish, z"

Das folgende Beispiel zeigt, dass eine Exception geworfen wird, wenn weder der Schlüssel gefunden wird, noch ein Defaultwert angegeben wurde. 

h = { "a" => 100, "b" => 200 }
h.fetch("z")
ergibt:
prog.rb:2:in `fetch': key not found (IndexError)
	from prog.rb:2

has_key? hsh.has_key?( einSchluessel ) -> true oder false

Gibt true zurück, wenn der angegebene Schlüssel in hsh auftritt.

h = { "a" => 100, "b" => 200 }
h.has_key?("a") » true
h.has_key?("z") » false

has_value? hsh.has_value?( einWert ) -> true oder false

Gibt true zurück, wenn der gesuchte Wert zu einem Schlüssel in hsh gehört.

h = { "a" => 100, "b" => 200 }
h.has_value?(100) » true
h.has_value?(999) » false

include? hsh.include?( einSchluessel ) -> true oder false

Synonym für Hash#has_key?.

index hsh.index( einWert ) -> einSchluessel

Gibt den Schlüssel für einen gegebenen Wert. Der Defaultwert wird zurückgegeben, wenn kein Schlüssel gefunden wurde.

h = { "a" => 100, "b" => 200 }
h.index(200) » "b"
h.index(999) » nil

indexes hsh.indexes( [key]+ ) -> einArray

Gibt ein neues Array aus den Werten der/des gegebenen Schlüssel/s. Diese Methode inseriert für nichtexistente Schlüssel den default Wert.

h = { "a" => 100, "b" => 200, "c" => 300 }
h.indexes("a", "c") » [100, 300]
h.indexes("a", "c", "z") » [100, 300, nil]

indices hsh.indices( [key]+ ) -> einArray

Synonym für Hash#indexes.

invert hsh.invert -> einHash

Gibt ein neues Hash zurück, in dem hshs Werte und Schlüssel vertauscht wurden.

h = { "n" => 100, "m" => 100, "y" => 300, "d" => 200, "a" => 0 }
h.invert » {200=>"d", 300=>"y", 0=>"a", 100=>"n"}

key? hsh.key?( einSchluessel ) -> true oder false

Synonym für Hash#has_key?.

keys hsh.keys -> einArray

Gibt ein neues Array zurück, das mit den Schlüsseln dieses Hashs gefüllt ist. Siehe auch Hash#Werts.

h = { "a" => 100, "b" => 200, "c" => 300, "d" => 400 }
h.keys » ["a", "b", "c", "d"]

length hsh.length -> eineNummer

Gibt die Nummer der Schlüssel-Wert-Paare im Hash zurück.

h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
h.length » 4
h.delete("a") » 200
h.length » 3

member? hsh.member?( einSchluessel ) -> true oder false

Synonym für Hash#has_key?.

rehash hsh.rehash -> hsh

Rekonstruiert den Hash auf der Basis der aktuellen Werte für jeden Schlüssel. Diese Methode re-indiziert hsh, wenn die Werte im Hash verändert worden sind, seit sie eingefügt wurden. Wenn Hash#rehash aufgerufen wird während ein Iterator durch den Hash läuft, wird ein IndexError im Iterator geworfen.

a = [ "a", "b" ]
c = [ "c", "d" ]
h = { a => 100, c => 300 }
h[a] » 100
a[0] = "z"
h[a] » nil
h.rehash » {["c", "d"]=>300, ["z", "b"]=>100}
h[a] » 100

reject hsh.reject {| Schlüssel, Wert | block }

-> einHash

Dieselbe Funktion wie Hash#delete_if, jedoch wird auf einer Kopie von hash gearbeitet, die auch zurückgegeben wird. Equivalent mit hsh.dup.delete_if.

reject! hsh.reject! {| Schlüssel, Wert | block }

-> hsh oder nil

Equivalent mit Hash#delete_if, jedoch wird nil zurückgegeben, wenn keine Änderungen gemacht wurden.

replace hsh.replace( einAnderesHash ) -> hsh

Ersetzt die Inhalte von hsh mit den Inhalten von einAnderesHash.

h = { "a" => 100, "b" => 200 }
h.replace({ "c" => 300, "d" => 400 }) » {"c"=>300, "d"=>400}

shift hsh.shift -> einArray oder nil

Entfernt ein Schlüssel-Wert-Paar aus hsh und gibt es als einArray mit zwei Feldern [Schlüssel, Wert] bzw. nil, wenn das Hash leer ist, zurück.

h = { 1 => "a", 2 => "b", 3 => "c" }
h.shift » [1, "a"]
h » {2=>"b", 3=>"c"}

size hsh.size -> aFixnum

Synonym für Hash#length.

sort hsh.sort -> einArray
hsh.sort {| a, b | block }

-> einArray

Konvertiert hsh in ein verschachteltes Array von [Schlüssel, Wert] Arrays und sortiert es mit Array#sort.

h = { "a" => 20, "b" => 30, "c" => 10  }
h.sort » [["a", 20], ["b", 30], ["c", 10]]
h.sort {|a,b| a[1]<=>b[1]} » [["c", 10], ["a", 20], ["b", 30]]

store hsh.store( einSchluessel, einWert ) -> einWert

Synonym für daie Elementzuweisung (Hash#[]=).

to_a hsh.to_a -> einArray

Konvertiert hsh in ein verschachteltes Array von [Schlüssel, Wert] Arrays.

h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
h.to_a » [["a", 100], ["c", 300], ["d", 400]]

to_s hsh.to_s -> einString

Konvertiert hsh in einen String indem das Hash in ein Array aus [Schlüssel, Wert] Paaren und dieses anschliessend mit Array#join in einen String umgewandelt wird.

h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
h.to_s » "a100c300d400"

update hsh.update( einAnderesHash ) -> hsh

Fügt die Inhalte von einAnderesHash in hshein, wobei Einträge mit doppelten Schlüsseln mit denen aus einAnderesHash überschrieben werden.

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 254, "c" => 300 }
h1.update(h2) » {"a"=>100, "b"=>254, "c"=>300}

value? hsh.value?( einWert ) -> true oder false

Synonym für Hash#has_value?.

values hsh.values -> einArray

Gibt ein neues Array zurück, das mit den Werten aus hsh gefüllt ist. Siehe auch Hash#keys.

h = { "a" => 100, "b" => 200, "c" => 300 }
h.values » [100, 200, 300]

Extracted from the book "Programming Ruby - The Pragmatic Programmer's Guide"
Übersetzung: Carsten Schinzer
Für das englische Original:
© 2000 Addison Wesley Longman, Inc. Released under the terms of the Open Publication License V1.0. That reference is available for download.
Diese Lizenz sowie das Original vom Herbst 2001 bilden die Grundlage der Übersetzung
Es wird darauf hingewiesen, dass sich die Lizenz des englischen Originals inzwischen geändert hat.
Für die deutsche Übersetzung:
© 2002 Jürgen Katins
Der Copyright-Eigner stellt folgende Lizenzen zur Verfügung:
Nicht-freie Lizenz:
This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at http://www.opencontent.org/openpub/). Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder. Distribution of the work or derivative of the work in any standard (paper) book form is prohibited unless prior permission is obtained from the copyright holder.
Freie Lizenz:
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License".