SKT: Optionals

Handling the absence of a value is a common challenge in programming. Swift, Kotlin, and TypeScript offer solutions to this through the concept of optionals (or nullable types), though with some differences.

Swift

Swift introduces optionals to handle situations where a value may be absent. An optional variable can hold either a value or nil.

var optionalName: String? = "Alice" //Optional String
var nilName: String? = nil

//Forced unwrapping (avoid if possible)
let name = optionalName!  //CRASH if optionalName is nil

//Optional binding (safe unwrapping)
if let name = optionalName {
    print("Hello, \(name)")
} else {
    print("No name")
}

//Nil coalescing operator
let name = nilName ?? "Guest"  //Default value if nilName is nil
print("Hello, \(name)")

Kotlin

Kotlin uses nullable types to represent values that can be null. By default, types are non-nullable.

val optionalName: String? = "Alice" //Nullable String
val nilName: String? = null

//Safe call
println(optionalName?.length)  //Prints length if not null, null otherwise

//Elvis operator (null coalescing)
val name = nilName ?: "Guest"
println("Hello, $name")

//Safe call with let
optionalName?.let {
    println("Hello, $it")
}

TypeScript

TypeScript doesn't have an "optional" type in the same way as Swift or Kotlin, but it uses union types with null or undefined to represent the possibility of a missing value. Optional properties in objects also serve a similar purpose.

let optionalName: string | null = "Alice"; //String or null
let nilName: string | null = null;

//Checking for null
if (optionalName != null) { //null or undefined check
  console.log(`Hello, ${optionalName}`);
}

//Nullish coalescing operator
const name: string = nilName ?? "Guest";  // ??  null or undefined
console.log("Hello, " + name);

//Optional chaining
console.log(optionalName?.length);  //No error if optionalName is null/undefined

// Strict null checks
function greet(name: string | null) {
  if (name != null) {
    console.log("Hello, " + name.toUpperCase());
  } else {
    console.log("Hello, Guest");
  }
}
greet("Alice");
greet(null);

Key Similarities

• Handling Absence of Value: All three languages provide mechanisms to handle the absence of a value.
• Null Coalescing: They offer operators to provide default values when a value is absent (?? in Swift, ?: in Kotlin, ?? in TypeScript).

Key Differences

• Explicit Optional Type: Swift has a dedicated optional type (?). Kotlin has nullable types (? on the type). TypeScript uses union types with null or undefined.
• Unwrapping: Swift uses optional binding (if let) for safe unwrapping. Kotlin uses safe calls (?.let). TypeScript uses null checks and optional chaining (?.).
• Null Safety: Kotlin and Swift are designed to be null-safe by default. TypeScript requires more explicit checks for null and undefined.