groovy => Groovy Truth (la vérité)

Remarques

Groovy évalue les conditions dans les instructions if , while et for de la même manière que Java pour les conditions Java standard : en Java, vous devez fournir une expression booléenne (une expression qui donne une valeur booléenne) et le résultat est le résultat de l'évaluation.

Dans Groovy, le résultat est le même qu'en Java pour ces conditions (aucun exemple fourni, ceci est le standard Java).

L'autre mécanisme d'évaluation de la véracité présenté par les exemples peut être résumé comme suit:

nombres: une valeur nulle est fausse, non nulle à vraie.
objects: une référence d'objet null est évaluée à false, une référence non null à true.
Caractère: un caractère avec une valeur zéro est évalué à faux, vrai sinon.
Chaîne: une chaîne est évaluée à true si elle n'est pas nulle et non vide, false si elle est nulle ou vide (s'applique également à GStrings et CharSequences).
Collections et cartes (y compris les sous-classes List , Map , Set , HashSet ...): prend également en compte la taille, évaluée à true si la collection n'est pas nulle et non vide, false si nulle ou vide.
Les énumérations et les itérateurs sont évalués à true s'ils ne sont pas nuls et ce sont d'autres éléments (groovy évalue hasMoreElements ou hasNext sur l'objet), false si null ou aucun autre élément.
Matcher: un matcher est évalué à true s'il y a au moins une correspondance, si false s'il n'y a pas de correspondance est trouvé.
Fermeture: une fermeture évalue à l'évaluation du résultat renvoyé par la fermeture.

La méthode asBoolean peut être remplacée dans une classe définie par l'utilisateur pour fournir une évaluation booléenne personnalisée.

Evaluation booléenne des nombres

pour les nombres, une valeur de zéro vaut false, non zéro à true

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

imprimera "rien"

Évaluation booléenne de chaînes

une chaîne (y compris GStrings) est évaluée à true si elle n'est pas nulle et non vide, false si nulle ou vide

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

va imprimer: 's is empty'

Évaluation booléenne des collections et des cartes

Les collections et les cartes sont évaluées à true si elles ne sont pas nulles et ne sont pas vides et false si elles sont nulles ou vides

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

ajoutera l' user: 'Groot' , species : 'unknown' par défaut userInfo puisque la map userInfo est vide (notez que la map n'est pas nulle ici)

Avec un objet nul, le code est légèrement différent, on ne peut pas invoquer << sur userInfo car il est nul, il faut faire une affectation (voir aussi l’évaluation booléenne Object):

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

Et avec une carte nulle:

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

Evaluation booléenne d'objet

une référence d'objet NULL donne la valeur false, une référence non null à true, mais pour les chaînes, les collections, les itérateurs et les énumérations, elle prend également en compte la taille.

def m = null

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

imprimera "vide"

def m = [:]

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

La carte n'est pas nulle mais vide, ce code affichera "vide"

Après avoir fait

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

il imprimera la carte:

[user:Groot]

Remplacement de l'évaluation booléenne dans une classe définie par l'utilisateur

Parfois, il peut être utile d'avoir une définition asBoolean spécifique dans votre propre programme pour certains types d'objets.

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

Ce code montre un contrôleur de robot trop simplifié qui vérifie que la position du robot ne dépasse pas 10 (avec une fermeture pour évaluation de la condition)

Évaluation de personnage

un caractère est évalué à true si sa valeur n'est pas zéro, faux si zéro

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

Évaluation matcher

un Matcher est évalué à true s'il peut trouver au moins une correspondance, false si aucune correspondance n'est trouvée

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

Évaluation de la fermeture

L'évaluation d'une fermeture est l'évaluation du résultat de la fermeture.

Toutes les règles s'appliquent: si la fermeture renvoie un nombre nul ou nul ou une chaîne, une collection, un mappage ou un tableau vide, la valeur false est définie sur true.

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

Sous licence CC BY-SA 3.0

Non affilié à Stack Overflow

groovy
Groovy Truth (la vérité)

Recherche…