En el Objetivo C, uno podría hacer lo siguiente para verificar las cadenas:

if ([myString isEqualToString:@""]) {
    NSLog(@"myString IS empty!");
} else {
    NSLog(@"myString IS NOT empty, it is: %@", myString);
}

¿Cómo se detectan cadenas vacías en Swift?

Ahora existe la capacidad incorporada para detectar cadenas vacías con .isEmpty:

if emptyString.isEmpty {
    print("Nothing to see here")
}

Documentación preliminar de Apple: "Cadenas y caracteres" .

Una forma concisa de verificar si la cadena es nula o vacía sería:

var myString: String? = nil

if (myString ?? "").isEmpty {
    print("String is nil or empty")
}

Estoy reescribiendo completamente mi respuesta ( nuevamente ). Esta vez es porque me he convertido en un fanático de la guarddeclaración y el regreso temprano . Hace un código mucho más limpio.

Cadena no opcional

Verifique la longitud cero.

let myString: String = ""

if myString.isEmpty {
    print("String is empty.")
    return // or break, continue, throw
}

// myString is not empty (if this point is reached)
print(myString)

Si la ifdeclaración se aprueba, puede usar la cadena de forma segura sabiendo que no está vacía. Si está vacío, la función volverá antes y nada después importará.

Cadena opcional

Verifique la longitud nula o cero.

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 lo opcional y verifica que no esté vacío al mismo tiempo. Después de pasar la guarddeclaración, puede usar con seguridad su cadena no vacía sin envolver.

En Xcode 11.3 swift 5.2 y posterior

Utilizar

var isEmpty: Bool { get } 

Ejemplo

let lang = "Swift 5"

if lang.isEmpty {
   print("Empty string")
}

Si quieres ignorar espacios en blanco

if lang.trimmingCharacters(in: .whitespaces).isEmpty {
   print("Empty string")
}

Así es como verifico si la cadena está en blanco. Por "en blanco" me refiero a una cadena que está vacía o que contiene solo caracteres de espacio / nueva línea.

struct MyString {
  static func blank(text: String) -> Bool {
    let trimmed = text.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)
    return trimmed.isEmpty
  }
}

Cómo utilizar:

MyString.blank(" ") // true

También puede usar una extensión opcional para no tener que preocuparse por desenvolver o usar == true:

extension String {
    var isBlank: Bool {
        return self.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
    }
}
extension Optional where Wrapped == String {
    var isBlank: Bool {
        if let unwrapped = self {
            return unwrapped.isBlank
        } else {
            return true
        }
    }
}

Nota: cuando llame a esto de forma opcional, asegúrese de no usarlo ?o, de lo contrario, será necesario desenvolverlo.

Para hacer la comprobación nula y la longitud simultáneamente de Swift 2.0 y iOS 9 en adelante, puede usar

if(yourString?.characters.count > 0){}

isEmpty hará lo que cree que hará, si string == "", devolverá verdadero. Algunas de las otras respuestas apuntan a una situación en la que tiene una cadena opcional.

¡POR FAVOR, use el encadenamiento opcional !

Si la cadena no es nula, se usará isEmpty, de lo contrario no se usará.

A continuación, la cadena opcional NO se establecerá porque la cadena es nula

let optionalString: String? = nil
if optionalString?.isEmpty == true {
     optionalString = "Lorem ipsum dolor sit amet"
}

Obviamente no usarías el código anterior. Las ganancias provienen del análisis JSON u otras situaciones en las que tiene un valor o no. Esto garantiza que el código se ejecutará si hay un valor.

Comprobar comprobar solo espacios y caracteres de nueva línea en el texto

extension String
{
    var  isBlank:Bool {
        return self.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet()).isEmpty
    }
}

utilizando

if text.isBlank
{
  //text is blank do smth
}

Para cadenas opcionales, ¿qué tal:

if let string = string where !string.isEmpty
{
    print(string)
}

if myString?.startIndex != myString?.endIndex {}

Qué pasa

if let notEmptyString = optionalString where !notEmptyString.isEmpty {
    // do something with emptyString 
    NSLog("Non-empty string is %@", notEmptyString)
} else {
    // empty or nil string
    NSLog("Empty or nil string")
}

Puedo recomendar agregar una pequeña extensión a String o Array que se vea como

extension Collection {
    public var isNotEmpty: Bool {
        return !self.isEmpty
    }
}

Con él puedes escribir código que sea más fácil de leer. Compara estas dos líneas

if !someObject.someParam.someSubParam.someString.isEmpty {}

y

if someObject.someParam.someSubParam.someString.isNotEmpty {}

¡Es fácil perderse ! firmar al comienzo de la primera línea.

Puedes usar esta extensión:

extension String {

    static func isNilOrEmpty(string: String?) -> Bool {
        guard let value = string else { return true }

        return value.trimmingCharacters(in: .whitespaces).isEmpty
    }

}

y luego úsalo así:

let isMyStringEmptyOrNil = String.isNilOrEmpty(string: myString)