# Swift Tip: A Cleaner Way to Handle Optional Defaults in Strings

%[https://youtu.be/L0X1BK4D6mc] 

Handling **Optionals** is a bread-and-butter task for Swift developers. We all know the standard way to unwrap a value or provide a fallback, but things get tricky when we are dealing with String interpolation and data types that don't match (like Integers vs Strings).

In this post, we’ll look at a common friction point when printing optional values and a cleaner syntax (introduced in newer Swift versions) to handle default values without messy type-casting.

## The Standard Approach: Nil-Coalescing

The most common way to handle a nil value inside a print statement is using the **Nil-Coalescing Operator (**`??`).

If you have a generic string optional, this works perfectly.

```swift
var name: String? = nil

// Standard coalescing works because both sides are Strings
print("Hello, \(name ?? "Unknown")") 

// Output: Hello, Unknown
```

If `name` has a value, it prints the name. If it is `nil`, it falls back to "Unknown". Simple, right?

## The Problem: Type Mismatch

The issue arises when the optional variable is **not** a String, but you want the default fallback to be text.

Let's say you are tracking a user's age. If the age is known, you want to print the number. If it is unknown (nil), you want to print "Unknown".

**Attempting to use** `??` will cause a crash or compiler error here:

Swift

```swift
var age: Int? = nil

// ❌ Error: Cannot convert value of type 'Int?' to expected argument type 'String'
print("Age: \(age ?? "Unknown")")
```

### Why does this fail?

The `??` operator expects both the left side (`Int?`) and the right side (`String`) to be of compatible types. Swift cannot magically decide that the result should be a String just because you are inside a print statement.

### The Old Workaround

Previously, developers might force the default value to match the type, resulting in bad semantics. For example, defaulting to `0`:

Swift

```swift
print("Age: \(age ?? 0)")
// Output: Age: 0
```

This is technically correct code, but logically incorrect. A user with an unknown age is not a newborn baby (0 years old).

## The Solution: Interpolation with Default

There is a much cleaner way to handle this directly inside String Interpolation without needing to convert types manually or use complex `if-let` statements.

You can use the `default:` parameter directly within the interpolation structure.

Here is the updated, clean code:

```swift
var age: Int? = nil

// ✅ The Clean Way
print("Age: \(age, default: "Unknown")")
```

### How it works:

1. **If** `age` is nil: Swift uses the value provided in the `default` parameter. It automatically handles the fact that "Unknown" is a String, allowing the print statement to compile successfully.
    
2. **If** `age` has a value (e.g., 25): It unwraps the Integer and prints "25".
    

```swift
// Example with a value
age = 25
print("Age: \(age, default: "Unknown")")

// Output: Age: 25
```