İçin dizeleri denetlemek için bir yolu var mı nilve ""Swift? Rails'de blank()kontrol etmek için kullanabilirim .

Şu anda buna sahibim, ancak aşırı görünüyor:

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

İsteğe bağlı Dizelerle uğraşıyorsanız, bu çalışır:

(string ?? "").isEmpty

??Dışı nil ise nil kaynaştırma operatör aksi takdirde sağ tarafını döner, sol tarafını döner.

Varsayılan bir değer döndürmek için şu şekilde de kullanabilirsiniz:

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

Belki if-let-where cümlesini kullanabilirsiniz:

Swift 3:

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

Swift 2:

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

Swift 2 kullanıyorsanız, isteğe bağlı Dizelere isNilOrEmpty özelliğini ekleyen iş arkadaşımın bulduğu bir örnek:

protocol OptionalString {}
extension String: OptionalString {}

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

Daha sonra isteğe bağlı dizenin kendisinde isNilOrEmpty kullanabilirsiniz

func testNilOrEmpty() {
    let nilString:String? = nil
    XCTAssertTrue(nilString.isNilOrEmpty)

    let emptyString:String? = ""
    XCTAssertTrue(emptyString.isNilOrEmpty)

    let someText:String? = "lorem"
    XCTAssertFalse(someText.isNilOrEmpty)
}

kullanma guarddeyimi

İfadeyi öğrenmeden önce Swift'i bir süre kullanıyordum guard. Şimdi büyük bir hayranıyım. İfadeye benzer şekilde kullanılır if, ancak erken dönüşe izin verir ve genel olarak çok daha temiz kod sağlar.

Bir dizenin ne boş ne de boş olmadığından emin olmak için kontrol ederken koruma kullanmak için aşağıdakileri yapabilirsiniz:

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)

Bu, isteğe bağlı dizeyi açar ve aynı anda tamamen boş olmadığını kontrol eder. Sıfırsa (veya boşsa), işlevinizden (veya döngüden) hemen dönersiniz ve ondan sonraki her şey yok sayılır. Ancak koruma ifadesi geçerse, sarılmamış dizenizi güvenle kullanabilirsiniz.

Ayrıca bakınız

• Beyanlar belgeleri
• Swift 2'deki Muhafız İfadesi

Swift 5 ile, isteğe bağlı bir dizenin değeri yoksa veya boşsa dönen bir boole özelliği ile tür Optionaliçin bir uzantı uygulayabilirsiniz String:

extension Optional where Wrapped == String {

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

}

Ancak, protokole uyarak özelliği Stringuygular . Bu nedenle önceki kodun jenerik kısıtlamasını (yerine daha geniş bir birinden (birlikte) ), böylece , ve aynı zamanda yeni yararlanacak özelliği:isEmptyCollectionWrapped == StringWrapped: CollectionArrayDictionarySetisNilOrEmpty

extension Optional where Wrapped: Collection {

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

}

S ile kullanım String:

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

S ile kullanım Array:

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

Kaynaklar:

• swiftbysundell.com - Swift'de opsiyonları genişletme
• objc.io - Swift İpucu: Boş Olmayan Koleksiyonlar

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

Bu sorunun pek çok cevabı olduğunu biliyorum, ancak bunların hiçbiri (bence) UITextFieldverileri doğrulamak için bu kadar uygun görünmüyor , ki bu onu kullanmak için en yaygın durumlardan biridir:

extension Optional where Wrapped == String {
    var isNilOrEmpty: Bool {
        return self?.trimmingCharacters(in: .whitespaces).isEmpty ?? true
    }
}

Sadece kullanabilirsin

textField.text.isNilOrEmpty

Ayrıca, .trimmingCharacters(in:.whitespaces)beyaz boşlukları boş bir dizge olarak görmüyorsanız atlayabilir veya daha karmaşık girdi testleri için kullanabilirsiniz.

var isValidInput: Bool {
    return !isNilOrEmpty && self!.trimmingCharacters(in: .whitespaces).characters.count >= MIN_CHARS
}

Ben tavsiye ederim.

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

mapisteğe bağlı ise işlev bağımsız değişkenini uygular .Some.
Oyun alanı yakalama, isteğe bağlı bağlama izin verilirse, yeni Swift 1.2 ile başka bir olasılık da gösterir.

Dizeye isteğe bağlı olmayan bir şekilde erişmek istiyorsanız, Ryan'ın Cevabını kullanmalısınız , ancak yalnızca dizenin boş olmamasını önemsiyorsanız, bunun için tercih ettiğim kısaltma şudur:

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

Dan beri == isteğe bağlı boolelerde ile çalışır ince, ben orijinal niyeti karıştırmadan bu yaprakları kod okunabilir düşünüyorum.

Tersini kontrol etmek istiyorsanız: eğer dize nilveya ise "", doğru niyeti göstermek için her iki durumu da açıkça kontrol etmeyi tercih ederim:

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

İsteğe bağlı dizede şu şekilde kullanın:

if myString.isNilOrEmpty { print("Crap, how'd this happen?") } 

Swift 3 Boş Dize'yi kontrol etmek için en iyi yol

if !string.isEmpty{

// do stuff

}

Çokça yapmayı beklediğiniz bir şeyse, kendi özel işlevinizi oluşturabilirsiniz.

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 çözümü İsteğe bağlı sarmalanmamış değeri kullanın ve boole ile karşılaştırmayı kontrol edin.

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

İsEmpty kullanma

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

AllSatisfy'i kullanma

extension String {
  var isBlank: Bool {
    return allSatisfy({ $0.isWhitespace })
  }
}

"Hello".isBlank        // false
"".isBlank             // true

İsteğe bağlı Dize kullanma

extension Optional where Wrapped == String {
  var isBlank: Bool {
    return self?.isBlank ?? true
  }
}

var title: String? = nil
title.isBlank            // true
title = ""               
title.isBlank            // true

Referans: https://useyourloaf.com/blog/empty-strings-in-swift/

Bir String sınıfı uzantısı oluşturun:

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

Dize bir veya daha fazla boşluk içeriyorsa bunun DOĞRU döndüreceğine dikkat edin. Boş dizeyi "boş" olarak değerlendirmek için şunu kullanın ...

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

... yerine. Bu, Foundation gerektirir.

Bunu kullanın ...

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

Swift 3 Bu, dizenin gerçekten boş olup olmadığını kontrol etmek için iyi çalışır. Çünkü isEmpty, bir boşluk olduğunda true değerini döndürür.

extension String {
    func isEmptyAndContainsNoWhitespace() -> Bool {
        guard self.isEmpty, self.trimmingCharacters(in: .whitespaces).isEmpty
            else {
               return false
        }
        return true
    }
}

Örnekler:

let myString = "My String"
myString.isEmptyAndContainsNoWhitespace() // returns false

let myString = ""
myString.isEmptyAndContainsNoWhitespace() // returns true

let myString = " "
myString.isEmptyAndContainsNoWhitespace() // returns false

Bunun gibi bir şey yapmalısınız:
if !(string?.isEmpty ?? true) { //Not nil nor empty }

Nil birleştirme operatörü, isteğe bağlı olanın sıfır olup olmadığını kontrol eder, sıfır olmaması durumunda, daha sonra özelliğini kontrol eder, bu durumda isEmpty. Bu isteğe bağlı sıfır olabileceğinden, isteğe bağlı değeriniz sıfır olduğunda kullanılacak varsayılan bir değer sağlarsınız.

Bu, Collectionaşağıdakileri içeren protokole uyan tüm türler için genel bir çözümdür String:

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

Değerleri yerel db'den sunucuya ve tersi şekilde geçirirken,? 'Ve!' Ler ile çok fazla sorun yaşıyordum.

Bu yüzden boş durumları ele almak için bir Swift3.0 aracı yaptım ve koddaki? 'Ve!' Leri neredeyse tamamen önleyebilirim.

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

Ör: -

Önce :

    let myDictionary: [String: String] = 
                      ["title": (dbObject?.title != nil ? dbObject?.title! : "")]

Sonra:

    let myDictionary: [String: String] = 
                        ["title": str(dbObject.title)]

ve geçerli bir dizenin kontrol edilmesi gerektiğinde,

    if !str(dbObject.title).isEmpty {
        //do stuff
    }

Bu, mantıklı bir şekilde kod yazdıktan sonra çok sayıda? Ve! 'Leri ekleme ve kaldırma zahmetinden kurtulmamı sağladı.

Üçlü operatörü kullanın (koşullu operatör olarak da bilinir C++ forever!):

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

stringA!Zorla Unwrapping sadece ne olur stringA != nilgüvenli yani. == falseAyrıntı içinde bir başka ünlem işareti biraz daha okunabilir !(stringA!.isEmpty).

Şahsen biraz farklı bir biçimi tercih ediyorum:

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

Yukarıdaki ifadede, ifbir değişken olduğunda tüm bloğun çalışmadığı hemen çok açıktır nil.

UITextField'dan değer alırken ve nil& emptystring'i kontrol ederken faydalıdır

@IBOutlet weak var myTextField: UITextField!

İşte buttonUITextField'den dize alan ve başka şeyler yapan işleviniz (a'ya dokunduğunuzda )

@IBAction func getStringFrom_myTextField(_ sender: Any) {

guard let string = myTextField.text, !(myTextField.text?.isEmpty)!  else { return }
    //use "string" to do your stuff.
}

Bu, dizenin nilyanı sıra değerle de ilgilenecektir empty.

Benim için gayet iyi çalıştı.

Bence, sıfır ve boş dizeyi kontrol etmenin en iyi yolu, dizi sayısını almaktır.

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

bu işlevi kullanabilirsin

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