groovy => Groovy Truth (true-ness)

Osservazioni

Groovy valuta le condizioni nelle istruzioni if , while e for allo stesso modo di Java per le condizioni standard di Java : in Java è necessario fornire un'espressione booleana (un'espressione che restituisce un valore booleano) e il risultato è il risultato della valutazione.

In Groovy, il risultato è lo stesso di Java per queste condizioni (nessun esempio fornito, questo è Java standard).

L'altro meccanismo di valutazione della veridicità mostrato dagli esempi può essere riassunto come:

numeri: un valore zero viene valutato su falso, diverso da zero a vero.
oggetti: un riferimento oggetto nullo restituisce false, un riferimento non nullo a vero.
Carattere: un personaggio con un valore zero è falso, vero altrimenti.
Stringa: una stringa restituisce true se non null e non vuota, false se null o vuota (si applica anche a GStrings e CharSequences).
Raccolte e mappe (comprese le sottoclassi Elenco , Mappa , Set , HashSet ...): tiene anche conto della dimensione, restituisce true se la raccolta non è nullo e non vuota, false se null o vuota.
Enumerations and Iterators restituisce true se non null e sono alcuni più elementi (groovy valuta hasMoreElements o hasNext sull'oggetto), false se null o non più elementi.
Matcher: un matcher viene valutato true se c'è almeno una corrispondenza, false se non viene trovata una corrispondenza.
Chiusura: una chiusura valuta la valutazione del risultato restituito dalla chiusura.

Il metodo asBoolean può essere sovrascritto in una classe definita dall'utente per fornire una valutazione booleana personalizzata.

Valutazione booleana di numeri

per i numeri, un valore zero viene valutato su falso, diverso da zero a vero

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

stamperà "niente"

Valutazione booleana di stringhe

una stringa (incluso GStrings) restituisce true se non null e non vuota, false if null o empty

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

stamperà: 's è vuoto'

Collezioni e mappe di valutazione booleana

Raccolte e mappe vengono valutati come veri se non nulli e non vuoti e falsi se nulli o vuoti

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

aggiungerà l' user: 'Groot' , species : 'unknown' come userInfo predefinito poiché la mappa userInfo è vuota (notare che la mappa non è nulla qui)

Con un oggetto nullo, il codice è leggermente differente, non possiamo invocare << su userInfo perché è nullo, dobbiamo fare un assegnamento (fare riferimento anche alla valutazione booleana dell'oggetto):

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

E con una mappa nulla:

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

Valutazione booleana dell'oggetto

un riferimento oggetto nullo restituisce false, un riferimento non nullo a true, ma per stringhe, raccolte, iteratori ed enumerazioni tiene anche conto della dimensione.

def m = null

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

stamperà "vuoto"

def m = [:]

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

La mappa non è nullo ma vuota, questo codice verrà stampato "vuoto"

Dopo averlo fatto

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

stamperà la mappa:

[user:Groot]

Sovrascrittura della valutazione booleana in una classe definita dall'utente

A volte può essere utile avere una definizione asoolea specifica nel proprio programma per alcuni tipi di oggetti.

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

Questo codice mostra un controller del robot eccessivamente semplificato che controlla che la posizione del robot non superi 10 (con una chiusura per la valutazione delle condizioni)

Valutazione dei caratteri

un carattere viene valutato true se il valore non è zero, false se zero

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

Valutazione del matcher

un Matcher restituisce true se riesce a trovare almeno una corrispondenza, false se non viene trovata alcuna corrispondenza

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

Valutazione della chiusura

La valutazione di una chiusura è la valutazione del risultato della chiusura.

Si applicano tutte le regole: se la chiusura restituisce un numero nullo, zero o una stringa vuota, una raccolta, una mappa o una matrice, viene valutata falsa, altrimenti vera.

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

Modified text is an extract of the original Stack Overflow Documentation

Autorizzato sotto CC BY-SA 3.0

Non affiliato con Stack Overflow

groovy
Groovy Truth (true-ness)

Ricerca…