التجزئة Hash في روبي
grades = { "Jane Doe" => 10, "Jim Doe" => 6 }
هي مجموعة تشبه القاموس وتتكون من مفاتيح فريدة وقيمها. كما تسمى أيضا المصفوفات الترابطية، فهي تشبه المصفوفات Arrays، ولكن بينما تستخدم المصفوفة Array فقط الأعداد الصحيحة كفهرس، تسمح Hash باستخدام أي من أنواع الكائنات.
تُرقِّم التجزئات قيمَها بنفس الترتيب الذي أُدرِجت فيه مفاتيحها المقابلة.
يمكن أن تُنشأ Hash بسهولة باستخدام شكلها الضمني:
تسمح التجزئات بصياغة بديلة للمفاتيح التي تكون رموزًا. بدلًا من
options = { :font_size => 10, :font_family => "Arial" }
و يمكن أن تُكتب:
options = { font_size: 10, font_family: "Arial" }
كل مفتاح مُسمَّي هو رمز يمكن الوصول إليه في التجزئة:
options[:font_size] # => 10
ويمكن أيضا أن تنشأ Hash من خلال التابع ::new
:
grades = Hash.new
grades["Dorothy Doe"] = 9
تتخذ التجزئات قيمة افتراضية تُعاد عند الوصول إلى مفاتيح غير موجودة في التجزئة. إذا لم تتعين قيمة افتراضية تُستخدم nil. ويمكن تعيين القيمة الافتراضية بإرسالها كوسيط إلى ::new
:
grades = Hash.new(0)
أو باستخدام التابع default=
:
grades = {"Timmy Doe" => 8}
grades.default = 0
يتطلب الوصول إلى قيمة ما في Hash استخدام مفتاحها:
puts grades["Jane Doe"] # => 0
الاستخدامات الشائعة
تُعد التجزئات طريقة سهلة لتمثيل هياكل البيانات، مثل
books = {}
books[:matz] = "The Ruby Programming Language"
books[:black] = "The Well-Grounded Rubyist"
كما يشيع استخدام التجزئات كطريقة للحصول على معاملات مسماة في الدوال. لاحظ أنه لا توجد أقواس مستخدمة أدناه. إذا كانت التجزئة هي الوسيط الأخير في استدعاء التابع، لا يلزم استخدام أقواس، وبالتالي إنشاء واجهة مُرتَّبة جدًا:
Person.create(name: "John Doe", age: 27)
def self.create(params)
@name = params[:name]
@age = params[:age]
end
مفاتيح التجزئة
يُشير كائنان إلى نفس مفتاح التجزئة عندما تكون قيمتا hash
الخاصة بهما متطابقة ويكون الكائنان eql?
لبعضهم البعض.
قد يستخدم صنف معرف من قِبَل المستخدم كمفتاح تجزئة إذا أُبطِل التابعَيْن hash
و eql?
لتوفير سلوك ذو معنى. بشكل افتراضي، تشير المثيلات المنفصلة إلى مفاتيح تجزئة منفصلة.
ويستند التطبيق النموذجي للتجزئة hash على بيانات الكائن، بينما يُعين عادةً اسم مستعار للتابع eql?
يشير إلى التابع المُبطِل ==
:
class Book
attr_reader :author, :title
def initialize(author, title)
@author = author
@title = title
end
def ==(other)
self.class === other and
other.author == @author and
other.title == @title
end
alias eql? ==
def hash
@author.hash ^ @title.hash # XOR
end
end
book1 = Book.new 'matz', 'Ruby in a Nutshell'
book2 = Book.new 'matz', 'Ruby in a Nutshell'
reviews = {}
reviews[book1] = 'Great reference!'
reviews[book2] = 'Nice and compact!'
reviews.length #=> 1
انظر أيضا Object#hash
و Object#eql?
.
توابع الصنف العام
Hash[ key, value, ... ] → new_hash
Hash[ [ [key, value], ... ] ] → new_hash
Hash[ object ] → new_hash
إنشاء تجزئة جديدة ممتلئة بالكائنات المعطاة.
على غرار القيمة الحرفية { key => value, ... }. في الشكل الأول، تأتي المفاتيح والقيم في أزواج، لذلك يجب أن يكون هناك عدد زوجي من الوسائط.
يُمرر في الشكلين الثاني والثالث وسيطٌا واحدٌا ويكون إما مصفوفة من أزواج القيمة-المفتاح أو كائن قابل للتحويل إلى تجزئة.
Hash["a", 100, "b", 200] #=> {"a"=>100, "b"=>200}
Hash[ [ ["a", 100], ["b", 200] ] ] #=> {"a"=>100, "b"=>200}
Hash["a" => 100, "b" => 200] #=> {"a"=>100, "b"=>200}
new → new_hash
new(obj) → new_hash
new {|hash, key| block } → new_hash
إعادة تجزئة جديدة فارغة. إذا وصل بعد ذلك مفتاحٌ لا يتوافق مع إدخال تجزئة إلى هذه التجزئة، تعتمد القيمة المُعادة على نمط new
يستخدم لإنشاء التجزئة. في الشكل الأول، يُعيد الوصول nil
. إذا حُدِد obj
، سيُستخدم هذا الكائن وحده لكافة القيم الافتراضية. إذا حُدِدت كتلة، ستُستدعى مع كائن التجزئة والمفتاح، ويجب إعادة القيمة الافتراضية. ومن مسؤولية الكتلة تخزين القيمة في التجزئة إذا لزم الأمر.
h = Hash.new("Go Fish")
h["a"] = 100
h["b"] = 200
h["a"] #=> 100
h["c"] #=> "Go Fish"
# The following alters the single default object
h["c"].upcase! #=> "GO FISH"
h["d"] #=> "GO FISH"
h.keys #=> ["a", "b"]
# While this creates a new default object each time
h = Hash.new { |hash, key| hash[key] = "Go Fish: #{key}" }
h["c"] #=> "Go Fish: c"
h["c"].upcase! #=> "GO FISH: C"
h["d"] #=> "Go Fish: d"
h.keys #=> ["c", "d"]
try_convert(obj) → hash or nil
محاولة تحويل obj
إلى تجزئة باستخدام التابع #to_hash
. وإعادة التجزئة المُحوَّلة أو nil
إذا تعذر تحويل obj
لأي سبب.
ash.try_convert({1=>2}) # => {1=>2}
Hash.try_convert("1=>2") # => nil
توابع المثيل العام
hash < other → true or false
يُعيد true
إذا كانت hash
مجموعة فرعية من other
.
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 < h2 #=> true
h2 < h1 #=> false
h1 < h1 #=> false
hash <= other → true or false
إعادة true
إذا كانت hash
مجموعة فرعية من other
أو تساوي other
.
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 <= h2 #=> true
h2 <= h1 #=> false
h1 <= h1 #=> true
hsh == other_hash → true or false
المساواة — تتساوى تجزئتان إذا كان كل منهما يحتوي على نفس العدد من المفاتيح وإذا كان كل زوج القيمة-المفتاح يساوي العناصر المناظرة في التجزئة الأخرى وفقًا Object#==
.
h1 = { "a" => 1, "c" => 2 }
h2 = { 7 => 35, "c" => 2, "a" => 1 }
h3 = { "a" => 1, "c" => 2, 7 => 35 }
h4 = { "a" => 1, "d" => 2, "f" => 35 }
h1 == h2 #=> false
h2 == h3 #=> true
h3 == h4 #=> false
لا يقارن ترتيب كل التجزئات.
h1 = { "a" => 1, "c" => 2 }
h2 = { "c" => 2, "a" => 1 }
h1 == h2 #=> true
hash > other → true or false
إعادة true
إذا كان other
مجموعة فرعية من hash
.
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 > h2 #=> false
h2 > h1 #=> true
h1 > h1 #=> false
hash >= other → true or false
إعادة true
إذا كان other
مجموعة فرعية من hash
أو يساوي hash
.
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 >= h2 #=> false
h2 >= h1 #=> true
h1 >= h1 #=> true
hsh[key] → value
مرجع العنصر — استرداد الكائن value
المقابل لكائن key
. وإذا لم يُعثر عليه، تُعاد القيمة الافتراضية (راجع Hash::new
لمزيد من التفاصيل).
h = { "a" => 100, "b" => 200 }
h["a"] #=> 100
h["c"] #=> nil
hsh[key] = value → value
تعيين عنصر
ربط القيمة value
المُعطاة مع المفتاح key
المُعطي.
h = { "a" => 100, "b" => 200 }
h["a"] = 9
h["c"] = 4
h #=> {"a"=>9, "b"=>200, "c"=>4}
h.store("d", 42) #=> 42
h #=> {"a"=>9, "b"=>200, "c"=>4, "d"=>42}
لا يجب تغيير قيمة key
أثناء استخدامه كمفتاح (ستكرر السلاسل غير المجمدة unfrozen
المُمررة كمفتاح وتُجمَّد).
a = "a"
b = "b".freeze
h = { a => 100, b => 200 }
h.key(100).equal? a #=> false
h.key(200).equal? b #=> true
VALUE
rb_hash_aset(VALUE hash, VALUE key, VALUE val)
{
int iter_lev = RHASH_ITER_LEV(hash);
st_table *tbl = RHASH(hash)->ntbl;
rb_hash_modify(hash);
if (!tbl) {
if (iter_lev > 0) no_new_key();
tbl = hash_tbl(hash);
}
if (tbl->type == &identhash || rb_obj_class(key) != rb_cString) {
RHASH_UPDATE_ITER(hash, iter_lev, key, hash_aset, val);
}
else {
RHASH_UPDATE_ITER(hash, iter_lev, key, hash_aset_str, val);
}
return val;
}
any? [{ |(key, value)| block }] → true or false
راجع أيضًا Enumerable#any?
static VALUE
rb_hash_any_p(int argc, VALUE *argv, VALUE hash)
{
VALUE args[2];
args[0] = Qfalse;
rb_check_arity(argc, 0, 1);
if (RHASH_EMPTY_P(hash)) return Qfalse;
if (argc) {
args[1] = argv[0];
rb_hash_foreach(hash, any_p_i_pattern, (VALUE)args);
}
else {
if (!rb_block_given_p()) {
/* yields pairs, never false */
return Qtrue;
}
if (rb_block_arity() > 1)
rb_hash_foreach(hash, any_p_i_fast, (VALUE)args);
else
rb_hash_foreach(hash, any_p_i, (VALUE)args);
}
return args[0];
}
assoc(obj) → an_array or nil
البحث خلال التجزئة عن طريق مقارنة obj
بالمفتاح باستخدام التابع ==
. وإعادة زوج القيمة-االمفتاح (مصفوفة من عنصرين) أو nil
إذا لم يعثر على أي تطابق. راجع Array#assoc
.
h = {"colors" => ["red", "blue", "green"],
"letters" => ["a", "b", "c" ]}
h.assoc("letters") #=> ["letters", ["a", "b", "c"]]
h.assoc("foo") #=> nil
clear → hsh
يزيل جميع أزواج القيمة-المفتاح من hsh
.
h = { "a" => 100, "b" => 200 } #=> {"a"=>100, "b"=>200}
h.clear #=> {}
compact → new_hash
إعادة تجزئة جديدة مع إزالة أزواج القيم/المفاتيح الصفرية.
h = { "a" => 100, "b" => 200 } #=> {"a"=>100, "b"=>200}
h.clear #=> {}
compact! → hsh or nil
إزالة جميع قيم hsh
من التجزئة. إعادة صفر إذا لم يُجرى أية تغييرات، وإلا يُعيد التجزئة.
h = { a: 1, b: false, c: nil }
h.compact! #=> { a: 1, b: false }
compare_by_identity → hsh
جعل hsh
يقارن مفاتيحه بواسطة مُعرِّفه، أي إنها سوف تعتبر نفس الكائنات على أنها نفس المفاتيح.
h1 = { "a" => 100, "b" => 200, :c => "c" }
h1["a"] #=> 100
h1.compare_by_identity
h1.compare_by_identity? #=> true
h1["a".dup] #=> nil # different objects.
h1[:c] #=> "c" # same symbols are all same.
compare_by_identity? → true or false
إعادة true
إذا كانت hsh
ستقارن مفاتيحها بواسطة مُعرِّفهم. راجع أيضا Hash#compare_by_identity
.
VALUE
rb_hash_compare_by_id_p(VALUE hash)
{
if (!RHASH(hash)->ntbl)
return Qfalse;
if (RHASH(hash)->ntbl->type == &identhash) {
return Qtrue;
}
return Qfalse;
}
default(key=nil) → obj
إعادة القيمة الافتراضية، القيمة مُعادة بواسطة hsh
إذا كان key
غير موجود في hsh
. راجع أيضًا Hash::new
و Hash#default=
.
h = Hash.new #=> {}
h.default #=> nil
h.default(2) #=> nil
h = Hash.new("cat") #=> {}
h.default #=> "cat"
h.default(2) #=> "cat"
h = Hash.new {|h,k| h[k] = k.to_i*10} #=> {}
h.default #=> nil
h.default(2) #=> 20
default = obj → obj
تعيين القيمة الافتراضية، القيمة المُعادة لمفتاح غير موجود في التجزئة. ليس من الممكن ضب القيمة الافتراضية على Proc
التي ستنفذ على كل بحث عن مفتاح.
h = { "a" => 100, "b" => 200 }
h.default = "Go fish"
h["a"] #=> 100
h["z"] #=> "Go fish"
# This doesn't do what you might hope...
h.default = proc do |hash, key|
hash[key] = key + key
end
h[2] #=> #<Proc:0x401b3948@-:6>
h["cat"] #=> #<Proc:0x401b3948@-:6>
default_proc → anObject
إذا استُدعي Hash::new
مع كتلة، سيُعيد هذه الكتلة، وإلا سيُعيد nil
.
h = Hash.new {|h,k| h[k] = k*k } #=> {}
p = h.default_proc #=> #<Proc:0x401b3d08@-:1>
a = [] #=> []
p.call(a, 2)
a #=> [nil, nil, 4]
default_proc = proc_obj or nil
تعيين proc
الافتراضية التي ستُنفَّذ عند فشل أي بحث عن مفتاح.
h.default_proc = proc do |hash, key|
hash[key] = key + key
end
h[2] #=> 4
h["cat"] #=> "catcat"
VALUE
rb_hash_set_default_proc(VALUE hash, VALUE proc)
{
VALUE b;
rb_hash_modify_check(hash);
if (NIL_P(proc)) {
SET_DEFAULT(hash, proc);
return proc;
}
b = rb_check_convert_type_with_id(proc, T_DATA, "Proc", idTo_proc);
if (NIL_P(b) || !rb_obj_is_proc(b)) {
rb_raise(rb_eTypeError,
"wrong default_proc type %s (expected Proc)",
rb_obj_classname(proc));
}
proc = b;
SET_PROC_DEFAULT(hash, proc);
return proc;
}
delete(key) → value
delete(key) {| key | block } → value
حذف زوج القيمة-المفتاح وإعادة القيمة من hsh
والذي يكون مفتاحها key
. ويُعيد nil
إذا كان المفتاح غير موجود. إذا توفرت كتلة الشيفرة البرمجية الاختيارية وكان المفتاح غير موجود، يُمرر المفتاح وتُعاد نتيجة block
.
h = { "a" => 100, "b" => 200 }
h.delete("a") #=> 100
h.delete("z") #=> nil
h.delete("z") { |el| "#{el} not found" } #=> "z not found"
static VALUE
rb_hash_delete_m(VALUE hash, VALUE key)
{
VALUE val;
rb_hash_modify_check(hash);
val = rb_hash_delete_entry(hash, key);
if (val != Qundef) {
return val;
}
else {
if (rb_block_given_p()) {
return rb_yield(key);
}
else {
return Qnil;
}
}
}
delete_if {| key, value | block } → hsh
delete_if → an_enumerator
حذف كل أزواج القيمة-المفتاح من hsh التي تُقيَّم لها block بالقيمة true.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
dig(key, ...) → object
استخراج القيمة المتداخلة المحددة بواسطة تسلسل كائنات key عن طريق استدعاء dig في كل خطوة، وإعادة nil إذا كانت أي خطوة متوسطة nil.
each {| key, value | block } → hsh
each_pair {| key, value | block } → hsh
each → an_enumerator
each_pair → an_enumerator
استدعاء block مرة واحدة لكل مفتاح في hsh، وتمرير زوج القيمة-المفتاح كمعاملات.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
يُنتِج:
each_key {| key | block } → hsh
each_key → an_enumerator
استدعاء block مرة واحدة لكل مفتاح في hsh، وتمرير المفتاح كمعامل.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
يُنتِج:
each_pair {| key, value | block } → hsh
each_pair → an_enumerator
استدعاء block مرة واحدة لكل مفتاح في hsh، وتمرير زوج القيمة-المفتاح كمعاملات.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
يُنتِج:
each_value {| value | block } → hsh
each_value → an_enumerator
استدعاء block مرة واحدة لكل مفتاح في hsh، وتمرير المفتاح كمعامل.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
يُنتِج:
empty? → true or false
إعادة true إذا كانت hsh لا تحتوي على أزواج القيمة-المفتاح.
eql?(other) → true or false
إعادة true إذا كان كلٌ من hash و other تجزئتين بنفس المحتوى. لا يقارن ترتيب كل التجزئات.
fetch(key [, default] ) → obj
fetch(key) {| key | block } → obj
إعادة قيمة من التجزئة لمفتاح معين. إذا كان المفتاح غير موجود، هناك عدة خيارات: مع عدم وجود وسائط أخرى، سيُجرى استثناء KeyError، إذا أُعطيَ default، ستُعاد هذه إذا حُدِدت كتلة الشيفرة البرمجية الاختيارية، ثم ستُنفَّذ وتُعاد نتيجتها.
يُظهِر المثال التالي إجراء استثناء إذا كان المفتاح غير موجود ولم تُعطى قيمة افتراضية.
يُنتِج:
fetch_values(key, ...) → array
fetch_values(key, ...) { |key| block } → array
إعادة مصفوفة تحتوي على القيم المقترنة بالمفاتيح المعطاة ولكن تُجرى أيضًا KeyError عند تعذر العثور على أحد المفاتيح. راجع أيضًا Hash#values_at و Hash#fetch.
flatten → an_array
flatten(level) → an_array
إعادة مصفوفة جديدة والتي تكون تسطيح أحادي الأبعاد لهذا التجزئة. أي أن لكل مفتاح أو قيمة تكون مصفوفة، تستخرج عناصرها إلى مصفوفة جديدة. على عكس Array#flatten، لا يُسطِّح هذا التابع بشكل عَودي افتراضيًا. يُحدد الوسيط الاختياري level مستوى عودية التسطح.
has_key?(key) → true or false
إعادة true إذا كان مفتاح معين موجود في hsh.
علمًا بأن include? و member? لا يختبرا تساوي الأعضاء باستخدام == كما تفعل غيرها من العدَّادات.
راجع أيضًا Enumerable#include?
has_value?(value) → true or false
إعادة true إذا كانت القيمة المُعطاة موجودة لمفتاح ما في hsh.
hash → integer
حساب رمز التجزئة لهذه التجزئة. سيكون لتجزئتين لهما نفس المحتوى نفس رمز التجزئة (وستقارن باستخدام eql?).
راجع أيضًا Object#hash.
include?(key) → true or false
إعادة true إذا كان مفتاح معين موجود في hsh.
علمًا بأن include? و member? لا يختبرا تساوي الأعضاء باستخدام == كما تفعل غيرها من العدَّادات.
راجع أيضًا Enumerable#include?
to_s → string
inspect → string
إعادة محتويات هذا التجزئة كسلسلة نصية.
ويُعيَّن له أيضًا الاسم المستعار: to_s.
invert → new_hash
إعادة تجزئة جديدة مُنشأة باستخدام قيم hsh كمفاتيح والمفاتيح كقيم. إذا وُجِد بالفعل مفتاح بنفس القيمة في hsh، سيستخدم آخر واحد مُعرَّف، وستُتجاهل القيم السابقة.
إذا لم يكن هناك مفتاح بنفس القيمة، تكون #invert ذاتية الانعكاس (involutive).
الشرط، ألا يوجد مفتاح بنفس القيمة، ويمكن اختباره بمقارنة حجم التجزئة المقلوبة.
keep_if {| key, value | block } → hsh
keep_if → an_enumerator
حذف كل أزواج القيمة-المفتاح من hsh والتي تقيَّم لها block بالقيمة false.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
key(value) → key
إعادة مفتاح تواجد قيمة معينة. ويُعيد nil إذا كانت القيمة غير موجود.
key?(key) → true or false
إعادة true إذا كان مفتاح معين موجود في hsh.
علمًا بأن include? و member? لا يختبرا تساوي الأعضاء باستخدام == كما تفعل غيرها من العدَّادات.
راجع أيضًا Enumerable#include?
keys → array
إعادة مصفوفة جديدة ممتلئة بالمفاتيح من هذه التجزئة. راجع أيضًا Hash#values.
length → integer
إعادة عدد أزواج القيمة-المفتاح في التجزئة.
member?(key) → true or false
إعادة true إذا كان مفتاح معين موجود في hsh.
علمًا بأن include? و member? لا يختبرا تساوي الأعضاء باستخدام == كما تفعل غيرها من العدَّادات.
راجع أيضًا Enumerable#include?
merge(other_hash) → new_hash
merge(other_hash){|key, oldval, newval| block} → new_hash
إعادة تجزئة جديدة تحتوي على محتويات other_hash ومحتويات hsh. إذا لم تُحدد أي كتلة، ستكون قيمة العناصر ذات المفاتيح المُكررة هي نفسها من other_hash. وإلا تُحدَد قيمة كل مفتاح مكرر عن طريق استدعاء الكتلة مع المفتاح، وتكون قيمته في hsh وقيمته في other_hash.
merge!(other_hash) → hsh
merge!(other_hash){|key, oldval, newval| block} → hsh
إضافة محتويات other_hash إلى hsh. إذا لم تُحدَد أي كتلة، يُكتب فوق الإدخالات ذات المفاتيح المكررة مع القيم من other_hash، وإلا تُحدَّد قيمة كل مفتاح مكرر عن طريق استدعاء الكتلة مع المفتاح وقيمته في hsh وقيمته في other_hash.
rassoc(obj) → an_array or nil
البحث خلال التجزئة عن طريق مقارنة obj بالقيمة باستخدام ==. إعادة أول زوج القيمة-المفتاح (مصفوفة من عنصرين) يتطابق. راجع أيضًا Array#rassoc.
rehash → hsh
إعادة بناء التجزئة استنادًا إلى قيم التجزئة الحالية لكل مفتاح. إذا تغيرت قيم كائنات المفاتيح منذ إدراجها، سيعيد هذا التابع فهرسة hsh. إذا اُستدعيَ Hash#rehash بينما يجتاز مُكرِّر التجزئة، سينطلق RuntimeError في المُكرِّر.
reject {|key, value| block} → a_hash
reject → an_enumerator
إعادة تجزئة جديدة تتكون من العناصر التي تعيد الكتلة لها false.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
reject! {| key, value | block } → hsh or nil
reject! → an_enumerator
يعادل Hash#delete_if، ولكن يُعيد nil إذا لم تُجرى أية تغييرات.
replace(other_hash) → hsh
استبدال محتويات hsh بمحتويات other_hash.
select {|key, value| block} → a_hash
select → an_enumerator
إعادة تجزئة جديدة تتكون من العناصر التي تعيد الكتلة لها true.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
select! {| key, value | block } → hsh or nil
select! → an_enumerator
يعادل Hash#keep_if، ولكن يُعيد nil إذا لم تُجرى أية تغييرات.
shift → anArray or obj
يزيل زوج القيمة-المفتاح من hsh ويقوم بإعادتها كمصفوفة من العنصرين [ key, value ]، أو القيمة الافتراضية للتجزئة إذا كانت التجزئة فارغة.
size → integer
إعادة عدد أزواج القيمة-المفتاح في التجزئة.
slice(*keys) → a_hash
إعادة تجزئة تحتوي فقط على المفاتيح المُعطاة وقيمها.
store(key, value) → value
تعيين عنصر
يربط القيمة value المُعطاة مع المفتاح key المُعطي.
لا يجب تغيير قيمة key أثناء استخدامه كمفتاح (ستكرر السلاسل غير المجمدة unfrozen المُمررة كمفتاح وتُجمَّد).
to_a → array
تحويل hsh إلى مصفوفة متداخلة من المصفوفات [ key, value ].
to_h → hsh or new_hash
إعادة self. إذا استُدعي علي صنف فرعي من Hash، تحوِّل المُتلقي إلى كائن Hash.
to_hash => hsh
إعادة self.
to_proc()
to_s()
اسم المستعار لـ inspect
transform_keys {|key| block } → new_hash
transform_keys → an_enumerator
إعادة تجزئة جديدة مع نتائج تشغيل الكتلة مرة واحدة لكل مفتاح. لا يُغيّر هذا التابع القيم.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
transform_keys! {|key| block } → hsh
transform_keys! → an_enumerator
استدعاء الكتلة المعطاة مرة واحدة لكل مفتاح في hsh، واستبداله بالمفتاح الجديد الذي تعيده الكتلة، ثم تُعيد hsh. لا يُغيّر هذا التابع القيم.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
transform_values {|value| block } → new_hash
transform_values → an_enumerator
إعادة تجزئة جديدة مع نتائج تشغيل الكتلة مرة واحدة لكل قيمة. لا يُغيّر هذا التابع المفاتيح.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
transform_values! {|value| block } → hsh
transform_values! → an_enumerator
استدعاء الكتلة المعطاة مرة واحدة لكل قيمة في hsh، واستبداله بالقيمة الجديدة التي تعيدها الكتلة، ثم تُعيد hsh. لا يُغيّر هذا التابع المفاتيح.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
update(other_hash) → hsh
update(other_hash){|key, oldval, newval| block} → hsh
إضافة محتويات other_hash إلى hsh. إذا لم تُحدَد أي كتلة، يُكتب فوق الإدخالات ذات المفاتيح المكررة مع القيم من other_hash، وإلا تُحدَّد قيمة كل مفتاح مكرر عن طريق استدعاء الكتلة مع المفتاح وقيمته في hsh وقيمته في other_hash.
value?(value) → true or false
إعادة true إذا كانت القيمة المُعطاة موجودة لمفتاح ما في hsh.
values → array
إعادة مصفوفة جديدة ممتلئة بالقيم من hsh. راجع أيضًا Hash#keys.
values_at(key, ...) → arrayclick to toggle source
إعادة مصفوفة تحتوي على القيم المرتبطة بالمفاتيح المُعطاة. راجع أيضًا Hash.select.
مصادر