Apakah ada cara untuk memeriksa string untuk nildan ""di Swift? Di Rails, saya bisa gunakan blank()untuk memeriksa.

Saat ini saya memiliki ini, tetapi tampaknya berlebihan:

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

Jika Anda berurusan dengan Strings opsional, ini berfungsi:

(string ?? "").isEmpty

The ??Operator nil penggabungan kembali sisi kiri jika non-nil, jika tidak maka kembali sisi kanan.

Anda juga dapat menggunakannya seperti ini untuk mengembalikan nilai default:

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

Anda mungkin bisa menggunakan klausa if-let-where:

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

Jika Anda menggunakan Swift 2, berikut adalah contoh yang dibuat oleh rekan saya, yang menambahkan properti isNilOrEmpty pada Strings opsional:

protocol OptionalString {}
extension String: OptionalString {}

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

Anda kemudian dapat menggunakan isNilOrEmpty pada string opsional itu sendiri

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

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

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

Menggunakan guardpernyataan itu

Saya menggunakan Swift untuk sementara waktu sebelum saya mengetahui tentang guardpernyataan itu. Sekarang saya penggemar berat. Ini digunakan mirip dengan ifpernyataan itu, tetapi memungkinkan untuk kembali lebih awal dan hanya membuat kode lebih bersih secara umum.

Untuk menggunakan pelindung saat memeriksa untuk memastikan bahwa string tidak nol atau kosong, Anda dapat melakukan hal berikut:

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)

Ini membuka bungkus string opsional dan memeriksa bahwa itu tidak kosong sekaligus. Jika nil (atau kosong), maka Anda segera kembali dari fungsi Anda (atau loop) dan semuanya setelah itu diabaikan. Tetapi jika pernyataan penjaga terlewati, maka Anda dapat menggunakan string yang terbuka dengan aman.

Lihat juga

• Dokumentasi pernyataan
• Pernyataan Penjaga dalam Cepat 2

Dengan Swift 5, Anda dapat menerapkan Optionalekstensi untuk Stringtipe dengan properti boolean yang kembali jika string opsional tidak memiliki nilai atau kosong:

extension Optional where Wrapped == String {

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

}

Namun, Stringmengimplementasikan isEmptyproperti dengan mematuhi protokol Collection. Karenanya kita dapat mengganti batasan generik kode sebelumnya ( Wrapped == String) dengan yang lebih luas ( Wrapped: Collection) sehingga Array, Dictionarydan Setjuga menguntungkan isNilOrEmptyproperti baru kami :

extension Optional where Wrapped: Collection {

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

}

Penggunaan dengan 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

Penggunaan dengan 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

Sumber:

• swiftbysundell.com - Memperluas opsional dalam Swift
• objc.io - Tip Cepat: Koleksi Non-Kosong

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

Saya tahu ada banyak jawaban untuk pertanyaan ini, tetapi tidak satu pun dari mereka tampaknya senyaman ini (menurut saya) untuk memvalidasi UITextFielddata, yang merupakan salah satu kasus paling umum untuk menggunakannya:

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

Anda bisa menggunakannya

textField.text.isNilOrEmpty

Anda juga dapat melewatkan .trimmingCharacters(in:.whitespaces)jika Anda tidak menganggap spasi putih sebagai string kosong atau menggunakannya untuk tes input yang lebih kompleks

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

Saya ingin merekomendasikan.

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

mapmenerapkan argumen fungsi jika opsional .Some.
Pengambilan taman bermain juga menunjukkan kemungkinan lain dengan Swift 1.2 baru jika memungkinkan penjilidan opsional.

Jika Anda ingin mengakses string sebagai non-opsional, Anda harus menggunakan Jawaban Ryan , tetapi jika Anda hanya peduli tentang kekosongan string, singkatan yang saya pilih untuk ini adalah

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

Karena ==berfungsi baik dengan boolean opsional, saya pikir ini membuat kode dapat dibaca tanpa mengaburkan niat asli.

Jika Anda ingin memeriksa yang sebaliknya: jika stringnya adalah nilatau "", saya lebih suka memeriksa kedua kasus secara eksplisit untuk menunjukkan maksud yang benar:

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

Gunakan seperti ini pada string opsional:

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

Swift 3 Untuk memeriksa String Kosong cara terbaik

if !string.isEmpty{

// do stuff

}

Anda dapat membuat fungsi kustom Anda sendiri, jika itu adalah sesuatu yang Anda harapkan banyak dilakukan.

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

Solusi Swift 3 Gunakan nilai unrapped opsional dan periksa boolean.

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

Menggunakan isEmpty

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

Menggunakan allSatisfy

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

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

Menggunakan String opsional

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

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

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

Buat ekstensi kelas 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

Perhatikan ini akan mengembalikan BENAR jika string berisi satu atau lebih kosong. Untuk memperlakukan string kosong sebagai "kosong", gunakan ...

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

... sebagai gantinya. Ini membutuhkan Yayasan.

Gunakan demikian ...

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

Swift 3 Ini berfungsi dengan baik untuk memeriksa apakah string benar-benar kosong. Karena isEmpty mengembalikan true ketika ada spasi putih.

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

Contoh:

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

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

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

Anda harus melakukan sesuatu seperti ini:
if !(string?.isEmpty ?? true) { //Not nil nor empty }

Operator penggabungan nol tidak akan memeriksa jika opsional tidak nol, dalam hal ini bukan nol lalu memeriksa propertinya, dalam hal ini adalah kosong. Karena opsional ini bisa nol, Anda memberikan nilai default yang akan digunakan ketika opsional Anda nol.

Ini adalah solusi umum untuk semua jenis yang sesuai dengan Collectionprotokol, yang meliputi String:

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

Ketika berhadapan dengan meneruskan nilai dari db lokal ke server dan sebaliknya, saya mengalami terlalu banyak masalah dengan? Dan! Dan apa yang tidak.

Jadi saya membuat utilitas Swift3.0 untuk menangani kasus nol dan saya hampir sepenuhnya dapat menghindari? Dan di kode.

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

Ex:-

Sebelum :

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

Setelah:

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

dan ketika diminta untuk memeriksa string yang valid,

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

Ini menyelamatkan saya harus melalui kesulitan menambahkan dan menghapus banyak dan setelah menulis kode yang masuk akal.

Gunakan operator ternary (juga dikenal sebagai operator kondisional, C++ forever!):

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

The stringA!kekuatan-unwrapping terjadi hanya jika stringA != nil, sehingga aman. Kata == falseini agak lebih mudah dibaca daripada tanda seru lainnya di !(stringA!.isEmpty).

Saya pribadi lebih suka bentuk yang sedikit berbeda:

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

Dalam pernyataan di atas, segera sangat jelas bahwa seluruh ifblok tidak dieksekusi ketika sebuah variabel nil.

membantu ketika mendapatkan nilai dari UITextField dan memeriksa nil& emptystring

@IBOutlet weak var myTextField: UITextField!

Inilah fungsi Anda (ketika Anda mengetuk a button) yang mendapat string dari UITextField dan melakukan beberapa hal lainnya

@IBAction func getStringFrom_myTextField(_ sender: Any) {

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

Ini akan menjaga nilnilai serta emptystring.

Ini bekerja dengan sangat baik untuk saya.

Menurut pendapat saya, cara terbaik untuk memeriksa nil dan string kosong adalah dengan mengambil jumlah string.

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

Anda dapat menggunakan fungsi ini

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