Ruby/Hash

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

تُرقِّم التجزئات قيمَها بنفس الترتيب الذي أُدرِجت فيه مفاتيحها المقابلة.

يمكن أن تُنشأ Hash بسهولة باستخدام شكلها الضمني:

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

تسمح التجزئات بصياغة بديلة للمفاتيح التي تكون رموزًا. بدلًا من

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[ 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 {|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

تعيين عنصر

ربط القيمة 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) {| 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 → an_enumerator

حذف كل أزواج القيمة-المفتاح من hsh التي تُقيَّم لها block بالقيمة true.

إذا لم تُعطَى block، يُعاد عدَّاد بدلًا من ذلك.

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

أمثلة

 
               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;
}

dig(key, ...) → object

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

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

أمثلة

 
               VALUE
rb_hash_dig(int argc, VALUE *argv, VALUE self)
{
    rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
    self = rb_hash_aref(self, *argv);
    if (!--argc) return self;
    ++argv;
    return rb_obj_dig(argc, argv, self, Qnil);
}

each_pair → an_enumerator

استدعاء block مرة واحدة لكل مفتاح في hsh، وتمرير زوج القيمة-المفتاح كمعاملات.

إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.

h = { "a" => 100, "b" => 200 }
h.each {|key, value| puts "#{key} is #{value}" }

يُنتِج:

a is 100
b is 200

أمثلة

 
               static VALUE
rb_hash_each_pair(VALUE hash)
{
    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    if (rb_block_arity() > 1)
        rb_hash_foreach(hash, each_pair_i_fast, 0);
    else
        rb_hash_foreach(hash, each_pair_i, 0);
    return hash;
}

each_key → an_enumerator

استدعاء block مرة واحدة لكل مفتاح في hsh، وتمرير المفتاح كمعامل.

إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.

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

يُنتِج:

a
b

أمثلة

 
               static VALUE
rb_hash_each_key(VALUE hash)
{
    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    rb_hash_foreach(hash, each_key_i, 0);
    return hash;
}

each_pair → an_enumerator

استدعاء block مرة واحدة لكل مفتاح في hsh، وتمرير زوج القيمة-المفتاح كمعاملات.

إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.

h = { "a" => 100, "b" => 200 }
h.each {|key, value| puts "#{key} is #{value}" }

يُنتِج:

a is 100
b is 200

أمثلة

 
               static VALUE
rb_hash_each_pair(VALUE hash)
{
    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    if (rb_block_arity() > 1)
        rb_hash_foreach(hash, each_pair_i_fast, 0);
    else
        rb_hash_foreach(hash, each_pair_i, 0);
    return hash;
}

each_value → an_enumerator

استدعاء block مرة واحدة لكل مفتاح في hsh، وتمرير المفتاح كمعامل.

إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.

h = { "a" => 100, "b" => 200 }
h.each_value {|value| puts value }

يُنتِج:

100
200

أمثلة

 
               static VALUE
rb_hash_each_value(VALUE hash)
{
    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    rb_hash_foreach(hash, each_value_i, 0);
    return hash;
}

empty? → true or false

إعادة true إذا كانت hsh لا تحتوي على أزواج القيمة-المفتاح.

{}.empty?   #=> true

أمثلة

 
               static VALUE
rb_hash_empty_p(VALUE hash)
{
    return RHASH_EMPTY_P(hash) ? Qtrue : Qfalse;
}

eql?(other) → true or false

إعادة true إذا كان كلٌ من hash و other تجزئتين بنفس المحتوى. لا يقارن ترتيب كل التجزئات.

أمثلة

 
               static VALUE
rb_hash_eql(VALUE hash1, VALUE hash2)
{
    return hash_equal(hash1, hash2, TRUE);
}

fetch(key) {| key | block } → obj

إعادة قيمة من التجزئة لمفتاح معين. إذا كان المفتاح غير موجود، هناك عدة خيارات: مع عدم وجود وسائط أخرى، سيُجرى استثناء KeyError، إذا أُعطيَ default، ستُعاد هذه إذا حُدِدت كتلة الشيفرة البرمجية الاختيارية، ثم ستُنفَّذ وتُعاد نتيجتها.

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"

يُظهِر المثال التالي إجراء استثناء إذا كان المفتاح غير موجود ولم تُعطى قيمة افتراضية.

h = { "a" => 100, "b" => 200 }
h.fetch("z")

يُنتِج:

prog.rb:2:in `fetch': key not found (KeyError)
 from prog.rb:2

أمثلة

 
               static VALUE
rb_hash_fetch_m(int argc, VALUE *argv, VALUE hash)
{
    VALUE key;
    st_data_t val;
    long block_given;

    rb_check_arity(argc, 1, 2);
    key = argv[0];

    block_given = rb_block_given_p();
    if (block_given && argc == 2) {
        rb_warn("block supersedes default value argument");
    }
    if (!RHASH(hash)->ntbl || !st_lookup(RHASH(hash)->ntbl, key, &val)) {
        if (block_given) return rb_yield(key);
        if (argc == 1) {
            VALUE desc = rb_protect(rb_inspect, key, 0);
            if (NIL_P(desc)) {
                desc = rb_any_to_s(key);
            }
            desc = rb_str_ellipsize(desc, 65);
            rb_key_err_raise(rb_sprintf("key not found: %"PRIsVALUE, desc), hash, key);
        }
        return argv[1];
    }
    return (VALUE)val;
}

fetch_values(key, ...) { |key| block } → array

إعادة مصفوفة تحتوي على القيم المقترنة بالمفاتيح المعطاة ولكن تُجرى أيضًا KeyError عند تعذر العثور على أحد المفاتيح. راجع أيضًا Hash#values_at و Hash#fetch.

h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }

h.fetch_values("cow", "cat")                   #=> ["bovine", "feline"]
h.fetch_values("cow", "bird")                  # raises KeyError
h.fetch_values("cow", "bird") { |k| k.upcase } #=> ["bovine", "BIRD"]

أمثلة

 
               VALUE
rb_hash_fetch_values(int argc, VALUE *argv, VALUE hash)
{
    VALUE result = rb_ary_new2(argc);
    long i;

    for (i=0; i<argc; i++) {
        rb_ary_push(result, rb_hash_fetch(hash, argv[i]));
    }
    return result;
}

flatten(level) → an_array

إعادة مصفوفة جديدة والتي تكون تسطيح أحادي الأبعاد لهذا التجزئة. أي أن لكل مفتاح أو قيمة تكون مصفوفة، تستخرج عناصرها إلى مصفوفة جديدة. على عكس Array#flatten، لا يُسطِّح هذا التابع بشكل عَودي افتراضيًا. يُحدد الوسيط الاختياري level مستوى عودية التسطح.

a =  {1=> "one", 2 => [2,"two"], 3 => "three"}
a.flatten    # => [1, "one", 2, [2, "two"], 3, "three"]
a.flatten(2) # => [1, "one", 2, 2, "two", 3, "three"]

أمثلة

 
               static VALUE
rb_hash_flatten(int argc, VALUE *argv, VALUE hash)
{
    VALUE ary;

    rb_check_arity(argc, 0, 1);

    if (argc) {
        int level = NUM2INT(argv[0]);

        if (level == 0) return rb_hash_to_a(hash);

        ary = rb_ary_new_capa(RHASH_SIZE(hash) * 2);
        rb_hash_foreach(hash, flatten_i, ary);
        level--;

        if (level > 0) {
            VALUE ary_flatten_level = INT2FIX(level);
            rb_funcallv(ary, id_flatten_bang, 1, &ary_flatten_level);
        }
        else if (level < 0) {
            /* flatten recursively */
            rb_funcallv(ary, id_flatten_bang, 0, 0);
        }
    }
    else {
        ary = rb_ary_new_capa(RHASH_SIZE(hash) * 2);
        rb_hash_foreach(hash, flatten_i, ary);
    }

    return ary;
}

has_key?(key) → true or false

إعادة true إذا كان مفتاح معين موجود في hsh.

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

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

راجع أيضًا Enumerable#include?‎

أمثلة

               VALUE
rb_hash_has_key(VALUE hash, VALUE key)
{
    if (!RHASH(hash)->ntbl)
        return Qfalse;
    if (st_lookup(RHASH(hash)->ntbl, key, 0)) {
        return Qtrue;
    }
    return Qfalse;
}

has_value?(value) → true or false

إعادة true إذا كانت القيمة المُعطاة موجودة لمفتاح ما في hsh.

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

أمثلة

 
               static VALUE
rb_hash_has_value(VALUE hash, VALUE val)
{
    VALUE data[2];

    data[0] = Qfalse;
    data[1] = val;
    rb_hash_foreach(hash, rb_hash_search_value, (VALUE)data);
    return data[0];
}

hash → integer

حساب رمز التجزئة لهذه التجزئة. سيكون لتجزئتين لهما نفس المحتوى نفس رمز التجزئة (وستقارن باستخدام eql?‎).

راجع أيضًا Object#hash.

أمثلة

 
               static VALUE
rb_hash_hash(VALUE hash)
{
    st_index_t size = RHASH_SIZE(hash);
    st_index_t hval = rb_hash_start(size);
    hval = rb_hash_uint(hval, (st_index_t)rb_hash_hash);
    if (size) {
        rb_hash_foreach(hash, hash_i, (VALUE)&hval);
    }
    hval = rb_hash_end(hval);
    return ST2FIX(hval);
}

include?(key) → true or false

إعادة true إذا كان مفتاح معين موجود في hsh.

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

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

راجع أيضًا Enumerable#include?‎

أمثلة

 
               VALUE
rb_hash_has_key(VALUE hash, VALUE key)
{
    if (!RHASH(hash)->ntbl)
        return Qfalse;
    if (st_lookup(RHASH(hash)->ntbl, key, 0)) {
        return Qtrue;
    }
    return Qfalse;
}

inspect → string

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

h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
h.to_s   #=> "{\"c\"=>300, \"a\"=>100, \"d\"=>400}"

ويُعيَّن له أيضًا الاسم المستعار: to_s. أمثلة

 
               static VALUE
rb_hash_inspect(VALUE hash)
{
    if (RHASH_EMPTY_P(hash))
        return rb_usascii_str_new2("{}");
    return rb_exec_recursive(inspect_hash, hash, 0);
}

invert → new_hash

إعادة تجزئة جديدة مُنشأة باستخدام قيم hsh كمفاتيح والمفاتيح كقيم. إذا وُجِد بالفعل مفتاح بنفس القيمة في hsh، سيستخدم آخر واحد مُعرَّف، وستُتجاهل القيم السابقة.

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

إذا لم يكن هناك مفتاح بنفس القيمة، تكون ‎#invert ذاتية الانعكاس (involutive).

h = { a: 1, b: 3, c: 4 }
h.invert.invert == h #=> true

الشرط، ألا يوجد مفتاح بنفس القيمة، ويمكن اختباره بمقارنة حجم التجزئة المقلوبة.

# no key with the same value
h = { a: 1, b: 3, c: 4 }
h.size == h.invert.size #=> true

# two (or more) keys has the same value
h = { a: 1, b: 3, c: 1 }
h.size == h.invert.size #=> false

أمثلة

              static VALUE
rb_hash_invert(VALUE hash)
{
    VALUE h = rb_hash_new_with_size(RHASH_SIZE(hash));

    rb_hash_foreach(hash, rb_hash_invert_i, h);
    return h;
}

keep_if → an_enumerator

حذف كل أزواج القيمة-المفتاح من hsh والتي تقيَّم لها block بالقيمة false.

إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.

أمثلة

               VALUE
rb_hash_keep_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, keep_if_i, hash);
    return hash;
}

key(value) → key

إعادة مفتاح تواجد قيمة معينة. ويُعيد nil إذا كانت القيمة غير موجود.

h = { "a" => 100, "b" => 200, "c" => 300, "d" => 300 }
h.key(200)   #=> "b"
h.key(300)   #=> "c"
h.key(999)   #=> nil

أمثلة

               static VALUE
rb_hash_key(VALUE hash, VALUE value)
{
    VALUE args[2];

    args[0] = value;
    args[1] = Qnil;

    rb_hash_foreach(hash, key_i, (VALUE)args);

    return args[1];
}

key?(key) → true or false

إعادة true إذا كان مفتاح معين موجود في hsh.

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

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

راجع أيضًا Enumerable#include?‎.

أمثلة

 
               VALUE
rb_hash_has_key(VALUE hash, VALUE key)
{
    if (!RHASH(hash)->ntbl)
        return Qfalse;
    if (st_lookup(RHASH(hash)->ntbl, key, 0)) {
        return Qtrue;
    }
    return Qfalse;
}

keys → array

إعادة مصفوفة جديدة ممتلئة بالمفاتيح من هذه التجزئة. راجع أيضًا Hash#values.

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

أمثلة

 
               VALUE
rb_hash_keys(VALUE hash)
{
    VALUE keys;
    st_index_t size = RHASH_SIZE(hash);

    keys = rb_ary_new_capa(size);
    if (size == 0) return keys;

    if (ST_DATA_COMPATIBLE_P(VALUE)) {
        st_table *table = RHASH(hash)->ntbl;

        rb_gc_writebarrier_remember(keys);
        RARRAY_PTR_USE(keys, ptr, {
            size = st_keys(table, ptr, size);
        });
        rb_ary_set_len(keys, size);
    }
    else {
        rb_hash_foreach(hash, keys_i, keys);
    }

    return keys;
}

length → integer

إعادة عدد أزواج القيمة-المفتاح في التجزئة.

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

أمثلة

 
               VALUE
rb_hash_size(VALUE hash)
{
    return INT2FIX(RHASH_SIZE(hash));
}

member?(key) → true or false

إعادة true إذا كان مفتاح معين موجود في hsh.

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

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

راجع أيضًا Enumerable#include?‎.

أمثلة

 
               VALUE
rb_hash_has_key(VALUE hash, VALUE key)
{
    if (!RHASH(hash)->ntbl)
        return Qfalse;
    if (st_lookup(RHASH(hash)->ntbl, key, 0)) {
        return Qtrue;
    }
    return Qfalse;
}

merge(other_hash) → new_hash

merge(other_hash){|key, oldval, newval| block} → new_hash

إعادة تجزئة جديدة تحتوي على محتويات other_hash ومحتويات hsh. إذا لم تُحدد أي كتلة، ستكون قيمة العناصر ذات المفاتيح المُكررة هي نفسها من other_hash. وإلا تُحدَد قيمة كل مفتاح مكرر عن طريق استدعاء الكتلة مع المفتاح، وتكون قيمته في hsh وقيمته في other_hash.

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 254, "c" => 300 }
h1.merge(h2)   #=> {"a"=>100, "b"=>254, "c"=>300}
h1.merge(h2){|key, oldval, newval| newval - oldval}
               #=> {"a"=>100, "b"=>54,  "c"=>300}
h1             #=> {"a"=>100, "b"=>200}

أمثلة

 
               static VALUE
rb_hash_merge(VALUE hash1, VALUE hash2)
{
    return rb_hash_update(rb_hash_dup(hash1), hash2);
}

merge!(other_hash){|key, oldval, newval| block} → hsh

إضافة محتويات other_hash إلى hsh. إذا لم تُحدَد أي كتلة، يُكتب فوق الإدخالات ذات المفاتيح المكررة مع القيم من other_hash، وإلا تُحدَّد قيمة كل مفتاح مكرر عن طريق استدعاء الكتلة مع المفتاح وقيمته في hsh وقيمته في other_hash.

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 254, "c" => 300 }
h1.merge!(h2)   #=> {"a"=>100, "b"=>254, "c"=>300}
h1              #=> {"a"=>100, "b"=>254, "c"=>300}

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 254, "c" => 300 }
h1.merge!(h2) { |key, v1, v2| v1 }
                #=> {"a"=>100, "b"=>200, "c"=>300}
h1              #=> {"a"=>100, "b"=>200, "c"=>300}

أمثلة

 
               static VALUE
rb_hash_update(VALUE hash1, VALUE hash2)
{
    rb_hash_modify(hash1);
    hash2 = to_hash(hash2);
    if (rb_block_given_p()) {
        rb_hash_foreach(hash2, rb_hash_update_block_i, hash1);
    }
    else {
        rb_hash_foreach(hash2, rb_hash_update_i, hash1);
    }
    return hash1;
}

rassoc(obj) → an_array or nil

البحث خلال التجزئة عن طريق مقارنة obj بالقيمة باستخدام ==. إعادة أول زوج القيمة-المفتاح (مصفوفة من عنصرين) يتطابق. راجع أيضًا Array#rassoc.

a = {1=> "one", 2 => "two", 3 => "three", "ii" => "two"}
a.rassoc("two")    #=> [2, "two"]
a.rassoc("four")   #=> nil

أمثلة

 
               VALUE
rb_hash_rassoc(VALUE hash, VALUE obj)
{
    VALUE args[2];

    args[0] = obj;
    args[1] = Qnil;
    rb_hash_foreach(hash, rassoc_i, (VALUE)args);
    return args[1];
}

rehash → hsh

إعادة بناء التجزئة استنادًا إلى قيم التجزئة الحالية لكل مفتاح. إذا تغيرت قيم كائنات المفاتيح منذ إدراجها، سيعيد هذا التابع فهرسة hsh. إذا اُستدعيَ Hash#rehash بينما يجتاز مُكرِّر التجزئة، سينطلق RuntimeError في المُكرِّر.

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

أمثلة

 
               VALUE
rb_hash_rehash(VALUE hash)
{
    VALUE tmp;
    st_table *tbl;

    if (RHASH_ITER_LEV(hash) > 0) {
        rb_raise(rb_eRuntimeError, "rehash during iteration");
    }
    rb_hash_modify_check(hash);
    if (!RHASH(hash)->ntbl)
        return hash;
    tmp = hash_alloc(0);
    tbl = st_init_table_with_size(RHASH(hash)->ntbl->type, RHASH(hash)->ntbl->num_entries);
    RHASH(tmp)->ntbl = tbl;

    rb_hash_foreach(hash, rb_hash_rehash_i, (VALUE)tbl);
    st_free_table(RHASH(hash)->ntbl);
    RHASH(hash)->ntbl = tbl;
    RHASH(tmp)->ntbl = 0;

    return hash;
}

reject → an_enumerator

إعادة تجزئة جديدة تتكون من العناصر التي تعيد الكتلة لها false.

إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.

h = { "a" => 100, "b" => 200, "c" => 300 }
h.reject {|k,v| k < "b"}  #=> {"b" => 200, "c" => 300}
h.reject {|k,v| v > 100}  #=> {"a" => 100}

أمثلة

 
               VALUE
rb_hash_reject(VALUE hash)
{
    VALUE result;

    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    if (RTEST(ruby_verbose)) {
        VALUE klass;
        if (HAS_EXTRA_STATES(hash, klass)) {
            rb_warn("extra states are no longer copied: %+"PRIsVALUE, hash);
        }
    }
    result = rb_hash_new();
    if (!RHASH_EMPTY_P(hash)) {
        rb_hash_foreach(hash, reject_i, result);
    }
    return result;
}

reject! → an_enumerator

يعادل Hash#delete_if، ولكن يُعيد nil إذا لم تُجرى أية تغييرات.

أمثلة

 
               VALUE
rb_hash_reject_bang(VALUE hash)
{
    st_index_t n;

    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    rb_hash_modify(hash);
    n = RHASH_SIZE(hash);
    if (!n) return Qnil;
    rb_hash_foreach(hash, delete_if_i, hash);
    if (n == RHASH(hash)->ntbl->num_entries) return Qnil;
    return hash;
}

replace(other_hash) → hsh

استبدال محتويات hsh بمحتويات other_hash.

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

أمثلة

 
               static VALUE
rb_hash_replace(VALUE hash, VALUE hash2)
{
    st_table *table2;

    rb_hash_modify_check(hash);
    if (hash == hash2) return hash;
    hash2 = to_hash(hash2);

    COPY_DEFAULT(hash, hash2);

    table2 = RHASH(hash2)->ntbl;

    rb_hash_clear(hash);
    if (table2) hash_tbl(hash)->type = table2->type;
    rb_hash_foreach(hash2, replace_i, hash);

    return hash;
}

select → an_enumerator

إعادة تجزئة جديدة تتكون من العناصر التي تعيد الكتلة لها true.

إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.

h = { "a" => 100, "b" => 200, "c" => 300 }
h.select {|k,v| k > "a"}  #=> {"b" => 200, "c" => 300}
h.select {|k,v| v < 200}  #=> {"a" => 100}

أمثلة

 
               VALUE
rb_hash_select(VALUE hash)
{
    VALUE result;

    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    result = rb_hash_new();
    if (!RHASH_EMPTY_P(hash)) {
        rb_hash_foreach(hash, select_i, result);
    }
    return result;
}

select! → an_enumerator

يعادل Hash#keep_if، ولكن يُعيد nil إذا لم تُجرى أية تغييرات.

أمثلة

 
               VALUE
rb_hash_select_bang(VALUE hash)
{
    st_index_t n;

    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    rb_hash_modify_check(hash);
    if (!RHASH(hash)->ntbl)
        return Qnil;
    n = RHASH(hash)->ntbl->num_entries;
    rb_hash_foreach(hash, keep_if_i, hash);
    if (n == RHASH(hash)->ntbl->num_entries) return Qnil;
    return hash;
}

shift → anArray or obj

يزيل زوج القيمة-المفتاح من hsh ويقوم بإعادتها كمصفوفة من العنصرين [ key, value ]، أو القيمة الافتراضية للتجزئة إذا كانت التجزئة فارغة.

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

أمثلة

 
               static VALUE
rb_hash_shift(VALUE hash)
{
    struct shift_var var;

    rb_hash_modify_check(hash);
    if (RHASH(hash)->ntbl) {
        var.key = Qundef;
        if (RHASH_ITER_LEV(hash) == 0) {
            if (st_shift(RHASH(hash)->ntbl, &var.key, &var.val)) {
                return rb_assoc_new(var.key, var.val);
            }
        }
        else {
            rb_hash_foreach(hash, shift_i_safe, (VALUE)&var);
            if (var.key != Qundef) {
                rb_hash_delete_entry(hash, var.key);
                return rb_assoc_new(var.key, var.val);
            }
        }
    }
    return rb_hash_default_value(hash, Qnil);
}

size → integer

إعادة عدد أزواج القيمة-المفتاح في التجزئة.

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

أمثلة

 
               VALUE
rb_hash_size(VALUE hash)
{
    return INT2FIX(RHASH_SIZE(hash));
}

slice(*keys) → a_hash

إعادة تجزئة تحتوي فقط على المفاتيح المُعطاة وقيمها.

h = { a: 100, b: 200, c: 300 }
h.slice(:a)           #=> {:a=>100}
h.slice(:b, :c, :d)   #=> {:b=>200, :c=>300}

أمثلة

 
               static VALUE
rb_hash_slice(int argc, VALUE *argv, VALUE hash)
{
    int i;
    VALUE key, value, result;

    if (argc == 0 || RHASH_EMPTY_P(hash)) {
        return rb_hash_new();
    }
    result = rb_hash_new_with_size(argc);

    for (i = 0; i < argc; i++) {
        key = argv[i];
        value = rb_hash_lookup2(hash, key, Qundef);
        if (value != Qundef)
            rb_hash_aset(result, key, value);
    }

    return result;
}

تعيين عنصر

store(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;
}

to_a → array

تحويل hsh إلى مصفوفة متداخلة من المصفوفات [ key, value ].

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

أمثلة

 
               static VALUE
rb_hash_to_a(VALUE hash)
{
    VALUE ary;

    ary = rb_ary_new_capa(RHASH_SIZE(hash));
    rb_hash_foreach(hash, to_a_i, ary);
    OBJ_INFECT(ary, hash);

    return ary;
}

to_h → hsh or new_hash

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

أمثلة

               static VALUE
rb_hash_to_h(VALUE hash)
{
    if (rb_obj_class(hash) != rb_cHash) {
        const VALUE flags = RBASIC(hash)->flags;
        hash = hash_dup(hash, rb_cHash, flags & HASH_PROC_DEFAULT);
    }
    return hash;
}

to_hash => hsh

إعادة self.

أمثلة

 
               static VALUE
rb_hash_to_hash(VALUE hash)
{
    return hash;
}

to_proc()‎ أمثلة

 
               static VALUE
rb_hash_to_proc(VALUE hash)
{
    return rb_func_proc_new(hash_proc_call, hash);
}

to_s()‎

اسم المستعار لـ inspect

أمثلة

transform_keys → an_enumerator

إعادة تجزئة جديدة مع نتائج تشغيل الكتلة مرة واحدة لكل مفتاح. لا يُغيّر هذا التابع القيم.

h = { a: 1, b: 2, c: 3 }
h.transform_keys {|k| k.to_s }  #=> { "a" => 1, "b" => 2, "c" => 3 }
h.transform_keys(&:to_s)        #=> { "a" => 1, "b" => 2, "c" => 3 }
h.transform_keys.with_index {|k, i| "#{k}.#{i}" }
                                #=> { "a.0" => 1, "b.1" => 2, "c.2" => 3 }

إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك. أمثلة

 
               static VALUE
rb_hash_transform_keys(VALUE hash)
{
    VALUE result;

    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    result = rb_hash_new();
    if (!RHASH_EMPTY_P(hash)) {
        rb_hash_foreach(hash, transform_keys_i, result);
    }

    return result;
}

transform_keys! → an_enumerator

استدعاء الكتلة المعطاة مرة واحدة لكل مفتاح في hsh، واستبداله بالمفتاح الجديد الذي تعيده الكتلة، ثم تُعيد hsh. لا يُغيّر هذا التابع القيم.

h = { a: 1, b: 2, c: 3 }
h.transform_keys! {|k| k.to_s }  #=> { "a" => 1, "b" => 2, "c" => 3 }
h.transform_keys!(&:to_sym)      #=> { a: 1, b: 2, c: 3 }
h.transform_keys!.with_index {|k, i| "#{k}.#{i}" }
                                 #=> { "a.0" => 1, "b.1" => 2, "c.2" => 3 }

إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك. أمثلة

 
               static VALUE
rb_hash_transform_keys_bang(VALUE hash)
{
    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    rb_hash_modify_check(hash);
    if (RHASH(hash)->ntbl) {
        long i;
        VALUE pairs = rb_hash_flatten(0, NULL, hash);
        rb_hash_clear(hash);
        for (i = 0; i < RARRAY_LEN(pairs); i += 2) {
            VALUE key = RARRAY_AREF(pairs, i), new_key = rb_yield(key),
                  val = RARRAY_AREF(pairs, i+1);
            rb_hash_aset(hash, new_key, val);
        }
    }
    return hash;
}

transform_values → an_enumerator

إعادة تجزئة جديدة مع نتائج تشغيل الكتلة مرة واحدة لكل قيمة. لا يُغيّر هذا التابع المفاتيح.

h = { a: 1, b: 2, c: 3 }
h.transform_values {|v| v * v + 1 }  #=> { a: 2, b: 5, c: 10 }
h.transform_values(&:to_s)           #=> { a: "1", b: "2", c: "3" }
h.transform_values.with_index {|v, i| "#{v}.#{i}" }
                                     #=> { a: "1.0", b: "2.1", c: "3.2" }

إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك. أمثلة

 
               static VALUE
rb_hash_transform_values(VALUE hash)
{
    VALUE result;

    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    result = rb_hash_new_with_size(RHASH_SIZE(hash));
    if (!RHASH_EMPTY_P(hash)) {
        rb_hash_foreach(hash, transform_values_i, result);
    }

    return result;
}

transform_values! → an_enumerator

استدعاء الكتلة المعطاة مرة واحدة لكل قيمة في hsh، واستبداله بالقيمة الجديدة التي تعيدها الكتلة، ثم تُعيد hsh. لا يُغيّر هذا التابع المفاتيح.

h = { a: 1, b: 2, c: 3 }
h.transform_values! {|v| v * v + 1 }  #=> { a: 2, b: 5, c: 10 }
h.transform_values!(&:to_s)           #=> { a: "2", b: "5", c: "10" }
h.transform_values!.with_index {|v, i| "#{v}.#{i}" }
                                      #=> { a: "2.0", b: "5.1", c: "10.2" }

إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك. أمثلة

               static VALUE
rb_hash_transform_values_bang(VALUE hash)
{
    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    rb_hash_modify_check(hash);
    if (RHASH(hash)->ntbl)
        rb_hash_foreach(hash, transform_values_i, hash);
    return hash;
}

update(other_hash){|key, oldval, newval| block} → hsh

إضافة محتويات other_hash إلى hsh. إذا لم تُحدَد أي كتلة، يُكتب فوق الإدخالات ذات المفاتيح المكررة مع القيم من other_hash، وإلا تُحدَّد قيمة كل مفتاح مكرر عن طريق استدعاء الكتلة مع المفتاح وقيمته في hsh وقيمته في other_hash.

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 254, "c" => 300 }
h1.merge!(h2)   #=> {"a"=>100, "b"=>254, "c"=>300}
h1              #=> {"a"=>100, "b"=>254, "c"=>300}

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 254, "c" => 300 }
h1.merge!(h2) { |key, v1, v2| v1 }
                #=> {"a"=>100, "b"=>200, "c"=>300}
h1              #=> {"a"=>100, "b"=>200, "c"=>300}

أمثلة

               static VALUE
rb_hash_update(VALUE hash1, VALUE hash2)
{
    rb_hash_modify(hash1);
    hash2 = to_hash(hash2);
    if (rb_block_given_p()) {
        rb_hash_foreach(hash2, rb_hash_update_block_i, hash1);
    }
    else {
        rb_hash_foreach(hash2, rb_hash_update_i, hash1);
    }
    return hash1;
}

value?(value) → true or false

إعادة true إذا كانت القيمة المُعطاة موجودة لمفتاح ما في hsh.

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

أمثلة

               static VALUE
rb_hash_has_value(VALUE hash, VALUE val)
{
    VALUE data[2];

    data[0] = Qfalse;
    data[1] = val;
    rb_hash_foreach(hash, rb_hash_search_value, (VALUE)data);
    return data[0];
}

values → array

إعادة مصفوفة جديدة ممتلئة بالقيم من hsh. راجع أيضًا Hash#keys.

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

أمثلة

 
               VALUE
rb_hash_values(VALUE hash)
{
    VALUE values;
    st_index_t size = RHASH_SIZE(hash);

    values = rb_ary_new_capa(size);
    if (size == 0) return values;

    if (ST_DATA_COMPATIBLE_P(VALUE)) {
        st_table *table = RHASH(hash)->ntbl;

        rb_gc_writebarrier_remember(values);
        RARRAY_PTR_USE(values, ptr, {
            size = st_values(table, ptr, size);
        });
        rb_ary_set_len(values, size);
    }
    else {
        rb_hash_foreach(hash, values_i, values);
    }

    return values;
}

values_at(key, ...) → array

إعادة مصفوفة تحتوي على القيم المرتبطة بالمفاتيح المُعطاة. راجع أيضًا Hash.select.

h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }
h.values_at("cow", "cat")  #=> ["bovine", "feline"]

أمثلة

               VALUE
rb_hash_values_at(int argc, VALUE *argv, VALUE hash)
{
    VALUE result = rb_ary_new2(argc);
    long i;

    for (i=0; i<argc; i++) {
        rb_ary_push(result, rb_hash_aref(hash, argv[i]));
    }
    return result;
}

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

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

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

مصادر

• صفحة Hash في توثيق روبي الرسمي.