以下のための文字列をチェックする方法があるnilと""スウィフトでは？Railsでは、blank()チェックに使用できます。

私は現在これを持っていますが、やりすぎのようです：

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

オプションの文字列を扱っている場合、これは機能します。

(string ?? "").isEmpty

??それが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ステートメントについて学ぶ前に、しばらくSwiftを使用していました。今、私は大ファンです。これはifステートメントと同様に使用されますが、早期の復帰を可能にし、一般的にはるかにクリーンなコードになります。

文字列がnilでも空でもないことを確認するときにガードを使用するには、次のようにします。

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のGuardステートメント

Swift 5では、オプションの文字列に値がないか空の場合に返されるブール型プロパティを使用して、typeのOptional拡張機能を実装できStringます。

extension Optional where Wrapped == String {

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

}

ただし、プロトコルに準拠してプロパティをString実装isEmptyしますCollection。そこで我々は、前のコードの一般的な制約を（置き換えることができWrapped == String、より広い1（と）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-Swiftのヒント：空でないコレクション

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データを検証するのにこれほど便利ではないようです（私の意見では）。これは、データを使用する最も一般的なケースの1つです。

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チェック用の空の文字列の最良の方法

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

文字列に1つ以上の空白が含まれている場合、これは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でないかどうかをチェックします。nilでない場合は、プロパティをチェックします。この場合はisEmptyです。このオプションはnilになる可能性があるため、オプションがnilの場合に使用されるデフォルト値を指定します。

これは、Collectionプロトコルに準拠するすべてのタイプの一般的なソリューションですString。

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

ローカルdbからサーバーへ、またはその逆の値の受け渡しを処理するときに、？と！と、そうでないことで問題が多すぎました。

したがって、nullのケースを処理する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!

buttonUITextFieldから文字列を取得し、その他の処理を行う関数（をタップしたとき）

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