string - has - Compruebe si una cadena está en blanco o no existe en Scala

scala check if option has value

Question

Tengo una Option[String] .

Quiero comprobar si existe una cadena y si existe no está en blanco.

def isBlank( input : Option[String]) : Boolean =
{
input.isEmpty ||
input.filter(_.trim.length > 0).isEmpty
}

¿Hay una mejor manera de hacer esto en Scala?

Answer 1

Añadí un Scalafiddle para jugar con eso: Scalafiddle

Eso muestra que la respuesta correcta marcada es incorrecta (como lo señala prayagupd):

def isBlank(str: Option[String]): Boolean =
str.forall(_.trim.isEmpty)

La solución es para no en blanco:

def isNotBlank(str: Option[String]): Boolean =
str.exists(_.trim.nonEmpty) 

Answer 2

Esto debería funcionar también, ya que el filtro de una Opción vacía da como resultado una Opción vacía

def isBlank( input : Option[String]) : Boolean =
input.filter(_.trim.length > 0).isEmpty 

Answer 3

Lo que debes hacer es comprobar que exists . Al igual que:

myOption.exists(_.trim.nonEmpty)

que devolverá True si y solo si la Option[String] no es None y no está vacía.

Answer 4

Soy de fondo C # y encontré métodos implícitos de Scala similares a las extensiones C #

import com.foo.bar.utils.MyExtensions._
...
"my string".isNullOrEmpty // false
"".isNullOrEmpty // true
" ".isNullOrEmpty // true
" ".isNullOrEmpty // true
val str: String = null
str.isNullOrEmpty // true

Implementación

package com.foo.bar.utils
object MyExtensions {
class StringEx(val input: String) extends AnyVal {
def isNullOrEmpty: Boolean =
if (input == null || input.trim.isEmpty)
true
else
false
}
implicit def isNullOrEmpty(input: String): StringEx = new StringEx(input)
}

Answer 5

Todas las soluciones propuestas se bloquearán con NullPointerException si pasa:

val str : Option[String] = Some(null). 

Por lo tanto, la comprobación de nulos es una necesidad :

def isBlank(input: Option[String]): Boolean =
input.filterNot(s => s == null || s.trim.isEmpty).isEmpty

Answer 6

Un enfoque basado en la coincidencia de patrones,

def isBlank( input : Option[String]) : Boolean =
input match {
case None => true
case Some(s) => s.trim.isEmpty
}

Answer 7

exists (Solución aceptada) funcionará cuando la entrada tenga al menos un elemento, es Some("") pero no cuando sea None .

exists verificación si al menos un elemento ( x ) se aplica a la función.

p.ej.

scala> List[String]("apple", "").exists(_.isEmpty)
res21: Boolean = true
//if theres no element then obviously returns false
scala> List[String]().exists(_.isEmpty)
res30: Boolean = false

Lo mismo sucede con Option.empty , ya que no hay ningún elemento en ella,

scala> Option.empty[String].exists(_.isEmpty)
res33: Boolean = false

Así que forall es lo que hace que la función aplique todos los elementos.

scala> def isEmpty(sOpt: Option[String]) = sOpt.forall(_.trim.isEmpty)
isEmpty: (sOpt: Option[String])Boolean
scala> isEmpty(Some(""))
res10: Boolean = true
scala> isEmpty(Some("non-empty"))
res11: Boolean = false
scala> isEmpty(Option(null))
res12: Boolean = true

La forma general es filtrar nonEmpty cadena que no nonEmpty y luego marcar option.isEmpty .

scala> def isEmpty(sOpt: Option[String]) = sOpt.filter(_.trim.nonEmpty).isEmpty
isEmpty: (sOpt: Option[String])Boolean
scala> isEmpty(None)
res20: Boolean = true
scala> isEmpty(Some(""))
res21: Boolean = true