Check string for nil & empty

14 Solutions Collect From Internet About “Check string for nil & empty”

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!

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

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

    let emptyString:String? = ""

    let someText:String? = "lorem"

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)

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

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

I would recommend.

if == 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.

enter image description here

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) {
else {

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


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

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

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

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

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! : "")


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.

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


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

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

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

you can use this func

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