Existe uma maneira de verificar seqüências de caracteres para nile ""no Swift? No Rails, eu posso usar blank()para verificar.

Atualmente, tenho isso, mas parece um exagero:

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

Se você está lidando com Strings opcionais, isso funciona:

(string ?? "").isEmpty

O ??operador coalescente nulo retorna o lado esquerdo se não for nulo; caso contrário, retorna o lado direito.

Você também pode usá-lo assim para retornar um valor padrão:

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

Talvez você possa usar a 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 */
}

Se você estiver usando o Swift 2, aqui está um exemplo que meu colega sugeriu, que adiciona a propriedade isNilOrEmpty nas Strings opcionais:

protocol OptionalString {}
extension String: OptionalString {}

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

Você pode usar isNilOrEmpty na própria sequência opcional

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

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

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

Usando a guarddeclaração

Eu estava usando Swift por um tempo antes de aprender sobre a guarddeclaração. Agora eu sou um grande fã. É usado de forma semelhante à ifdeclaração, mas permite retorno antecipado e apenas cria um código muito mais limpo em geral.

Para usar guarda ao verificar para garantir que uma sequência não seja nula nem vazia, você pode fazer o seguinte:

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 a cadeia opcional e verifica se ela não está vazia de uma só vez. Se for nulo (ou vazio), você retornará da sua função (ou loop) imediatamente e tudo depois que ela for ignorada. Mas se a declaração de guarda for aprovada, você poderá usar com segurança sua corda não embrulhada.

Veja também

• Documentação de declarações
• A declaração de guarda em Swift 2

Com o Swift 5, você pode implementar uma Optionalextensão para o Stringtipo com uma propriedade booleana que retorna se uma sequência opcional não tiver valor ou estiver vazia:

extension Optional where Wrapped == String {

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

}

No entanto, Stringimplementa a isEmptypropriedade conforme o protocolo Collection. Portanto, podemos substituir restrição genérica do código anterior ( Wrapped == String) com um mais amplo ( Wrapped: Collection) para que Array, Dictionarye Settambém beneficiar o nosso novo isNilOrEmptyimóvel:

extension Optional where Wrapped: Collection {

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

}

Uso com 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 com 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

Fontes:

• swiftbysundell.com - Estendendo opcionais no Swift
• objc.io - Dica rápida: coleções não vazias

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

Eu sei que existem muitas respostas para essa pergunta, mas nenhuma delas parece ser tão conveniente quanto esta (na minha opinião) para validar UITextFielddados, que é um dos casos mais comuns de uso:

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

Você pode apenas usar

textField.text.isNilOrEmpty

Você também pode pular a opção .trimmingCharacters(in:.whitespaces)se não considerar espaços em branco como uma sequência vazia ou usá-la para testes de entrada mais complexos, como

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

Eu recomendaria.

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

mapaplica-se o argumento da função se o opcional é .Some.
A captura do playground também mostra outra possibilidade com o novo Swift 1.2, se for permitido o encadernação.

Se você deseja acessar a string como não opcional, use a resposta de Ryan , mas se você se importa apenas com o não vazio da string, minha abreviação preferida para isso é

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

Como ==funciona bem com booleanos opcionais, acho que isso deixa o código legível sem obscurecer a intenção original.

Se você quiser verificar o oposto: se a string for nilor "", eu prefiro verificar os dois casos explicitamente para mostrar a intenção correta:

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 assim na sequência opcional:

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

Swift 3 Para verificar a melhor maneira de String vazia

if !string.isEmpty{

// do stuff

}

Você pode criar sua própria função personalizada, se isso é algo que você espera fazer muito.

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

Solução Swift 3 Use o valor desembrulhado opcional e verifique com o 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 String opcional

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

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

Referência: https://useyourloaf.com/blog/empty-strings-in-swift/

Crie uma extensão de classe String:

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

Observe que isso retornará TRUE se a string contiver um ou mais espaços em branco. Para tratar a string em branco como "vazia", ​​use ...

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

... em vez de. Isso requer fundação.

Use-o assim ...

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

Swift 3 Isso funciona bem para verificar se a string está realmente vazia. Porque isEmpty retorna true quando há um espaço em branco.

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

Exemplos:

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

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

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

Você deve fazer algo assim:
if !(string?.isEmpty ?? true) { //Not nil nor empty }

O operador coalescente nulo verifica se o opcional não é nulo; caso contrário, verifica sua propriedade; nesse caso, é Vazio. Como esse opcional pode ser nulo, você fornece um valor padrão que será usado quando o opcional for nulo.

Esta é uma solução geral para todos os tipos que estão em conformidade com o Collectionprotocolo, que inclui String:

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

Ao lidar com a passagem de valores do banco de dados local para o servidor e vice-versa, eu estava tendo muitos problemas com? E! E se não.

Então, eu criei um utilitário Swift3.0 para lidar com casos nulos e quase totalmente posso evitar? E! No código.

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

Ex:-

Antes :

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

Depois de :

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

e quando for necessário verificar uma sequência válida,

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

Isso me salvou de ter que lidar com o problema de adicionar e remover vários 's' e! 'S depois de escrever um código que fazia sentido.

Use o operador ternário (também conhecido como operador condicional C++ forever!):

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

O stringA!desembrulhamento forçado acontece apenas quando stringA != nil, portanto, é seguro. A == falseverbosidade é um pouco mais legível do que outro ponto de exclamação !(stringA!.isEmpty).

Pessoalmente, prefiro uma forma ligeiramente diferente:

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

Na declaração acima, é imediatamente muito claro que o ifbloco inteiro não é executado quando uma variável é nil.

útil ao obter valor de UITextField e verificar nil& emptystring

@IBOutlet weak var myTextField: UITextField!

Heres sua função (quando você toca em um button) que obtém a string do UITextField e faz outras coisas

@IBAction func getStringFrom_myTextField(_ sender: Any) {

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

Isso cuidará do nilvalor e também da emptystring.

Funcionou perfeitamente bem para mim.

Na minha opinião, a melhor maneira de verificar a cadeia nula e vazia é fazer a contagem de cadeias.

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

você pode usar esta função

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