groovy
ग्रूवी ट्रुथ (सच्चा-नेस)

टिप्पणियों

बूलियन मूल्यांकन संख्या

संख्याओं के लिए, एक शून्य मान असत्य, गैर शून्य से सत्य का मूल्यांकन करता है

    int i = 0
...
    if (i)
        print "some ${i}"
    else
        print "nothing"

"कुछ नहीं" छापेंगे

स्ट्रिंग्स बूलियन मूल्यांकन

एक स्ट्रिंग (GStrings सहित) सही का मूल्यांकन करता है यदि रिक्त नहीं है और रिक्त नहीं है, तो यदि शून्य या रिक्त नहीं है

def s = ''
...
if (s) 
    println 's is not empty'
else
    println 's is empty'

प्रिंट होगा: 'खाली है'

संग्रह और नक्शे बूलियन मूल्यांकन

संग्रह और मानचित्र सत्य का मूल्यांकन करते हैं यदि शून्य और रिक्त नहीं है और यदि शून्य या रिक्त है तो रिक्त नहीं है

/* an empty map example*/
def userInfo = [:]
if (!userInfo)
    userInfo << ['user': 'Groot', 'species' : 'unknown' ]

user: 'Groot' , species : 'unknown' जोड़ देगा user: 'Groot' , species : 'unknown' को डिफ़ॉल्ट userInfo के रूप में क्योंकि userInfo मानचित्र खाली है (ध्यान दें कि मानचित्र यहां शून्य नहीं है)

एक अशक्त वस्तु के साथ, कोड हल्के से भिन्न होता है, हम <<In userInfo पर आमंत्रित नहीं कर सकते क्योंकि यह शून्य है, हमें एक असाइनमेंट करना होगा (संदर्भ बूलियन मूल्यांकन के लिए भी देखें):

/* an example with a null object (def does not implies Map type) */
def userInfo = null
if (!userInfo)
    userInfo = ['user': 'Groot', 'species' : 'unknown' ]

और एक अशक्त मानचित्र के साथ:

/* The same example with a null Map */
Map<String,String> userInfo = null
if (!userInfo)
    userInfo = ['user': 'Groot', 'species' : 'unknown' ]

ऑब्जेक्ट बूलियन मूल्यांकन

एक अशक्त वस्तु संदर्भ झूठ का मूल्यांकन करता है, एक अशक्त सत्य का संदर्भ, लेकिन तार, संग्रह, पुनरावृत्तियों और गणना के लिए यह भी आकार को ध्यान में रखता है।

def m = null

if (!m)
    println "empty"
else
    println "${m}"

"रिक्त" प्रिंट करेगा

def m = [:]

if (!m)
    println "empty"
else
    println "${m}"

नक्शा शून्य नहीं है, लेकिन खाली है, यह कोड "रिक्त" प्रिंट करेगा

करने के बाद

m << ['user' : 'Groot' ]

यह नक्शा मुद्रित करेगा:

[user:Groot]

उपयोगकर्ता परिभाषित वर्ग में बूलियन मूल्यांकन को ओवरराइड करना

कभी-कभी कुछ प्रकार की वस्तुओं के लिए अपने स्वयं के कार्यक्रम में एक विशिष्ट आसियान परिभाषा होना उपयोगी हो सकता है।

/** an oversimplified robot controller */
class RunController {
    
    def complexCondition
    int position = 0
    
    def asBoolean() {
        return complexCondition(this);
    }
    def advanceTo(step) {
        position += step
    }
}
def runController = new RunController(complexCondition : { c -> c.position < 10 } )

assert runController
runController.advanceTo(5)
assert runController
runController.advanceTo(5)
// The limit has been reached : the controller evaluates to false
assert !runController

यह कोड एक ओवरसिम्प्लाइड रोबोट कंट्रोलर दिखाता है जो यह जाँचता है कि रोबोट की स्थिति 10 से अधिक नहीं है (स्थिति मूल्यांकन के बंद होने के साथ)

चरित्र का मूल्यांकन

यदि मूल्य शून्य नहीं है, तो कोई चरित्र सत्य का मूल्यांकन करता है, यदि शून्य शून्य है

assert ! new Character((char)0)
assert ! new Character('\u0000Hello Zero Char'.charAt(0))
assert  new Character('Hello'.charAt(0))

मैचर मूल्यांकन

एक मिलानकर्ता सही का मूल्यांकन करता है यदि वह कम से कम एक मैच पा सकता है, तो कोई मैच नहीं मिलने पर गलत

// a match is found => true
assert 'foo' =~ /[a-z]/
// the regexp does not match fully => no match => false
assert !( 'foo' ==~ /[a-z]/ )
// a match is found => true
assert 'foo' =~ /o/
// no match => false
assert !( 'foo' =~ /[A-Z]/ )

बंद मूल्यांकन

एक क्लोजर का मूल्यांकन क्लोजर के परिणाम का मूल्यांकन है।

सभी नियम लागू होते हैं: यदि क्लोजर शून्य, शून्य संख्या या रिक्त स्ट्रिंग, संग्रह, मानचित्र या सरणी को वापस करता है तो यह सत्य के अन्यथा गलत होने का मूल्यांकन करता है।

// Closure return non zero number => true
assert { 42 }()
// closure returns 0 => false
assert ! ( { 0 }())
// closure returns null => false
assert !( { }())