array - swift string format

Verifique que la cadena sea nula y vacía

Question

¿Hay alguna forma de verificar cadenas para nil y "" en Swift? En Rails, puedo usar blank() para verificar.

Actualmente tengo esto, pero parece excesivo:

    if stringA? != nil {
        if !stringA!.isEmpty {
            ...blah blah
        }
    }

Answer 1

Usando la declaración de guard

Estuve usando Swift por un tiempo antes de conocer la declaración de guard . Ahora soy un gran admirador. Se usa de manera similar a la instrucción if , pero permite un retorno temprano y solo genera un código mucho más limpio en general.

Para usar la protección al verificar para asegurarse de que una cadena no sea nula ni esté vacía, puede hacer lo siguiente:

let myOptionalString: String? = nil

guard let myString = myOptionalString, !myString.isEmpty else {
    print("String is nil or empty.")
    return // or break, continue, throw
}

/// myString is neither nil nor empty (if this point is reached)
print(myString)

Esto desenvuelve la cadena opcional y verifica que no esté vacía de una vez. Si es nulo (o vacío), entonces regresa de su función (o bucle) inmediatamente y todo lo que se ignora después. Pero si se aprueba la declaración de guardia, entonces puede usar con seguridad su cadena sin envolver.

Ver también

• Documentación de declaraciones
• La declaración de guardia en Swift 2

Answer 2

útil cuando se obtiene valor de UITextField y se verifica la cadena nil y empty

@IBOutlet weak var myTextField: UITextField!

Aquí está su función (cuando toca un button ) que obtiene una cadena de UITextField y hace algunas otras cosas

@IBAction func getStringFrom_myTextField(_ sender: Any) {

guard let string = myTextField.text, !(myTextField.text?.isEmpty)!  else { return }
    //use "string" to do your stuff.
}

Esto se encargará del valor nil y de la cadena empty .

Funcionó perfectamente bien para mí.

Answer 3

Al tratar de pasar valores de la base de datos local al servidor y viceversa, estaba teniendo demasiados problemas con? Sy! Y qué no.

Así que hice una utilidad Swift3.0 para manejar casos nulos y puedo evitar casi por completo los ''y'' en el código.

func str(_ string: String?) -> String {
    return (string != nil ? string! : "")
}

Ex:-

Antes de :

    let myDictionary: [String: String] = 
                      ["title": (dbObject?.title != nil ? dbObject?.title! : "")]

Después :

    let myDictionary: [String: String] = 
                        ["title": str(dbObject.title)]

y cuando se requiere verificar una cadena válida,

    if !str(dbObject.title).isEmpty {
        //do stuff
    }

Esto me ahorró tener que pasar por la molestia de agregar y eliminar numerosos? Y después de escribir un código que razonablemente tenga sentido.

Answer 4

Con Swift 5, puede implementar una extensión Optional para String tipo de String con una propiedad booleana que se devuelve si una cadena opcional no tiene valor o está vacía:

extension Optional where Wrapped == String {

    var isNilOrEmpty: Bool {
        return self?.isEmpty ?? true
    }

}

Sin embargo, String implementa la propiedad isEmpty conforme al protocolo Collection . Por lo tanto, podemos reemplazar la restricción genérica del código anterior ( Wrapped == String ) con una más amplia ( Wrapped: Collection ) para que Array , Dictionary y Set también beneficien nuestra nueva propiedad isNilOrEmpty :

extension Optional where Wrapped: Collection {

    var isNilOrEmpty: Bool {
        return self?.isEmpty ?? true
    }

}

Uso con String s:

let optionalString: String? = nil
print(optionalString.isNilOrEmpty) // prints: true

let optionalString: String? = ""
print(optionalString.isNilOrEmpty) // prints: true

let optionalString: String? = "Hello"
print(optionalString.isNilOrEmpty) // prints: false

Uso con Array s:

let optionalArray: Array<Int>? = nil
print(optionalArray.isNilOrEmpty) // prints: true

let optionalArray: Array<Int>? = []
print(optionalArray.isNilOrEmpty) // prints: true

let optionalArray: Array<Int>? = [10, 22, 3]
print(optionalArray.isNilOrEmpty) // prints: false

Fuentes:

• Ampliación de opcionales en Swift
• Consejo rápido: colecciones no vacías

Answer 5

Cree una extensión de clase de cadena:

extension String
{   //  returns false if passed string is nil or empty
    static func isNilOrEmpty(_ string:String?) -> Bool
    {   if  string == nil                   { return true }
        return string!.isEmpty
    }
}// extension: String

Tenga en cuenta que esto devolverá VERDADERO si la cadena contiene uno o más espacios en blanco. Para tratar la cadena en blanco como "vacía", use ...

return string!.trimmingCharacters(in: CharacterSet.whitespaces).isEmpty

... en cambio. Esto requiere Fundación.

Úselo así ...

if String.isNilOrEmpty("hello world") == true 
{   print("it''s a string!")
}

Answer 6

Deberías hacer algo como esto:
if !(string?.isEmpty ?? true) { //Not nil nor empty }

El operador de fusión nula comprueba si el opcional no es nulo, en caso de que no sea nulo, comprueba su propiedad, en este caso es vacío. Debido a que este opcional puede ser nulo, proporciona un valor predeterminado que se utilizará cuando su opcional sea nulo.

Answer 7

Esta es una solución general para todos los tipos que se ajustan al protocolo de recopilación, que incluye String :

extension Optional where Wrapped: Collection {
    var isNilOrEmpty: Bool {
        return self?.isEmpty ?? true
    }
}

Answer 8

Puede crear su propia función personalizada, si eso es algo que espera hacer mucho.

func isBlank (optionalString :String?) -> Bool {
    if let string = optionalString {
        return string.isEmpty
    } else {
        return true
    }
}



var optionalString :String? = nil

if isBlank(optionalString) {
    println("here")
}
else {
    println("there")
}

Answer 9

Quizás podría usar la cláusula if-let-where:

Swift 3:

if let string = string, !string.isEmpty {
    /* string is not blank */
}

Swift 2:

if let string = string where !string.isEmpty {
    /* string is not blank */
}

Answer 10

Sé que hay muchas respuestas a esta pregunta, pero ninguna de ellas parece ser tan conveniente como esta (en mi opinión) para validar los datos de UITextField , que es uno de los casos más comunes para usarlo:

extension Optional where Wrapped == String {
    var isNilOrEmpty: Bool {
        return self?.trimmingCharacters(in: .whitespaces).isEmpty ?? true
    }
}

Puedes usar

textField.text.isNilOrEmpty

También puede omitir los caracteres .trimmingCharacters(in:.whitespaces) si no considera los espacios en blanco como una cadena vacía o lo utiliza para pruebas de entrada más complejas como

var isValidInput: Bool {
    return !isNilOrEmpty && self!.trimmingCharacters(in: .whitespaces).characters.count >= MIN_CHARS
}

Answer 11

Si desea acceder a la cadena como no opcional, debe usar la Respuesta de Ryan , pero si solo le importa la falta de vacío de la cadena, mi taquigrafía preferida para esto es

if stringA?.isEmpty == false {
    ...blah blah
}

Como == funciona bien con booleanos opcionales, creo que esto deja el código legible sin oscurecer la intención original.

Si desea verificar lo contrario: si la cadena es nil o "" , prefiero verificar ambos casos explícitamente para mostrar la intención correcta:

if stringA == nil || stringA?.isEmpty == true {
    ...blah blah
}

Answer 12

Si está utilizando Swift 2, aquí hay un ejemplo que ideó mi colega, que agrega la propiedad isNilOrEmpty en cadenas opcionales:

protocol OptionalString {}
extension String: OptionalString {}

extension Optional where Wrapped: OptionalString {
    var isNilOrEmpty: Bool {
        return ((self as? String) ?? "").isEmpty
    }
}

Luego puede usar isNilOrEmpty en la cadena opcional en sí

func testNilOrEmpty() {
    let nilString:String? = nil
    XCTAssertTrue(nilString.isNilOrEmpty)

    let emptyString:String? = ""
    XCTAssertTrue(emptyString.isNilOrEmpty)

    let someText:String? = "lorem"
    XCTAssertFalse(someText.isNilOrEmpty)
}

Answer 13

Si se trata de cadenas opcionales, esto funciona:

(string ?? "").isEmpty

El ?? El operador de fusión nula devuelve el lado izquierdo si no es nulo; de lo contrario, devuelve el lado derecho.

También puede usarlo así para devolver un valor predeterminado:

(string ?? "").isEmpty ? "Default" : string!

Answer 14

Solución Swift 3 Utilice el valor sin envolver opcional y compárelo con el valor booleano.

if (string?.isempty == true) {
    // Perform action
}

Answer 15

Swift 3 Esto funciona bien para verificar si la cadena está realmente vacía. Porque isEmpty devuelve verdadero cuando hay un espacio en blanco.

extension String {
    func isEmptyAndContainsNoWhitespace() -> Bool {
        guard self.isEmpty, self.trimmingCharacters(in: .whitespaces).isEmpty
            else {
               return false
        }
        return true
    }
}

Ejemplos:

let myString = "My String"
myString.isEmptyAndContainsNoWhitespace() // returns false

let myString = ""
myString.isEmptyAndContainsNoWhitespace() // returns true

let myString = " "
myString.isEmptyAndContainsNoWhitespace() // returns false

Answer 16

Swift 3 Para comprobar la cadena vacía de la mejor manera

if !string.isEmpty{

// do stuff

}

Answer 17

Use el operador ternario (también conocido como operador condicional, C++ forever! ):

if stringA != nil ? stringA!.isEmpty == false : false { /* ... */ }

La stringA! el desenvolvimiento forzado ocurre solo cuando stringA != nil , por lo que es seguro. La == false verbosidad es algo más legible que otro signo de exclamación en !(stringA!.isEmpty) .

Personalmente prefiero una forma ligeramente diferente:

if stringA == nil ? false : stringA!.isEmpty == false { /* ... */ }

En la declaración anterior, es muy claro de inmediato que todo el bloque if no se ejecuta cuando una variable es nil .

Answer 18

Yo recomendaria.

if stringA.map(isEmpty) == false {
    println("blah blah")
}

map aplica el argumento de la función si el opcional es .Some .
La captura del patio también muestra otra posibilidad con el nuevo Swift 1.2 si se permite la encuadernación opcional.

Answer 19

puedes usar esta función

 class func stringIsNilOrEmpty(aString: String) -> Bool { return (aString).isEmpty }

Answer 20

SWIFT 3

extension Optional where Wrapped == String {

    /// Checks to see whether the optional string is nil or empty ("")
    public var isNilOrEmpty: Bool {
        if let text = self, !text.isEmpty { return false }
        return true
    }
}

Use así en una cadena opcional:

if myString.isNilOrEmpty { print("Crap, how''d this happen?") } 

Answer 21

Usando isEmpty

"Hello".isEmpty  // false
"".isEmpty       // true

Usando allSatisfy

extension String {
  var isBlank: Bool {
    return allSatisfy({ $0.isWhitespace })
  }
}

"Hello".isBlank        // false
"".isBlank             // true

Usando cadena opcional

extension Optional where Wrapped == String {
  var isBlank: Bool {
    return self?.isBlank ?? true
  }
}

var title: String? = nil
title.isBlank            // true
title = ""               
title.isBlank            // true

Referencia: https://useyourloaf.com/blog/empty-strings-in-swift/

Answer 22

var str: String? = nil

if str?.isEmpty ?? true {
    print("str is nil or empty")
}

str = ""

if str?.isEmpty ?? true {
    print("str is nil or empty")
}