Why Union types in practice in PHP? - Purpose & Use Cases

The Big Idea

Discover how union types can save you from messy type checks and bugs!

The Scenario

Imagine you are writing a function that can accept either a number or a string. Without union types, you have to write extra code to check the type manually and handle each case separately.

The Problem

This manual checking makes your code longer, harder to read, and easy to forget some cases. It also increases the chance of bugs because you might miss handling a type or mix up the logic.

The Solution

Union types let you declare that a function or variable can accept multiple types directly. This means PHP will automatically check the types for you, making your code cleaner, safer, and easier to understand.

Before vs After

✗ Before

function process($input) {
  if (is_int($input)) {
    // handle int
  } elseif (is_string($input)) {
    // handle string
  } else {
    throw new Exception('Invalid type');
  }
}

✓ After

function process(int|string $input) {
  // handle int or string directly
}

What It Enables

It enables writing flexible functions that clearly state what types they accept, reducing bugs and improving code readability.

Real Life Example

For example, a function that formats user input can accept either a string or a number, and union types let you declare this clearly without extra checks.

Key Takeaways

Manual type checks make code long and error-prone.

Union types let you declare multiple accepted types simply.

This leads to cleaner, safer, and easier-to-read code.

Practice

1. What does a union type declaration like int|string mean in PHP?

easy

A. The value must be both an integer and a string at the same time.

B. The value can only be a string.

C. The value can only be an integer.

D. The value can be either an integer or a string.

Solution

1. Step 1: Understand union type syntax

   The | symbol means the value can be one of the listed types.

2. Step 2: Interpret int|string

   This means the value can be either an integer or a string, not both simultaneously.

3. Final Answer:

   The value can be either an integer or a string. -> Option D

4. Quick Check:

   Union type int|string means either int or string [OK]

Hint: Union types allow multiple possible types separated by | [OK]

Common Mistakes:

• Thinking the value must be both types at once
• Confusing union with intersection types
• Assuming only one type is allowed

2. Which of the following is the correct syntax for an optional function parameter that accepts either an array or null using union types?

easy

A. function example(array|null $data = null) {}

B. function example(array&null $data) {}

C. function example(array? $data) {}

D. function example(array|null $data) {}

Solution

1. Step 1: Identify correct union type syntax

   Union types use | between types, so array|null is correct.

2. Step 2: Check default value for nullable parameter

   To accept null, the parameter should default to null, so $data = null is needed.

3. Final Answer:

   function example(array|null $data = null) {} -> Option A

4. Quick Check:

   Union type with default null = correct syntax [OK]

Hint: Use | for union and default null for optional nullable [OK]

Common Mistakes:

• Using & instead of | for union
• Missing default null for nullable parameter
• Using ? without type for union

3. What will be the output of this PHP code?

function describe(mixed $value): string {
    return match (gettype($value)) {
        'integer' => 'Number: ' . $value,
        'string' => 'Text: ' . $value,
        default => 'Unknown type'
    };
}

echo describe(10) . ', ' . describe('hello') . ', ' . describe(3.14);

medium

A. Number: 10, Text: hello, Unknown type

B. Number: 10, Text: hello, Number: 3.14

C. Unknown type, Text: hello, Unknown type

D. Number: 10, Unknown type, Unknown type

Solution

1. Step 1: Analyze the match expression with gettype()

   For 10, gettype returns 'integer', so output is 'Number: 10'. For 'hello', gettype returns 'string', so output is 'Text: hello'. For 3.14, gettype returns 'double', which matches default case 'Unknown type'.

2. Step 2: Combine outputs

   Outputs joined by commas: 'Number: 10, Text: hello, Unknown type'.

3. Final Answer:

   Number: 10, Text: hello, Unknown type -> Option A

4. Quick Check:

   Match on gettype gives expected strings [OK]

Hint: Match gettype results carefully for each input [OK]

Common Mistakes:

• Assuming float is treated as integer
• Ignoring default case in match
• Confusing gettype return values

4. Identify the error in this PHP function using union types:

function process(int|string $input): int {
    if (is_string($input)) {
        return strlen($input);
    } else {
        return $input + 1;
    }
}

process(true);

medium

A. The is_string check is incorrect syntax.

B. The function should return string, not int.

C. Passing a boolean to a parameter expecting int|string causes a TypeError.

D. The function does not handle float inputs.

Solution

1. Step 1: Check parameter type declaration

   The function expects int|string, so only integers or strings are allowed.

2. Step 2: Analyze the call with true

   Passing true (boolean) violates the declared union type, causing a TypeError at runtime.

3. Final Answer:

   Passing a boolean to a parameter expecting int|string causes a TypeError. -> Option C

4. Quick Check:

   Type mismatch causes error [OK]

Hint: Check argument types match union types exactly [OK]

Common Mistakes:

• Ignoring type mismatch errors
• Thinking is_string is invalid syntax
• Assuming function return type is wrong

5. You want to write a function that accepts either a string or an array of strings and returns a single string. Which of the following implementations correctly uses union types and handles both cases?

hard

A. function joinStrings(string|array $input): string {
return implode(', ', $input);
}

B. function joinStrings(string|array $input): string {
if (is_array($input)) {
return implode(', ', $input);
}
return $input;
}

C. function joinStrings(string|array $input): string {
if (is_string($input)) {
return implode(', ', $input);
}
return $input;
}

D. function joinStrings(array|string $input): string {
if (is_array($input)) {
return $input;
}
return implode(', ', $input);
}

Solution

1. Step 1: Check union type declaration

   Both string|array and array|string are valid syntax.

2. Step 2: Verify handling of each type

   function joinStrings(string|array $input): string { if (is_array($input)) { return implode(', ', $input); } return $input; } checks if input is array, then joins with implode. If input is string, returns it directly. This correctly handles both cases.

3. Step 3: Identify errors in other options

   function joinStrings(string|array $input): string { return implode(', ', $input); } tries to implode without checking type, causing error if input is string. function joinStrings(string|array $input): string { if (is_string($input)) { return implode(', ', $input); } return $input; } incorrectly calls implode on string input. function joinStrings(array|string $input): string { if (is_array($input)) { return $input; } return implode(', ', $input); } returns array directly without joining.

4. Final Answer:

   function joinStrings(string|array $input): string { if (is_array($input)) { return implode(', ', $input); } return $input; } -> Option B

5. Quick Check:

   Check type then handle accordingly [OK]

Hint: Check type before processing union inputs [OK]

Common Mistakes:

• Calling implode on string input
• Returning array instead of string
• Not checking input type before processing