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

Actualmente tengo esto, pero parece excesivo:

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

Si se trata de cadenas opcionales, esto funciona:

(string ?? "").isEmpty

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!

Tal vez 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 */
}

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)
}

Usando la guarddeclaración

Estuve usando Swift por un tiempo antes de conocer la guarddeclaración. Ahora soy un gran admirador. Se usa de manera similar a la ifdeclaración, 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

Con Swift 5, puede implementar una Optionalextensión para el Stringtipo con una propiedad booleana que 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, Stringimplementa la isEmptypropiedad conforme al protocoloCollection . 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, Dictionaryy Settambién beneficiar nuestra nueva isNilOrEmptypropiedad:

extension Optional where Wrapped: Collection {

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

}

Uso con Strings:

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 Arrays:

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:

• swiftbysundell.com - Ampliación de opciones en Swift
• objc.io - Consejo rápido: colecciones no vacías

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")
}

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 UITextFielddatos, 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 el .trimmingCharacters(in:.whitespaces)si no considera los espacios en blanco como una cadena vacía o usarlo para pruebas de entrada más complejas como

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

Yo recomendaria.

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

mapaplica 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.

Si desea acceder a la cadena como no opcional, debe usar la Respuesta de Ryan , pero si solo le importa el no 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 nilo "", prefiero verificar ambos casos explícitamente para mostrar la intención correcta:

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

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?") } 

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

if !string.isEmpty{

// do stuff

}

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")
}

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

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

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/

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!")
}

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

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.

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

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

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.

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

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

El stringA!desenvolvimiento forzado ocurre solo cuando stringA != nil, por lo que es seguro. La == falseverbosidad es algo más legible que otro signo de exclamación !(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 el ifbloque completo no se ejecuta cuando una variable es nil.

útil para obtener valor de UITextField y verificar nil& emptystring

@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 cuidará tanto el nilvalor comoempty cadena.

Funcionó perfectamente bien para mí.

En mi opinión, la mejor manera de verificar la cadena nula y vacía es tomar el recuento de cadenas.

var nilString : String?
print(nilString.count) // count is nil

var emptyString = ""
print(emptyString.count) // count is 0

// combine both conditions for optional string variable
if string?.count == nil || string?.count == 0 {
   print("Your string is either empty or nil")
}

puedes usar esta función

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