Union types in practice in PHP - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of function with union type return

What is the output of this PHP code using union types in the return declaration?

PHP

<?php
function test(int|string $input): int|string {
    if (is_int($input)) {
        return $input * 2;
    }
    return strtoupper($input);
}

echo test(5) . ' ' . test('hello');

A TypeError

B 5 hello

C 10 hello

D 10 HELLO

💡 Hint

Remember the function returns int or string depending on input type.

The function doubles the integer input and converts string input to uppercase. So test(5) returns 10 and test('hello') returns 'HELLO'.

❓ Predict Output

intermediate

Variable type with union type hint

What will be the output of this PHP code that uses union types for a variable?

PHP

<?php
/** @var int|string $var */
$var = 10;
if (is_string($var)) {
    echo 'string';
} elseif (is_int($var)) {
    echo 'int';
} else {
    echo 'other';
}

A int

B string

C other

D TypeError

💡 Hint

Check the actual value type assigned to the variable.

The variable $var is assigned the integer 10, so is_int($var) is true and 'int' is printed.

🔧 Debug

advanced

Identify the error with union types in method parameter

What error will this PHP code produce when calling the method with a float argument?

PHP

<?php
class Calculator {
    public function multiply(int|float $a, int|float $b): float {
        return $a * $b;
    }
}

$calc = new Calculator();
echo $calc->multiply(3.5, 2.0);

A TypeError: Argument 1 passed must be int|float, float given

B No error, outputs 7

C Fatal error: Return type must be float, int given

D Parse error: Syntax error in union type declaration

💡 Hint

Check if float is allowed in parameter and return types.

The method accepts int or float for parameters and returns a float. Multiplying 3.5 and 2.0 returns 7.0 with no error.

📝 Syntax

advanced

Which union type declaration is invalid?

Which of the following union type declarations in PHP is invalid and causes a syntax error?

A function foo(int|string $param): int|string {}

B function bar(int|float|null $param): int|float|null {}

C function baz(int|void $param): int|void {}

D function qux(string|false $param): string|false {}

💡 Hint

Check if 'void' can be used in union types.

'void' cannot be used as a union type with other types. It is only valid alone as a return type.

🚀 Application

expert

Determine the output of complex union type usage

What is the output of this PHP code that uses union types with nullable and mixed types?

PHP

<?php
function process(int|string|null $value): string|int|null {
    return match(true) {
        is_int($value) => $value * 3,
        is_string($value) => strtoupper($value),
        default => null
    };
}

var_dump(process(4));
var_dump(process('abc'));
var_dump(process(null));

A

int(12)
string(3) "ABC"
NULL

B

int(12)
string(3) "abc"
NULL

C TypeError on null input

D

int(4)
string(3) "ABC"
NULL

💡 Hint

Check how match expression handles each type and the return values.

For int input 4, it returns 4*3=12. For string 'abc', it returns 'ABC'. For null, it returns null. var_dump shows types and values.

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