groovy
Groovy Truth (sannhet)

Anmärkningar

Nummer booleska utvärdering

för siffror utvärderas ett nollvärde till falskt, icke noll till sant

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

kommer att skriva ut "ingenting"

Strängar booleska utvärdering

en sträng (inklusive GStrings) utvärderar till true om inte null och inte tom, falsk om null eller tom

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

kommer att skriva ut: 's is tom'

Samlingar och kartläggning av booleska utvärdering

Samlingar och kartor utvärderar till sann om inte null och inte tom och falsk om null eller tom

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

lägger till user: 'Groot' , species : 'unknown' som standard userInfo eftersom userInfo-kartan är tom (notera att kartan inte är noll här)

Med ett nollobjekt är koden lätt annorlunda, vi kan inte åberopa << på userInfo eftersom det är noll, vi måste göra en uppgift (se även booleska utvärdering av objekt):

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

Och med en null karta:

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

Objekt booleska utvärdering

en nullobjektreferens utvärderar till falsk, en icke-nullreferens till sann, men för strängar, samlingar, iteratorer och uppräkningar tar den också hänsyn till storleken.

def m = null

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

kommer att skriva ut "tom"

def m = [:]

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

Kartan är inte noll utan tom, den här koden kommer att skriva ut "tom"

Efter att ha gjort

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

det kommer att skriva ut kartan:

[user:Groot]

Överstyr booleska utvärdering i en användardefinierad klass

Ibland kan det vara bra att ha en specifik asBoolean-definition i ditt eget program för något slags objekt.

/** 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

Denna kod visar en överförenklad robotkontroller som kontrollerar att robotens position inte överstiger 10 (med en stängning för utvärdering av tillstånd)

Karaktär utvärdering

en karaktär utvärderar till true om dess värde inte är noll, falskt om noll

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

Matcher utvärdering

en Matcher utvärderar till true om den kan hitta minst en match, falsk om ingen matchning hittas

// 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]/ )

Stängningsutvärdering

Utvärderingen av en nedläggning är utvärderingen av resultatet av nedläggningen.

Alla regler gäller: om nedläggningen returnerar ett noll, nollnummer eller tomt sträng, samling, karta eller array utvärderas det till falskt annars till sant.

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