有没有一种方法来检查字符串nil和""斯威夫特？在Rails中，我可以blank()用来检查。

我目前有这个，但似乎矫kill过正：

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

如果您要处理可选的字符串，则可以使用：

(string ?? "").isEmpty

如果??nil不为nil，则nil合并运算符返回左侧，否则返回右侧。

您还可以像这样使用它来返回默认值：

(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语句

在了解该guard语句之前，我使用了一段时间。现在我是一个狂热的粉丝。它的使用类似于该if语句，但是它允许提早返回，并且通常使代码更简洁。

要在检查以确保字符串既不为nil也不为空时使用guard，可以执行以下操作：

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)

这将取消包装可选字符串，并立即检查它是否不是空的。如果它为nil（或为空），那么您将立即从函数（或循环）中返回，并且其后的所有内容都将被忽略。但是，如果guard语句通过，则可以安全地使用未包装的字符串。

也可以看看

• 声明文件
• Swift 2中的卫兵声明

使用Swift 5，您可以使用boolean属性实现类型的Optional扩展，String如果可选字符串没有值或为空，则返回boolean属性：

extension Optional where Wrapped == String {

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

}

但是，通过遵守protocol来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的运动场捕获也显示了另一种可能性。

如果要以非可选方式访问字符串，则应使用Ryan's Answer，但是如果您只关心字符串的非空性，则我的首选速记方式是

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对于检查Empty String的最佳方法

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解决方案使用可选的unwrapped值，并检查布尔值。

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

使用isEmpty

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

使用全部满意

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

请注意，如果字符串包含一个或多个空格，它将返回TRUE。要将空白字符串视为“空”，请使用...

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

...代替。这需要基金会。

因此使用它...

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，如果不是，则检查其属性，在这种情况下为isEmpty。由于此可选值可以为nil，因此您提供了一个默认值，当您的可选值为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＆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字符串。

对我来说效果很好。

我认为，检查nil和空字符串的最佳方法是获取字符串计数。

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 }