الفرق بين المراجعتين ل"Ruby/Hash"
Khaled-yassin (نقاش | مساهمات) |
Khaled-yassin (نقاش | مساهمات) |
||
سطر 1: | سطر 1: | ||
− | + | هي مجموعة تشبه القاموس وتتكون من مفاتيح فريدة وقيمها. كما تسمى أيضا المصفوفات الترابطية، فهي تشبه المصفوفات Arrays، ولكن بينما تستخدم المصفوفة Array فقط الأعداد الصحيحة كفهرس، تسمح Hash باستخدام أي من أنواع الكائنات. | |
− | |||
− | |||
− | |||
تُرقِّم التجزئات قيمَها بنفس الترتيب الذي أُدرِجت فيه مفاتيحها المقابلة. | تُرقِّم التجزئات قيمَها بنفس الترتيب الذي أُدرِجت فيه مفاتيحها المقابلة. | ||
− | يمكن أن تُنشأ Hash بسهولة باستخدام شكلها الضمني: | + | يمكن أن تُنشأ Hash بسهولة باستخدام شكلها الضمني:<syntaxhighlight lang="ruby"> |
+ | grades = { "Jane Doe" => 10, "Jim Doe" => 6 } | ||
− | تسمح التجزئات بصياغة بديلة للمفاتيح التي تكون رموزًا. بدلًا من<syntaxhighlight lang="ruby"> | + | </syntaxhighlight>تسمح التجزئات بصياغة بديلة للمفاتيح التي تكون رموزًا. بدلًا من<syntaxhighlight lang="ruby"> |
options = { :font_size => 10, :font_family => "Arial" } | options = { :font_size => 10, :font_family => "Arial" } | ||
سطر 415: | سطر 413: | ||
g.dig(:foo, 1, 0) #=> TypeError: Integer does not have #dig method | g.dig(:foo, 1, 0) #=> TypeError: Integer does not have #dig method | ||
g.dig(:foo, :bar) #=> TypeError: no implicit conversion of Symbol into Integer | g.dig(:foo, :bar) #=> TypeError: no implicit conversion of Symbol into Integer | ||
− | </syntaxhighlight>أمثلة | + | </syntaxhighlight>أمثلة<syntaxhighlight lang="ruby"> |
− | + | ||
+ | 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); | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
====<code>each {| key, value | block } → hsh</code>==== | ====<code>each {| key, value | block } → hsh</code>==== | ||
====<code>each_pair {| key, value | block } → hsh</code>==== | ====<code>each_pair {| key, value | block } → hsh</code>==== | ||
====<code>each → an_enumerator</code>==== | ====<code>each → an_enumerator</code>==== | ||
====<code>each_pair → an_enumerator</code>==== | ====<code>each_pair → an_enumerator</code>==== | ||
− | استدعاء block مرة واحدة لكل مفتاح في | + | استدعاء <code>block</code> مرة واحدة لكل مفتاح في <code>hsh</code>، وتمرير زوج القيمة-المفتاح كمعاملات. |
− | إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك. | + | إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.<syntaxhighlight lang="ruby"> |
− | + | h = { "a" => 100, "b" => 200 } | |
− | يُنتِج: | + | h.each {|key, value| puts "#{key} is #{value}" } |
− | + | </syntaxhighlight>يُنتِج:<syntaxhighlight lang="ruby"> | |
− | أمثلة | + | a is 100 |
+ | b is 200 | ||
+ | </syntaxhighlight>أمثلة<syntaxhighlight lang="ruby"> | ||
+ | |||
+ | 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; | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
====<code>each_key {| key | block } → hsh</code>==== | ====<code>each_key {| key | block } → hsh</code>==== | ||
====<code>each_key → an_enumerator</code>==== | ====<code>each_key → an_enumerator</code>==== | ||
− | استدعاء block مرة واحدة لكل مفتاح في | + | استدعاء <code>block</code> مرة واحدة لكل مفتاح في <code>hsh</code>، وتمرير المفتاح كمعامل. |
− | إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك. | + | إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.<syntaxhighlight lang="ruby"> |
− | + | h = { "a" => 100, "b" => 200 } | |
− | يُنتِج: | + | h.each_key {|key| puts key } |
− | + | </syntaxhighlight>يُنتِج:<syntaxhighlight lang="ruby"> | |
− | أمثلة | + | a |
+ | b | ||
+ | </syntaxhighlight>أمثلة<syntaxhighlight lang="ruby"> | ||
+ | |||
+ | 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; | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
====<code>each_pair {| key, value | block } → hsh</code>==== | ====<code>each_pair {| key, value | block } → hsh</code>==== | ||
====<code>each_pair → an_enumerator</code>==== | ====<code>each_pair → an_enumerator</code>==== | ||
− | استدعاء block مرة واحدة لكل مفتاح في | + | استدعاء <code>block</code> مرة واحدة لكل مفتاح في <code>hsh</code>، وتمرير زوج القيمة-المفتاح كمعاملات. |
− | إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك. | + | إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.<syntaxhighlight lang="ruby"> |
− | + | h = { "a" => 100, "b" => 200 } | |
− | يُنتِج: | + | h.each {|key, value| puts "#{key} is #{value}" } |
− | + | </syntaxhighlight>يُنتِج:<syntaxhighlight lang="ruby"> | |
− | أمثلة | + | a is 100 |
+ | b is 200 | ||
+ | </syntaxhighlight>أمثلة<syntaxhighlight lang="ruby"> | ||
+ | |||
+ | 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; | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
====<code>each_value {| value | block } → hsh</code>==== | ====<code>each_value {| value | block } → hsh</code>==== | ||
====<code>each_value → an_enumerator</code>==== | ====<code>each_value → an_enumerator</code>==== | ||
− | استدعاء block مرة واحدة لكل مفتاح في | + | استدعاء <code>block</code> مرة واحدة لكل مفتاح في <code>hsh</code>، وتمرير المفتاح كمعامل. |
− | إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك. | + | إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.<syntaxhighlight lang="ruby"> |
− | + | h = { "a" => 100, "b" => 200 } | |
− | يُنتِج: | + | h.each_value {|value| puts value } |
− | + | </syntaxhighlight>يُنتِج:<syntaxhighlight lang="ruby"> | |
− | أمثلة | + | 100 |
+ | 200 | ||
+ | </syntaxhighlight>أمثلة<syntaxhighlight lang="ruby"> | ||
+ | |||
+ | 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; | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
====<code>empty? → true or false</code>==== | ====<code>empty? → true or false</code>==== | ||
− | إعادة true إذا كانت hsh لا تحتوي على أزواج القيمة-المفتاح. | + | إعادة <code>true</code> إذا كانت <code>hsh</code> لا تحتوي على أزواج القيمة-المفتاح.<syntaxhighlight lang="ruby"> |
+ | {}.empty? #=> true | ||
− | أمثلة | + | </syntaxhighlight>أمثلة<syntaxhighlight lang="ruby"> |
+ | |||
+ | static VALUE | ||
+ | rb_hash_empty_p(VALUE hash) | ||
+ | { | ||
+ | return RHASH_EMPTY_P(hash) ? Qtrue : Qfalse; | ||
+ | } | ||
+ | </syntaxhighlight> | ||
====<code>eql?(other) → true or false</code>==== | ====<code>eql?(other) → true or false</code>==== | ||
− | إعادة true إذا كان كلٌ من hash و other تجزئتين بنفس المحتوى. لا يقارن ترتيب كل التجزئات. | + | إعادة <code>true</code> إذا كان كلٌ من <code>hash</code> و <code>other</code> تجزئتين بنفس المحتوى. لا يقارن ترتيب كل التجزئات. |
− | أمثلة | + | أمثلة<syntaxhighlight lang="ruby"> |
+ | |||
+ | static VALUE | ||
+ | rb_hash_eql(VALUE hash1, VALUE hash2) | ||
+ | { | ||
+ | return hash_equal(hash1, hash2, TRUE); | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
====<code>fetch(key [, default] ) → obj</code>==== | ====<code>fetch(key [, default] ) → obj</code>==== | ||
====<code>fetch(key) {| key | block } → obj</code>==== | ====<code>fetch(key) {| key | block } → obj</code>==== | ||
− | إعادة قيمة من التجزئة لمفتاح معين. إذا كان المفتاح غير موجود، هناك عدة خيارات: مع عدم وجود وسائط أخرى، سيُجرى استثناء | + | إعادة قيمة من التجزئة لمفتاح معين. إذا كان المفتاح غير موجود، هناك عدة خيارات: مع عدم وجود وسائط أخرى، سيُجرى استثناء <code>KeyError</code>، إذا أُعطيَ <code>default</code>، ستُعاد هذه إذا حُدِدت كتلة الشيفرة البرمجية الاختيارية، ثم ستُنفَّذ وتُعاد نتيجتها.<syntaxhighlight lang="ruby"> |
+ | 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" | ||
+ | </syntaxhighlight>يُظهِر المثال التالي إجراء استثناء إذا كان المفتاح غير موجود ولم تُعطى قيمة افتراضية.<syntaxhighlight lang="ruby"> | ||
+ | h = { "a" => 100, "b" => 200 } | ||
+ | h.fetch("z") | ||
+ | </syntaxhighlight>يُنتِج:<syntaxhighlight lang="ruby"> | ||
+ | prog.rb:2:in `fetch': key not found (KeyError) | ||
+ | from prog.rb:2 | ||
+ | </syntaxhighlight>أمثلة<syntaxhighlight lang="ruby"> | ||
+ | |||
+ | 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; | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
====<code>fetch_values(key, ...) → array</code>==== | ====<code>fetch_values(key, ...) → array</code>==== | ||
====<code>fetch_values(key, ...) { |key| block } → array</code>==== | ====<code>fetch_values(key, ...) { |key| block } → array</code>==== | ||
− | إعادة مصفوفة تحتوي على القيم المقترنة بالمفاتيح المعطاة ولكن تُجرى أيضًا KeyError عند تعذر العثور على أحد المفاتيح. راجع أيضًا Hash#values_at و Hash#fetch. | + | إعادة مصفوفة تحتوي على القيم المقترنة بالمفاتيح المعطاة ولكن تُجرى أيضًا <code>KeyError</code> عند تعذر العثور على أحد المفاتيح. راجع أيضًا <code>Hash#values_at</code> و <code>Hash#fetch</code>.<syntaxhighlight lang="ruby"> |
+ | 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"] | ||
+ | </syntaxhighlight>أمثلة<syntaxhighlight lang="ruby"> | ||
+ | |||
+ | 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; | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
====<code>flatten → an_array</code>==== | ====<code>flatten → an_array</code>==== | ||
====<code>flatten(level) → an_array</code>==== | ====<code>flatten(level) → an_array</code>==== | ||
− | إعادة مصفوفة جديدة والتي تكون تسطيح أحادي الأبعاد لهذا التجزئة. أي أن لكل مفتاح أو قيمة تكون مصفوفة، تستخرج عناصرها إلى مصفوفة جديدة. على عكس Array# | + | إعادة مصفوفة جديدة والتي تكون تسطيح أحادي الأبعاد لهذا التجزئة. أي أن لكل مفتاح أو قيمة تكون مصفوفة، تستخرج عناصرها إلى مصفوفة جديدة. على عكس <code>Array#flatten</code>، لا يُسطِّح هذا التابع بشكل عَودي افتراضيًا. يُحدد الوسيط الاختياري <code>level</code> مستوى عودية التسطح.<syntaxhighlight lang="ruby"> |
+ | 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"] | ||
+ | </syntaxhighlight>أمثلة<syntaxhighlight lang="ruby"> | ||
+ | |||
+ | 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; | ||
+ | } | ||
+ | </syntaxhighlight> | ||
====<code>has_key?(key) → true or false</code>==== | ====<code>has_key?(key) → true or false</code>==== | ||
− | إعادة true إذا كان مفتاح معين موجود في hsh. | + | إعادة <code>true</code> إذا كان مفتاح معين موجود في <code>hsh</code>.<syntaxhighlight lang="ruby"> |
+ | h = { "a" => 100, "b" => 200 } | ||
+ | h.has_key?("a") #=> true | ||
+ | h.has_key?("z") #=> false | ||
+ | </syntaxhighlight>علمًا بأن <code>include?</code> و <code>member?</code> لا يختبرا تساوي الأعضاء باستخدام <code>==</code> كما تفعل غيرها من العدَّادات. | ||
− | + | راجع أيضًا <code>[[Ruby/Enumerable|Enumerable#include?]]</code> | |
− | + | أمثلة<syntaxhighlight lang="ruby"> | |
− | + | 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; | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
====<code>has_value?(value) → true or false</code>==== | ====<code>has_value?(value) → true or false</code>==== | ||
− | إعادة true إذا كانت القيمة المُعطاة موجودة لمفتاح ما في hsh. | + | إعادة <code>true</code> إذا كانت القيمة المُعطاة موجودة لمفتاح ما في <code>hsh</code>.<syntaxhighlight lang="ruby"> |
− | + | h = { "a" => 100, "b" => 200 } | |
− | أمثلة | + | h.value?(100) #=> true |
+ | h.value?(999) #=> false | ||
+ | </syntaxhighlight>أمثلة<syntaxhighlight lang="ruby"> | ||
+ | |||
+ | 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]; | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
====<code>hash → integer</code>==== | ====<code>hash → integer</code>==== | ||
− | حساب رمز التجزئة لهذه التجزئة. سيكون لتجزئتين لهما نفس المحتوى نفس رمز التجزئة (وستقارن باستخدام eql?). | + | حساب رمز التجزئة لهذه التجزئة. سيكون لتجزئتين لهما نفس المحتوى نفس رمز التجزئة (وستقارن باستخدام <code>eql?</code>). |
− | راجع أيضًا Object#hash. | + | راجع أيضًا <code>Object#hash</code>. |
− | |||
− | |||
+ | أمثلة<syntaxhighlight lang="ruby"> | ||
+ | |||
+ | 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); | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
====<code>include?(key) → true or false</code>==== | ====<code>include?(key) → true or false</code>==== | ||
− | إعادة true إذا كان مفتاح معين موجود في hsh. | + | إعادة <code>true</code> إذا كان مفتاح معين موجود في <code>hsh</code>.<syntaxhighlight lang="ruby"> |
+ | h = { "a" => 100, "b" => 200 } | ||
+ | h.has_key?("a") #=> true | ||
+ | h.has_key?("z") #=> false | ||
+ | </syntaxhighlight>علمًا بأن <code>include?</code> و <code>member?</code> لا يختبرا تساوي الأعضاء باستخدام <code>==</code> كما تفعل غيرها من العدَّادات. | ||
− | + | راجع أيضًا [[Ruby/Enumerable|<code>Enumerable#include?</code>]]<code></code> | |
− | |||
− | راجع أيضًا <code>Enumerable#include?</code> | ||
− | |||
− | |||
+ | أمثلة<syntaxhighlight lang="ruby"> | ||
+ | |||
+ | 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; | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
====<code>to_s → string</code>==== | ====<code>to_s → string</code>==== | ||
====<code>inspect → string</code>==== | ====<code>inspect → string</code>==== | ||
− | إعادة محتويات هذا التجزئة كسلسلة نصية. | + | إعادة محتويات هذا التجزئة كسلسلة نصية.<syntaxhighlight lang="ruby"> |
+ | h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300 } | ||
+ | h.to_s #=> "{\"c\"=>300, \"a\"=>100, \"d\"=>400}" | ||
− | ويُعيَّن له أيضًا الاسم المستعار: to_s. | + | </syntaxhighlight>ويُعيَّن له أيضًا الاسم المستعار: <code>to_s</code>. |
− | |||
− | |||
+ | أمثلة<syntaxhighlight lang="ruby"> | ||
+ | |||
+ | 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); | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
====<code>invert → new_hash</code>==== | ====<code>invert → new_hash</code>==== | ||
− | إعادة تجزئة جديدة مُنشأة باستخدام قيم hsh كمفاتيح والمفاتيح كقيم. إذا وُجِد بالفعل مفتاح بنفس القيمة في | + | إعادة تجزئة جديدة مُنشأة باستخدام قيم <code>hsh</code> كمفاتيح والمفاتيح كقيم. إذا وُجِد بالفعل مفتاح بنفس القيمة في <code>hsh</code>، سيستخدم آخر واحد مُعرَّف، وستُتجاهل القيم السابقة.<syntaxhighlight lang="ruby"> |
+ | h = { "n" => 100, "m" => 100, "y" => 300, "d" => 200, "a" => 0 } | ||
+ | h.invert #=> {0=>"a", 100=>"m", 200=>"d", 300=>"y"} | ||
+ | </syntaxhighlight>إذا لم يكن هناك مفتاح بنفس القيمة، تكون <code>#invert</code> ذاتية الانعكاس (involutive).<syntaxhighlight lang="ruby"> | ||
+ | h = { a: 1, b: 3, c: 4 } | ||
+ | h.invert.invert == h #=> true | ||
+ | </syntaxhighlight>الشرط، ألا يوجد مفتاح بنفس القيمة، ويمكن اختباره بمقارنة حجم التجزئة المقلوبة.<syntaxhighlight lang="ruby"> | ||
+ | # 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 | |
− | + | </syntaxhighlight>أمثلة<syntaxhighlight lang="ruby"> | |
− | + | 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; | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
====<code>keep_if {| key, value | block } → hsh</code>==== | ====<code>keep_if {| key, value | block } → hsh</code>==== | ||
====<code>keep_if → an_enumerator</code>==== | ====<code>keep_if → an_enumerator</code>==== | ||
− | حذف كل أزواج القيمة-المفتاح من hsh والتي تقيَّم لها block بالقيمة false. | + | حذف كل أزواج القيمة-المفتاح من <code>hsh</code> والتي تقيَّم لها <code>block</code> بالقيمة <code>false</code>. |
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك. | إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك. | ||
− | أمثلة | + | أمثلة<syntaxhighlight lang="ruby"> |
+ | 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; | ||
+ | } | ||
+ | </syntaxhighlight> | ||
====<code>key(value) → key</code>==== | ====<code>key(value) → key</code>==== | ||
− | إعادة مفتاح تواجد قيمة معينة. ويُعيد nil إذا كانت القيمة غير موجود. | + | إعادة مفتاح تواجد قيمة معينة. ويُعيد <code>nil</code> إذا كانت القيمة غير موجود.<syntaxhighlight lang="ruby"> |
+ | h = { "a" => 100, "b" => 200, "c" => 300, "d" => 300 } | ||
+ | h.key(200) #=> "b" | ||
+ | h.key(300) #=> "c" | ||
+ | h.key(999) #=> nil | ||
+ | </syntaxhighlight>أمثلة<syntaxhighlight lang="ruby"> | ||
+ | |||
+ | 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]; | ||
+ | } | ||
+ | </syntaxhighlight> | ||
====<code>key?(key) → true or false</code>==== | ====<code>key?(key) → true or false</code>==== | ||
− | إعادة true إذا كان مفتاح معين موجود في hsh. | + | إعادة <code>true</code> إذا كان مفتاح معين موجود في <code>hsh</code>.<syntaxhighlight lang="ruby"> |
+ | h = { "a" => 100, "b" => 200 } | ||
+ | h.has_key?("a") #=> true | ||
+ | h.has_key?("z") #=> false | ||
+ | </syntaxhighlight>علمًا بأن <code>include?</code> و <code>member?</code> لا يختبرا تساوي الأعضاء باستخدام <code>==</code> كما تفعل غيرها من العدَّادات. | ||
− | + | راجع أيضًا <code>[[Ruby/Enumerable|Enumerable#include?]]</code>[[Ruby/Enumerable|]]. | |
− | راجع أيضًا | + | أمثلة<syntaxhighlight lang="ruby"> |
+ | |||
+ | 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; | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
+ | ====<code>keys → array</code>==== | ||
+ | إعادة مصفوفة جديدة ممتلئة بالمفاتيح من هذه التجزئة. راجع أيضًا <code>Hash#values</code>.<syntaxhighlight lang="ruby"> | ||
+ | h = { "a" => 100, "b" => 200, "c" => 300, "d" => 400 } | ||
+ | h.keys #=> ["a", "b", "c", "d"] | ||
+ | </syntaxhighlight>أمثلة<syntaxhighlight lang="ruby"> | ||
+ | |||
+ | 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; | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
====<code>length → integer</code>==== | ====<code>length → integer</code>==== | ||
− | إعادة عدد أزواج القيمة-المفتاح في التجزئة. | + | إعادة عدد أزواج القيمة-المفتاح في التجزئة.<syntaxhighlight lang="ruby"> |
− | + | h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 } | |
− | أمثلة | + | h.length #=> 4 |
+ | h.delete("a") #=> 200 | ||
+ | h.length #=> 3 | ||
+ | </syntaxhighlight>أمثلة<syntaxhighlight lang="ruby"> | ||
+ | |||
+ | VALUE | ||
+ | rb_hash_size(VALUE hash) | ||
+ | { | ||
+ | return INT2FIX(RHASH_SIZE(hash)); | ||
+ | } | ||
+ | |||
+ | </syntaxhighlight> | ||
====<code>member?(key) → true or false</code>==== | ====<code>member?(key) → true or false</code>==== | ||
− | إعادة true إذا كان مفتاح معين موجود في hsh. | + | إعادة <code>true</code> إذا كان مفتاح معين موجود في <code>hsh</code>.<syntaxhighlight lang="ruby"> |
+ | h = { "a" => 100, "b" => 200 } | ||
+ | h.has_key?("a") #=> true | ||
+ | h.has_key?("z") #=> false | ||
+ | </syntaxhighlight>علمًا بأن <code>include?</code> و <code>member?</code> لا يختبرا تساوي الأعضاء باستخدام <code>==</code> كما تفعل غيرها من العدَّادات. | ||
− | + | راجع أيضًا <code>[[Ruby/Enumerable|Enumerable#include?]]</code>. | |
− | + | أمثلة<syntaxhighlight lang="ruby"> | |
− | + | ||
− | + | 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; | ||
+ | } | ||
+ | </syntaxhighlight> | ||
====<code>merge(other_hash) → new_hash</code>==== | ====<code>merge(other_hash) → new_hash</code>==== | ||
− | merge(other_hash){|key, oldval, newval| block} → new_hash | + | <code>merge(other_hash){|key, oldval, newval| block} → new_hash</code> |
− | إعادة تجزئة جديدة تحتوي على محتويات other_hash ومحتويات hsh. إذا لم تُحدد أي كتلة، ستكون قيمة العناصر ذات المفاتيح المُكررة هي نفسها من other_hash. وإلا تُحدَد قيمة كل مفتاح مكرر عن طريق استدعاء الكتلة مع المفتاح، وتكون قيمته في hsh وقيمته في other_hash. | + | إعادة تجزئة جديدة تحتوي على محتويات <code>other_hash</code> ومحتويات <code>hsh</code>. إذا لم تُحدد أي كتلة، ستكون قيمة العناصر ذات المفاتيح المُكررة هي نفسها من <code>other_hash</code>. وإلا تُحدَد قيمة كل مفتاح مكرر عن طريق استدعاء الكتلة مع المفتاح، وتكون قيمته في <code>hsh</code> وقيمته في <code>other_hash</code>.<syntaxhighlight lang="ruby"> |
− | + | 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} | ||
+ | </syntaxhighlight>أمثلة<syntaxhighlight lang="ruby"> | ||
+ | |||
+ | static VALUE | ||
+ | rb_hash_merge(VALUE hash1, VALUE hash2) | ||
+ | { | ||
+ | return rb_hash_update(rb_hash_dup(hash1), hash2); | ||
+ | } | ||
+ | </syntaxhighlight> | ||
====<code>merge!(other_hash) → hsh</code>==== | ====<code>merge!(other_hash) → hsh</code>==== | ||
====<code>merge!(other_hash){|key, oldval, newval| block} → hsh</code>==== | ====<code>merge!(other_hash){|key, oldval, newval| block} → hsh</code>==== | ||
سطر 586: | سطر 944: | ||
أمثلة | أمثلة | ||
− | |||
====<code>reject {|key, value| block} → a_hash</code>==== | ====<code>reject {|key, value| block} → a_hash</code>==== | ||
====<code>reject → an_enumerator</code>==== | ====<code>reject → an_enumerator</code>==== | ||
سطر 638: | سطر 995: | ||
أمثلة | أمثلة | ||
− | |||
====<code>to_h → hsh or new_hash</code>==== | ====<code>to_h → hsh or new_hash</code>==== | ||
إعادة self. إذا استُدعي علي صنف فرعي من Hash، تحوِّل المُتلقي إلى كائن Hash. | إعادة self. إذا استُدعي علي صنف فرعي من Hash، تحوِّل المُتلقي إلى كائن Hash. | ||
أمثلة | أمثلة | ||
− | |||
====<code>to_hash => hsh</code>==== | ====<code>to_hash => hsh</code>==== | ||
إعادة self. | إعادة self. | ||
سطر 654: | سطر 1٬009: | ||
أمثلة | أمثلة | ||
− | |||
====<code>transform_keys {|key| block } → new_hash</code>==== | ====<code>transform_keys {|key| block } → new_hash</code>==== | ||
====<code>transform_keys → an_enumerator</code>==== | ====<code>transform_keys → an_enumerator</code>==== | ||
سطر 662: | سطر 1٬016: | ||
أمثلة | أمثلة | ||
− | |||
====<code>transform_keys! {|key| block } → hsh</code>==== | ====<code>transform_keys! {|key| block } → hsh</code>==== | ||
====<code>transform_keys! → an_enumerator</code>==== | ====<code>transform_keys! → an_enumerator</code>==== | ||
سطر 700: | سطر 1٬053: | ||
إعادة مصفوفة تحتوي على القيم المرتبطة بالمفاتيح المُعطاة. راجع أيضًا Hash.select. | إعادة مصفوفة تحتوي على القيم المرتبطة بالمفاتيح المُعطاة. راجع أيضًا Hash.select. | ||
=مصادر= | =مصادر= | ||
− | * <span> </span><span> </span>[http://ruby-doc.org/core-2.5.1/Hash.html صفحة Hash في توثيق روبي الرسمي.] | + | *<span> </span><span> </span>[http://ruby-doc.org/core-2.5.1/Hash.html صفحة Hash في توثيق روبي الرسمي.] |
+ | |||
+ | * | ||
[[تصنيف:Ruby]] | [[تصنيف:Ruby]] |
مراجعة 00:00، 23 أكتوبر 2018
هي مجموعة تشبه القاموس وتتكون من مفاتيح فريدة وقيمها. كما تسمى أيضا المصفوفات الترابطية، فهي تشبه المصفوفات 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[ key, value, ... ] → new_hash
Hash[ [ [key, value], ... ] ] → new_hash
Hash[ object ] → new_hash
إنشاء تجزئة جديدة ممتلئة بالكائنات المعطاة.
على غرار القيمة الحرفية { key => value, ... }. في الشكل الأول، تأتي المفاتيح والقيم في أزواج، لذلك يجب أن يكون هناك عدد زوجي من الوسائط.
يُمرر في الشكلين الثاني والثالث وسيطٌا واحدٌا ويكون إما مصفوفة من أزواج القيمة-المفتاح أو كائن قابل للتحويل إلى تجزئة.
Hash["a", 100, "b", 200] #=> {"a"=>100, "b"=>200}
Hash[ [ ["a", 100], ["b", 200] ] ] #=> {"a"=>100, "b"=>200}
Hash["a" => 100, "b" => 200] #=> {"a"=>100, "b"=>200}
new → new_hash
new(obj) → new_hash
new {|hash, key| block } → new_hash
إعادة تجزئة جديدة فارغة. إذا وصل بعد ذلك مفتاحٌ لا يتوافق مع إدخال تجزئة إلى هذه التجزئة، تعتمد القيمة المُعادة على نمط new
يستخدم لإنشاء التجزئة. في الشكل الأول، يُعيد الوصول nil
. إذا حُدِد obj
، سيُستخدم هذا الكائن وحده لكافة القيم الافتراضية. إذا حُدِدت كتلة، ستُستدعى مع كائن التجزئة والمفتاح، ويجب إعادة القيمة الافتراضية. ومن مسؤولية الكتلة تخزين القيمة في التجزئة إذا لزم الأمر.
h = Hash.new("Go Fish")
h["a"] = 100
h["b"] = 200
h["a"] #=> 100
h["c"] #=> "Go Fish"
# The following alters the single default object
h["c"].upcase! #=> "GO FISH"
h["d"] #=> "GO FISH"
h.keys #=> ["a", "b"]
# While this creates a new default object each time
h = Hash.new { |hash, key| hash[key] = "Go Fish: #{key}" }
h["c"] #=> "Go Fish: c"
h["c"].upcase! #=> "GO FISH: C"
h["d"] #=> "Go Fish: d"
h.keys #=> ["c", "d"]
try_convert(obj) → hash or nil
محاولة تحويل obj
إلى تجزئة باستخدام التابع #to_hash
. وإعادة التجزئة المُحوَّلة أو nil
إذا تعذر تحويل obj
لأي سبب.
ash.try_convert({1=>2}) # => {1=>2}
Hash.try_convert("1=>2") # => nil
توابع المثيل العام
hash < other → true or false
يُعيد true
إذا كانت hash
مجموعة فرعية من other
.
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 < h2 #=> true
h2 < h1 #=> false
h1 < h1 #=> false
hash <= other → true or false
إعادة true
إذا كانت hash
مجموعة فرعية من other
أو تساوي other
.
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 <= h2 #=> true
h2 <= h1 #=> false
h1 <= h1 #=> true
hsh == other_hash → true or false
المساواة — تتساوى تجزئتان إذا كان كل منهما يحتوي على نفس العدد من المفاتيح وإذا كان كل زوج القيمة-المفتاح يساوي العناصر المناظرة في التجزئة الأخرى وفقًا Object#==
.
h1 = { "a" => 1, "c" => 2 }
h2 = { 7 => 35, "c" => 2, "a" => 1 }
h3 = { "a" => 1, "c" => 2, 7 => 35 }
h4 = { "a" => 1, "d" => 2, "f" => 35 }
h1 == h2 #=> false
h2 == h3 #=> true
h3 == h4 #=> false
لا يقارن ترتيب كل التجزئات.
h1 = { "a" => 1, "c" => 2 }
h2 = { "c" => 2, "a" => 1 }
h1 == h2 #=> true
hash > other → true or false
إعادة true
إذا كان other
مجموعة فرعية من hash
.
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 > h2 #=> false
h2 > h1 #=> true
h1 > h1 #=> false
hash >= other → true or false
إعادة true
إذا كان other
مجموعة فرعية من hash
أو يساوي hash
.
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 >= h2 #=> false
h2 >= h1 #=> true
h1 >= h1 #=> true
hsh[key] → value
مرجع العنصر — استرداد الكائن value
المقابل لكائن key
. وإذا لم يُعثر عليه، تُعاد القيمة الافتراضية (راجع Hash::new
لمزيد من التفاصيل).
h = { "a" => 100, "b" => 200 }
h["a"] #=> 100
h["c"] #=> nil
hsh[key] = value → value
تعيين عنصر
ربط القيمة value
المُعطاة مع المفتاح key
المُعطي.
h = { "a" => 100, "b" => 200 }
h["a"] = 9
h["c"] = 4
h #=> {"a"=>9, "b"=>200, "c"=>4}
h.store("d", 42) #=> 42
h #=> {"a"=>9, "b"=>200, "c"=>4, "d"=>42}
لا يجب تغيير قيمة key
أثناء استخدامه كمفتاح (ستكرر السلاسل غير المجمدة unfrozen
المُمررة كمفتاح وتُجمَّد).
a = "a"
b = "b".freeze
h = { a => 100, b => 200 }
h.key(100).equal? a #=> false
h.key(200).equal? b #=> true
VALUE
rb_hash_aset(VALUE hash, VALUE key, VALUE val)
{
int iter_lev = RHASH_ITER_LEV(hash);
st_table *tbl = RHASH(hash)->ntbl;
rb_hash_modify(hash);
if (!tbl) {
if (iter_lev > 0) no_new_key();
tbl = hash_tbl(hash);
}
if (tbl->type == &identhash || rb_obj_class(key) != rb_cString) {
RHASH_UPDATE_ITER(hash, iter_lev, key, hash_aset, val);
}
else {
RHASH_UPDATE_ITER(hash, iter_lev, key, hash_aset_str, val);
}
return val;
}
any? [{ |(key, value)| block }] → true or false
راجع أيضًا Enumerable#any?
static VALUE
rb_hash_any_p(int argc, VALUE *argv, VALUE hash)
{
VALUE args[2];
args[0] = Qfalse;
rb_check_arity(argc, 0, 1);
if (RHASH_EMPTY_P(hash)) return Qfalse;
if (argc) {
args[1] = argv[0];
rb_hash_foreach(hash, any_p_i_pattern, (VALUE)args);
}
else {
if (!rb_block_given_p()) {
/* yields pairs, never false */
return Qtrue;
}
if (rb_block_arity() > 1)
rb_hash_foreach(hash, any_p_i_fast, (VALUE)args);
else
rb_hash_foreach(hash, any_p_i, (VALUE)args);
}
return args[0];
}
assoc(obj) → an_array or nil
البحث خلال التجزئة عن طريق مقارنة obj
بالمفتاح باستخدام التابع ==
. وإعادة زوج القيمة-االمفتاح (مصفوفة من عنصرين) أو nil
إذا لم يعثر على أي تطابق. راجع Array#assoc
.
h = {"colors" => ["red", "blue", "green"],
"letters" => ["a", "b", "c" ]}
h.assoc("letters") #=> ["letters", ["a", "b", "c"]]
h.assoc("foo") #=> nil
clear → hsh
يزيل جميع أزواج القيمة-المفتاح من hsh
.
h = { "a" => 100, "b" => 200 } #=> {"a"=>100, "b"=>200}
h.clear #=> {}
compact → new_hash
إعادة تجزئة جديدة مع إزالة أزواج القيم/المفاتيح الصفرية.
h = { "a" => 100, "b" => 200 } #=> {"a"=>100, "b"=>200}
h.clear #=> {}
compact! → hsh or nil
إزالة جميع قيم hsh
من التجزئة. إعادة صفر إذا لم يُجرى أية تغييرات، وإلا يُعيد التجزئة.
h = { a: 1, b: false, c: nil }
h.compact! #=> { a: 1, b: false }
compare_by_identity → hsh
جعل hsh
يقارن مفاتيحه بواسطة مُعرِّفه، أي إنها سوف تعتبر نفس الكائنات على أنها نفس المفاتيح.
h1 = { "a" => 100, "b" => 200, :c => "c" }
h1["a"] #=> 100
h1.compare_by_identity
h1.compare_by_identity? #=> true
h1["a".dup] #=> nil # different objects.
h1[:c] #=> "c" # same symbols are all same.
compare_by_identity? → true or false
إعادة true
إذا كانت hsh
ستقارن مفاتيحها بواسطة مُعرِّفهم. راجع أيضا Hash#compare_by_identity
.
VALUE
rb_hash_compare_by_id_p(VALUE hash)
{
if (!RHASH(hash)->ntbl)
return Qfalse;
if (RHASH(hash)->ntbl->type == &identhash) {
return Qtrue;
}
return Qfalse;
}
default(key=nil) → obj
إعادة القيمة الافتراضية، القيمة مُعادة بواسطة hsh
إذا كان key
غير موجود في hsh
. راجع أيضًا Hash::new
و Hash#default=
.
h = Hash.new #=> {}
h.default #=> nil
h.default(2) #=> nil
h = Hash.new("cat") #=> {}
h.default #=> "cat"
h.default(2) #=> "cat"
h = Hash.new {|h,k| h[k] = k.to_i*10} #=> {}
h.default #=> nil
h.default(2) #=> 20
default = obj → obj
تعيين القيمة الافتراضية، القيمة المُعادة لمفتاح غير موجود في التجزئة. ليس من الممكن ضب القيمة الافتراضية على Proc
التي ستنفذ على كل بحث عن مفتاح.
h = { "a" => 100, "b" => 200 }
h.default = "Go fish"
h["a"] #=> 100
h["z"] #=> "Go fish"
# This doesn't do what you might hope...
h.default = proc do |hash, key|
hash[key] = key + key
end
h[2] #=> #<Proc:0x401b3948@-:6>
h["cat"] #=> #<Proc:0x401b3948@-:6>
default_proc → anObject
إذا استُدعي Hash::new
مع كتلة، سيُعيد هذه الكتلة، وإلا سيُعيد nil
.
h = Hash.new {|h,k| h[k] = k*k } #=> {}
p = h.default_proc #=> #<Proc:0x401b3d08@-:1>
a = [] #=> []
p.call(a, 2)
a #=> [nil, nil, 4]
default_proc = proc_obj or nil
تعيين proc
الافتراضية التي ستُنفَّذ عند فشل أي بحث عن مفتاح.
h.default_proc = proc do |hash, key|
hash[key] = key + key
end
h[2] #=> 4
h["cat"] #=> "catcat"
VALUE
rb_hash_set_default_proc(VALUE hash, VALUE proc)
{
VALUE b;
rb_hash_modify_check(hash);
if (NIL_P(proc)) {
SET_DEFAULT(hash, proc);
return proc;
}
b = rb_check_convert_type_with_id(proc, T_DATA, "Proc", idTo_proc);
if (NIL_P(b) || !rb_obj_is_proc(b)) {
rb_raise(rb_eTypeError,
"wrong default_proc type %s (expected Proc)",
rb_obj_classname(proc));
}
proc = b;
SET_PROC_DEFAULT(hash, proc);
return proc;
}
delete(key) → value
delete(key) {| key | block } → value
حذف زوج القيمة-المفتاح وإعادة القيمة من hsh
والذي يكون مفتاحها key
. ويُعيد nil
إذا كان المفتاح غير موجود. إذا توفرت كتلة الشيفرة البرمجية الاختيارية وكان المفتاح غير موجود، يُمرر المفتاح وتُعاد نتيجة block
.
h = { "a" => 100, "b" => 200 }
h.delete("a") #=> 100
h.delete("z") #=> nil
h.delete("z") { |el| "#{el} not found" } #=> "z not found"
static VALUE
rb_hash_delete_m(VALUE hash, VALUE key)
{
VALUE val;
rb_hash_modify_check(hash);
val = rb_hash_delete_entry(hash, key);
if (val != Qundef) {
return val;
}
else {
if (rb_block_given_p()) {
return rb_yield(key);
}
else {
return Qnil;
}
}
}
delete_if {| key, value | block } → hsh
delete_if → an_enumerator
حذف كل أزواج القيمة-المفتاح من hsh
التي تُقيَّم لها block
بالقيمة true
.
إذا لم تُعطَى 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 {| key, value | block } → hsh
each_pair {| key, value | block } → hsh
each → an_enumerator
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 {| key | block } → hsh
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 {| key, value | block } → hsh
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 {| value | block } → hsh
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 [, default] ) → obj
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, ...) → array
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 → an_array
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;
}
to_s → string
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 {| key, value | block } → hsh
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) → hsh
merge!(other_hash){|key, oldval, newval| block} → hsh
إضافة محتويات other_hash إلى hsh. إذا لم تُحدَد أي كتلة، يُكتب فوق الإدخالات ذات المفاتيح المكررة مع القيم من other_hash، وإلا تُحدَّد قيمة كل مفتاح مكرر عن طريق استدعاء الكتلة مع المفتاح وقيمته في hsh وقيمته في other_hash.
أمثلة
rassoc(obj) → an_array or nil
البحث خلال التجزئة عن طريق مقارنة obj بالقيمة باستخدام ==. إعادة أول زوج القيمة-المفتاح (مصفوفة من عنصرين) يتطابق. راجع أيضًا Array#rassoc.
أمثلة
rehash → hsh
إعادة بناء التجزئة استنادًا إلى قيم التجزئة الحالية لكل مفتاح. إذا تغيرت قيم كائنات المفاتيح منذ إدراجها، سيعيد هذا التابع فهرسة hsh. إذا اُستدعيَ Hash#rehash بينما يجتاز مُكرِّر التجزئة، سينطلق RuntimeError في المُكرِّر.
أمثلة
reject {|key, value| block} → a_hash
reject → an_enumerator
إعادة تجزئة جديدة تتكون من العناصر التي تعيد الكتلة لها false.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
أمثلة
reject! {| key, value | block } → hsh or nil
reject! → an_enumerator
يعادل Hash#delete_if، ولكن يُعيد nil إذا لم تُجرى أية تغييرات.
أمثلة
replace(other_hash) → hsh
استبدال محتويات hsh بمحتويات other_hash.
أمثلة
select {|key, value| block} → a_hash
select → an_enumerator
إعادة تجزئة جديدة تتكون من العناصر التي تعيد الكتلة لها true.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
أمثلة
select! {| key, value | block } → hsh or nil
select! → an_enumerator
يعادل Hash#keep_if، ولكن يُعيد nil إذا لم تُجرى أية تغييرات.
أمثلة
shift → anArray or obj
يزيل زوج القيمة-المفتاح من hsh ويقوم بإعادتها كمصفوفة من العنصرين [ key, value ]، أو القيمة الافتراضية للتجزئة إذا كانت التجزئة فارغة.
أمثلة
size → integer
إعادة عدد أزواج القيمة-المفتاح في التجزئة.
أمثلة
slice(*keys) → a_hash
إعادة تجزئة تحتوي فقط على المفاتيح المُعطاة وقيمها.
أمثلة
store(key, value) → value
تعيين عنصر
يربط القيمة value المُعطاة مع المفتاح key المُعطي.
لا يجب تغيير قيمة key أثناء استخدامه كمفتاح (ستكرر السلاسل غير المجمدة unfrozen المُمررة كمفتاح وتُجمَّد).
أمثلة
to_a → array
تحويل hsh إلى مصفوفة متداخلة من المصفوفات [ key, value ].
أمثلة
to_h → hsh or new_hash
إعادة self. إذا استُدعي علي صنف فرعي من Hash، تحوِّل المُتلقي إلى كائن Hash.
أمثلة
to_hash => hsh
إعادة self.
أمثلة
to_proc()
to_s()
اسم المستعار لـ inspect
أمثلة
transform_keys {|key| block } → new_hash
transform_keys → an_enumerator
إعادة تجزئة جديدة مع نتائج تشغيل الكتلة مرة واحدة لكل مفتاح. لا يُغيّر هذا التابع القيم.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
أمثلة
transform_keys! {|key| block } → hsh
transform_keys! → an_enumerator
استدعاء الكتلة المعطاة مرة واحدة لكل مفتاح في hsh، واستبداله بالمفتاح الجديد الذي تعيده الكتلة، ثم تُعيد hsh. لا يُغيّر هذا التابع القيم.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
أمثلة
transform_values {|value| block } → new_hash
transform_values → an_enumerator
إعادة تجزئة جديدة مع نتائج تشغيل الكتلة مرة واحدة لكل قيمة. لا يُغيّر هذا التابع المفاتيح.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
أمثلة
transform_values! {|value| block } → hsh
transform_values! → an_enumerator
استدعاء الكتلة المعطاة مرة واحدة لكل قيمة في hsh، واستبداله بالقيمة الجديدة التي تعيدها الكتلة، ثم تُعيد hsh. لا يُغيّر هذا التابع المفاتيح.
إذا لم تُعطَى كتلة، يُعاد عدَّاد بدلًا من ذلك.
أمثلة
update(other_hash) → hsh
update(other_hash){|key, oldval, newval| block} → hsh
إضافة محتويات other_hash إلى hsh. إذا لم تُحدَد أي كتلة، يُكتب فوق الإدخالات ذات المفاتيح المكررة مع القيم من other_hash، وإلا تُحدَّد قيمة كل مفتاح مكرر عن طريق استدعاء الكتلة مع المفتاح وقيمته في hsh وقيمته في other_hash.
أمثلة
value?(value) → true or false
إعادة true إذا كانت القيمة المُعطاة موجودة لمفتاح ما في hsh.
أمثلة
values → array
إعادة مصفوفة جديدة ممتلئة بالقيم من hsh. راجع أيضًا Hash#keys.
أمثلة
values_at(key, ...) → arrayclick to toggle source
إعادة مصفوفة تحتوي على القيم المرتبطة بالمفاتيح المُعطاة. راجع أيضًا Hash.select.