الفرق بين المراجعتين لصفحة: «Ruby/Proc/lambda-3F»

من موسوعة حسوب
< Ruby‏ | Proc
أنشأ الصفحة ب'{{DISPLAYTITLE:التابع ?Proc.lambda في روبي}} يتحقَّق التابع ?lambda إذا كانت معالجة الوسائط صارمةً في الكائن...'
 
طلا ملخص تعديل
 
سطر 1: سطر 1:
{{DISPLAYTITLE:التابع ?Proc.lambda في روبي}}
{{DISPLAYTITLE:التابع <code>?Proc.lambda</code> في روبي}}
يتحقَّق التابع <code>?lambda</code> إذا كانت معالجة الوسائط صارمةً في الكائن <code>Proc</code> (أي يجب تمرير نفس العدد تمامًا من الوسائط المعرَّفة عند إنشاء الكائن). تُنشأ هذه الكائنات عادةً بوساطة <code>lambda</code>.


يتحقَّق التابع ?lambda إذا كانت معالجة الوسائط صارمةً في الكائن Proc (أي يجب تمرير نفس العدد تمامًا من الوسائط المعرَّفة عند إنشاء الكائن). تُنشأ هذه الكائنات عادةً بوساطة lambda.
كائنات الصنف <code>Proc</code> المُنشأة بوساطة <code>proc</code> ليست صارمةً وتمتلك الميزات التالية:
 
كائنات الصنف Proc المُنشأة بوساطة proc ليست صارمةً وتمتلك الميزات التالية:
* تتجاهل الوسائط الإضافيَّة:
* تتجاهل الوسائط الإضافيَّة:
<syntaxhighlight lang="ruby">
proc {|a,b| [a,b] }.call(1,2,3)    #=> [1,2]
proc {|a,b| [a,b] }.call(1,2,3)    #=> [1,2]
* تُعيِّن القيمة nil للوسائط الناقصة:
</syntaxhighlight>
* تُعيِّن القيمة <code>nil</code> للوسائط الناقصة:
<syntaxhighlight lang="ruby">
proc {|a,b| [a,b] }.call(1)        #=> [1,nil]
proc {|a,b| [a,b] }.call(1)        #=> [1,nil]
</syntaxhighlight>
* توسِّع وسيط مصفوفة مفردة:
* توسِّع وسيط مصفوفة مفردة:
<syntaxhighlight lang="ruby">
proc {|a,b| [a,b] }.call([1,2])    #=> [1,2]
proc {|a,b| [a,b] }.call([1,2])    #=> [1,2]
 
</syntaxhighlight>كائن الصنف <code>Proc</code> المُنشأ بواسطة <code>lambda</code> لا يمتلك هذه الميِّزات.<syntaxhighlight lang="ruby">
كائن الصنف Proc المُنشأ بواسطة lambda لا يمتلك هذه الميِّزات.<syntaxhighlight lang="ruby">
lambda {|a,b| [a,b] }.call(1,2,3)  #=> ArgumentError
lambda {|a,b| [a,b] }.call(1,2,3)  #=> ArgumentError
lambda {|a,b| [a,b] }.call(1)      #=> ArgumentError
lambda {|a,b| [a,b] }.call(1)      #=> ArgumentError
lambda {|a,b| [a,b] }.call([1,2])  #=> ArgumentError
lambda {|a,b| [a,b] }.call([1,2])  #=> ArgumentError


</syntaxhighlight>التابع ?lambda هو تابعٌ خَبَريٌ (predicate) لهذه الميِّزات. يُعيد القيمة true إذا لم تُطبَّق أي ميِّزة.<syntaxhighlight lang="ruby">
</syntaxhighlight>التابع <code>?lambda</code> هو تابعٌ خَبَريٌ (predicate) لهذه الميِّزات. يُعيد القيمة <code>true</code> إذا لم تُطبَّق أي ميِّزة.<syntaxhighlight lang="ruby">
lambda {}.lambda?            #=> true
lambda {}.lambda?            #=> true
proc {}.lambda?              #=> false
proc {}.lambda?              #=> false


</syntaxhighlight>يؤدي التابع new نفس عمل proc.
</syntaxhighlight>يؤدي التابع <code>[[Ruby/Proc/new|new]]</code> نفس عمل <code>proc</code>.<syntaxhighlight lang="ruby">
 
Proc.new {}.lambda?          #=> false
Proc.new {}.lambda?          #=> false
 
</syntaxhighlight>تحافظ <code>lambda</code> و <code>proc</code> و <code>new</code> على ميزات كائن الصنف <code>Proc</code> المعطيَّة بالوسيط <code>&</code>.<syntaxhighlight lang="ruby">
تحافظ lambda و proc و new على ميزات كائن الصنف Proc المعطيَّة بالوسيط &.<syntaxhighlight lang="ruby">
lambda(&lambda {}).lambda?  #=> true
lambda(&lambda {}).lambda?  #=> true
proc(&lambda {}).lambda?    #=> true
proc(&lambda {}).lambda?    #=> true
سطر 33: سطر 34:
Proc.new(&proc {}).lambda?  #=> false
Proc.new(&proc {}).lambda?  #=> false


</syntaxhighlight>يمتلك كائن الصنف Proc المُنشَأ عبر الوسيط & تلك الميزات.<syntaxhighlight lang="ruby">
</syntaxhighlight>يمتلك كائن الصنف <code>Proc</code> المُنشَأ عبر الوسيط <code>&</code> تلك الميزات.<syntaxhighlight lang="ruby">
def n(&b) b.lambda? end
def n(&b) b.lambda? end
n {}                        #=> false
n {}                        #=> false


</syntaxhighlight>يحتفظ الوسيط & بهذه الميِّزات إذا أُعطي كائن الصنف Proc عبر الوسيط &.<syntaxhighlight lang="ruby">
</syntaxhighlight>يحتفظ الوسيط <code>&</code> بهذه الميِّزات إذا أُعطي كائن الصنف <code>Proc</code> عبر الوسيط <code>&</code>.<syntaxhighlight lang="ruby">
n(&lambda {})                #=> true
n(&lambda {})                #=> true
n(&proc {})                  #=> false
n(&proc {})                  #=> false
n(&Proc.new {})              #=> false
n(&Proc.new {})              #=> false


</syntaxhighlight>لا يمتلك كائن Proc المُحوَّل من تابع أي ميِّزات.<syntaxhighlight lang="ruby">
</syntaxhighlight>لا يمتلك كائن <code>Proc</code> المُحوَّل من تابع أي ميِّزات.<syntaxhighlight lang="ruby">
def m() end
def m() end
method(:m).to_proc.lambda?  #=> true
method(:m).to_proc.lambda?  #=> true
سطر 49: سطر 50:
n(&method(:m).to_proc)      #=> true
n(&method(:m).to_proc)      #=> true


</syntaxhighlight>يُعامَل define_method كما يُعامل تعريف التابع. لا يمتلك التابع المُعرَّف أية ميِّزات.<syntaxhighlight lang="ruby">
</syntaxhighlight>يُعامَل <code>define_method</code> كما يُعامل تعريف التابع. لا يمتلك التابع المُعرَّف أية ميِّزات.<syntaxhighlight lang="ruby">
class C
class C
   define_method(:d) {}
   define_method(:d) {}
سطر 56: سطر 57:
C.new.method(:d).to_proc.lambda?  #=> true
C.new.method(:d).to_proc.lambda?  #=> true


</syntaxhighlight>يُعرِّف define_method تابعًا من دون ميِّزات دومًا حتى إذا أُعطي كائنٌ من النوع Proc لم يُنشأ باستعمال lambda. هذا الاستثناء الوحيد الذي لا تُحفظ فيه الميِّزات.<syntaxhighlight lang="ruby">
</syntaxhighlight>يُعرِّف <code>define_method</code> تابعًا من دون ميِّزات دومًا حتى إذا أُعطي كائنٌ من النوع <code>Proc</code> لم يُنشأ باستعمال <code>lambda</code>. هذا الاستثناء الوحيد الذي لا تُحفظ فيه الميِّزات.<syntaxhighlight lang="ruby">
class C
class C
   define_method(:e, &proc {})
   define_method(:e, &proc {})
سطر 73: سطر 74:
C.new.f(1,2)      #=> ArgumentError
C.new.f(1,2)      #=> ArgumentError


</syntaxhighlight>يُعرَّف المُغلِّف def2 تابعًا لا يمتلك ميِّزات.
</syntaxhighlight>يُعرَّف المُغلِّف <code>def2</code> تابعًا لا يمتلك ميِّزات.


== البنية العامة ==
== البنية العامة ==
<syntaxhighlight lang="ruby">
lambda? → true or false
lambda? → true or false
</syntaxhighlight>


== القيم المعادة ==
== القيم المعادة ==
تُعاد القيمة true إذا كانت معالجة الوسائط صارمةً، أو تعاد القيمة false خلاف ذلك.
تُعاد القيمة <code>true</code> إذا كانت معالجة الوسائط صارمةً، أو تعاد القيمة <code>false</code> خلاف ذلك.


== انظر أيضًا ==
== انظر أيضًا ==
* التابع hash: يحسب قيمة التجزئة الموافقة لجسم الكتلة proc التي استدعيت معه ثمَّ يعيدها.
* التابع [[Ruby/Proc/hash|<code>hash</code>]]: يحسب قيمة التجزئة الموافقة لجسم الكتلة <code>proc</code> التي استدعيت معه ثمَّ يعيدها.
* التابع to_proc: يُعدُّ جزءًا من البروتوكول المستخدم في تحويل الكائنات إلى كائناتٍ من الصنف Proc.
* المعامل ===: يستدعي الكتلة بتمرير الكائن الواقع على يمينه كمعاملٍ للنسخة proc.
* التابع call: يستدعي الكتلة المرتبطة بالمتغير الذي استعمل معه مُعيِّنًا معاملات الكتلة إلى القيم المعطاة ضمنه ويُعيد المعامل قيمة آخر تعبيرٍ قُيِّم في الكتلة.


*التابع <code>[[Ruby/Proc/to proc|to_proc]]</code>: يُعدُّ جزءًا من البروتوكول المستخدم في تحويل الكائنات إلى كائناتٍ من الصنف <code>Proc</code>.
*المعامل <code>[[Ruby/Proc/3D-3D-3D|===]]</code>: يستدعي الكتلة بتمرير الكائن الواقع على يمينه كمعاملٍ للنسخة <code>proc</code>.
*التابع <code>[[Ruby/Proc/call|call]]</code>: يستدعي الكتلة المرتبطة بالمتغير الذي استعمل معه مُعيِّنًا معاملات الكتلة إلى القيم المعطاة ضمنه ويُعيد المعامل قيمة آخر تعبيرٍ قُيِّم في الكتلة.
== مصادر ==
== مصادر ==
* [http://ruby-doc.org/core-2.5.1/Proc.html#method-i-lambda-3F صفحة التابع ?lambda في الصنف Proc في توثيق روبي الرسمي.]
* [http://ruby-doc.org/core-2.5.1/Proc.html#method-i-lambda-3F صفحة التابع ?lambda في الصنف Proc في توثيق روبي الرسمي.]

المراجعة الحالية بتاريخ 07:54، 26 نوفمبر 2018

يتحقَّق التابع ?lambda إذا كانت معالجة الوسائط صارمةً في الكائن Proc (أي يجب تمرير نفس العدد تمامًا من الوسائط المعرَّفة عند إنشاء الكائن). تُنشأ هذه الكائنات عادةً بوساطة lambda.

كائنات الصنف Proc المُنشأة بوساطة proc ليست صارمةً وتمتلك الميزات التالية:

  • تتجاهل الوسائط الإضافيَّة:
proc {|a,b| [a,b] }.call(1,2,3)    #=> [1,2]
  • تُعيِّن القيمة nil للوسائط الناقصة:
proc {|a,b| [a,b] }.call(1)        #=> [1,nil]
  • توسِّع وسيط مصفوفة مفردة:
proc {|a,b| [a,b] }.call([1,2])    #=> [1,2]

كائن الصنف Proc المُنشأ بواسطة lambda لا يمتلك هذه الميِّزات.

lambda {|a,b| [a,b] }.call(1,2,3)  #=> ArgumentError
lambda {|a,b| [a,b] }.call(1)      #=> ArgumentError
lambda {|a,b| [a,b] }.call([1,2])  #=> ArgumentError

التابع ?lambda هو تابعٌ خَبَريٌ (predicate) لهذه الميِّزات. يُعيد القيمة true إذا لم تُطبَّق أي ميِّزة.

lambda {}.lambda?            #=> true
proc {}.lambda?              #=> false

يؤدي التابع new نفس عمل proc.

Proc.new {}.lambda?          #=> false

تحافظ lambda و proc و new على ميزات كائن الصنف Proc المعطيَّة بالوسيط &.

lambda(&lambda {}).lambda?   #=> true
proc(&lambda {}).lambda?     #=> true
Proc.new(&lambda {}).lambda? #=> true

lambda(&proc {}).lambda?     #=> false
proc(&proc {}).lambda?       #=> false
Proc.new(&proc {}).lambda?   #=> false

يمتلك كائن الصنف Proc المُنشَأ عبر الوسيط & تلك الميزات.

def n(&b) b.lambda? end
n {}                         #=> false

يحتفظ الوسيط & بهذه الميِّزات إذا أُعطي كائن الصنف Proc عبر الوسيط &.

n(&lambda {})                #=> true
n(&proc {})                  #=> false
n(&Proc.new {})              #=> false

لا يمتلك كائن Proc المُحوَّل من تابع أي ميِّزات.

def m() end
method(:m).to_proc.lambda?   #=> true

n(&method(:m))               #=> true
n(&method(:m).to_proc)       #=> true

يُعامَل define_method كما يُعامل تعريف التابع. لا يمتلك التابع المُعرَّف أية ميِّزات.

class C
  define_method(:d) {}
end
C.new.d(1,2)       #=> ArgumentError
C.new.method(:d).to_proc.lambda?   #=> true

يُعرِّف define_method تابعًا من دون ميِّزات دومًا حتى إذا أُعطي كائنٌ من النوع Proc لم يُنشأ باستعمال lambda. هذا الاستثناء الوحيد الذي لا تُحفظ فيه الميِّزات.

class C
  define_method(:e, &proc {})
end
C.new.e(1,2)       #=> ArgumentError
C.new.method(:e).to_proc.lambda?   #=> true

يَضمن هذا الاستثناء أنَّ التوابع لا تمتلك ميِّزاتٍ ويجعل من السَّهل على المُغلِّفات (wrappers) تعريف التوابع التي تسلك سلوكًا طبيعيًّا.

class C
  def self.def2(name, &body)
    define_method(name, &body)
  end

  def2(:f) {}
end
C.new.f(1,2)       #=> ArgumentError

يُعرَّف المُغلِّف def2 تابعًا لا يمتلك ميِّزات.

البنية العامة

lambda?  true or false

القيم المعادة

تُعاد القيمة true إذا كانت معالجة الوسائط صارمةً، أو تعاد القيمة false خلاف ذلك.

انظر أيضًا

  • التابع hash: يحسب قيمة التجزئة الموافقة لجسم الكتلة proc التي استدعيت معه ثمَّ يعيدها.
  • التابع to_proc: يُعدُّ جزءًا من البروتوكول المستخدم في تحويل الكائنات إلى كائناتٍ من الصنف Proc.
  • المعامل ===: يستدعي الكتلة بتمرير الكائن الواقع على يمينه كمعاملٍ للنسخة proc.
  • التابع call: يستدعي الكتلة المرتبطة بالمتغير الذي استعمل معه مُعيِّنًا معاملات الكتلة إلى القيم المعطاة ضمنه ويُعيد المعامل قيمة آخر تعبيرٍ قُيِّم في الكتلة.

مصادر