检查字符串是否为nil＆amp;空

Question

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

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

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

Answer 1

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

(string ?? "").isEmpty

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

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

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

Answer 2

你也许可以使用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 */
}

Answer 3

如果您使用的是Swift 2，这是我的同事提出的一个示例，它在可选字符串上添加了isNilOrEmpty属性：

        Code    "#75603"    string
+       Currency    {Api.mMApiFkField}  Api.mMApiFkField
        ItemId  2700454 int
        ItemType    "S" string
        Name    null    string
        PageSize    0   long
        Price   0.46    double
        RebatePercent   0.0 double
+       RevenueAccountDomestic  {Api.RevenueAccountDomestic}    Api.RevenueAccountDomestic
+       RevenueAccountEU    {Api.RevenueAccountEU}  Api.RevenueAccountEU
+       RevenueAccountOutsideEU {Api.RevenueAccountOutsideEU}   Api.RevenueAccountOutsideEU
+       Rows    null    System.Collections.Generic.List<Api.ItemsPage>
        RowVersion  null    string
        StocksAccount   null    object
        Title   "Izdelava etiket"   string
        UnitOfMeasurement   ""  string
        Usage   null    string
+       VatRate {Api.mMApiFkField}  Api.mMApiFkField

然后，您可以在可选字符串本身上使用isNilOrEmpty

protocol OptionalString {}
extension String: OptionalString {}

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

Answer 4

使用guard语句

在我了解guard声明之前，我正在使用Swift一段时间。现在我是一个忠实粉丝。它与if语句类似地使用，但它允许early return，并且通常可以提供更清晰的代码。

要在检查以确保字符串既不为空也不为空时使用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（或为空），则立即从函数（或循环）返回，并忽略其后的所有内容。但是如果守护声明通过，那么你可以安全地使用你的解包字符串。

另见

• Statements documentation
• The Guard Statement in Swift 2

Answer 5

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

Answer 6

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

Answer 7

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

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

由于==使用可选的布尔值可以正常工作，我认为这样可以使代码可读而不会模糊原始意图。

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

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

Answer 8

我会推荐。

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

如果可选项为map，

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

Answer 9

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

}

---

与String s一起使用：

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

与Array s一起使用：

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

---

来源：

• Extending optionals in Swift
• Swift Tip: Non-Empty Collections

Answer 10

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

Answer 11

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

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

Answer 12

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

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

Answer 13

雨燕3 检查空字符串的最佳方法

if !string.isEmpty{

// do stuff

}

Answer 14

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

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

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

Answer 15

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

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

Answer 16

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

Answer 17

创建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。要将空白字符串视为＆＃34;清空＆＃34;，请使用...

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

......相反。这需要基金会。

因此使用它......

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

Answer 18

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

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

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

我个人更喜欢略有不同的形式：

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

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

Answer 19

从 UITextField 获取价值并检查nil＆amp; 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字符串。

对我来说效果非常好。

Answer 20

您应该执行以下操作：
if !(string?.isEmpty ?? true) { //Not nil nor empty }

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

Answer 21

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

Answer 22

当处理从本地数据库到服务器的值传递时，反之亦然，我在使用？和s时遇到了太多麻烦。什么不是。

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

https://website.com/-id1

例如： -

之前：

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)]

这节省了我在编写合理有意义的代码后，不得不经历添加和删除众多？和！的麻烦。

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

Answer 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

Answer 25

你可以使用这个功能

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