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