มีวิธีตรวจสอบสตริงสำหรับnilและ""ใน Swift หรือไม่? ใน Rails ฉันสามารถใช้blank()เพื่อตรวจสอบ

ขณะนี้ฉันมีสิ่งนี้ แต่ดูเหมือนว่าจะมากเกินไป:

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

หากคุณกำลังจัดการกับสตริงที่เป็นทางเลือกสิ่งนี้ใช้ได้:

(string ?? "").isEmpty

??ผู้ประกอบการศูนย์หลอมรวมผลตอบแทนทางด้านซ้ายถ้ามันไม่ใช่ไม่มีมิฉะนั้นก็จะส่งกลับทางด้านขวา

คุณยังสามารถใช้วิธีนี้เพื่อส่งคืนค่าเริ่มต้น:

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

คุณอาจใช้ประโยค 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 */
}

หากคุณกำลังใช้ 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คำสั่ง

ฉันใช้ Swift มาระยะหนึ่งก่อนที่จะได้เรียนรู้เกี่ยวกับguardคำชี้แจง ตอนนี้ฉันเป็นแฟนตัวยง ใช้คล้ายกับifคำสั่ง แต่อนุญาตให้ส่งคืนก่อนกำหนดและทำให้โค้ดสะอาดขึ้นโดยทั่วไป

หากต้องการใช้ตัวป้องกันเมื่อตรวจสอบเพื่อให้แน่ใจว่าสตริงไม่เป็นศูนย์หรือว่างเปล่าคุณสามารถทำสิ่งต่อไปนี้:

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)

การดำเนินการนี้จะคลายสตริงที่เป็นทางเลือกและตรวจสอบว่าไม่ได้ว่างเปล่าพร้อมกัน หากเป็นศูนย์ (หรือว่างเปล่า) คุณจะกลับจากฟังก์ชัน (หรือวนซ้ำ) ทันทีและทุกอย่างหลังจากนั้นจะถูกละเว้น แต่ถ้าคำสั่งยามผ่านคุณก็สามารถใช้สายอักขระที่ไม่ได้ปิดกั้นได้อย่างปลอดภัย

ดูสิ่งนี้ด้วย

• เอกสารงบ
• แถลงการณ์ของ Guard ใน Swift 2

ด้วย 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
    }

}

การใช้งานกับ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 - เคล็ดลับอย่างรวดเร็ว: คอลเล็กชันที่ไม่ว่างเปล่า

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ข้อมูลซึ่งเป็นหนึ่งในกรณีที่พบบ่อยที่สุดสำหรับการใช้งาน:

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แต่ถ้าคุณสนใจเฉพาะความว่างเปล่าของสตริงชวเลขที่ฉันต้องการสำหรับสิ่งนี้คือ

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 สำหรับการตรวจสอบ Empty String วิธีที่ดีที่สุด

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

ใช้ allS Satisfy

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

สังเกตว่าสิ่งนี้จะส่งกลับ TRUE หากสตริงมีช่องว่างอย่างน้อยหนึ่งช่อง หากต้องการให้สตริงว่างเป็น "ว่าง" ให้ใช้ ...

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

... แทน. สิ่งนี้ต้องใช้ Foundation

ใช้มันจึง ...

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

Swift 3 ใช้งานได้ดีในการตรวจสอบว่าสตริงว่างเปล่าหรือไม่ เนื่องจาก isEmpty จะคืนค่าจริงเมื่อมีช่องว่าง

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 จะตรวจสอบว่าตัวเลือกนั้นไม่ใช่ศูนย์หรือไม่ในกรณีที่ไม่ใช่ศูนย์จากนั้นจะตรวจสอบคุณสมบัติในกรณีนี้คือว่างเปล่า เนื่องจากทางเลือกนี้สามารถเป็นศูนย์ได้คุณจึงระบุค่าเริ่มต้นซึ่งจะใช้เมื่อทางเลือกของคุณเป็นศูนย์

นี่เป็นวิธีแก้ปัญหาทั่วไปสำหรับทุกประเภทที่เป็นไปตามCollectionโปรโตคอลซึ่งรวมถึงString:

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

เมื่อจัดการกับการส่งผ่านค่าจากฐานข้อมูลในเครื่องไปยังเซิร์ฟเวอร์และในทางกลับกันฉันประสบปัญหามากเกินไปกับ? และ!

ดังนั้นฉันจึงสร้างยูทิลิตี้ Swift3.0 เพื่อจัดการกรณีว่างและฉันเกือบจะหลีกเลี่ยง? 's and!' ในโค้ดได้

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

Ex: -

ก่อน:

    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
    }

สิ่งนี้ช่วยให้ฉันไม่ต้องประสบปัญหาในการเพิ่มและลบจำนวนมากและ! หลังจากเขียนโค้ดที่สมเหตุสมผล

ใช้ตัวดำเนินการ ternary (หรือเรียกอีกอย่างว่าตัวดำเนินการตามเงื่อนไขC++ forever!):

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

การstringA!บังคับแกะจะเกิดขึ้นก็ต่อเมื่อstringA != nilจึงปลอดภัย การใช้== falseคำฟุ่มเฟือยค่อนข้างอ่านได้ง่ายกว่าเครื่องหมายอัศเจรีย์อื่นใน!(stringA!.isEmpty)ฟุ่มเฟื่อยค่อนข้างอ่านได้มากขึ้นกว่ายังเครื่องหมายอัศเจรีย์อีก

โดยส่วนตัวแล้วฉันชอบรูปแบบที่แตกต่างกันเล็กน้อย:

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

ในคำสั่งข้างต้นก็คือทันทีที่ชัดเจนว่าทั้งบล็อกไม่ได้ดำเนินการเมื่อตัวแปรคือifnil

มีประโยชน์เมื่อรับค่าจากUITextField และตรวจสอบnil& emptyสตริง

@IBOutlet weak var myTextField: UITextField!

นี่คือฟังก์ชั่นของคุณ (เมื่อคุณแตะที่ a 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สตริง

มันทำงานได้ดีสำหรับฉัน

ในความคิดของฉันวิธีที่ดีที่สุดในการตรวจสอบ 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")
}

คุณสามารถใช้ func นี้ได้

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