No Objetivo C, pode-se fazer o seguinte para verificar se há strings:

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

Como se detecta strings vazias no Swift?

Agora existe a capacidade integrada de detectar uma string vazia com .isEmpty:

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

Documentação de pré-lançamento da Apple: "Strings and Characters" .

Uma maneira concisa de verificar se a sequência é nula ou vazia seria:

var myString: String? = nil

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

Estou reescrevendo completamente minha resposta ( novamente ). Desta vez é porque me tornei fã da guarddeclaração e retorno antecipado . Isso cria um código muito mais limpo.

Sequência não opcional

Verifique o comprimento zero.

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)

Se a ifinstrução for aprovada, você poderá usar a string com segurança, sabendo que ela não está vazia. Se estiver vazio, a função retornará mais cedo e nada depois que importa.

Sequência opcional

Verifique o comprimento nulo ou zero.

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)

Isso desembrulha o opcional e verifica se ele não está vazio ao mesmo tempo. Depois de passar a guardinstrução, você pode usar com segurança sua seqüência de caracteres não vazia não empacotada.

No Xcode 11.3 swift 5.2 e posterior

Usar

var isEmpty: Bool { get } 

Exemplo

let lang = "Swift 5"

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

Se você deseja ignorar espaços em branco

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

Aqui está como eu verifico se a string está em branco. Por 'em branco', quero dizer uma string que está vazia ou contém apenas caracteres de espaço / nova linha.

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

Como usar:

MyString.blank(" ") // true

Você também pode usar uma extensão opcional para não precisar se preocupar em desembrulhar ou 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: ao chamar isso como opcional, certifique-se de não usá ?-lo; caso contrário, ainda será necessário desembrulhar.

Para fazer a verificação e o comprimento nulos simultaneamente, o Swift 2.0 e o iOS 9 em diante, você pode usar

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

isEmpty fará o que você pensa que, se string == "", retornará verdadeiro. Algumas das outras respostas apontam para uma situação em que você tem uma sequência opcional.

POR FAVOR, use o encadeamento opcional !!!!

Se a sequência não for nula, isEmpty será usado, caso contrário, não será.

Abaixo, o opcionalString NÃO será definido porque o string é nulo

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

Obviamente você não usaria o código acima. Os ganhos vêm da análise JSON ou de outras situações em que você tem um valor ou não. Este código de garantias será executado se houver um valor.

Marque a verificação apenas para caracteres de espaços e novas linhas no texto

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

usando

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

Para Strings opcionais, que tal:

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

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

A respeito

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

Posso recomendar adicionar uma pequena extensão a String ou Array que se pareça com

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

Com ele, você pode escrever um código mais fácil de ler. Compare estas duas linhas

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

e

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

É fácil perder ! Cadastre-se no início da linha do punho.

Você pode usar esta extensão:

extension String {

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

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

}

e use-o assim:

let isMyStringEmptyOrNil = String.isNilOrEmpty(string: myString)