Check string for nil & empty

Question

Is there a way to check strings for nil and "" in Swift? In Rails, I can use blank() to check.

I currently have this, but it seems overkill:

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

Cytologist

possible duplicate of Unwrap String and check emptiness in the same if statement – Selima

(@sutra and @imanou-petit)'s answers are better. – Mikkanen

Answer 1

If you're dealing with optional Strings, this works:

(string ?? "").isEmpty

The ?? nil coalescing operator returns the left side if it's non-nil, otherwise it returns the right side.

You can also use it like this to return a default value:

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

Pled

what is the benefit of using isEmpty over == "" comparison? Thanks for your answer – Yount

Answer 2

You could perhaps use the if-let-where clause:

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

Glycogen

Doesn't work with Swift 2, getting this run time error fatal error: unexpectedly found nil while unwrapping an Optional value but my constant string has a string data. – Kauffman

This works in Swift 3: if let string = string, !string.isEmpty { /* string is not blank */ } – Vang

@AmrLotfy guard let is an alternative if you want to end control flow below the statement. However nothing is being unwrapped in the where clause here (the ! is a boolean negation) – Glycogen

so how about this !str?.isEmpty instead of string = string where !string.isEmpty – Milkandwater

Answer 3

With Swift 5, you can implement an Optional extension for String type with a boolean property that returns if an optional string is empty or has no value:

extension Optional where Wrapped == String {

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

}

However, String implements isEmpty property by conforming to protocol Collection. Therefore we can replace the previous code's generic constraint (Wrapped == String) with a broader one (Wrapped: Collection) so that Array, Dictionary and Set also benefit our new isEmptyOrNil property:

extension Optional where Wrapped: Collection {

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

}

---

Usage with Strings:

let optionalString: String? = nil
print(optionalString.isEmptyOrNil) // prints: true

let optionalString: String? = ""
print(optionalString.isEmptyOrNil) // prints: true

let optionalString: String? = "Hello"
print(optionalString.isEmptyOrNil) // prints: false

Usage with Arrays:

let optionalArray: Array<Int>? = nil
print(optionalArray.isEmptyOrNil) // prints: true

let optionalArray: Array<Int>? = []
print(optionalArray.isEmptyOrNil) // prints: true

let optionalArray: Array<Int>? = [10, 22, 3]
print(optionalArray.isEmptyOrNil) // prints: false

---

Sources:

• swiftbysundell.com - Extending optionals in Swift
• objc.io - Swift Tip: Non-Empty Collections

Baseless

I like this, the only tweak I would make is to rename it from isNilOrEmpty to isEmptyOrNil to match the prefix so it's easily findable via the same pattern for autocomplete. I've noticed more adoption of this extension from colleagues I work with just from them finding it this way. – Malloy

Answer 4

Using the guard statement

I was using Swift for a while before I learned about the guard statement. Now I am a big fan. It is used similarly to the if statement, but it allows for early return and just makes for much cleaner code in general.

To use guard when checking to make sure that a string is neither nil nor empty, you can do the following:

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)

This unwraps the optional string and checks that it isn't empty all at once. If it is nil (or empty), then you return from your function (or loop) immediately and everything after it is ignored. But if the guard statement passes, then you can safely use your unwrapped string.

See Also

• Statements documentation
• The Guard Statement in Swift 2

Steck

be careful. print(myString) will not run, if String is nil or empty, because guard is designed not to fall down after come into else phase. – Elizaelizabet

@KangByul, that's correct and is the intent of the logic here. Presumably if the string is nil or empty, one would not want to call print(myString). If you needed to continue execution after a nil or empty String, then you would use if let rather than guard. – Steck

Thanks for a commend. I know, I just tell other ones who dont know about guard much. – Elizaelizabet

@KangByul I do not understand the point of your "be careful" comment, I think it scares people off from a great solution, the return statement is clearly right in the guard else statement, I think you should delete your comment – Lustrate

Answer 5

If you are using Swift 2, here is an example my colleague came up with, which adds isNilOrEmpty property on optional Strings:

protocol OptionalString {}
extension String: OptionalString {}

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

You can then use isNilOrEmpty on the optional string itself

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

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

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

Serica

Can you please clarify what you did here or some resource which can explain this in detail. Like why OptionalString is declared? I am not getting the Syntax. It is not like normal extension implementation So. Thanks a lot in advance – Ariana

@VinayakParmar OptionalString is declared here because the where Wrapped: must specify a protocol and not a type. – Dulaney

Maybe you could name isNilOrEmpty to hasValue (or something like that) and reverse the logic – Orbital

Answer 6

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

Malaise

Elegant but awkward ;), the "true" kinda throws off the intution – Excrescent

Answer 7

I know there are a lot of answers to this question, but none of them seems to be as convenient as this (in my opinion) to validate UITextField data, which is one of the most common cases for using it:

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

You can just use

textField.text.isNilOrEmpty

You can also skip the .trimmingCharacters(in:.whitespaces) if you don't consider whitespaces as an empty string or use it for more complex input tests like

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

Gills

Great answer, the Op didn't precise if whitespaces where counted as blank so here is my version : public extension Optional where Wrapped == String { var isEmptyOrNil: Bool { return (self ?? "").isEmpty } } – Playgoer

Answer 8

If you want to access the string as a non-optional, you should use Ryan's Answer, but if you only care about the non-emptiness of the string, my preferred shorthand for this is

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

Since == works fine with optional booleans, I think this leaves the code readable without obscuring the original intention.

If you want to check the opposite: if the string is nil or "", I prefer to check both cases explicitly to show the correct intention:

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

Compliancy

@Excrescent that's correct, the goal of the first example is to check if the string is not empty. – Compliancy

Answer 9

I would recommend.

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

map applies the function argument if the optional is .Some.
The playground capture also shows another possibility with the new Swift 1.2 if let optional binding.

Jibe

Answer 10

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

Use like this on optional string:

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

Penelopa

Answer 11

Swift 3 For check Empty String best way

if !string.isEmpty{

// do stuff

}

Benoni

This won't even compile since string is optional. – Azaleeazan

Answer 12

Swift 3 solution Use the optional unwrapped value and check against the boolean.

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

Phlox

Answer 13

You should do something like this:
if !(string?.isEmpty ?? true) { //Not nil nor empty }

Nil coalescing operator checks if the optional is not nil, in case it is not nil it then checks its property, in this case isEmpty. Because this optional can be nil you provide a default value which will be used when your optional is nil.

Makings

Answer 14

Based on this Medium post, with a little tweak for Swift 5, I got to this code that worked.

if let stringA, !stringA.isEmpty {
    ...blah blah
}

Although I understand the benefits of creating an extension, I thought it might help someone needing just for a small component / package.

Gomar

Answer 15

You can create your own custom function, if that is something you expect to do a lot.

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

Ejaculatory

Answer 16

Create a String class extension:

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

Notice this will return TRUE if the string contains one or more blanks. To treat blank string as "empty", use...

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

... instead. This requires Foundation.

Use it thus...

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

Shelter

Using a force unwrap in code that is supposed to see if something is nil or empty is not a good idea. – Azaleeazan

Answer 17

Swift 3 This works well to check if the string is really empty. Because isEmpty returns true when there's a whitespace.

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

Examples:

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

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

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

Pyrometallurgy

Answer 18

Using isEmpty

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

Using allSatisfy

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

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

Using optional String

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

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

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

Inadvisable

Answer 19

This is a general solution for all types that conform to the Collection protocol, which includes String:

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

Kristof

Answer 20

Swift 5.6 - Xcode 13

extension Optional where Wrapped: Collection {
  var isEmptyOrNil: Bool {
    guard let self = self else { return true }
    return self.isEmpty
  }
}

Usage:

var name: String?

if name.isEmptyOrNil { 
  ///true
}

name = "John Peter"

guard !name.isEmptyOrNil else { return } 
/// Name is not empty

Wessling

You can also simply do self?.isEmpty ?? true; – Hippie

Answer 21

When dealing with passing values from local db to server and vice versa, I was having too much trouble with ?'s and !'s and what not.

So I made a Swift3.0 utility to handle null cases and i can almost totally avoid ?'s and !'s in the code.

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

Ex:-

Before :

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

After :

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

and when its required to check for a valid string,

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

This saved me having to go through the trouble of adding and removing numerous ?'s and !'s after writing code that reasonably make sense.

Gegenschein

Answer 22

Use the ternary operator (also known as the conditional operator, C++ forever!):

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

The stringA! force-unwrapping happens only when stringA != nil, so it is safe. The == false verbosity is somewhat more readable than yet another exclamation mark in !(stringA!.isEmpty).

I personally prefer a slightly different form:

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

In the statement above, it is immediately very clear that the entire if block does not execute when a variable is nil.

Inkerman

Answer 23

helpful when getting value from UITextField and checking for nil & empty string

@IBOutlet weak var myTextField: UITextField!

Heres your function (when you tap on a button) that gets string from UITextField and does some other stuff

@IBAction func getStringFrom_myTextField(_ sender: Any) {

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

This will take care of nil value as well as empty string.

It worked perfectly well for me.

Publicize

Answer 24

extension String? {
    var isEmptyOrNil: Bool {
        guard let self else { return true }
        return self.isEmpty
    }
}

usage

var string1: String?
var string2: String? = "test3"
var string3: String? = ""

print(string1.isEmptyOrNil) // true
print(string2.isEmptyOrNil) // false
print(string3.isEmptyOrNil) // true

Devisee

this answer would be useful if you explain where to put the extension – Senna

Answer 25

you can use this func

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

Fleshly

Not a swift user; could you explain why this doesn't throw an exception if nil is passed? – Jann

It doesn't throw an exception because you cannot pass nil into this function at all (except from objc, in which case it will indeed crash). – Musky

This doesn't answer the question. It doesn't check for nil as it doesn't accept an optional – Thermoelectrometer