التجزئة Hash في روبي

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

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

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

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

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

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

و يمكن أن تُكتب:

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

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

options[:font_size]  # => 10

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

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

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

grades = Hash.new(0)

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

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

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

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

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

تُعد التجزئات طريقة سهلة لتمثيل هياكل البيانات، مثل

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

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

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

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

مفاتيح التجزئة

يُشير كائنان إلى نفس مفتاح التجزئة عندما تكون قيمتا hash الخاصة بهما متطابقة ويكون الكائنان eql?‎ لبعضهم البعض.

قد يستخدم صنف معرف من قِبَل المستخدم كمفتاح تجزئة إذا أُبطِل التابعَيْن hash و eql?‎ لتوفير سلوك ذو معنى. بشكل افتراضي، تشير المثيلات المنفصلة إلى مفاتيح تجزئة منفصلة.

ويستند التطبيق النموذجي للتجزئة hash على بيانات الكائن، بينما يُعين عادةً اسم مستعار للتابع eql?‎ يشير إلى التابع المُبطِل ==:

class Book
  attr_reader :author, :title

  def initialize(author, title)
    @author = author
    @title = title
  end

  def ==(other)
    self.class === other and
      other.author == @author and
      other.title == @title
  end

  alias eql? ==

  def hash
    @author.hash ^ @title.hash # XOR
  end
end

book1 = Book.new 'matz', 'Ruby in a Nutshell'
book2 = Book.new 'matz', 'Ruby in a Nutshell'

reviews = {}

reviews[book1] = 'Great reference!'
reviews[book2] = 'Nice and compact!'

reviews.length #=> 1

انظر أيضا Object#hash و Object#eql?‎.

توابع الصنف العام

Hash[ 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.

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

dig(key, ...) → object

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

each_pair → an_enumerator

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

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

يُنتِج:

each_key → an_enumerator

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

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

يُنتِج:

each_pair → an_enumerator

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

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

يُنتِج:

each_value → an_enumerator

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

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

يُنتِج:

empty? → true or false

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

eql?(other) → true or false

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

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

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

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

يُنتِج:

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

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

flatten(level) → an_array

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

has_key?(key) → true or false

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

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

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

has_value?(value) → true or false

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

hash → integer

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

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

include?(key) → true or false

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

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

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

inspect → string

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

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

invert → new_hash

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

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

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

keep_if → an_enumerator

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

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

key(value) → key

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

key?(key) → true or false

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

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

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

keys → array

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

length → integer

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

member?(key) → true or false

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

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

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

merge(other_hash) → new_hash

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

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

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

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

rassoc(obj) → an_array or nil

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

rehash → hsh

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

reject → an_enumerator

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

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

reject! → an_enumerator

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

replace(other_hash) → hsh

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

select → an_enumerator

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

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

select! → an_enumerator

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

shift → anArray or obj

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

size → integer

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

slice(*keys) → a_hash

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

تعيين عنصر

يربط القيمة value المُعطاة مع المفتاح key المُعطي.

لا يجب تغيير قيمة key أثناء استخدامه كمفتاح (ستكرر السلاسل غير المجمدة unfrozen المُمررة كمفتاح وتُجمَّد).

to_a → array

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

to_h → hsh or new_hash

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

to_hash => hsh

إعادة self.

to_proc()‎

to_s()‎

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

transform_keys → an_enumerator

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

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

transform_keys! → an_enumerator

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

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

transform_values → an_enumerator

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

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

transform_values! → an_enumerator

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

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

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

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

value?(value) → true or false

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

values → array

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

values_at(key, ...) → arrayclick to toggle source

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

مصادر

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