Periksa string untuk nil & kosong

Jawaban:

211

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!
jrc
sumber
3
Anggun ??? Anda pada dasarnya menulis "jika string bukan nol, maka string kosong dan panggilan itu kosong pada ... Pernyataan yang logis.
Renetik
73

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 */
}
Ryan
sumber
2
Tidak bekerja dengan Swift 2, mendapatkan galat run time ini fatal error: unexpectedly found nil while unwrapping an Optional valuetetapi konstanta saya stringmemiliki data string.
Nagendra Rao
3
Ini berfungsi di Swift 3:if let string = string, !string.isEmpty { /* string is not blank */ }
EricS
1
@ AmrLotfy guard letadalah alternatif jika Anda ingin mengakhiri aliran kontrol di bawah pernyataan. Namun tidak ada yang dibuka di mana klausa di sini (the! Adalah negasi boolean)
Ryan
jadi bagaimana dengan ini! str? .isEmpty bukannya string = string where! string.isEmpty
Pankaj
28

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)
}
Ken Ko
sumber
Bisakah Anda menjelaskan apa yang Anda lakukan di sini atau sumber daya yang dapat menjelaskan ini secara rinci. Seperti mengapa OptionalString dideklarasikan? Saya tidak mendapatkan Sintaksnya. Ini tidak seperti implementasi ekstensi normal. Terima kasih banyak sebelumnya
Vinayak Parmar
@VinayakParmar OptionalString dideklarasikan di sini karena where Wrapped:harus menentukan protokol dan bukan tipe.
Adam Johns
Mungkin Anda bisa nama isNilOrEmptyuntuk hasValue(atau sesuatu seperti itu) dan reverse logika
Islam Q.
28

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

Suragch
sumber
hati-hati. print (myString) tidak akan berjalan, jika String nihil atau kosong, karena penjaga dirancang untuk tidak jatuh setelah masuk ke fase lain.
Kang Byul
@ KangByul, itu benar dan maksud dari logika di sini. Agaknya jika string nilatau kosong, orang tidak mau menelepon print(myString). Jika Anda perlu melanjutkan eksekusi setelah nilatau kosong String, maka Anda akan menggunakan if letdaripada guard.
Suragch
Terima kasih atas pujiannya. Saya tahu, saya hanya memberi tahu orang lain yang tidak tahu banyak tentang penjaga.
Kang Byul
4
@ KangByul Saya tidak mengerti maksud dari komentar "hati-hati" Anda, saya pikir itu menakut-nakuti orang dari solusi hebat, pernyataan pengembalian jelas benar dalam pernyataan penjaga lain, saya pikir Anda harus menghapus komentar Anda
Brian Ogden
16

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:

Imanou Petit
sumber
1
Saya suka ini, satu-satunya perubahan yang saya lakukan adalah mengubah nama dari isNilOrEmptymenjadi isEmptyOrNiluntuk mencocokkan awalan sehingga mudah ditemukan melalui pola yang sama untuk pelengkapan otomatis. Saya perhatikan lebih banyak adopsi ekstensi ini dari kolega yang bekerja sama dengan saya hanya dari mereka yang menemukannya dengan cara ini.
Aaron
14
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")
}
Sutra
sumber
1
Elegan tapi canggung;), yang "benar" agak membuang intusi
TruMan1
9

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
}
Tuan Codesalot
sumber
Jawaban bagus, Op tidak tepat jika spasi putih di mana dihitung sebagai kosong jadi di sini adalah versi saya: ekstensi publik Opsional di mana Dibungkus == String {var isEmptyOrNil: Bool {return (self ?? "") .isEmpty}}
sachadso
7

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.

masukkan deskripsi gambar di sini

Harga Ringo
sumber
7

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
}
Alex Pretzlav
sumber
@ TruMan1 itu benar, tujuan dari contoh pertama adalah untuk memeriksa apakah string tidak kosong.
Alex Pretzlav
4

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?") } 
Joshua Hart
sumber
4

Swift 3 Untuk memeriksa String Kosong cara terbaik

if !string.isEmpty{

// do stuff

}
Anas
sumber
2

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")
}
vol7ron
sumber
2

Solusi Swift 3 Gunakan nilai unrapped opsional dan periksa boolean.

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

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/

raaz
sumber
1

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!")
}
JustPixelz
sumber
1

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
FredFlinstone
sumber
1

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.

Dominik Babić
sumber
1

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
    }
}
Daniel
sumber
0

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.

Nikhil Mathew
sumber
0

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.

Gary
sumber
0

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.

Soropromo
sumber
0

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")
}
yo2bh
sumber
-4

Anda dapat menggunakan fungsi ini

 class func stringIsNilOrEmpty(aString: String) -> Bool { return (aString).isEmpty }
Ahmed Khemiri
sumber
2
Bukan pengguna cepat; Bisakah Anda menjelaskan mengapa ini tidak membuang pengecualian jika nihil disahkan?
Foon
Ini tidak membuang pengecualian karena Anda tidak bisa masuk nilke fungsi ini sama sekali (kecuali dari objc, dalam hal ini memang akan crash).
Alfonso
Ini tidak menjawab pertanyaan. Itu tidak memeriksa nol karena tidak menerima opsional
Wayne Ellery