Есть ли способ проверить строки для Swift nilи ""в нем? В Rails я могу использовать blank()для проверки.

Сейчас у меня есть это, но кажется излишним:

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

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

(string ?? "").isEmpty

??Оператор ноль сливающихся возвращает левую сторону , если это не-ноль, в противном случае она возвращает правую сторону.

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

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

Возможно, вы могли бы использовать предложение if-let-where:

Свифт 3:

if let string = string, !string.isEmpty {
    /* string is not blank */
}

Свифт 2:

if let string = string where !string.isEmpty {
    /* string is not blank */
}

Если вы используете 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)
}

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

Я некоторое время использовал Swift, прежде чем узнал об этом guardзаявлении. Теперь я большой поклонник. Он используется аналогично ifоператору, но допускает ранний возврат и просто делает код намного чище в целом.

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

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 5 вы можете реализовать Optionalрасширение для Stringтипа с помощью логического свойства, которое возвращается, если необязательная строка не имеет значения или пуста:

extension Optional where Wrapped == String {

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

}

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

extension Optional where Wrapped: Collection {

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

}

Использование с 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

Использование с 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

Источники:

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

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

Я знаю, что на этот вопрос есть много ответов, но ни один из них не кажется таким же удобным, как это (на мой взгляд) для проверки 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/

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

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

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

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

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

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

Пример: -

Перед :

    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& emptystring

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

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

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