الفرق بين المراجعتين لصفحة: «Ruby/Hash»

من موسوعة حسوب
→ التعديل السابق
مرئينص الويكي
لا ملخص تعديل
طلا ملخص تعديل
 
(3 مراجعات متوسطة بواسطة مستخدمين اثنين آخرين غير معروضة)
سطر 1: سطر 1:
<syntaxhighlight lang="ruby">
<noinclude>{{DISPLAYTITLE: الصنف <code>Hash</code> في روبي}}</noinclude>
grades = { "Jane Doe" => 10, "Jim Doe" => 6 }
النوع <code>Hash</code> (أو [[wikipedia:Hash_table|الجدول Hash]] كما يطلق عليه أحيانًا) هو مجموعة تشبه القاموس ويتكون من مفاتيح فريدة وقيم مرتبطة بها. كما يسمى أيضًا المصفوفات الترابطية، فهو يشبه [[Ruby/Array|المصفوفات]]، ولكن بينما تستخدم [[Ruby/Array|المصفوفة]] فقط الأعداد الصحيحة كفهرس، يسمح النوع <code>Hash</code> باستخدام أيٍّ من أنواع الكائنات لاستعمالها كفهرس وربطها بقيمٍ.


</syntaxhighlight>هي مجموعة تشبه القاموس وتتكون من مفاتيح فريدة وقيمها. كما تسمى أيضا المصفوفات الترابطية، فهي تشبه المصفوفات Arrays، ولكن بينما تستخدم المصفوفة Array فقط الأعداد الصحيحة كفهرس، تسمح Hash باستخدام أي من أنواع الكائنات.
ترتَّب وتحصى القيم في النوع <code>Hash</code> بنفس الترتيب الذي أُدرِجت فيه مفاتيحها المقابلة.


تُرقِّم التجزئات قيمَها بنفس الترتيب الذي أُدرِجت فيه مفاتيحها المقابلة.
يمكن إنشاء جدول <code>Hash</code> بسهولة باستخدام شكله الصريح:<syntaxhighlight lang="ruby">
 
grades = { "Jane Doe" => 10, "Jim Doe" => 6 }
يمكن أن تُنشأ Hash بسهولة باستخدام شكلها الضمني:


تسمح التجزئات بصياغة بديلة للمفاتيح التي تكون رموزًا. بدلًا من<syntaxhighlight lang="ruby">
</syntaxhighlight>يسمح الجدول <code>Hash</code> باستعمال [[Ruby/Symbol|الرموز]] كصيغة بديلة للمفاتيح. انظر مثلًا إلى المثال التالي:<syntaxhighlight lang="ruby">
options = { :font_size => 10, :font_family => "Arial" }
options = { :font_size => 10, :font_family => "Arial" }


</syntaxhighlight>و يمكن أن تُكتب:<syntaxhighlight lang="ruby">
</syntaxhighlight>و يمكن أن تُكتب أيضًا بالشكل التالي:<syntaxhighlight lang="ruby">
options = { font_size: 10, font_family: "Arial" }
options = { font_size: 10, font_family: "Arial" }


</syntaxhighlight>كل مفتاح مُسمَّي هو رمز يمكن الوصول إليه في التجزئة:<syntaxhighlight lang="ruby">
</syntaxhighlight>كل مفتاح مُسمَّى هو [[Ruby/Symbol|رمز]] يمكن الوصول إليه في الجدول <code>Hash</code>:<syntaxhighlight lang="ruby">
options[:font_size]  # => 10
options[:font_size]  # => 10


</syntaxhighlight>ويمكن أيضا أن تنشأ Hash من خلال التابع ‎<code>::new</code>:<syntaxhighlight lang="ruby">
</syntaxhighlight>ويمكن أيضا أن إنشاء جدول <code>Hash</code> من خلال التابع ‎<code>[[Ruby/Hash/new|new]]</code>:<syntaxhighlight lang="ruby">
grades = Hash.new
grades = Hash.new
grades["Dorothy Doe"] = 9
grades["Dorothy Doe"] = 9
</syntaxhighlight>تتخذ التجزئات قيمة افتراضية تُعاد عند الوصول إلى مفاتيح غير موجودة في التجزئة. إذا لم تتعين قيمة افتراضية تُستخدم nil. ويمكن تعيين القيمة الافتراضية بإرسالها كوسيط إلى ‎<code>::new</code>:<syntaxhighlight lang="ruby">
</syntaxhighlight>تملك الجداول <code>Hash</code> قيمةً افتراضيةً تُعاد عند الوصول إلى مفاتيح غير موجودة. إذا لم تُعيَّن قيمة افتراضية، فستُستخدم القيمة <code>nil</code>. ويمكن تعيين القيمة الافتراضية بتمريرها إلى ‎[[Ruby/Hash/new|<code>new</code>]]:<syntaxhighlight lang="ruby">
grades = Hash.new(0)
grades = Hash.new(0)


</syntaxhighlight>أو باستخدام التابع <code>default=</code>‎:<syntaxhighlight lang="ruby">
</syntaxhighlight>أو باستخدام التابع [[Ruby/Hash/default-3D|<code>default</code>‎]]:<syntaxhighlight lang="ruby">
grades = {"Timmy Doe" => 8}
grades = {"Timmy Doe" => 8}
grades.default = 0
grades.default = 0
</syntaxhighlight>يتطلب الوصول إلى قيمة ما في Hash استخدام مفتاحها:<syntaxhighlight lang="ruby">
</syntaxhighlight>يتطلب الوصول إلى قيمة ما في الجدول <code>Hash</code> استخدام مفتاحها:<syntaxhighlight lang="ruby">
puts grades["Jane Doe"] # => 0
puts grades["Jane Doe"] # => 0


</syntaxhighlight>
</syntaxhighlight>
===الاستخدامات الشائعة===
==استخدامات شائعة==
تُعد التجزئات طريقة سهلة لتمثيل هياكل البيانات، مثل<syntaxhighlight lang="ruby">
يعد النوع <code>Hash</code> طريقةً سهلةً لتمثيل هياكل البيانات مثل:<syntaxhighlight lang="ruby">
books        = {}
books        = {}
books[:matz]  = "The Ruby Programming Language"
books[:matz]  = "The Ruby Programming Language"
books[:black] = "The Well-Grounded Rubyist"
books[:black] = "The Well-Grounded Rubyist"


</syntaxhighlight>كما يشيع استخدام التجزئات كطريقة للحصول على معاملات مسماة في الدوال. لاحظ أنه لا توجد أقواس مستخدمة أدناه. إذا كانت التجزئة هي الوسيط الأخير في استدعاء التابع، لا يلزم استخدام أقواس، وبالتالي إنشاء واجهة مُرتَّبة جدًا:<syntaxhighlight lang="ruby">
</syntaxhighlight>كما يشيع استخدام النوع <code>Hash</code> كطريقة للحصول على [[Ruby/methods#.D8.A7.D9.84.D9.88.D8.B3.D8.A7.D8.A6.D8.B7 .D8.A7.D9.84.D9.85.D8.B3.D9.85.D8.A7.D8.A9|معاملات مسماة]] في الدوال. لاحظ أنَّه لا توجد أقواس مستخدمة في المثال في الأسفل. إذا كان النوع <code>Hash</code> هو الوسيط الأخير في استدعاء [[Ruby/methods|تابع]]، فلا يلزم استخدام أقواس، وبالتالي يمكن إنشاء واجهة مُرتَّبة جدًا:<syntaxhighlight lang="ruby">
Person.create(name: "John Doe", age: 27)
Person.create(name: "John Doe", age: 27)


سطر 44: سطر 43:
end
end
</syntaxhighlight>
</syntaxhighlight>
===مفاتيح التجزئة===
==المفاتيح في النوع <code>Hash</code>==
يُشير كائنان إلى نفس مفتاح التجزئة عندما تكون قيمتا <code>hash</code> الخاصة بهما متطابقة ويكون الكائنان <code>eql?</code>‎ لبعضهم البعض.
يُشير كائنان إلى نفس المفتاح في الجدول <code>Hash</code> عندما تكون القيمة المرتبطة بأحدهما مماثلة ومساوية للقيمة المرتبطة بالمفتاح الآخر.


قد يستخدم صنف معرف من قِبَل المستخدم كمفتاح تجزئة إذا أُبطِل التابعَيْن <code>hash</code> و <code>eql?</code>‎ لتوفير سلوك ذو معنى. بشكل افتراضي، تشير المثيلات المنفصلة إلى مفاتيح تجزئة منفصلة.
قد يُستخدَم صنف معرف من قِبَل المستخدم كمفتاح إذا استُبدِل التابعَيْن <code>[[Ruby/Hash/hash|hash]]</code> و <code>[[Ruby/Hash/eql-3F|eql?]]</code>‎ لتوفير سلوك ذو معنى. بشكل افتراضي، تشير النُسَخ المنفصلة إلى مفاتيح منفصلة.


ويستند التطبيق النموذجي للتجزئة hash على بيانات الكائن، بينما يُعين عادةً اسم مستعار للتابع <code>eql?</code>‎ يشير إلى التابع المُبطِل <code>==</code>:<syntaxhighlight lang="ruby">
ويستند التنفيذ النموذجي للتابع [[Ruby/Hash/hash|<code>hash</code>]] على بيانات الكائن، بينما يُعين عادةً اسم بديل للتابع <code>[[Ruby/Hash/eql-3F|eql?]]</code>‎ يشير إلى المعامل <code>[[Ruby/Hash/equal|==]]</code> المُستبدَل:<syntaxhighlight lang="ruby">
class Book
class Book
   attr_reader :author, :title
   attr_reader :author, :title
سطر 80: سطر 79:


reviews.length #=> 1
reviews.length #=> 1
</syntaxhighlight>انظر أيضا <code>Object#hash</code> و <code>Object#eql?</code>‎.
</syntaxhighlight>انظر أيضًا التابع <code>[[Ruby/Object/hash|Object.hash]]</code> والتابع <code>[[Ruby/Object/eql-3F|Object.eql?]]</code>‎.
===توابع الصنف العام===
==توابع الصنف العام==
====<code>Hash[ key, value, ... ] → new_hash</code>====
===<code>[[Ruby/Hash/index|Hash[]‎]]</code>===
====<code>Hash[ [ [key, value], ... ] ] → new_hash</code>====
ينشئ جدول <code>Hash</code> جديد ويضع فيه الكائنات المعطاة.
====<code>Hash[ object ] → new_hash</code>====
إنشاء تجزئة جديدة ممتلئة بالكائنات المعطاة.
 
على غرار القيمة الحرفية ‎{ key => value, ... }‎. في الشكل الأول، تأتي المفاتيح والقيم في أزواج، لذلك يجب أن يكون هناك عدد زوجي من الوسائط.
 
يُمرر في الشكلين الثاني والثالث وسيطٌا واحدٌا ويكون إما مصفوفة من أزواج القيمة-المفتاح أو كائن قابل للتحويل إلى تجزئة.<syntaxhighlight lang="ruby">
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}
</syntaxhighlight>
====<code>new → new_hash</code>====
====<code>new(obj) → new_hash</code>====
====<code>new {|hash, key| block } → new_hash</code>====
إعادة تجزئة جديدة فارغة. إذا وصل بعد ذلك مفتاحٌ لا يتوافق مع إدخال تجزئة إلى هذه التجزئة، تعتمد القيمة المُعادة على نمط <code>new</code> يستخدم لإنشاء التجزئة. في الشكل الأول، يُعيد الوصول <code>nil</code>. إذا حُدِد <code>obj</code> ، سيُستخدم هذا الكائن وحده لكافة القيم الافتراضية. إذا حُدِدت كتلة، ستُستدعى مع كائن التجزئة والمفتاح، ويجب إعادة القيمة الافتراضية. ومن مسؤولية الكتلة تخزين القيمة في التجزئة إذا لزم الأمر.<syntaxhighlight lang="ruby">
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"]
</syntaxhighlight>
====<code>try_convert(obj) → hash or nil</code>====
محاولة تحويل <code>obj</code> إلى تجزئة باستخدام التابع <code>‎#to_hash</code>. وإعادة التجزئة المُحوَّلة أو <code>nil</code> إذا تعذر تحويل <code>obj</code> لأي سبب.<syntaxhighlight lang="ruby">
ash.try_convert({1=>2})  # => {1=>2}
Hash.try_convert("1=>2")  # => nil
</syntaxhighlight>
===توابع المثيل العام===
====<code>hash < other → true or false</code>====
يُعيد <code>true</code> إذا كانت <code>hash</code> مجموعة فرعية من <code>other</code>.<syntaxhighlight lang="ruby">
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 < h2    #=> true
h2 < h1    #=> false
h1 < h1    #=> false
</syntaxhighlight>
====<code>hash <= other → true or false</code>====
إعادة <code>true</code> إذا كانت <code>hash</code> مجموعة فرعية من <code>other</code> أو تساوي <code>other</code>.<syntaxhighlight lang="ruby">
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 <= h2  #=> true
h2 <= h1  #=> false
h1 <= h1  #=> true
</syntaxhighlight>
====<code>hsh == other_hash → true or false</code>====
المساواة — تتساوى تجزئتان إذا كان كل منهما يحتوي على نفس العدد من المفاتيح وإذا كان كل زوج القيمة-المفتاح يساوي العناصر المناظرة في التجزئة الأخرى وفقًا <code>Object#==</code>‎.<syntaxhighlight lang="ruby">
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
</syntaxhighlight>لا يقارن ترتيب كل التجزئات.<syntaxhighlight lang="ruby">
h1 = { "a" => 1, "c" => 2 }
h2 = { "c" => 2, "a" => 1 }
h1 == h2  #=> true
</syntaxhighlight>
====<code>hash > other → true or false</code>====
إعادة <code>true</code> إذا كان <code>other</code> مجموعة فرعية من <code>hash</code>.<syntaxhighlight lang="ruby">
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 > h2    #=> false
h2 > h1    #=> true
h1 > h1    #=> false
</syntaxhighlight>
====<code>hash >= other → true or false</code>====
إعادة <code>true</code> إذا كان <code>other</code> مجموعة فرعية من <code>hash</code> أو يساوي <code>hash</code>.<syntaxhighlight lang="ruby">
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 >= h2  #=> false
h2 >= h1  #=> true
h1 >= h1  #=> true
</syntaxhighlight>
====<code>hsh[key] → value</code>====
مرجع العنصر — استرداد الكائن <code>value</code> المقابل لكائن <code>key</code>. وإذا لم يُعثر عليه، تُعاد القيمة الافتراضية (راجع <code>Hash::new</code> لمزيد من التفاصيل).<syntaxhighlight lang="ruby">
h = { "a" => 100, "b" => 200 }
h["a"]  #=> 100
h["c"]  #=> nil
</syntaxhighlight>
====<code>hsh[key] = value → value</code>====
==تعيين عنصر==
ربط القيمة <code>value</code> المُعطاة مع المفتاح <code>key</code> المُعطي.<syntaxhighlight lang="ruby">
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}
</syntaxhighlight>لا يجب تغيير قيمة <code>key</code> أثناء استخدامه كمفتاح (ستكرر السلاسل غير المجمدة <code>unfrozen</code> المُمررة كمفتاح وتُجمَّد).<syntaxhighlight lang="ruby">
a = "a"
b = "b".freeze
h = { a => 100, b => 200 }
h.key(100).equal? a #=> false
h.key(200).equal? b #=> true
</syntaxhighlight><syntaxhighlight lang="ruby">
 
              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;
}
     
</syntaxhighlight>
====<code>any? [{ |(key, value)| block }] → true or false</code>====
راجع أيضًا <code>Enumerable#any?‎</code><syntaxhighlight lang="ruby">
              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];
}
</syntaxhighlight>
====<code>assoc(obj) → an_array or nil</code>====
البحث خلال التجزئة عن طريق مقارنة <code>obj</code> بالمفتاح باستخدام التابع <code>==</code>. وإعادة زوج القيمة-االمفتاح (مصفوفة من عنصرين) أو <code>nil</code> إذا لم يعثر على أي تطابق. راجع <code>Array#assoc</code>.<syntaxhighlight lang="ruby">
h = {"colors"  => ["red", "blue", "green"],
    "letters" => ["a", "b", "c" ]}
h.assoc("letters")  #=> ["letters", ["a", "b", "c"]]
h.assoc("foo")      #=> nil
</syntaxhighlight>
====<code>clear → hsh</code>====
يزيل جميع أزواج القيمة-المفتاح من <code>hsh</code>.<syntaxhighlight lang="ruby">
h = { "a" => 100, "b" => 200 }  #=> {"a"=>100, "b"=>200}
h.clear                          #=> {}
</syntaxhighlight>
====<code>compact → new_hash</code>====
إعادة تجزئة جديدة مع إزالة أزواج القيم/المفاتيح الصفرية.<syntaxhighlight lang="ruby">
h = { "a" => 100, "b" => 200 }  #=> {"a"=>100, "b"=>200}
h.clear                          #=> {}
</syntaxhighlight>
====<code>compact! → hsh or nil</code>====
إزالة جميع قيم <code>hsh</code> من التجزئة. إعادة صفر إذا لم يُجرى أية تغييرات، وإلا يُعيد التجزئة.<syntaxhighlight lang="ruby">
h = { a: 1, b: false, c: nil }
h.compact!    #=> { a: 1, b: false }
</syntaxhighlight>
====<code>compare_by_identity → hsh</code>====
جعل <code>hsh</code> يقارن مفاتيحه بواسطة مُعرِّفه، أي إنها سوف تعتبر نفس الكائنات على أنها نفس المفاتيح.<syntaxhighlight lang="ruby">
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.
</syntaxhighlight>
====<code>compare_by_identity? → true or false</code>====
إعادة <code>true</code> إذا كانت <code>hsh</code> ستقارن مفاتيحها بواسطة مُعرِّفهم. راجع أيضا <code>Hash#compare_by_identity</code>.<syntaxhighlight lang="ruby">
              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;
}
           
</syntaxhighlight>
====<code>default(key=nil) → obj</code>====
إعادة القيمة الافتراضية، القيمة مُعادة بواسطة <code>hsh</code> إذا كان <code>key</code> غير موجود في <code>hsh</code>. راجع أيضًا <code>Hash::new</code> و <code>Hash#default=‎</code>.<syntaxhighlight lang="ruby">
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
</syntaxhighlight>
====<code>default = obj → obj</code>====
تعيين القيمة الافتراضية، القيمة المُعادة لمفتاح غير موجود في التجزئة. ليس من الممكن ضب القيمة الافتراضية على <code>Proc</code> التي ستنفذ على كل بحث عن مفتاح.<syntaxhighlight lang="ruby">
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>
</syntaxhighlight>
====<code>default_proc → anObject</code>====
إذا استُدعي <code>Hash::new</code> مع كتلة، سيُعيد هذه الكتلة، وإلا سيُعيد <code>nil</code>.<syntaxhighlight lang="ruby">
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]
</syntaxhighlight>
====<code>default_proc = proc_obj or nil</code>====
تعيين <code>proc</code> الافتراضية التي ستُنفَّذ عند فشل أي بحث عن مفتاح.<syntaxhighlight lang="ruby">
h.default_proc = proc do |hash, key|
  hash[key] = key + key
end
h[2]      #=> 4
h["cat"]  #=> "catcat"
</syntaxhighlight><syntaxhighlight lang="ruby">
              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;
}
           
</syntaxhighlight>
====<code>delete(key) → value</code>====
====<code>delete(key) {| key | block } → value</code>====
حذف زوج القيمة-المفتاح وإعادة القيمة من <code>hsh</code> والذي يكون مفتاحها <code>key</code>. ويُعيد <code>nil</code> إذا كان المفتاح غير موجود. إذا توفرت كتلة الشيفرة البرمجية الاختيارية وكان المفتاح غير موجود، يُمرر المفتاح وتُعاد نتيجة <code>block</code>.<syntaxhighlight lang="ruby">
h = { "a" => 100, "b" => 200 }
h.delete("a")                              #=> 100
h.delete("z")                              #=> nil
h.delete("z") { |el| "#{el} not found" }  #=> "z not found"
</syntaxhighlight><syntaxhighlight lang="ruby">
              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;
        }
    }
}
 
</syntaxhighlight>
====<code>delete_if {| key, value | block } → hsh</code>====
====<code>delete_if → an_enumerator</code>====
حذف كل أزواج القيمة-المفتاح من <code>hsh</code> التي تُقيَّم لها <code>block</code> بالقيمة <code>true</code>.
 
إذا لم تُعطَى <code>block</code>، يُعاد عدَّاد بدلًا من ذلك.<syntaxhighlight lang="ruby">
h = { "a" => 100, "b" => 200, "c" => 300 }
h.delete_if {|key, value| key >= "b" }  #=> {"a"=>100}
 
</syntaxhighlight>أمثلة<syntaxhighlight lang="ruby">
              VALUE
rb_hash_delete_if(VALUE hash)
{
    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    rb_hash_modify_check(hash);
    if (RHASH(hash)->ntbl)
        rb_hash_foreach(hash, delete_if_i, hash);
    return hash;
}
         
</syntaxhighlight>
====<code>dig(key, ...) → object</code>====
استخراج القيمة المتداخلة المحددة بواسطة تسلسل كائنات <code>key</code> عن طريق استدعاء <code>dig</code> في كل خطوة، وإعادة <code>nil</code> إذا كانت أي خطوة متوسطة <code>nil</code>.<syntaxhighlight lang="ruby">
h = { foo: {bar: {baz: 1}}}
 
h.dig(:foo, :bar, :baz)    #=> 1
h.dig(:foo, :zot, :xyz)    #=> nil
 
g = { foo: [10, 11, 12] }
g.dig(:foo, 1)              #=> 11
g.dig(:foo, 1, 0)          #=> TypeError: Integer does not have #dig method
g.dig(:foo, :bar)          #=> TypeError: no implicit conversion of Symbol into Integer
</syntaxhighlight>أمثلة
 
====<code>each {| key, value | block } → hsh</code>====
====<code>each_pair {| key, value | block } → hsh</code>====
====<code>each → an_enumerator</code>====
====<code>each_pair → an_enumerator</code>====
استدعاء block مرة واحدة لكل مفتاح في hsh، وتمرير زوج القيمة-المفتاح كمعاملات.
 
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
 
يُنتِج:
 
أمثلة
====<code>each_key {| key | block } → hsh</code>====
====<code>each_key → an_enumerator</code>====
استدعاء block مرة واحدة لكل مفتاح في hsh، وتمرير المفتاح كمعامل.
 
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
 
يُنتِج:
 
أمثلة
====<code>each_pair {| key, value | block } → hsh</code>====
====<code>each_pair → an_enumerator</code>====
استدعاء block مرة واحدة لكل مفتاح في hsh، وتمرير زوج القيمة-المفتاح كمعاملات.
 
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
 
يُنتِج:
 
أمثلة
====<code>each_value {| value | block } → hsh</code>====
====<code>each_value → an_enumerator</code>====
استدعاء block مرة واحدة لكل مفتاح في hsh، وتمرير المفتاح كمعامل.
 
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
 
يُنتِج:
 
أمثلة
====<code>empty? → true or false</code>====
إعادة true إذا كانت hsh لا تحتوي على أزواج القيمة-المفتاح.
 
أمثلة
====<code>eql?(other) → true or false</code>====
إعادة true إذا كان كلٌ من hash و other تجزئتين بنفس المحتوى. لا يقارن ترتيب كل التجزئات.
 
أمثلة
====<code>fetch(key [, default] ) → obj</code>====
====<code>fetch(key) {| key | block } → obj</code>====
إعادة قيمة من التجزئة لمفتاح معين. إذا كان المفتاح غير موجود، هناك عدة خيارات: مع عدم وجود وسائط أخرى، سيُجرى استثناء KeyError، إذا أُعطيَ default، ستُعاد هذه إذا حُدِدت كتلة الشيفرة البرمجية الاختيارية، ثم ستُنفَّذ وتُعاد نتيجتها.
 
يُظهِر المثال التالي إجراء استثناء إذا كان المفتاح غير موجود ولم تُعطى قيمة افتراضية.
 
يُنتِج:
 
أمثلة
 
====<code>fetch_values(key, ...) → array</code>====
====<code>fetch_values(key, ...) { |key| block } → array</code>====
إعادة مصفوفة تحتوي على القيم المقترنة بالمفاتيح المعطاة ولكن تُجرى أيضًا KeyError عند تعذر العثور على أحد المفاتيح. راجع أيضًا Hash#values_at و Hash#fetch.


أمثلة
===<code>[[Ruby/Hash/new|new]]</code>===
====<code>flatten → an_array</code>====
ينشئ جدول <code>Hash</code> جديد فارغ ثم يعيده.
====<code>flatten(level) → an_array</code>====
إعادة مصفوفة جديدة والتي تكون تسطيح أحادي الأبعاد لهذا التجزئة. أي أن لكل مفتاح أو قيمة تكون مصفوفة، تستخرج عناصرها إلى مصفوفة جديدة. على عكس Array#flatten، لا يُسطِّح هذا التابع بشكل عَودي افتراضيًا. يُحدد الوسيط الاختياري level مستوى عودية التسطح.


أمثلة
===<code>[[Ruby/Hash/try_convert|try_convert]]</code>===
====<code>has_key?(key) → true or false</code>====
يحاول تحويل الكائن المُمرَّر إليه إلى النوع <code>Hash</code> باستخدام التابع<code>[[Ruby/Hash/to hash|to_hash]]</code>. 
إعادة true إذا كان مفتاح معين موجود في hsh.


علمًا بأن include?‎ و member?‎ لا يختبرا تساوي الأعضاء باستخدام == كما تفعل غيرها من العدَّادات.
== توابع النسخة العامة ==


راجع أيضًا <code>Enumerable#include?‎</code>
===<code>[[Ruby/Hash/lt|>]]</code>===
يعيد القيمة <code>true</code> إذا كان الكائن <code>Hash</code> الواقع على يساره مجموعةً فرعيةً من الكائن الواقع على يمينه.


أمثلة
===<code>[[Ruby/Hash/le|=>]]</code>===
====<code>has_value?(value) → true or false</code>====
يعيد القيمة <code>true</code> إذا كان الكائن <code>Hash</code> الواقع على يساره مجموعةً فرعيةً من الكائن الواقع على يمينه أو يساويه تمامًا.
إعادة true إذا كانت القيمة المُعطاة موجودة لمفتاح ما في hsh.


أمثلة
===<code>[[Ruby/Hash/equal|==]]</code>===
يتحقق من تساوي كائنين من النوع <code>Hash</code>.


====<code>hash → integer</code>====
===<code>[[Ruby/Hash/gt|<]]</code>===
حساب رمز التجزئة لهذه التجزئة. سيكون لتجزئتين لهما نفس المحتوى نفس رمز التجزئة (وستقارن باستخدام eql?‎).
يعيد القيمة <code>true</code> إذا كان الكائن الواقع على يمينه مجموعةً فرعيةً من الكائن الواقع على يساره.


راجع أيضًا Object#hash.
===<code>[[Ruby/Hash/ge|=<]]</code>===
يعيد المعامل <code>=<</code> القيمة <code>true</code> إذا كان الكائن الواقع على يمينه مجموعةً فرعيةً من الكائن الواقع على يساره أو يساويه تمامًا.


أمثلة
===<code>[[Ruby/Hash/5B-5D|[]]]</code>===
يجلب القيمة المقابلة لمفتاح معين في الجدول <code>Hash</code> المعطى.


====<code>include?(key) → true or false</code>====
===<code>[[Ruby/Hash/5B-5D-3D|=[]]]</code>===
إعادة true إذا كان مفتاح معين موجود في hsh.
يربط عند استدعائه بالشكل <code>hsh[key] = value</code> القيمة <code>value</code> المعطاة بالمفتاح<code>key</code> في الجدول <code>Hash</code>.


علمًا بأن include?‎ و member?‎ لا يختبرا تساوي الأعضاء باستخدام == كما تفعل غيرها من العدَّادات.
===<code>[[Ruby/Hash/any-3F|any?‎]]</code>===
يمرر كل زوج من مفتاح/قيمة من أزواج الكائن <code>[[Ruby/Hash|Hash]]</code> المعطى إلى كتلة معينة ثم يعيد القيمة <code>true</code> إن أعادت الكتلة قيمة غير القيمة <code>false</code> أو <code>nil</code>.


راجع أيضًا <code>Enumerable#include?‎</code>
===<code>[[Ruby/Hash/assoc|assoc]]</code>===
يبحث ضمن الكائن <code>[[Ruby/Hash|Hash]]</code> عن طريق موازنة الكائن المُمرَّر إليه بمفاتيحه باستخدام المعامل <code>[[Ruby/Hash/equal|==]]</code> ثم يعيد الزوج قيمة-مفتاح (مصفوفة من عنصرين) أو <code>nil</code> إذا لم يعثر على أي تطابق.


أمثلة
===<code>[[Ruby/Hash/clear|clear]]</code>===
يزيل جميع الأزواج قيمة-مفتاح من الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه.


====<code>to_s → string</code>====
===<code>[[Ruby/Hash/compact|compact]]</code>===
====<code>inspect → string</code>====
يعيد كائن <code>Hash</code> جديد يحوي جميع الأزواج قيم/مفاتيح للكائن الذي استدعي معه باستثناء الأزواج المعدومة (أي ذات القيمة <code>nil</code>).
إعادة محتويات هذا التجزئة كسلسلة نصية.


ويُعيَّن له أيضًا الاسم المستعار: to_s.
===<code>[[Ruby/Hash/compact!|compact!]]</code>===
يزيل جميع الأزواج قيمة/مفتاح المعدومة (أي ذات القيمة <code>nil</code>) من الكائن الذي استدعي معه.


أمثلة
===<code>[[Ruby/Hash/compare_by_identity|compare_by_identity]]</code>===
يجعل الكائن <code>[[Ruby/Hash|Hash]]</code> يقارن مفاتيحه بواسطة مُعرِّفاتها، أي أنَّها سوف تُعدُّ نفس الكائنات على أنَّها نفس المفاتيح.


====<code>invert → new_hash</code>====
===<code>[[Ruby/Hash/compare_by_identity-3F|compare_by_identity?‎]]</code>===
إعادة تجزئة جديدة مُنشأة باستخدام قيم hsh كمفاتيح والمفاتيح كقيم. إذا وُجِد بالفعل مفتاح بنفس القيمة في hsh، سيستخدم آخر واحد مُعرَّف، وستُتجاهل القيم السابقة.
يتحقق إذا كان الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه سيقارن مفاتيحه بواسطة مُعرِّفاتهم.


إذا لم يكن هناك مفتاح بنفس القيمة، تكون #invert ذاتية الانعكاس (involutive).
===<code>[[Ruby/Hash/default|default]]</code>===
يعيد القيمة الافتراضية للمفتاح المُمرَّر إليه؛ أي يعيد القيمة التي سيعيدها الكائن<code>[[Ruby/Hash|Hash]]</code> إذا كان المفتاح غير موجود فيه.


الشرط، ألا يوجد مفتاح بنفس القيمة، ويمكن اختباره بمقارنة حجم التجزئة المقلوبة.
===[[Ruby/Hash/default-3D|<code rel="mw:WikiLink" href="Ruby/Hash/default-3D" title="Ruby/Hash/default-3D">=default</code>]]===
يضبط عند استدعائه بالشكل <code>default = obj</code> القيمة الافتراضية <code>obj</code> وهي القيمة التي ستُعاد لمفتاح غير موجود في الكائن <code>[[Ruby/Hash|Hash]]</code>.


أمثلة
===<code>[[Ruby/Hash/default_proc|default_proc]]</code>===
يعيد الكتلة التي استُدعي التابع <code>[[Ruby/Hash/new|new]]</code> معها عند إنشاء الكائن <code>[[Ruby/Hash|Hash]]</code>المعطى، وإلا سيُعيد القيمة <code>nil</code>.


====<code>keep_if {| key, value | block } → hsh</code>====
===<code>[[Ruby/Hash/default_proc-3D|=default_proc]]</code>===
====<code>keep_if → an_enumerator</code>====
يضبط إن استدعي بالشكل <code>default_proc = proc_obj</code> القيمة الافتراضية للكتلة التي ستُنفَّذ عند فشل أية عملية بحث عن مفتاح للكائن <code>[[Ruby/Hash|Hash]]</code> المعطى.
حذف كل أزواج القيمة-المفتاح من hsh والتي تقيَّم لها block بالقيمة false.


إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
===<code>[[Ruby/Hash/delete|delete]]</code>===
يحذف زوجًا ذا مفتاح محدَّد ويعيد قيمته من الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه.


أمثلة
===<code>[[Ruby/Hash/delete_if|delete_if]]</code>===
يحذف كل زوج قيمة-مفتاح يحقق شرطًا معيَّنًا من أزواج الكائن <code>[[Ruby/Hash|Hash]]</code> المعطى.


====<code>key(value) → key</code>====
===<code>[[Ruby/Hash/dig|dig]]</code>===
إعادة مفتاح تواجد قيمة معينة. ويُعيد nil إذا كانت القيمة غير موجود.
يستخرج القيمة المتداخلة المحددة بواسطة تسلسل كائنات تمثِّل المفاتيح عن طريق استدعاء <code>dig</code> في كل خطوة، ويعيد القيمة <code>nil</code> إذا كانت أي خطوة متوسطة هي <code>nil</code>.


أمثلة
===<code>[[Ruby/Hash/each|each]]</code>===
====<code>key?(key) → true or false</code>====
يستدعي الكتلة المعطاة مرةً واحدةً لكل مفتاح من مفاتيح أزواج الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه بعد تمرير مفتاح وقيمة الأزواج إليها.
إعادة true إذا كان مفتاح معين موجود في hsh.


علمًا بأن include?‎ و member?‎ لا يختبرا تساوي الأعضاء باستخدام == كما تفعل غيرها من العدَّادات.
===<code>[[Ruby/Hash/each_key|each_key]]</code>===
يستدعي الكتلة المعطاة مرةً واحدةً لكل مفتاح من مفاتيح أزواج الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه بعد تمرير مفتاح كل زوج إليها.


راجع أيضًا Enumerable#include?‎
===<code>[[Ruby/Hash/each_pair|each_pair]]</code>===
يستدعي الكتلة المعطاة مرةً واحدةً لكل مفتاح من مفاتيح أزواج الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه بعد تمرير مفتاح وقيمة الأزواج إليها.


أمثلة
===<code>[[Ruby/Hash/each_value|each_value]]</code>===
يستدعي الكتلة المعطاة مرةً واحدةً لكل مفتاح من مفاتيح أزواج الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه بعد تمرير قيمة كل زوج إليها.


====<code>keys → array</code>====
===<code>[[Ruby/Hash/empty-3F|empty?‎]]</code>===
إعادة مصفوفة جديدة ممتلئة بالمفاتيح من هذه التجزئة. راجع أيضًا Hash#values.
يتحقق إذا كان الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه فارغًا أي لا يحتوي على أية أزواج.


أمثلة
===<code>[[Ruby/Hash/eql-3F|eql?‎]]</code>===
يتحقق إذا كان كائنان من نفس النوع (النوع <code>[[Ruby/Hash|Hash]]</code>) ولهما نفس المحتوى. لا يؤخذ ترتيب الأزواج بالحسبان.


====<code>length → integer</code>====
===<code>[[Ruby/Hash/fetch|fetch]]</code>===
إعادة عدد أزواج القيمة-المفتاح في التجزئة.
يعيد قيمة من الكائن <code>[[Ruby/Hash|Hash]]</code> لمفتاح معين.


أمثلة
===<code>[[Ruby/Hash/fetch_values|fetch_values]]</code>===
====<code>member?(key) → true or false</code>====
يعيد مصفوفة تحتوي على القيم المقترنة بالمفاتيح المعطاة.
إعادة true إذا كان مفتاح معين موجود في hsh.


علمًا بأن include?‎ و member?‎ لا يختبرا تساوي الأعضاء باستخدام == كما تفعل غيرها من العدَّادات.
===<code>[[Ruby/Hash/flatten|flatten]]</code>===
يعيد مصفوفة جديدة والتي تكون تسطيح أحادي الأبعاد للكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه.


راجع أيضًا Enumerable#include?‎
===<code>[[Ruby/Hash/has_key-3F|has_key?‎]]</code>===
يتحقق إذا كان مفتاحٌ معيَّن موجودًا في الكائن <code>[[Ruby/Hash|Hash]]</code> المعطى.


أمثلة
===<code>[[Ruby/Hash/has_value-3F|has_value?‎]]</code>===
====<code>merge(other_hash) → new_hash</code>====
يعيد إذا كانت قيمةٌ معيَّنةٌ موجودةً في الكائن <code>[[Ruby/Hash|Hash]]</code> المعطى ومرتبطة بمفتاح.
merge(other_hash){|key, oldval, newval| block} → new_hash


إعادة تجزئة جديدة تحتوي على محتويات other_hash ومحتويات hsh. إذا لم تُحدد أي كتلة، ستكون قيمة العناصر ذات المفاتيح المُكررة هي نفسها من other_hash. وإلا تُحدَد قيمة كل مفتاح مكرر عن طريق استدعاء الكتلة مع المفتاح، وتكون قيمته في hsh وقيمته في other_hash.
===<code>[[Ruby/Hash/hash|hash]]</code>===
يحسب الشيفرة hash للكائن <code>[[Ruby/Hash|Hash]]</code> المستدعى معها.


أمثلة
===<code>[[Ruby/Hash/include-3F|include?‎]]</code>===
====<code>merge!(other_hash) → hsh</code>====
يعيد إذا كان مفتاحٌ معيَّن موجودًا في الكائن <code>[[Ruby/Hash|Hash]]</code> المعطى.
====<code>merge!(other_hash){|key, oldval, newval| block} → hsh</code>====
إضافة محتويات other_hash إلى hsh. إذا لم تُحدَد أي كتلة، يُكتب فوق الإدخالات ذات المفاتيح المكررة مع القيم من other_hash، وإلا تُحدَّد قيمة كل مفتاح مكرر عن طريق استدعاء الكتلة مع المفتاح وقيمته في hsh وقيمته في other_hash.


أمثلة
===<code>[[Ruby/Hash/inspect|inspect]]</code>===
====<code>rassoc(obj) → an_array or nil</code>====
يعيد محتوى الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه في سلسلة نصية.
البحث خلال التجزئة عن طريق مقارنة obj بالقيمة باستخدام ==. إعادة أول زوج القيمة-المفتاح (مصفوفة من عنصرين) يتطابق. راجع أيضًا Array#rassoc.


أمثلة
===<code>[[Ruby/Hash/invert|invert]]</code>===
====<code>rehash → hsh</code>====
يعيد كائن جديد من النوع <code>[[Ruby/Hash|Hash]]</code> يحوي قيم الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه كمفاتيح ومفاتيحه كقيم فيه.
إعادة بناء التجزئة استنادًا إلى قيم التجزئة الحالية لكل مفتاح. إذا تغيرت قيم كائنات المفاتيح منذ إدراجها، سيعيد هذا التابع فهرسة hsh. إذا اُستدعيَ Hash#rehash بينما يجتاز مُكرِّر التجزئة، سينطلق RuntimeError في المُكرِّر.


أمثلة
===<code>[[Ruby/Hash/keep_if|keep_if]]</code>===
يبقي كل زوج قيمة-مفتاح يحقق شرطًا معيَّنًا من أزواج الكائن <code>[[Ruby/Hash|Hash]]</code> المعطى.


====<code>reject {|key, value| block} → a_hash</code>====
===<code>[[Ruby/Hash/key|key]]</code>===
====<code>reject → an_enumerator</code>====
يعيد المفتاح المقابل لقيمة معيَّنة في الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه.
إعادة تجزئة جديدة تتكون من العناصر التي تعيد الكتلة لها false.


إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
===<code>[[Ruby/Hash/key-3F|key?‎]]</code>===
يتحقق إذا كان مفتاحٌ محدَّدٌ موجودًا في الكائن <code>[[Ruby/Hash|Hash]]</code> المستدعى معه.


أمثلة
===<code>[[Ruby/Hash/keys|keys]]</code>===
====<code>reject! {| key, value | block } → hsh or nil</code>====
يعيد مصفوفة جديدة تحوي مفاتيح الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه.
====<code>reject! → an_enumerator</code>====
يعادل Hash#delete_if، ولكن يُعيد nil إذا لم تُجرى أية تغييرات.


أمثلة
===<code>[[Ruby/Hash/length|length]]</code>===
====<code>replace(other_hash) → hsh</code>====
يعيد عدد الأزواج قيمة-مفتاح الموجودة في الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه.
استبدال محتويات hsh بمحتويات other_hash.


أمثلة
===<code>[[Ruby/Hash/member-3F|member?‎]]</code>===
====<code>select {|key, value| block} → a_hash</code>====
يتحقق إذا كان مفتاحٌ معيَّن موجودًا في الكائن <code>[[Ruby/Hash|Hash]]</code> المعطى.
====<code>select → an_enumerator</code>====
إعادة تجزئة جديدة تتكون من العناصر التي تعيد الكتلة لها true.


إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
===<code>[[Ruby/Hash/merge|merge]]</code>===
يدمج كائنين من النوع <code>[[Ruby/Hash|Hash]]</code> مع بعضهما بعضًا في كائن جديد من النوع <code>[[Ruby/Hash|Hash]]</code> ثم يعيده.


أمثلة
===<code>[[Ruby/Hash/merge!|merge!‎]]</code>===
====<code>select! {| key, value | block } → hsh or nil</code>====
يضيف محتويات الكائن <code>[[Ruby/Hash|Hash]]</code> الذي مُمرِّر إليه إلى الكائن الذي استدعي معه.
====<code>select! → an_enumerator</code>====
يعادل Hash#keep_if، ولكن يُعيد nil إذا لم تُجرى أية تغييرات.


أمثلة
===<code>[[Ruby/Hash/rassoc|rassoc]]</code>===
====<code>shift → anArray or obj</code>====
يبحث خلال الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه عن طريق مقارنة القيمة التي مُمرِّرت إليه مع قيم ذلك الكائن باستخدام المعامل <code>[[Ruby/Hash/equal|==]]</code> ثم يعيد أول زوج قيمة-مفتاح متطابق.
يزيل زوج القيمة-المفتاح من hsh ويقوم بإعادتها كمصفوفة من العنصرين [ key, value ]، أو القيمة الافتراضية للتجزئة إذا كانت التجزئة فارغة.


أمثلة
===<code>[[Ruby/Hash/rehash|rehash]]</code>===
====<code>size → integer</code>====
يعيد بناء الكائن <code>[[Ruby/Hash|Hash]]</code> استنادًا إلى القيم الحالية لكل مفتاح.
إعادة عدد أزواج القيمة-المفتاح في التجزئة.


أمثلة
===<code>[[Ruby/Hash/reject|reject]]</code>===
====<code>slice(*keys) → a_hash</code>====
يعيد كائن جديد من النوع <code>[[Ruby/Hash|Hash]]</code> يتكون من الأزواج التي ترفضها الكتلة المعطاة.
إعادة تجزئة تحتوي فقط على المفاتيح المُعطاة وقيمها.


أمثلة
===<code>[[Ruby/Hash/reject!|reject!‎]]</code>===
====<code>store(key, value) → value</code>====
يحذف الأزواج التي ترفضها الكتلة المعطاة من الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه. 
==تعيين عنصر==
يربط القيمة value المُعطاة مع المفتاح key المُعطي.


لا يجب تغيير قيمة key أثناء استخدامه كمفتاح (ستكرر السلاسل غير المجمدة unfrozen المُمررة كمفتاح وتُجمَّد).
===<code>[[Ruby/Hash/replace|replace]]</code>===
يُبدِّل محتويات الكائن المُمرَّر إليه مكان محتويات الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه.


أمثلة
===<code>[[Ruby/Hash/select|select]]</code>===
====<code>to_a → array</code>====
يعيد كائن جديد من النوع <code>[[Ruby/Hash|Hash]]</code> يتكون من العناصر التي تعيد الكتلة المعطاة معها القيمة <code>true</code>.
تحويل hsh إلى مصفوفة متداخلة من المصفوفات [ key, value ].


أمثلة
===<code>[[Ruby/Hash/select!|select!‎]]</code>===
يحذف الأزواج التي تقبلها الكتلة المعطاة من الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه. 


====<code>to_h → hsh or new_hash</code>====
===<code>[[Ruby/Hash/shift|shift]]</code>===
إعادة self. إذا استُدعي علي صنف فرعي من Hash، تحوِّل المُتلقي إلى كائن Hash.
يزيل زوجًا من قيمة-مفتاح من الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه ويعيده في مصفوفة، أو يعيد القيمة الافتراضية لهذا الكائن إذا كان فارغًا.


أمثلة
===<code>[[Ruby/Hash/size|size]]</code>===
يعيد عدد الأزواج القيمة-المفتاح الموجودة في الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه.


====<code>to_hash => hsh</code>====
===<code>[[Ruby/Hash/slice|slice]]</code>===
إعادة self.
يعيد كائنًا من النوع <code>[[Ruby/Hash|Hash]]</code> يحتوي فقط على مفاتيح محدَّدة وقيمها.


أمثلة
===<code>[[Ruby/Hash/store|store]]</code>===
يربط قيمة محددة مع مفتاح محدد في الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه.


<code>to_proc()‎</code>
===<code>[[Ruby/Hash/to_a|to_a]]</code>===
====<code>to_s()‎</code>====
يحول الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه إلى مصفوفة متشعبة من المصفوفات <code>[ key, value ]</code>.
اسم المستعار لـ inspect


أمثلة
===<code>[[Ruby/Hash/to_h|to_h]]</code>===
يعيد الكائن [[Ruby/Hash|<code>Hash</code>]] المعطى نفسه. إذا استُدعي على صنف فرعي من <code>[[Ruby/Hash|Hash]]</code>، فستحوِّل المستقبل إلى كائن من النوع <code>[[Ruby/Hash|Hash]]</code>.


====<code>transform_keys {|key| block } → new_hash</code>====
===<code>[[Ruby/Hash/to_hash|to_hash]]</code>===
====<code>transform_keys → an_enumerator</code>====
يعيد الكائن [[Ruby/Hash|<code>Hash</code>]] المعطى نفسه.
إعادة تجزئة جديدة مع نتائج تشغيل الكتلة مرة واحدة لكل مفتاح. لا يُغيّر هذا التابع القيم.


إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
===<code>[[Ruby/Hash/to_proc|to_proc]]</code>===
===<code>[[Ruby/Hash/to_s|to_s]]</code>===
يعيد محتوى الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه في سلسلة نصية.


أمثلة
===<code>[[Ruby/Hash/transform_keys|transform_keys]]</code>===
يعيد كائن جديد من النوع <code>[[Ruby/Hash|Hash]]</code> مع ناتج تنفيذ الكتلة المعطاة مرةً واحدةً لكل مفتاح من مفاتيح الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه.


====<code>transform_keys! {|key| block } → hsh</code>====
===<code>[[Ruby/Hash/transform_keys!|transform_keys!‎]]</code>===
====<code>transform_keys! → an_enumerator</code>====
يستدعي الكتلة المعطاة مرةً واحدةً لكل مفتاح من مفاتيح الكائن [[Ruby/Hash|<code>Hash</code>]] المعطى، ويستبدل به المفتاح الجديد الذي تعيده الكتلة، ثم يعيد هذا الكائن.
استدعاء الكتلة المعطاة مرة واحدة لكل مفتاح في hsh، واستبداله بالمفتاح الجديد الذي تعيده الكتلة، ثم تُعيد hsh. لا يُغيّر هذا التابع القيم.


إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
===<code>[[Ruby/Hash/transform_values|transform_values]]</code>===
يعيد كائن جديد من النوع <code>[[Ruby/Hash|Hash]]</code> مع ناتج تنفيذ الكتلة المعطاة مرةً واحدةً لكل قيمة من قيم الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه.


أمثلة
===<code>[[Ruby/Hash/transform_values!|transform_values!‎]]</code>===
====<code>transform_values {|value| block } → new_hash</code>====
يستدعي الكتلة المعطاة مرةً واحدةً لكل قيمة من قيم الكائن [[Ruby/Hash|<code>Hash</code>]] المعطى، ويستبدل به القيمة الجديد التي تعيدها الكتلة، ثم يعيد هذا الكائن. لا يُغيّر هذا التابع المفاتيح.
====<code>transform_values → an_enumerator</code>====
إعادة تجزئة جديدة مع نتائج تشغيل الكتلة مرة واحدة لكل قيمة. لا يُغيّر هذا التابع المفاتيح.


إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
===<code>[[Ruby/Hash/update|update]]</code>===
يضيف محتويات الكائن المُمرَّر إليه إلى الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه.


أمثلة
===<code>[[Ruby/Hash/value-3F|value?‎]]</code>===
====<code>transform_values! {|value| block } → hsh</code>====
يتحقق إذا كانت القيمة المُمرَّرة إليه موجودةً ومرتبطةً بمفتاح ما في الكائن <code>[[Ruby/Hash|Hash]]</code> المعطى.
====<code>transform_values! → an_enumerator</code>====
استدعاء الكتلة المعطاة مرة واحدة لكل قيمة في hsh، واستبداله بالقيمة الجديدة التي تعيدها الكتلة، ثم تُعيد hsh. لا يُغيّر هذا التابع المفاتيح.


إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
===<code>[[Ruby/Hash/values|values]]</code>===
يعيد مصفوفة جديدة تحوي قيم الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه.


أمثلة
===<code>[[Ruby/Hash/values_at|values_at]]</code>===
====<code>update(other_hash) → hsh</code>====
يعيد مصفوفةً تحتوي على القيم المرتبطة بمفاتيح محدَّدة من الكائن <code>[[Ruby/Hash|Hash]]</code> الذي استدعي معه.
====<code>update(other_hash){|key, oldval, newval| block} → hsh</code>====
إضافة محتويات other_hash إلى hsh. إذا لم تُحدَد أي كتلة، يُكتب فوق الإدخالات ذات المفاتيح المكررة مع القيم من other_hash، وإلا تُحدَّد قيمة كل مفتاح مكرر عن طريق استدعاء الكتلة مع المفتاح وقيمته في hsh وقيمته في other_hash.


أمثلة
== ملاحظات إضافية ==
====<code>value?(value) → true or false</code>====
تأتي بعض التوابع التي يستخدمها البعض مع الكائن <code>Hash</code> من الوحدة <code>[[Ruby/Enumerable|Enumerable]]</code>.
إعادة true إذا كانت القيمة المُعطاة موجودة لمفتاح ما في hsh.


أمثلة
إذا لم تعثر على ما تبحث عنه في هذا التوثيق، فاطلع على توثيق <code>[[Ruby/Enumerable|Enumerable]]</code>.
====<code>values → array</code>====
إعادة مصفوفة جديدة ممتلئة بالقيم من hsh. راجع أيضًا Hash#keys.


أمثلة
====<code>values_at(key, ...) → arrayclick to toggle source</code>====
إعادة مصفوفة تحتوي على القيم المرتبطة بالمفاتيح المُعطاة. راجع أيضًا Hash.select.
=مصادر=
=مصادر=
* <span> </span><span> </span>[http://ruby-doc.org/core-2.5.1/Hash.html صفحة Hash في توثيق روبي الرسمي.]
* <span> </span>[http://ruby-doc.org/core-2.5.1/Hash.html صفحة الصنف Hash في توثيق روبي الرسمي.]
[[تصنيف:Ruby]]
[[تصنيف:Ruby]]
[[تصنيف:Ruby Class]]
[[تصنيف:Ruby Hash]]

المراجعة الحالية بتاريخ 07:32، 13 يناير 2019

النوع Hash (أو الجدول Hash كما يطلق عليه أحيانًا) هو مجموعة تشبه القاموس ويتكون من مفاتيح فريدة وقيم مرتبطة بها. كما يسمى أيضًا المصفوفات الترابطية، فهو يشبه المصفوفات، ولكن بينما تستخدم المصفوفة فقط الأعداد الصحيحة كفهرس، يسمح النوع Hash باستخدام أيٍّ من أنواع الكائنات لاستعمالها كفهرس وربطها بقيمٍ.

ترتَّب وتحصى القيم في النوع Hash بنفس الترتيب الذي أُدرِجت فيه مفاتيحها المقابلة.

يمكن إنشاء جدول Hash بسهولة باستخدام شكله الصريح:

grades = { "Jane Doe" => 10, "Jim Doe" => 6 }

يسمح الجدول Hash باستعمال الرموز كصيغة بديلة للمفاتيح. انظر مثلًا إلى المثال التالي:

options = { :font_size => 10, :font_family => "Arial" }

و يمكن أن تُكتب أيضًا بالشكل التالي:

options = { font_size: 10, font_family: "Arial" }

كل مفتاح مُسمَّى هو رمز يمكن الوصول إليه في الجدول Hash:

options[:font_size]  # => 10

ويمكن أيضا أن إنشاء جدول Hash من خلال التابع ‎new:

grades = Hash.new
grades["Dorothy Doe"] = 9

تملك الجداول Hash قيمةً افتراضيةً تُعاد عند الوصول إلى مفاتيح غير موجودة. إذا لم تُعيَّن قيمة افتراضية، فستُستخدم القيمة nil. ويمكن تعيين القيمة الافتراضية بتمريرها إلى ‎new:

grades = Hash.new(0)

أو باستخدام التابع default‎:

grades = {"Timmy Doe" => 8}
grades.default = 0

يتطلب الوصول إلى قيمة ما في الجدول Hash استخدام مفتاحها:

puts grades["Jane Doe"] # => 0

استخدامات شائعة

يعد النوع Hash طريقةً سهلةً لتمثيل هياكل البيانات مثل:

books         = {}
books[:matz]  = "The Ruby Programming Language"
books[:black] = "The Well-Grounded Rubyist"

كما يشيع استخدام النوع Hash كطريقة للحصول على معاملات مسماة في الدوال. لاحظ أنَّه لا توجد أقواس مستخدمة في المثال في الأسفل. إذا كان النوع Hash هو الوسيط الأخير في استدعاء تابع، فلا يلزم استخدام أقواس، وبالتالي يمكن إنشاء واجهة مُرتَّبة جدًا:

Person.create(name: "John Doe", age: 27)

def self.create(params)
  @name = params[:name]
  @age  = params[:age]
end

المفاتيح في النوع Hash

يُشير كائنان إلى نفس المفتاح في الجدول Hash عندما تكون القيمة المرتبطة بأحدهما مماثلة ومساوية للقيمة المرتبطة بالمفتاح الآخر.

قد يُستخدَم صنف معرف من قِبَل المستخدم كمفتاح إذا استُبدِل التابعَيْن 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[]‎

ينشئ جدول Hash جديد ويضع فيه الكائنات المعطاة.

new

ينشئ جدول Hash جديد فارغ ثم يعيده.

try_convert

يحاول تحويل الكائن المُمرَّر إليه إلى النوع Hash باستخدام التابعto_hash. 

توابع النسخة العامة

>

يعيد القيمة true إذا كان الكائن Hash الواقع على يساره مجموعةً فرعيةً من الكائن الواقع على يمينه.

=>

يعيد القيمة true إذا كان الكائن Hash الواقع على يساره مجموعةً فرعيةً من الكائن الواقع على يمينه أو يساويه تمامًا.

==

يتحقق من تساوي كائنين من النوع Hash.

<

يعيد القيمة true إذا كان الكائن الواقع على يمينه مجموعةً فرعيةً من الكائن الواقع على يساره.

=<

يعيد المعامل =< القيمة true إذا كان الكائن الواقع على يمينه مجموعةً فرعيةً من الكائن الواقع على يساره أو يساويه تمامًا.

[]

يجلب القيمة المقابلة لمفتاح معين في الجدول Hash المعطى.

=[]

يربط عند استدعائه بالشكل hsh[key] = value القيمة value المعطاة بالمفتاحkey في الجدول Hash.

any?‎

يمرر كل زوج من مفتاح/قيمة من أزواج الكائن Hash المعطى إلى كتلة معينة ثم يعيد القيمة true إن أعادت الكتلة قيمة غير القيمة false أو nil.

assoc

يبحث ضمن الكائن Hash عن طريق موازنة الكائن المُمرَّر إليه بمفاتيحه باستخدام المعامل == ثم يعيد الزوج قيمة-مفتاح (مصفوفة من عنصرين) أو nil إذا لم يعثر على أي تطابق.

clear

يزيل جميع الأزواج قيمة-مفتاح من الكائن Hash الذي استدعي معه.

compact

يعيد كائن Hash جديد يحوي جميع الأزواج قيم/مفاتيح للكائن الذي استدعي معه باستثناء الأزواج المعدومة (أي ذات القيمة nil).

compact!

يزيل جميع الأزواج قيمة/مفتاح المعدومة (أي ذات القيمة nil) من الكائن الذي استدعي معه.

compare_by_identity

يجعل الكائن Hash يقارن مفاتيحه بواسطة مُعرِّفاتها، أي أنَّها سوف تُعدُّ نفس الكائنات على أنَّها نفس المفاتيح.

compare_by_identity?‎

يتحقق إذا كان الكائن Hash الذي استدعي معه سيقارن مفاتيحه بواسطة مُعرِّفاتهم.

default

يعيد القيمة الافتراضية للمفتاح المُمرَّر إليه؛ أي يعيد القيمة التي سيعيدها الكائنHash إذا كان المفتاح غير موجود فيه.

=default

يضبط عند استدعائه بالشكل default = obj القيمة الافتراضية obj وهي القيمة التي ستُعاد لمفتاح غير موجود في الكائن Hash.

default_proc

يعيد الكتلة التي استُدعي التابع new معها عند إنشاء الكائن Hashالمعطى، وإلا سيُعيد القيمة nil.

=default_proc

يضبط إن استدعي بالشكل default_proc = proc_obj القيمة الافتراضية للكتلة التي ستُنفَّذ عند فشل أية عملية بحث عن مفتاح للكائن Hash المعطى.

delete

يحذف زوجًا ذا مفتاح محدَّد ويعيد قيمته من الكائن Hash الذي استدعي معه.

delete_if

يحذف كل زوج قيمة-مفتاح يحقق شرطًا معيَّنًا من أزواج الكائن Hash المعطى.

dig

يستخرج القيمة المتداخلة المحددة بواسطة تسلسل كائنات تمثِّل المفاتيح عن طريق استدعاء dig في كل خطوة، ويعيد القيمة nil إذا كانت أي خطوة متوسطة هي nil.

each

يستدعي الكتلة المعطاة مرةً واحدةً لكل مفتاح من مفاتيح أزواج الكائن Hash الذي استدعي معه بعد تمرير مفتاح وقيمة الأزواج إليها.

each_key

يستدعي الكتلة المعطاة مرةً واحدةً لكل مفتاح من مفاتيح أزواج الكائن Hash الذي استدعي معه بعد تمرير مفتاح كل زوج إليها.

each_pair

يستدعي الكتلة المعطاة مرةً واحدةً لكل مفتاح من مفاتيح أزواج الكائن Hash الذي استدعي معه بعد تمرير مفتاح وقيمة الأزواج إليها.

each_value

يستدعي الكتلة المعطاة مرةً واحدةً لكل مفتاح من مفاتيح أزواج الكائن Hash الذي استدعي معه بعد تمرير قيمة كل زوج إليها.

empty?‎

يتحقق إذا كان الكائن Hash الذي استدعي معه فارغًا أي لا يحتوي على أية أزواج.

eql?‎

يتحقق إذا كان كائنان من نفس النوع (النوع Hash) ولهما نفس المحتوى. لا يؤخذ ترتيب الأزواج بالحسبان.

fetch

يعيد قيمة من الكائن Hash لمفتاح معين.

fetch_values

يعيد مصفوفة تحتوي على القيم المقترنة بالمفاتيح المعطاة.

flatten

يعيد مصفوفة جديدة والتي تكون تسطيح أحادي الأبعاد للكائن Hash الذي استدعي معه.

has_key?‎

يتحقق إذا كان مفتاحٌ معيَّن موجودًا في الكائن Hash المعطى.

has_value?‎

يعيد إذا كانت قيمةٌ معيَّنةٌ موجودةً في الكائن Hash المعطى ومرتبطة بمفتاح.

hash

يحسب الشيفرة hash للكائن Hash المستدعى معها.

include?‎

يعيد إذا كان مفتاحٌ معيَّن موجودًا في الكائن Hash المعطى.

inspect

يعيد محتوى الكائن Hash الذي استدعي معه في سلسلة نصية.

invert

يعيد كائن جديد من النوع Hash يحوي قيم الكائن Hash الذي استدعي معه كمفاتيح ومفاتيحه كقيم فيه.

keep_if

يبقي كل زوج قيمة-مفتاح يحقق شرطًا معيَّنًا من أزواج الكائن Hash المعطى.

key

يعيد المفتاح المقابل لقيمة معيَّنة في الكائن Hash الذي استدعي معه.

key?‎

يتحقق إذا كان مفتاحٌ محدَّدٌ موجودًا في الكائن Hash المستدعى معه.

keys

يعيد مصفوفة جديدة تحوي مفاتيح الكائن Hash الذي استدعي معه.

length

يعيد عدد الأزواج قيمة-مفتاح الموجودة في الكائن Hash الذي استدعي معه.

member?‎

يتحقق إذا كان مفتاحٌ معيَّن موجودًا في الكائن Hash المعطى.

merge

يدمج كائنين من النوع Hash مع بعضهما بعضًا في كائن جديد من النوع Hash ثم يعيده.

merge!‎

يضيف محتويات الكائن Hash الذي مُمرِّر إليه إلى الكائن الذي استدعي معه.

rassoc

يبحث خلال الكائن Hash الذي استدعي معه عن طريق مقارنة القيمة التي مُمرِّرت إليه مع قيم ذلك الكائن باستخدام المعامل == ثم يعيد أول زوج قيمة-مفتاح متطابق.

rehash

يعيد بناء الكائن Hash استنادًا إلى القيم الحالية لكل مفتاح.

reject

يعيد كائن جديد من النوع Hash يتكون من الأزواج التي ترفضها الكتلة المعطاة.

reject!‎

يحذف الأزواج التي ترفضها الكتلة المعطاة من الكائن Hash الذي استدعي معه. 

replace

يُبدِّل محتويات الكائن المُمرَّر إليه مكان محتويات الكائن Hash الذي استدعي معه.

select

يعيد كائن جديد من النوع Hash يتكون من العناصر التي تعيد الكتلة المعطاة معها القيمة true.

select!‎

يحذف الأزواج التي تقبلها الكتلة المعطاة من الكائن Hash الذي استدعي معه. 

shift

يزيل زوجًا من قيمة-مفتاح من الكائن Hash الذي استدعي معه ويعيده في مصفوفة، أو يعيد القيمة الافتراضية لهذا الكائن إذا كان فارغًا.

size

يعيد عدد الأزواج القيمة-المفتاح الموجودة في الكائن Hash الذي استدعي معه.

slice

يعيد كائنًا من النوع Hash يحتوي فقط على مفاتيح محدَّدة وقيمها.

store

يربط قيمة محددة مع مفتاح محدد في الكائن Hash الذي استدعي معه.

to_a

يحول الكائن Hash الذي استدعي معه إلى مصفوفة متشعبة من المصفوفات [ key, value ].

to_h

يعيد الكائن Hash المعطى نفسه. إذا استُدعي على صنف فرعي من Hash، فستحوِّل المستقبل إلى كائن من النوع Hash.

to_hash

يعيد الكائن Hash المعطى نفسه.

to_proc

to_s

يعيد محتوى الكائن Hash الذي استدعي معه في سلسلة نصية.

transform_keys

يعيد كائن جديد من النوع Hash مع ناتج تنفيذ الكتلة المعطاة مرةً واحدةً لكل مفتاح من مفاتيح الكائن Hash الذي استدعي معه.

transform_keys!‎

يستدعي الكتلة المعطاة مرةً واحدةً لكل مفتاح من مفاتيح الكائن Hash المعطى، ويستبدل به المفتاح الجديد الذي تعيده الكتلة، ثم يعيد هذا الكائن.

transform_values

يعيد كائن جديد من النوع Hash مع ناتج تنفيذ الكتلة المعطاة مرةً واحدةً لكل قيمة من قيم الكائن Hash الذي استدعي معه.

transform_values!‎

يستدعي الكتلة المعطاة مرةً واحدةً لكل قيمة من قيم الكائن Hash المعطى، ويستبدل به القيمة الجديد التي تعيدها الكتلة، ثم يعيد هذا الكائن. لا يُغيّر هذا التابع المفاتيح.

update

يضيف محتويات الكائن المُمرَّر إليه إلى الكائن Hash الذي استدعي معه.

value?‎

يتحقق إذا كانت القيمة المُمرَّرة إليه موجودةً ومرتبطةً بمفتاح ما في الكائن Hash المعطى.

values

يعيد مصفوفة جديدة تحوي قيم الكائن Hash الذي استدعي معه.

values_at

يعيد مصفوفةً تحتوي على القيم المرتبطة بمفاتيح محدَّدة من الكائن Hash الذي استدعي معه.

ملاحظات إضافية

تأتي بعض التوابع التي يستخدمها البعض مع الكائن Hash من الوحدة Enumerable.

إذا لم تعثر على ما تبحث عنه في هذا التوثيق، فاطلع على توثيق Enumerable.

مصادر

مجلوبة من «https://wiki.hsoub.com/index.php?title=Ruby/Hash&oldid=27170»