"शून्य या शून्य" के लिए सर्वश्रेष्ठ रूबी मुहावरे

Question 1

मैं यह देखने के लिए एक संक्षिप्त तरीके की तलाश कर रहा हूं कि क्या यह शून्य या शून्य है या नहीं। वर्तमान में मैं कुछ ऐसा कर रहा हूं:

if (!val || val == 0)
  # Is nil or zero
end

लेकिन यह बहुत ही भद्दा लगता है।

Question 2

वस्तुओं में एक शून्य है? विधि ।

if val.nil? || val == 0
  [do something]
end

या, सिर्फ एक निर्देश के लिए:

[do something] if val.nil? || val == 0

Question 3

यदि आपको वास्तव में अंत में प्रश्नवाचक चिन्ह वाले विधि नाम पसंद हैं:


if val.nil? || val.zero?
  # do stuff
end

आपका समाधान ठीक है, जैसा कि कुछ अन्य समाधान हैं।

यदि आप सावधान नहीं हैं, तो रूबी आपको सब कुछ करने के लिए एक शानदार तरीके से खोज कर सकती है।

Question 4

रूबी 2.3.0 आगे से, आप सुरक्षित नेविगेशन ऑपरेटर ( &.) के साथ संयोजन कर सकते हैं Numeric#nonzero?। यदि संख्या थी और - यदि संख्या थी तो &.रिटर्न :nilnilnonzero?0

unless val&.nonzero?
  # Is nil or zero
end

या पोस्टफिक्स:

do_something unless val&.nonzero?

Question 5

सबसे पहले मुझे लगता है कि आप उस विशेष स्थिति के लिए जाँच कर सकते हैं सबसे संक्षिप्त तरीके के बारे में है।

दूसरा, मेरे लिए यह एक कोड गंध है जो आपके डिजाइन में संभावित दोष को इंगित करता है। आम तौर पर शून्य और शून्य का मतलब एक ही चीज़ नहीं होना चाहिए। यदि संभव हो तो आपको इस कोड को हिट करने से पहले वैल होने की संभावना को खत्म करने की कोशिश करनी चाहिए, या तो यह देखने के लिए कि विधि या किसी अन्य तंत्र की शुरुआत में।

ऐसा करने के लिए आपके पास एक पूरी तरह से वैध कारण हो सकता है, जिस स्थिति में मुझे लगता है कि आपका कोड अच्छा है, लेकिन मैं कम से कम इस बात पर विचार करना चाहूंगा कि यदि संभव हो तो शून्य जांच से छुटकारा पाएं।

Question 6

आप Object.nil का उपयोग कर सकते हैं? विशेष रूप से नील के लिए परीक्षण करने के लिए (और झूठे और नील के बीच नहीं फंसना)। आप एक विधि के रूप में अच्छी तरह से वस्तु में बंदर कर सकते हैं।

class Object
   def nil_or_zero?
     return (self.nil? or self == 0)
   end
end

my_object = MyClass.new
my_object.nil_or_zero?
==> false

यह अनुशंसित नहीं है क्योंकि सहकर्मियों के लिए ऑब्जेक्ट में परिवर्तन ट्रेस करना मुश्किल है, और आपके कोड को दूसरों के लिए अप्रत्याशित बना सकते हैं।

Question 7

nil.to_i शून्य देता है, इसलिए मैं अक्सर ऐसा करता हूं:

val.to_i.zero?

हालाँकि, आपको एक अपवाद मिलेगा यदि वैल एक ऐसी वस्तु है जो प्रतिक्रिया नहीं देती है।

Question 8

मेरा मानना है कि आपका कोड गलत है; : यह तीन मूल्यों के लिए तथ्य परीक्षा में होगा nil, falseऔर शून्य,। ऐसा इसलिए है क्योंकि !valअभिव्यक्ति उन सभी मूल्यों के लिए सही है जो झूठे हैं, जो रूबी में है nilऔर false।

सबसे अच्छा मैं अभी आ सकता हूं

if val == nil || val == 0
  # do stuff
end

कौन सा पाठ्यक्रम बहुत चालाक नहीं है, लेकिन (बहुत) स्पष्ट है।

Question 9

मेरा समाधान भी परिशोधन का उपयोग करता है, स्थिति को छोटा करता है।

module Nothingness
  refine Numeric do
    alias_method :nothing?, :zero?
  end

  refine NilClass do
    alias_method :nothing?, :nil?
  end
end

using Nothingness

if val.nothing?
  # Do something
end

Question 10

रेल यह विशेषता क्वेरी विधियों के माध्यम से करता है, जहां गलत और शून्य के अलावा, 0 और "" भी गलत का मूल्यांकन करता है।

if (model.attribute?) # => false if attribute is 0 and model is an ActiveRecord::Base derivation

हालाँकि, इसके पास अवरोधकों का अपना हिस्सा है। http://www.joegrossberg.com/archives/002995.html

Question 11

संभव के रूप में मुहावरेदार होने के लिए, मैं यह सुझाव देता हूं।

if val.nil? or val == 0
    # Do something
end

चूंकि:

यह नील का उपयोग करता है? तरीका।
यह "या" ऑपरेटर का उपयोग करता है, जो बेहतर है ||
यह कोष्ठकों का उपयोग नहीं करता है, जो इस मामले में आवश्यक नहीं हैं। कोष्ठक का उपयोग केवल तब किया जाना चाहिए जब वे किसी उद्देश्य की पूर्ति करते हैं, जैसे कि कुछ ऑपरेटरों की पूर्वता को ओवरराइड करना।

Question 12

छोटा और स्पष्ट

[0, nil].include?(val)

Question 13

सबसे छोटा और सबसे अच्छा तरीका होना चाहिए

if val&.>(0)
  # do something
end

इसके लिए val&.>(0) जब शून्य शून्य होता है तब से शून्य वापस आ जाता है> मूल रूप से एक विधि भी है, माणिक में झूठे के बराबर शून्य। यह झूठे जब लौटते हैं val == 0।

Question 14

मैं एक "है?" को परिभाषित करके इससे निपटता हूं विधि, जिसे मैं बाद में विभिन्न वर्गों पर अलग-अलग लागू कर सकता हूं। तो ऐरे के लिए, "है?" का अर्थ है "आकार> 0"; फिक्सनम के लिए इसका अर्थ है "स्व! = 0"; स्ट्रिंग के लिए इसका अर्थ है "स्व! = ''"। निलक्लास, निश्चित रूप से, परिभाषित करता है "है?" बस के रूप में शून्य लौट रहा है।

Question 15

आप चाहें caseतो इस्तेमाल कर सकते हैं :

 case val with nil, 0
      # do stuff
 end

फिर आप कुछ भी काम कर सकते हैं ===, जो कभी-कभी अच्छा होता है। या ऐसा कुछ करें:

not_valid = nil, 0
case val1 with *not_valid
      # do stuff
 end
 #do other stuff
 case val2 with *not_valid, false    #Test for values that is nil, 0 or false
      # do other other stuff
 end

यह बिल्कुल अच्छा OOP नहीं है, लेकिन यह बहुत लचीला है और यह काम करता है। मेरा ifआमतौर पर caseवैसे भी खत्म होता है।

निश्चित रूप से Enum.any?/ Enum.include?तरह के काम भी ... यदि आप वास्तव में गुप्त रखना चाहते हैं:

if [0, nil].include? val
    #do stuff
end

एक विधि या कार्य को परिभाषित करने के लिए सही काम करना निश्चित रूप से है। या, यदि आपको कई मूल्यों के साथ एक ही काम करना है, तो उन अच्छे पुनरावृत्तियों के संयोजन का उपयोग करें।

Question 16

मैं वास्तव में रेल की तरह blank?बातें उस तरह के लिए विधि है, लेकिन यह नहीं लौटेगा trueके लिए 0। तो आप अपना तरीका जोड़ सकते हैं:

def nil_zero? 
  if respond_to?(:zero?) 
    zero? 
  else 
    !self 
  end 
end

और यह जांच करेगा कि क्या कुछ मूल्य शून्य है या 0:

nil.nil_zero?
=> true
0.nil_zero?
=> true
10.nil_zero?
=> false

if val.nil_zero?
  #...
end

Question 17

बंदर को एक कक्षा में रखने के बजाय, आप रूबी 2.1 में शुरू होने वाले शोधन का उपयोग कर सकते हैं । शोधन बंदर पैचिंग के समान है; उस में, वे आपको कक्षा को संशोधित करने की अनुमति देते हैं, लेकिन संशोधन उस दायरे तक सीमित है जिसे आप इसमें उपयोग करना चाहते हैं।

यदि आप एक बार इस जाँच को करना चाहते हैं तो यह ओवरकिल है, लेकिन यदि आप अपने आप को दोहरा रहे हैं तो यह बन्दर पैचिंग का एक बढ़िया विकल्प है।

module NilOrZero
  refine Object do
    def nil_or_zero?
      nil? or zero?
    end
  end
end

using NilOrZero
class Car
  def initialize(speed: 100)
    puts speed.nil_or_zero?
  end
end

car = Car.new              # false
car = Car.new(speed: nil)  # true
car = Car.new(speed: 0)    # true

अंतिम मिनट में फ़ाइल में स्कूप करने के लिए परिशोधन को बदल दिया गया था। तो पहले के उदाहरणों ने यह दिखाया होगा, जो काम नहीं करेगा।

class Car
  using NilOrZero
end

Question 18

यह बहुत संक्षिप्त है:

if (val || 0) == 0
  # Is nil, false, or zero.
end

यह तब तक काम करता है जब तक आप falseउसी के साथ व्यवहार नहीं करते nil। मैंने जिन परियोजनाओं में काम किया है, उनमें यह अंतर केवल एक बार में ही मायने रखता है। बाकी समय मैं व्यक्तिगत रूप से स्किप करना पसंद करता हूं .nil?और थोड़ा कम कोड रखता हूं ।

[ अद्यतन : मैं इस तरह की बात किसी भी अधिक नहीं लिखता हूं। यह काम करता है लेकिन बहुत गूढ़ है। मैंने कुछ जगहों पर जहां मैंने यह किया है, बदलकर अपने कुकर्मों को सही करने की कोशिश की है।]

वैसे, मैंने इसका उपयोग नहीं किया .zero?क्योंकि यह एक अपवाद को बढ़ाता valहै, अगर कहते हैं, एक स्ट्रिंग। लेकिन .zero?ठीक होगा यदि आप जानते हैं कि ऐसा नहीं है।

Question 19

यह शून्य और शून्य के लिए सही का मूल्यांकन करता है: nil.to_s.to_d == 0

Question 20

unless (val || 0).zero?

    # do stufff

end

Question 21

एक और समाधान:

if val.to_i == 0
  # do stuff
end

Question 22

val ||= 0
if val == 0
# do something here
end