How to Make String? + String? Return null in Kotlin

Learn how to handle `String?` concatenation in Kotlin, ensuring that the result is `null` when any input is `null`.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: In Kotlin, what is the best way to make `String? + String?` return `null` if any of the inputs are `null`?

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Handling Nullable String Concatenation in Kotlin

In Kotlin, working with nullable types (like String?) can often lead to unexpected behaviors, especially when concatenating strings. A common problem developers face is the need for a concatenation operation where the output should return null if any of the involved strings are null. In this guide, we will explore this concern and discuss an effective way to address it.

The Problem at Hand

Consider the following Kotlin code snippet:

[[See Video to Reveal this Text or Code Snippet]]

In the snippet above, the row variable will contain the string "key: label". However, if either key or value is null, Kotlin will convert the null to the string "null" during concatenation, producing unexpected results. For example:

[[See Video to Reveal this Text or Code Snippet]]

This behavior is often not desirable if we expect our output to remain null when inputs are null. A temporary solution one might consider is to use the Elvis operator ?: to replace null with an empty string:

[[See Video to Reveal this Text or Code Snippet]]

However, this still does not solve the root problem, as the intended output should be null instead of simply omitting the null value.

The Best Solution So Far

To address this issue, one viable approach is to create an extension function that efficiently handles nullability during string concatenation. Here's how that can be achieved:

[[See Video to Reveal this Text or Code Snippet]]

How the nullSafeConcat Function Works

Initialization: The function takes an array of nullable strings (Array<String?>).

Iterate Through Elements: It uses a loop to traverse each string.

Check for null: If any string is found to be null, the function immediately returns null.

Concatenation: If no strings are null, they are appended to a StringBuilder.

Return Concatenated Result: Finally, the constructed string is returned.

Main Advantage

This extension function is reusable and helps in maintaining clean code. You simply call nullSafeConcat with any combination of nullable strings, ensuring that you get null if there’s any invalid input.

Alternative Approach: Operator Overriding

An alternative solution involves overriding the + operator for nullable strings. Here's how that can be implemented:

[[See Video to Reveal this Text or Code Snippet]]

Example Usage

With the operator overridden, examples could look like this:

[[See Video to Reveal this Text or Code Snippet]]

Considerations

While this approach is effective, it does come with caveats:

Overriding Concerns: If the operator is not properly encapsulated, existing code might unintentionally utilize your custom behavior.

Readability: Future developers might be surprised by the overridden functionality if they do not notice it in the code, leading to confusion.

Conclusion

When working with String? concatenation in Kotlin, it's essential to discuss approaches that return null when any of the strings involved are null. We have covered two primary methods: implementing a custom extension function and overriding the + operator. Each method has its benefits and potential pitfalls, so it's crucial to choose the right approach based on your project needs. Remember, clarity and intention in your code can significantly influence maintainability and collaboration with other developers.

Whether you opt for a dedicated function or operator overloading, your goal will remain the same: making your code both effective and understandable. Happy coding!