【问题标题】：Check string for nil & empty检查字符串是否为空或为空
【发布时间】：2015-06-05 13:56:17
【问题描述】：

有没有办法在 Swift 中检查 nil 和 "" 的字符串？在 Rails 中，我可以使用blank() 进行检查。

我目前有这个，但它似乎有点矫枉过正：

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

【问题讨论】：

Unwrap String and check emptiness in the same if statement 的可能重复项
（@sutra 和@imanou-petit）的答案更好。

标签： swift string optional is-empty

【解决方案1】：

我会推荐。

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

map 如果可选项为 .Some，则应用函数参数。
如果让可选绑定，操场捕获还显示了新的 Swift 1.2 的另一种可能性。

【讨论】：

【解决方案2】：

您可以创建自己的自定义函数，如果这是您期望做的很多事情。

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

【讨论】：

【解决方案3】：

你也许可以使用 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，出现此运行时错误 fatal error: unexpectedly found nil while unwrapping an Optional value 但我的常量 string 有一个字符串数据。
这适用于 Swift 3：if let string = string, !string.isEmpty { /* string is not blank */ }
@AmrLotfy guard let 如果您想在语句下方结束控制流，则可以选择。然而，这里的 where 子句中没有任何内容被展开（！是布尔否定）
那么这个 !str?.isEmpty 而不是 string = string where !string.isEmpty 怎么样

【解决方案4】：

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

【讨论】：

优雅但笨拙;)，“真实”有点让人不快

【解决方案5】：

如果您正在处理可选字符串，这可行：

(string ?? "").isEmpty

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

你也可以像这样使用它来返回一个默认值：

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

【讨论】：

使用 isEmpty 而不是 == "" 比较有什么好处？感谢您的回答

【解决方案6】：

如果你使用的是 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)
}

【讨论】：

您能否澄清一下您在这里做了什么或一些可以详细解释这一点的资源。就像为什么声明 OptionalString 一样？我没有得到语法。它不像普通的扩展实现所以。提前非常感谢
@VinayakParmar OptionalString 在这里声明，因为where Wrapped: 必须指定协议而不是类型。
也许您可以将isNilOrEmpty 命名为hasValue（或类似名称）并颠倒逻辑

【解决方案7】：

如果你想以非可选的方式访问字符串，你应该使用Ryan's Answer，但如果你只关心字符串的非空性，我首选的简写是

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

由于== 可以很好地与可选的布尔值配合使用，我认为这样可以使代码保持可读性，而不会掩盖其初衷。

如果您想检查相反的情况：如果字符串是nil 或""，我更愿意明确检查这两种情况以显示正确的意图：

if stringA == nil || stringA?.isEmpty == true {
    ...blah blah
}

【讨论】：

@TruMan1 没错，第一个例子的目的是检查字符串是否不为空。

【解决方案8】：

使用`guard` 语句

在了解guard 语句之前，我使用了一段时间的 Swift。现在我是一个大粉丝。它的使用与if 语句类似，但它允许early return，并且通常只会使代码更简洁。

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

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 （或空），那么你会立即从你的函数（或循环）返回，并且它之后的所有内容都将被忽略。但是如果保护语句通过了，那么你就可以安全地使用你解包的字符串了。

另见

【讨论】：

小心。如果 String 为 nil 或为空，print(myString) 将不会运行，因为 guard 被设计为在进入 else 阶段后不会倒下。
@KangByul，这是正确的，也是这里逻辑的意图。大概如果字符串是nil 或为空，则不想调用print(myString)。如果您需要在nil 或空String 之后继续执行，那么您将使用if let 而不是guard。
感谢您的称赞。我知道，我只是告诉其他不太了解守卫的人。
@KangByul 我不明白你的“小心”评论的意思，我认为它把人们从一个很好的解决方案中吓跑了，return 语句在后卫 else 语句中显然是正确的，我认为你应该删除你的评论

【解决方案9】：

你可以使用这个函数

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

【讨论】：

不是 swift 用户；你能解释一下为什么如果通过 nil 不会抛出异常吗？
它不会抛出异常，因为你根本无法将nil 传递给这个函数（除了来自objc，在这种情况下它确实会崩溃）。
这不能回答问题。它不检查 nil，因为它不接受可选的

【解决方案10】：

在处理将值从本地数据库传递到服务器（反之亦然）时，我在处理 ? 和 ! 时遇到了太多麻烦。

所以我制作了一个 Swift3.0 实用程序来处理 null 情况，我几乎可以完全避免代码中的 ? 和 !。

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
    }

这让我不必在编写合理的代码之后再添加和删除大量的 ? 和 !。

【讨论】：

【解决方案11】：

Swift 3 解决方案使用可选的展开值并检查布尔值。

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

【讨论】：

【解决方案12】：

创建一个字符串类扩展：

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

... 相反。这需要 Foundation。

这样使用它...

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

【讨论】：

【解决方案13】：

斯威夫特 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

【讨论】：

【解决方案14】：

我知道这个问题有很多答案，但似乎没有一个比这更方便（在我看来）来验证 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
}

【讨论】：

很好的答案，如果空格算作空白，Op 并不精确，所以这是我的版本： public extension Optional where Wrapped == String { var isEmptyOrNil: Bool { return (self ?? "" ).isEmpty } }

【解决方案15】：

使用三元运算符（也称为条件运算符，C++ forever!）：

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

stringA! 强制解包仅在stringA != nil 时发生，因此是安全的。 == false 详细程度比 !(stringA!.isEmpty) 中的另一个感叹号更具可读性。

我个人更喜欢稍微不同的形式：

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

在上面的语句中，很明显，当变量为nil时，整个if块不会执行。

【讨论】：

【解决方案16】：

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

【讨论】：

【解决方案17】：

有助于从 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 字符串。

对我来说效果很好。

【讨论】：

【解决方案18】：

斯威夫特 3 检查空字符串的最佳方法

if !string.isEmpty{

// do stuff

}

【讨论】：

【解决方案19】：

你应该这样做：
if !(string?.isEmpty ?? true) { //Not nil nor empty }

Nil 合并运算符检查可选项是否不是 nil，如果不是 nil，则检查其属性，在这种情况下是 isEmpty。因为这个可选值可以是 nil，所以你提供了一个默认值，当你的可选值是 nil 时将使用它。

【讨论】：

【解决方案20】：

在 Swift 5 中，您可以为 String 类型实现 Optional 扩展，该扩展带有一个布尔属性，如果可选字符串为空或没有值则返回：

extension Optional where Wrapped == String {

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

}

但是，String 通过遵循协议Collection 来实现isEmpty 属性。因此，我们可以将之前代码的通用约束 (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

来源：

【讨论】：

我喜欢这个，我要做的唯一调整是将其从 isNilOrEmpty 重命名为 isEmptyOrNil 以匹配前缀，以便通过相同的自动完成模式轻松找到它。我注意到与我共事的同事更多地采用了这个扩展，只是他们以这种方式发现它。

【解决方案21】：

使用 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/

【讨论】：

【解决方案22】：

这是符合Collection协议的所有类型的通用解决方案，其中包括String：

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

【讨论】：

【解决方案23】：

在我看来，检查 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")
}

【讨论】：

【解决方案24】：

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

【讨论】：

你也可以简单地做self?.isEmpty ?? true;

【解决方案25】：

基于this Medium post，对 Swift 5 稍作调整，我得到了这个有效的代码。

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

虽然我了解创建扩展的好处，但我认为它可能会帮助那些只需要一个小组件/包的人。

【讨论】：

使用guard 语句

另见

使用`guard` 语句