যখন লম্বডা ব্যবহার করা হবে, তখন Proc.new ব্যবহার করতে হবে?

রুবি 1.8 এ, একদিকে proc / lambda মধ্যে সূক্ষ্ম পার্থক্য আছে, এবং অন্যদিকে নতুন।

  • এই পার্থক্যগুলি কি?
  • আপনি কোনটি চয়ন করতে পারেন তা নির্ধারণ করার জন্য কি নির্দেশিকা দিতে পারেন?
  • রুবি 1.9, প্রসেস এবং ল্যাম্বডা ভিন্ন। চুক্তি কি?
0
যোগ সম্পাদিত
মতামত: 1
আপনি উত্তর গ্রহণ করেছেন যে কেবলমাত্র প্রসেস এবং ল্যাম্বডার মধ্যে পার্থক্য কি বলে, যখন আপনার প্রশ্নটির শিরোনাম হল সেগুলি ব্যবহার করার সময়
যোগ লেখক Shri, উৎস
আরও দেখুন: রুবি প্রোগ্রামিং ভাষা বইটি ম্যাট এবং ফ্লানাগন দ্বারা, এটি ব্যাপকভাবে এই বিষয়টিকে আচ্ছাদিত করেছে। proc একটি ব্লক - ফলক শব্দবিদ্যা মত আচরণ করে, যেখানে লম্বda একটি পদ্ধতি মত আচরণ - পদ্ধতি কল শব্দবিজ্ঞান। এছাড়াও ফিরে, বিরতি, এবং সব procs এন lambdas মধ্যে diff আচরণ
যোগ লেখক Gishu, উৎস
এটি CEWP ব্যবহার করার সুপারিশ করা হয় না কারণ এটি অনেকগুলি কারণ URL গুলি সম্পূর্ণ ইউআরএল হিসাবে সঞ্চয় করে থাকে, এর সংস্করণ ইতিহাস নেই ইত্যাদি। andrewconnell.com/blog/archive/2009/02/01/করছে & hellip;
যোগ লেখক Greg, উৎস
আগে যে শোনা ছিল না, কিন্তু যে অর্থে তোলে এই প্রচেষ্টাটি ছিল এমন এক, যেখানে আমরা শর্ট কাট করার চেষ্টা করেছি। এই পোস্টের অল্পসময় পরে আমরা সেই পথটি বাতিল করেছিলাম এবং দেখুন পৃষ্ঠার পরিবর্তে শ্রেণীতে নির্দিষ্ট একটি বিন্যাস বিকাশ করার সিদ্ধান্ত নিয়েছে।
যোগ লেখক Daemin, উৎস
এছাড়াও ruby Procs এবং Lambdas এর মধ্যে প্রবাহের পার্থক্যগুলি নিয়ন্ত্রণ করুন
যোগ লেখক Akshay Rawat, উৎস

13 উত্তর

এসপি ডিজাইনার ব্যবহার করে এটি পরীক্ষা করার চেষ্টা করুন

2
যোগ
ভাল যে কাজ এটি আরও অদ্ভুত যে, আমাদের 10 টি পরিবর্তনের অন্যান্য সেটিংগুলির জন্য এটি আগে পরীক্ষা করা হয়নি। যেহেতু মতামত কন্টেন্ট অনুমোদন না, এবং এটি ইন্টারফেস এটি SPD মধ্যে এটি করতে আমার না ঘটতে মাধ্যমে করা যাবে না। ধন্যবাদ!
যোগ লেখক Daemin, উৎস

আমি এই পৃষ্ঠাটি পেয়েছি যা দেখায় যে Proc.new এবং < কোড> লেবান্ড </কোড> হয়। পৃষ্ঠার মতে, একমাত্র পার্থক্য হচ্ছে যে লেবেলটি গ্রহণ করা আর্গুমেন্টের সংখ্যাটি কঠোর, তবে Proc.new নিল </কোড> তে অনুপস্থিত আর্গুমেন্টগুলি পরিবর্তিত করে। এখানে আইআরবি সেশনের একটি উদাহরণ হল পার্থক্য ব্যাখ্যা করা:

irb(main):001:0> l = lambda { |x, y| x + y }
=> #
irb(main):002:0> p = Proc.new { |x, y| x + y }
=> #
irb(main):003:0> l.call "hello", "world"
=> "helloworld"
irb(main):004:0> p.call "hello", "world"
=> "helloworld"
irb(main):005:0> l.call "hello"
ArgumentError: wrong number of arguments (1 for 2)
    from (irb):1
    from (irb):5:in `call'
    from (irb):5
    from :0
irb(main):006:0> p.call "hello"
TypeError: can't convert nil into String
    from (irb):2:in `+'
    from (irb):2
    from (irb):6:in `call'
    from (irb):6
    from :0

The page also recommends using lambda unless you specifically want the error tolerant behavior. I agree with this sentiment. Using a lambda seems a tad more concise, and with such an insignificant difference, it seems the better choice in the average situation.

As for ruby 1.9, sorry, I haven't looked into 1.9 yet, but I don't imagine they would change it all that much (don't take my word for it though, it seems you have heard of some changes, so I am probably wrong there).

0
যোগ
তুলনা lambdas তুলনায় ভিন্নভাবে ফিরে।
যোগ লেখক Cam, উৎস
"" "Proc.new নীল থেকে অনুপস্থিত আর্গুমেন্ট রূপান্তরিত" "Proc.new অতিরিক্ত আর্গুমেন্ট উপেক্ষা (অবশ্যই লেবান্ড একটি ত্রুটি সঙ্গে এই অভিযোগ)।
যোগ লেখক weakish, উৎস

রিটার্ন </কোড> এর সাথে আচরণের পার্থক্য হচ্ছে IMHO ২ এর মধ্যে সবচেয়ে গুরুত্বপূর্ণ পার্থক্য। আমি ল্যাম্বডা পছন্দ করি কারণ এটি Proc.new এর তুলনায় কম টাইপিং রয়েছে :-)

0
যোগ
আপডেট করতে: procs এখন proc {} ব্যবহার করে তৈরি করা যায়। আমি নিশ্চিত নই যখন এটি কার্যকর হয়ে গেছে, কিন্তু Proc.new টাইপ করার চেয়ে এটি (সামান্য) সহজ।
যোগ লেখক aceofbassgreg, উৎস

অ্যাকর্ডিয়ন গায় এর প্রতিক্রিয়া বিস্তারিতভাবে ব্যাখ্যা করতে:

লক্ষ্য করুন যে Proc.new একটি ব্লক প্রেরণ করে একটি প্র্যাকটিস তৈরি করে। আমি বিশ্বাস করি যে ল্যাম্বডা {...} একটি পদ্ধতির পরিবর্তে একটি শাখায় রূপান্তরিত হয় যা ব্লকটি পাস করে। ফেরত </কোড> একটি পদ্ধতি কল সংযুক্ত একটি ব্লক ভিতর ing থেকে, পদ্ধতি থেকে ফিরে আসবে, এবং Proc.new মামলা এটি খেলার একটি উদাহরণ।

(এই 1.8 হয়। আমি জানি না কিভাবে এই অনুবাদ 1.9।)

0
যোগ

আমি এটাকে একটু দেরী করছি, তবে এখানে একটি মহান কিন্তু সামান্য পরিচিত জিনিস Proc.new সম্পর্কে মন্তব্য করা হয়নি। ডকুমেন্টেশন অনুসারে:

প্রস: নতুন একটি সংযুক্ত ব্লক সহ একটি পদ্ধতিতে ব্লক ছাড়াও বলা যেতে পারে, যে ক্ষেত্রে ব্লকটি Proc <// শক্তিশালী> অবজেক্ট।

যে বলেন, <�কোড> Proc.new চেন উত্পাদন পদ্ধতিতে দেয়:

def m1
  yield 'Finally!' if block_given?
end

def m2
  m1 &Proc.new
end

m2 { |e| puts e } 
#? Finally!
0
যোগ
আকর্ষণীয়, এটা এবং defএবং ব্লক আর্গুমেন্ট ঘোষণা করার মত একই জিনিস করে কিন্তু ডিগ্র আরগ তালিকায় তা না করেই।
যোগ লেখক jrochkind, উৎস

এটি দেখতে ভাল উপায় হল যে লম্বডাগুলি তাদের নিজস্ব সুযোগসুবিধায় মৃত্যুদন্ড কার্যকর করা হয় (যেমন এটি একটি পদ্ধতিগত কল ছিল), যখন প্রসেসগুলি কলিং পদ্ধতির সাথে সম্পাদিত ইনলাইন হিসেবে দেখা যেতে পারে, অন্তত এটি ব্যবহার করার জন্য যে কোনও একটিকে বেছে নেওয়ার একটি ভাল উপায়। অস্ত্রোপচার.

0
যোগ

আমি সূক্ষ্ম পার্থক্য সম্পর্কে অনেক কিছু বলতে পারেন না। যাইহোক, আমি উল্লেখ করতে পারি যে ruby 1.9 এখন lambdas এবং ব্লকগুলির জন্য ঐচ্ছিক পরামিতিগুলি অনুমোদন করে।

এখানে স্ট্যাব্বি কম্বল জন্য নতুন সিনট্যাক্স 1.9 অধীনে:

stabby = ->(msg='inside the stabby lambda') { puts msg }

রুবি 1.8 তে সিনট্যাক্স নেই। ব্লক ঘোষণা করার প্রচলিত উপায় / lambdas ঐচ্ছিক আর্গুম সমর্থন না:

# under 1.8
l = lambda { |msg = 'inside the stabby lambda'|  puts msg }
SyntaxError: compile error
(irb):1: syntax error, unexpected '=', expecting tCOLON2 or '[' or '.'
l = lambda { |msg = 'inside the stabby lambda'|  puts msg }

রুবি 1.9, যদিও, পুরোনো সিনট্যাক্সের সাথে ঐচ্ছিক আর্গুমেন্ট সমর্থন করে:

l = lambda { |msg = 'inside the regular lambda'|  puts msg }
#=> #
l.call
#=> inside the regular lambda
l.call('jeez')
#=> jeez

If you wanna build Ruby1.9 for Leopard or Linux, check out this article (shameless self promotion).

0
যোগ
আপনি ব্লক ডিফল্ট পরামিতি দেখাচ্ছে না, শুধুমাত্র lambdas
যোগ লেখক iconoclast, উৎস
লম্বডা এর মধ্যে ঐচ্ছিক পরামিতিগুলি অনেক প্রয়োজন ছিল, আমি খুশি যে তারা 1.9 এ যোগ করেছে। আমি অনুমান ব্লক এছাড়াও ঐচ্ছিক প্যারামিটার এমনকি খুব আছে (1.9)?
যোগ লেখক mpd, উৎস

আরো স্পষ্টীকরণ প্রদান:

জোয়ি বলেছেন যে পুনঃপ্রতিষ্ঠা </কোড> এর বিনিময়ের আচরণ বিস্ময়কর। তবে যখন আপনি বিবেচনা করেন যে Proc.new একটি ব্লকের মত আচরণ করে তবে এটি বিস্ময়কর নয় কারণ এটি ব্লকগুলি যথোপযুক্তভাবে আচরণ করে না। অন্যদিকে লাম্বা অনেক বেশি পদ্ধতিতে আচরণ করে।

এটি আসলে ব্যাখ্যা করে কেন প্রসেসগুলি নমনীয় হয় যখন এটি আদিমত্বের (আর্গুমেন্টের সংখ্যা) আসে তবে ল্যাম্বদাস নয়। ব্লকগুলি তাদের সমস্ত আর্গুমেন্টের প্রয়োজন হয় না তবে পদ্ধতিগুলি (যদি না একটি ডিফল্ট দেওয়া হয়) লেব্বা আর্গুমেন্ট ডিফল্ট প্রদান করার সময় রুবি 1.8-তে একটি বিকল্প নয়, এটি বিকল্প ল্যাম্বা সিনট্যাক্সের সাথে রুবি 1.9 তে সমর্থিত (ওয়েবমেট দ্বারা উল্লিখিত):

concat = ->(a, b=2){ "#{a}#{b}" }
concat.call(4,5) # => "45"
concat.call(1)   # => "12"

এবং Michiel ডি Mare (OP) পদ্ধতি এবং Lambda রুবি 1.9 মধ্যে arity সঙ্গে একই আচরণ আচরণ সম্পর্কে ভুল। আমি যাচাই করা আছে যে তারা এখনো 1.8 হিসাবে উপরে উল্লিখিত আচরণ বজায় রাখে।

break statements don't actually make much sense in either Procs or lambdas. In Procs, the break would return you from Proc.new which has already been completed. And it doesn't make any sense to break from a lambda since it's essentially a method, and you would never break from the top level of a method.

next, redo, and raise behave the same in both Procs and lambdas. Whereas retry is not allowed in either and will raise an exception.

এবং অবশেষে, proc পদ্ধতিটি ব্যবহার করা উচিত না কারণ এটি অসঙ্গত এবং অপ্রত্যাশিত আচরণ। রুবি 1.8 এটি আসলে একটি লাবাডা ফেরৎ! রুবি 1.9 এ এটি সংশোধন করা হয়েছে এবং এটি একটি প্রসেস প্রদান করে। যদি আপনি কোন প্রকার তৈরি করতে চান, তবে Proc.new এর সাথে থাকুন।

আরো তথ্যের জন্য, আমি অত্যন্ত O'Reilly এর রুবি প্রোগ্রামিং ভাষা সুপারিশ করছি যা এই তথ্যের জন্য আমার উৎস।

0
যোগ
"" "তবে যখন আপনি বিবেচনা করেন যে Proc.new একটি ব্লকের মত আচরণ করে তবে এটি অদ্ভুত নয় কারণ ব্লকগুলি যথাযথভাবে আচরণ করে।" "" <- ব্লক একটি বস্তুর অংশ, যখন Proc.new একটি বস্তু তৈরি করে উভয় Lambda এবং Proc.new একটি বস্তুর সৃষ্টি করে যার বর্গ প্রকার, কেন পার্থক্য?
যোগ লেখক weakish, উৎস

ল্যাম্বা </কোড> এবং Proc.new দিয়ে তৈরি procs এ return স্টেটমেন্টটি কিভাবে পরিচালনা করে তা হল:

  • In a lambda-created proc, the return statement returns only from the proc itself
  • In a Proc.new-created proc, the return statement is a little more surprising: it returns control not just from the proc, but also from the method enclosing the proc!

এখানে <�কোড> ল্যাম্বডা </কোড> - অ্যাক্সেসেড প্রসেসের <�কোড> প্রত্যাবর্তন </কোড>। এটা সম্ভবত আপনি আশা যে একটি উপায় আচরণ:

def whowouldwin

  mylambda = lambda {return "Freddy"}
  mylambda.call

  # mylambda gets called and returns "Freddy", and execution
  # continues on the next line

  return "Jason"

end


whowouldwin
#=> "Jason"

এখন এখানে একটি Proc.new -সেটেড প্রসেস এর <�কোড> রিটার্ন একই জিনিস করছেন। আপনি এমন একটি মামলা দেখতে পাচ্ছেন যেখানে রুবি কমপক্ষে সবচেয়ে আশ্চর্যজনক নীতিমালা ভঙ্গ করে:

def whowouldwin2

  myproc = Proc.new {return "Freddy"}
  myproc.call

  # myproc gets called and returns "Freddy", 
  # but also returns control from whowhouldwin2!
  # The line below *never* gets executed.

  return "Jason"

end


whowouldwin2         
#=> "Freddy"

এই বিস্ময়কর আচরণের জন্য ধন্যবাদ (কম টাইপিং হিসাবেও), আমি lambda ওভার Proc.new ব্যবহার করে প্রজেক্ট তৈরির পক্ষে সমর্থন করি।

0
যোগ
যোগ লেখক ma11hew28, উৎস
আমি বিশ্বাস করি যে একটি বড় পার্থক্য হল যে প্রসেস </ কোড> গুলি ভুল / অতিরিক্ত আর্গুমেন্টগুলি প্রদান করে না যখন lambda গুলি একটি ভুল আর্গুমেন্টের সংখ্যা নিক্ষেপ করবে ত্রুটি
যোগ লেখক Edmund, উৎস
@ মেটডিপাস্কেল আমার পরীক্ষায়, proc লেবেল এর মতো কাজ করে এবং রিটার্ন স্টেটমেন্টের সাথে Proc.new পছন্দ করে না। মানে রুবি ডকটি অস্পষ্ট।
যোগ লেখক Kelvin, উৎস
@ ম্যাটডিপাস্কেলে দুঃখিত আমি মাত্র অর্ধেক ডান proc লম্বডা মত কাজ </ কোড> 1.8 এ, কিন্তু 1.9 মধ্যে Proc.new এর মত কাজ করে। পিটার Wagenet এর উত্তর দেখুন।
যোগ লেখক Kelvin, উৎস
তারপর এখানে proc পদ্ধতিও রয়েছে। এটা কি কোডের জন্য একটি সংজ্ঞায়িত?
যোগ লেখক panzi, উৎস
কেন এই "বিস্ময়কর" আচরণ? একটি লম্বডা </ কোড> একটি বেনামী পদ্ধতি। যেহেতু এটা একটি পদ্ধতি, এটি একটি মান ফেরত দেয়, এবং এটি বলা হয় যে পদ্ধতিটি এটি চাই, এটি উপেক্ষা এবং একটি ভিন্ন মান ফেরত সহ এটি করতে পারেন যাই হোক না কেন। একটি প্রসেস </ কোড> একটি কোড স্নিপেটে আটকানো মত। এটি একটি পদ্ধতি মত কাজ করে না। সুতরাং যখন একটি রিটার্নটি প্রসেস / কোড> এর মধ্যে হয়, তখন এটি সেই পদ্ধতির কোডের অংশ যা এটি বলে।
যোগ লেখক Arcolye, উৎস
Arcolye দ্বারা নির্দেশিত হিসাবে, "রুবি মধ্যে প্রসেস কোড স্ন্যিপ্ট ড্রপ হয়, না পদ্ধতি"। থেকে robertsosinski.com/2008/12/ থেকে 21 / করছে & hellip; । তাই এটি রিটার্ন মত whowouldwin2 নিজেই হয়।
যোগ লেখক Pietro, উৎস

আমি queston মধ্যে তৃতীয় পদ্ধতিতে কোন মন্তব্য লক্ষ্য করেনি, "proc" যা অবচিত হয়, কিন্তু 1.8 এবং 1.9 এ ভিন্নভাবে পরিচালিত।

এখানে একটি মোটামুটি মূল্যবোধের উদাহরণ যা এই তিনটি অনুরূপ কলগুলির মধ্যে পার্থক্যগুলি দেখতে সহজ করে তোলে:

def meth1
  puts "method start"

  pr = lambda { return }
  pr.call

  puts "method end"  
end

def meth2
  puts "method start"

  pr = Proc.new { return }
  pr.call

  puts "method end"  
end

def meth3
  puts "method start"

  pr = proc { return }
  pr.call

  puts "method end"  
end

puts "Using lambda"
meth1
puts "--------"
puts "using Proc.new"
meth2
puts "--------"
puts "using proc"
meth3
0
যোগ
আমি মনে করি Pickaxe একটি পাদটীকা মধ্যে কোথাও যে proc হয় কার্যকরভাবে depricated বা কিছু। আমার সঠিক পৃষ্ঠার সংখ্যা নেই।
যোগ লেখক dertoni, উৎস
@ ব্যাবসার: proc 1.8 তে একটি ল্যাম্বা ফিরিয়ে আনা; এটি এখন 1.9 একটি ক্রয় ফেরত নির্ধারিত হয়েছে - তবে এটি একটি বিরতি পরিবর্তন; তাই এখন আর ব্যবহার করার সুপারিশ নেই
যোগ লেখক Gishu, উৎস
যেখানে আপনি যে proc অপহৃত ছিল পড়া হয়নি?
যোগ লেখক horseyguy, উৎস
Matz তিনি এটি প্রত্যাহার করার পরিকল্পনা বলেছিলেন যে কারণ এটি proc এবং Proc.new বিভিন্ন ফলাফল ফেরত যাও বিভ্রান্তিকর ছিল। 1.9 এ তারা একই আচরণ করে (proc প্রসপেক্টএউউএল থেকে একটি উপনাম)। eigenclass.org/hiki/Changes+in+Ruby+1.9#l47
যোগ লেখক Dave Rapin, উৎস

সংক্ষিপ্ত উত্তর: কি কোড হয়: ল্যাম্বডা নিজেই ফিরে আসে, এবং proc নিজের থেকে ফিরে আসে এবং এটি বলা ফাংশন।

আপনি প্রতিটি ব্যবহার করতে চান কেন কম স্পষ্ট হয়। লাম্বা আমরা যা আশা করি তার একটি কার্যকরী প্রোগ্রামারাইজড অর্থে কি করা উচিত। এটি মূলত বর্তমান সুযোগ সঙ্গে স্বয়ংক্রিয়ভাবে আবদ্ধ একটি বেনামী পদ্ধতি। দুইটি, লাম্বাটি হচ্ছে আপনার সম্ভবত ব্যবহার করা উচিত।

অন্যদিকে প্রসপ, ভাষা নিজেই বাস্তবায়ন করার জন্য সত্যিই দরকারী। উদাহরণস্বরূপ আপনি "if" স্টেটমেন্টগুলি বা তাদের সাথে "loops" করতে পারেন। ক্রয়ের মধ্যে পাওয়া যে কোনও রিটার্নটি পদ্ধতিটি থেকে বের হয়ে আসবে, এটি শুধু "if" বিবৃতি নয়। এইভাবে ভাষাগুলি কীভাবে কাজ করে, কিভাবে "যদি" বিবৃতি কাজ করে, তাই আমার অনুমান হল রুবি কভারের নিচে এইটি ব্যবহার করে এবং এটি কেবল এটি প্রকাশ করে কারণ এটি শক্তিশালী মনে হচ্ছে

আপনি যদি সত্যিই নতুন ভাষা তৈরি করেন যেমন loops, অন্যথায় তৈরি করা ইত্যাদি।

0
যোগ

Understanding ruby Blocks, Procs and Lambdas by Robert Sosinski clearly explains these programming concepts and reinforces the explanations with example code. Method objects are related and covered as well.

0
যোগ

লাফল্ড অন্যান্য ভাষার মতো প্রত্যাশার সাথে কাজ করে।

ওয়্যার্ড <�কোড> প্রসারিত। বিস্ময়কর এবং বিভ্রান্তিকর।

রিটার্ন </কোড> স্টেটমেন্টে Proc.new দ্বারা তৈরি করা হয় কেবল নিজের থেকে নিয়ন্ত্রণ ফেরত দেবে না, তবে এটিকে অন্তর্ভুক্ত করা পদ্ধতি থেকেও

def some_method
  myproc = Proc.new {return "End."}
  myproc.call

  # Any code below will not get executed!
  # ...
end

আপনি যুক্তি দিতে পারেন যে Proc.new কোডটিকে সন্নিবেশিত পদ্ধতিতে সন্নিবেশ করান, ঠিক যেমন ব্লক। কিন্তু Proc.new একটি বস্তু তৈরি করে, যখন ব্লক একটি বস্তুর অংশ

এবং লম্বডা এবং Proc.new এর মধ্যে আরেকটি পার্থক্য আছে, যা তাদের (ভুল) আর্গুমেন্টগুলি পরিচালনা করছে। ল্যাম্বা এই বিষয়ে অভিযোগ করে, যখন Proc.new অতিরিক্ত আর্গুমেন্টগুলি উপেক্ষা করে বা নিখরচায় আর্গুমেন্টের অনুপস্থিতি বিবেচনা করে।

irb(main):021:0> l = -> (x) { x.to_s }
=> #
irb(main):022:0> p = Proc.new { |x| x.to_s}
=> #
irb(main):025:0> l.call
ArgumentError: wrong number of arguments (0 for 1)
        from (irb):21:in `block in irb_binding'
        from (irb):25:in `call'
        from (irb):25
        from /usr/bin/irb:11:in `
' irb(main):026:0> p.call => "" irb(main):049:0> l.call 1, 2 ArgumentError: wrong number of arguments (2 for 1) from (irb):47:in `block in irb_binding' from (irb):49:in `call' from (irb):49 from /usr/bin/irb:11:in `
' irb(main):050:0> p.call 1, 2 => "1"

BTW, proc in ruby 1.8 creates a lambda, while in ruby 1.9+ behaves like Proc.new, which is really confusing.

0
যোগ