groovy => Verdad maravillosa (la verdad)

Observaciones

Groovy evalúa las condiciones en las sentencias if , while y for de la misma manera que lo hace Java para las condiciones estándar de Java : en Java, debe proporcionar una expresión booleana (una expresión que se evalúe como booleana) y el resultado es el resultado de la evaluación.

En Groovy, el resultado es el mismo que en Java para estas condiciones (no se proporcionan ejemplos, esto es Java estándar).

El otro mecanismo de evaluación de la veracidad mostrado en los ejemplos se puede resumir como:

números: un valor cero se evalúa como falso, no cero como verdadero.
objetos: una referencia de objeto nula se evalúa como falsa, una referencia no nula como verdadera.
Carácter: un carácter con un valor cero se evalúa como falso, de lo contrario verdadero.
Cadena: una cadena se evalúa como verdadera si no es nula y no está vacía, falsa si es nula o está vacía (también se aplica a GStrings y CharSequences).
Colecciones y mapas (incluidas las subclases Lista , Mapa , Conjunto , HashSet ...): también tiene en cuenta el tamaño, se evalúa como verdadero si la colección no es nula y no está vacía, falsa si es nula o está vacía.
Las enumeraciones e iteradores se evalúan como verdaderas si no son nulas y son algunos más elementos (groovy evalúa hasMoreElements o hasNext en el objeto), false si son nulas o no hay más elementos.
Matcher: un matcher se evalúa como verdadero si hay al menos una coincidencia, falso si no se encuentra.
Cierre: un cierre evalúa la evaluación del resultado devuelto por el cierre.

El método asBoolean se puede anular en una clase definida por el usuario para proporcionar una evaluación booleana personalizada.

Evaluación booleana de números

para los números, un valor cero se evalúa como falso, no cero como verdadero

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

imprimirá "nada"

Cadenas de evaluación booleana.

una cadena (incluyendo GStrings) se evalúa como verdadera si no es nula y no está vacía, falsa si es nula o está vacía

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

imprimirá: 's está vacío'

Colecciones y mapas de evaluación booleana.

Colecciones y mapas se evalúa como verdadero si no es nulo y no está vacío y falso si es nulo o está vacío

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

agregará user: 'Groot' , species : 'unknown' como información de usuario predeterminada ya que el mapa de información de usuario está vacío (tenga en cuenta que el mapa no es nulo aquí)

Con un objeto nulo, el código es ligeramente diferente, no podemos invocar << en userInfo porque es nulo, tenemos que realizar una asignación (consulte también la evaluación booleana de Object):

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

Y con un mapa nulo:

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

Evaluación booleana de objetos

una referencia de objeto nula se evalúa como falsa, una referencia no nula a verdadera, pero para cadenas, colecciones, iteradores y enumeraciones también tiene en cuenta el tamaño.

def m = null

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

imprimirá "vacío"

def m = [:]

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

El mapa no es nulo sino que está vacío, este código se imprimirá "vacío"

Después de hacer

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

se imprimirá el mapa:

[user:Groot]

Anulando la evaluación booleana en una clase definida por el usuario

A veces puede ser útil tener una definición específica de boolean en su propio programa para algún tipo de objetos.

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

Este código muestra un controlador de robot demasiado simplificado que verifica que la posición del robot no exceda de 10 (con un cierre para la evaluación de la condición)

Evaluación de personajes

un Carácter se evalúa como verdadero si su valor no es cero, falso si es cero

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

Evaluación del emparejador

un Matcher se evalúa como verdadero si puede encontrar al menos una coincidencia, falso si no se encuentra ninguna coincidencia

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

Evaluación de cierre

La evaluación de un cierre es la evaluación del resultado del cierre.

Se aplican todas las reglas: si el cierre devuelve un nulo, un número cero o una Cadena, Colección, Mapa o Array vacíos, se evalúa como falso en 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

Licenciado bajo CC BY-SA 3.0

No afiliado a Stack Overflow

groovy
Verdad maravillosa (la verdad)

Buscar..