Có cách nào để kiểm tra chuỗi cho nilvà ""trong Swift không? Trong Rails, tôi có thể sử dụng blank()để kiểm tra.

Tôi hiện đang có điều này, nhưng có vẻ như quá mức cần thiết:

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

Nếu bạn đang xử lý các Chuỗi tùy chọn, điều này hoạt động:

(string ?? "").isEmpty

Các ??nhà điều hành nil coalescing trả về bên trái nếu nó không bằng không, nếu không nó sẽ trả về phía bên phải.

Bạn cũng có thể sử dụng nó như thế này để trả về giá trị mặc định:

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

Có lẽ bạn có thể sử dụng mệnh đề 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 */
}

Nếu bạn đang sử dụng Swift 2, đây là một ví dụ mà đồng nghiệp của tôi đã đưa ra, có thêm thuộc tính isNilOrEmpty trên Chuỗi tùy chọn:

protocol OptionalString {}
extension String: OptionalString {}

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

Sau đó, bạn có thể sử dụng isNilOrEmpty trên chính chuỗi tùy chọn

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

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

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

Sử dụng guardtuyên bố

Tôi đã sử dụng Swift một thời gian trước khi tôi biết về guardtuyên bố này. Bây giờ tôi là một fan hâm mộ lớn. Nó được sử dụng tương tự như iftuyên bố, nhưng nó cho phép trả lại sớm và chỉ làm cho mã sạch hơn nhiều nói chung.

Để sử dụng bảo vệ khi kiểm tra để đảm bảo rằng một chuỗi không có cũng không trống, bạn có thể làm như sau:

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)

Điều này hủy bỏ chuỗi tùy chọn và kiểm tra xem nó không trống tất cả cùng một lúc. Nếu nó không (hoặc trống), thì bạn trở về từ hàm (hoặc vòng lặp) ngay lập tức và mọi thứ sau khi nó bị bỏ qua. Nhưng nếu tuyên bố bảo vệ vượt qua, thì bạn có thể sử dụng chuỗi chưa được mở của mình một cách an toàn.

Xem thêm

• Tài liệu báo cáo
• Tuyên bố bảo vệ trong Swift 2

Với Swift 5, bạn có thể triển khai Optionaltiện ích mở rộng cho Stringloại có thuộc tính boolean trả về nếu một chuỗi tùy chọn không có giá trị hoặc trống:

extension Optional where Wrapped == String {

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

}

Tuy nhiên, Stringthực hiện isEmptytài sản bằng cách tuân thủ giao thức Collection. Vì vậy chúng tôi có thể thay thế chế generic mã trước ( Wrapped == String) với một rộng hơn ( Wrapped: Collection) do đó Array, Dictionaryvà Setcũng được hưởng lợi mới của chúng tôi isNilOrEmptysở hữu:

extension Optional where Wrapped: Collection {

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

}

Sử dụng với 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

Sử dụng với 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

Nguồn:

• swiftbysundell.com - Mở rộng tùy chọn trong Swift
• objc.io - Mẹo Swift: Bộ sưu tập không trống

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

Tôi biết có rất nhiều câu trả lời cho câu hỏi này, nhưng không ai trong số chúng có vẻ thuận tiện như điều này (theo ý kiến ​​của tôi) để xác thực UITextFielddữ liệu, đây là một trong những trường hợp phổ biến nhất để sử dụng nó:

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

Bạn chỉ có thể sử dụng

textField.text.isNilOrEmpty

Bạn cũng có thể bỏ qua .trimmingCharacters(in:.whitespaces)nếu bạn không coi khoảng trắng là một chuỗi trống hoặc sử dụng nó cho các thử nghiệm đầu vào phức tạp hơn như

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

Tôi muốn giới thiệu.

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

mapáp dụng đối số hàm nếu tùy chọn là .Some.
Việc chụp sân chơi cũng cho thấy một khả năng khác với Swift 1.2 mới nếu để ràng buộc tùy chọn.

Nếu bạn muốn truy cập chuỗi dưới dạng không tùy chọn, bạn nên sử dụng Câu trả lời của Ryan , nhưng nếu bạn chỉ quan tâm đến tính không trống của chuỗi, thì tốc ký ưa thích của tôi cho điều này là

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

Vì ==hoạt động tốt với các booleans tùy chọn, tôi nghĩ rằng điều này để lại mã có thể đọc được mà không làm lu mờ ý định ban đầu.

Nếu bạn muốn kiểm tra ngược lại: nếu chuỗi là nilhoặc "", tôi thích kiểm tra rõ ràng cả hai trường hợp để hiển thị ý định chính xác:

if stringA == nil || stringA?.isEmpty == true {
    ...blah blah
}

Chuyển 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
    }
}

Sử dụng như thế này trên chuỗi tùy chọn:

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

Swift 3 Để kiểm tra chuỗi rỗng cách tốt nhất

if !string.isEmpty{

// do stuff

}

Bạn có thể tạo chức năng tùy chỉnh của riêng mình, nếu đó là điều bạn mong đợi sẽ làm được rất nhiều.

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

Giải pháp Swift 3 Sử dụng giá trị chưa được tùy chọn và kiểm tra đối với boolean.

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

Sử dụng isEmpty

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

Sử dụng tất cả sự hài lòng

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

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

Sử dụng Chuỗi tùy chọn

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

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

Tham khảo: https://useyourloaf.com/blog/empty-strings-in-swift/

Tạo một phần mở rộng lớp 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

Lưu ý điều này sẽ trả về ĐÚNG nếu chuỗi chứa một hoặc nhiều khoảng trống. Để coi chuỗi trống là "trống", hãy sử dụng ...

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

... thay thế. Điều này đòi hỏi Foundation.

Sử dụng nó như vậy ...

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

Swift 3 Điều này hoạt động tốt để kiểm tra xem chuỗi có thực sự trống không. Bởi vì isEmpty trả về true khi có khoảng trắng.

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

Ví dụ:

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

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

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

Bạn nên làm một cái gì đó như thế này:
if !(string?.isEmpty ?? true) { //Not nil nor empty }

Toán tử hợp nhất Nil kiểm tra nếu tùy chọn không phải là không, trong trường hợp không phải là không thì nó sẽ kiểm tra thuộc tính của nó, trong trường hợp này làEmpty. Bởi vì tùy chọn này có thể là không, bạn cung cấp một giá trị mặc định sẽ được sử dụng khi tùy chọn của bạn là không.

Đây là một giải pháp chung cho tất cả các loại phù hợp với Collectiongiao thức, bao gồm String:

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

Khi xử lý việc chuyển các giá trị từ db cục bộ sang máy chủ và ngược lại, tôi đã gặp quá nhiều rắc rối với? Và và những gì không.

Vì vậy, tôi đã tạo ra một tiện ích Swift3.0 để xử lý các trường hợp null và tôi gần như hoàn toàn có thể tránh được? Và trong mã.

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

Ví dụ:-

Trước :

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

Sau :

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

và khi cần kiểm tra chuỗi hợp lệ,

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

Điều này giúp tôi tiết kiệm được việc phải trải qua những rắc rối trong việc thêm và xóa rất nhiều? Và sau khi viết mã hợp lý.

Sử dụng toán tử ternary (còn được gọi là toán tử có điều kiện C++ forever!):

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

Việc stringA!tháo gỡ lực lượng chỉ xảy ra khi stringA != nil, vì vậy nó an toàn. Độ == falsedài có phần dễ đọc hơn một dấu chấm than khác trong!(stringA!.isEmpty) .

Cá nhân tôi thích một hình thức hơi khác:

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

Trong câu lệnh trên, ngay lập tức rất rõ ràng rằng toàn bộ ifkhối không thực thi khi có một biến nil.

hữu ích khi nhận giá trị từ UITextField và kiểm tra nil& emptychuỗi

@IBOutlet weak var myTextField: UITextField!

Đây là chức năng của bạn (khi bạn nhấn vào a button) lấy chuỗi từ UITextField và thực hiện một số nội dung khác

@IBAction func getStringFrom_myTextField(_ sender: Any) {

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

Điều này sẽ chăm sóc nilgiá trị cũng như emptychuỗi.

Nó làm việc hoàn toàn tốt cho tôi.

Theo tôi, cách tốt nhất để kiểm tra chuỗi số không và chuỗi rỗng là lấy số đếm chuỗi.

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

bạn có thể sử dụng chức năng này

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