Если вы имеете дело с необязательными строками, это работает:

(string ?? "").isEmpty

Оператор объединения ?? nil возвращает левую часть, если она не равна нулю, в противном случае возвращает правую часть.

Вы также можете использовать его так, чтобы вернуть значение по умолчанию:

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

Возможно, вы могли бы использовать предложение 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 */
}

Использование guard заявление

Некоторое время я использовал Swift, прежде чем узнал о _ 2_ инструкция. Теперь я большой поклонник. Он используется аналогично _ 3_, но он позволяет досрочно вернуть и просто делает код намного чище в целом.

Чтобы использовать охрану при проверке, чтобы убедиться, что строка не пуста и не пуста, вы можете сделать следующее:

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)

Это разворачивает необязательную строку и сразу проверяет, не пуста ли она. Если оно равно нулю (или пусто), вы немедленно возвращаетесь из своей функции (или цикла), и все, что находится после него, игнорируется. Но если оператор защиты проходит, вы можете безопасно использовать развернутую строку.

Смотрите также

• Документация по заявлениям
• Заявление о защите в Swift 2

Если вы используете Swift 2, вот пример, который придумал мой коллега, который добавляет свойство isNilOrEmpty в необязательные строки:

protocol OptionalString {}
extension String: OptionalString {}

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

Затем вы можете использовать isNilOrEmpty в самой необязательной строке

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

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

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

В Swift 5 вы можете реализовать расширение Optional для типа String с логическим свойством, которое возвращает, если необязательная строка пуста или не имеет значения:

extension Optional where Wrapped == String {

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

}

Однако String реализует свойство isEmpty в соответствии с протоколом Collection. Поэтому мы можем заменить общее ограничение предыдущего кода (Wrapped == String) на более широкое (Wrapped: Collection), чтобы Array, Dictionary и Set также использовали наше новое свойство isEmptyOrNil:

extension Optional where Wrapped: Collection {

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

}

Использование с Strings:

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

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

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

Использование с Arrays:

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

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

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

Источники:

• swiftbysundell.com - Расширение дополнительных возможностей в Swift
• objc.io - Быстрый совет: непустые коллекции

Я знаю, что на этот вопрос есть много ответов, но ни один из них не кажется столь же удобным, как это (на мой взгляд) для проверки данных UITextField, что является одним из наиболее распространенных случаев их использования:

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

Вы можете просто использовать

textField.text.isNilOrEmpty

Вы также можете пропустить .trimmingCharacters(in:.whitespaces), если вы не рассматриваете пробелы как пустую строку или не используете их для более сложных входных тестов, таких как

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

Я бы порекомендовал.

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

map применяет аргумент функции, если необязательным является .Some.
Захват игровой площадки также показывает другую возможность с новым Swift 1.2, если позволяет необязательная привязка.

Если вы хотите получить доступ к строке как к необязательной, вам следует использовать ответ Райана, но если вас интересует только непустота строки, я предпочитаю сокращать это

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

Поскольку == отлично работает с необязательными логическими значениями, я думаю, что это оставляет код читабельным, не скрывая первоначального намерения.

Если вы хотите проверить обратное: если строка nil или "", я предпочитаю явно проверить оба случая, чтобы показать правильное намерение:

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

Используйте это в необязательной строке:

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

Swift 3 Лучше всего проверить пустую строку

if !string.isEmpty{

// do stuff

}

Вы можете создать свою собственную пользовательскую функцию, если от этого много ожидаете.

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

Решение Swift 3 Используйте необязательное развернутое значение и сравните его с логическим значением.

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

Использование isEmpty

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

Использование allSatisfy

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

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

Использование необязательной строки

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

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

Ссылка: https://useyourloaf.com/blog/empty-strings-in-swift/

Это общее решение для всех типов, которые соответствуют протоколу Collection, который включает String:

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

Создайте расширение класса 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

Обратите внимание, что это вернет ИСТИНА, если строка содержит один или несколько пробелов. Чтобы рассматривать пустую строку как «пустую», используйте ...

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

... вместо. Для этого требуется Foundation.

Используйте это так ...

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

Swift 3 Это хорошо работает, чтобы проверить, действительно ли строка пуста. Потому что isEmpty возвращает true, когда есть пробел.

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

Примеры:

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

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

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

Вы должны сделать что-то вроде этого:
if !(string?.isEmpty ?? true) { //Not nil nor empty }

Оператор объединения Nil проверяет, не является ли параметр nil, если он не равен nil, затем проверяет его свойство, в данном случае isEmpty. Поскольку этот необязательный параметр может иметь значение nil, вы указываете значение по умолчанию, которое будет использоваться, когда значение параметра optional равно нулю.

На основе этот пост на Medium, с небольшой настройкой для Swift 5, я получил этот код, который работал.

if let stringA, !stringA.isEmpty {
    ...blah blah
}

Хотя я понимаю преимущества создания расширения, я подумал, что это может помочь кому-то, кому нужен только небольшой компонент / пакет.

Когда я имел дело с передачей значений из локальной базы данных на сервер и наоборот, у меня было слишком много проблем с? И! И с чем нет.

Итак, я создал утилиту Swift3.0 для обработки нулевых случаев, и я могу почти полностью избежать? И! В коде.

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

Ex:-

До :

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

После :

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

и когда требуется проверить правильность строки,

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

Это избавило меня от необходимости добавлять и удалять многочисленные символы? И! После написания кода, который имеет разумный смысл.

Используйте тернарный оператор (также известный как условный оператор C++ forever!):

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

stringA! принудительное разворачивание происходит только когда stringA != nil, так что это безопасно. Многословие == false несколько более читабельно, чем еще один восклицательный знак в !(stringA!.isEmpty).

Лично я предпочитаю немного другую форму:

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

В приведенном выше утверждении сразу становится ясно, что весь блок if не выполняется, когда переменная равна nil.

полезно при получении значения из UITextField и проверке строки nil & empty

@IBOutlet weak var myTextField: UITextField!

Вот ваша функция (когда вы нажимаете button), которая получает строку из UITextField и выполняет некоторые другие вещи

@IBAction func getStringFrom_myTextField(_ sender: Any) {

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

Это позаботится о значении nil, а также о строке empty.

У меня это сработало отлично.

На мой взгляд, лучший способ проверить нулевую и пустую строку - это подсчитать количество строк.

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

Swift 5.4

extension Optional where Wrapped: Collection {
  var isEmptyOrNil: Bool {
    guard let value = self else { return true }
    return value.isEmpty
  }
}

Использование:

var name: String?
name.isEmptyOrNil //true
name = "John Peter"
name.isEmptyOrNil //false

вы можете использовать эту функцию

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