Check for Empty String in Swift

When you’re coding in Swift, managing strings is a crucial part of the process. One frequent task is checking for empty strings, which becomes especially important for tasks like validating user input.

In this tutorial, you’ll learn different methods to check for and handle empty strings in Swift.

Comparing with an Empty String in Swift

The first approach that would come to your mind would be comparing the string with an empty string directly using the equality operator (==). The comparison will yield true if the string is an empty string. Here’s an illustration:

let emptyString = ""
if emptyString == "" {
    print("The string is empty!")
} else {
    print("The string is not empty!")
}

This approach is straightforward and can be helpful, especially for those starting with Swift.

While the == operator can be used to check if a string is empty, there are more straightforward approaches in Swift for this specific task. The .count and .isEmpty properties of a string provide a more straightforward and readable means of determining whether the string is an empty string. These alternatives not only enhance code clarity but also provide more efficient and direct ways for beginners to handle empty string checks in Swift.

If you’re interested in learning more about comparing strings and other objects in Swift, consider checking out the dedicated tutorial on the Comparable Protocol: How to Compare Custom Objects. This tutorial provides a beginner-friendly guide to understanding and using Swift’s Comparable protocol for effective comparisons.

Using .count Property in Swift’s strings

Another approach to check if the String is empty is to use the String’s  .count property. This property can be used to check the number of characters in a string. If the count is zero, the string is empty. However, note that this method might be less efficient than .isEmpty as it requires iterating over the string. I will talk more about it a little bit below in this article. But here a little code example that uses the .count property.

let anotherEmptyString = ""
if anotherEmptyString.count == 0 {
    print("The string is empty!")
} else {
    print("The string is not empty!")
}

Using .isEmpty Property in Swift’s strings

Swift also provides a simple and direct way to check if a string is empty through the .isEmpty property. This property returns true if the string has no characters and false otherwise. Here’s a quick example:

let yetAnotherEmptyString = ""
if yetAnotherEmptyString.isEmpty {
    print("The string is empty!")
} else {
    print("The string is not empty!")
}

In this example, the isEmpty property is utilized to determine whether yetAnotherEmptyString is empty or not.

Remember that a Character in Swift represents a single Unicode character, while a String is composed of Character instances, and its length is based on the number of visible characters perceived by the reader, just as you learned in the Case-Insensitive Comparison of Strings in Swift tutorial.

Choosing the Best Approach: .isEmpty vs. .count

When it comes to checking if a string is empty in Swift, the isEmpty property stands out as the preferred choice, and here’s why:

.isEmpty:  an Efficient Solution

• Direct and Readable: The .isEmpty property directly reflects the intent of checking if a string has no characters, enhancing code readability.
• Swift Standard Library Optimization: Swift’s standard library is optimized for checking the emptiness of strings using .isEmpty. It efficiently determines whether the string has any characters without the need to count them explicitly.
• Performance Considerations: Using count to check emptiness could introduce unnecessary performance overhead, especially with large strings. Calculating the length of a string before making a comparison might be less efficient.

Why Avoid .count for Emptiness Check in Swift?

Consider the following example:

let hugeString = String(repeating: "a", count: 1_000_000)

// Using count for emptiness check
if hugeString.count == 0 {
    print("The string is empty!")
} else {
    print("The string is not empty!")
}

In this case, using .count to check for emptiness would require Swift to iterate over the entire string, counting its length before making the comparison. For extremely large strings, this approach may impact performance, and even Apple’s Official Documentation suggests avoid using .count property!

On the other hand, with .isEmpty:

// Using isEmpty for emptiness check
if hugeString.isEmpty {
    print("The string is empty!")
} else {
    print("The string is not empty!")
}

Swift efficiently determines emptiness without counting the entire length, making it a more optimized and concise solution.

Checking if a String is Empty in a Practical Scenario

Let’s apply your newly acquired knowledge of string comparisons in a practical function: checking if a password is valid. Here’s a simple Swift function that takes a string (password) as input and returns a boolean indicating whether the password is not empty and meets a minimum length requirement:

func isPasswordValid(_ password: String) -> Bool {
    // Check if the password is not empty
    // The '!' operator is used to negate the result of 'isEmpty'
    // so false would be converted into true and viceversa
    let isNotEmpty = !password.isEmpty
    
    // Check if the password's length is greater than or equal to 8
    // This ensures the password meets a minimum length requirement
    let meetsLengthRequirement = password.count >= 8
    
    // Using the '&&' (logical AND) operator ensures that
    // the function returns true only if both conditions are true
    return isNotEmpty && meetsLengthRequirement
}

In this example, the isPasswordValid function checks if the entered password is not empty and has a minimum length of 8 characters. Take a look at how the isEmpty property is used to ensure the password is not an empty string, and then the string length is checked to meet a minimum requirement of 8 characters. This is a practical example demonstrating how you can use string comparison techniques for common tasks like validating passwords.

If you’re intrigued by the concept of functions in Swift and want to delve deeper into creating your own functions, consider reading our dedicated post Create a Function in Swift. This resource provides a beginner-friendly guide to understanding and implementing functions, offering valuable insights into structuring your code for efficiency and clarity. It’s a recommended read to enhance your skills and broaden your understanding of Swift’s functional capabilities.

Conclusion: Opt for .isEmpty for checking empty strings in Swift

In summary, when checking for empty strings in Swift, choose the elegance and efficiency of the .isEmpty property. It not only aligns with Swift’s design principles but also ensures your code remains clean and performs optimally, even with large strings.

To learn more about Swift and find other code examples, check out the Swift Code Examples page.