Union types in practice in PHP - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a function that accepts an int or a string.

PHP

<?php
function printValue([1] $value) {
    echo $value;
}
?>

Drag options to blanks, or click blank then click option'

Astring

Bint&string

Cint|string|null

Dint|string

Attempts:

3 left

💡 Hint

Common Mistakes

Using & instead of | for union types.

Adding null when not needed.

Using only one type instead of a union.

The union type int|string allows the function to accept either an integer or a string.

2fill in blank

medium

Complete the code to declare a variable that can hold either an array or null.

PHP

<?php
/** @var [1] $data */
$data = null;
?>

Drag options to blanks, or click blank then click option'

Aarray&null

Barray|null

Carray|string

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Using & instead of |.

Using unrelated types like string.

Not including null when needed.

The union type array|null means the variable can be an array or null.

3fill in blank

hard

Fix the error in the function parameter type declaration to accept int or float.

PHP

<?php
function calculateArea([1] $radius) {
    return pi() * $radius * $radius;
}
?>

Drag options to blanks, or click blank then click option'

Aint|float

Bfloat

Cint&float

Dint

Attempts:

3 left

💡 Hint

Common Mistakes

Using & instead of |.

Using only one type.

Using unrelated types.

The union type int|float allows the function to accept either an integer or a float.

4fill in blank

hard

Fill both blanks to declare a function that returns int or string and accepts int or string.

PHP

<?php
function convert([1] $input): [2] {
    if (is_int($input)) {
        return (string)$input;
    }
    return strlen($input);
}
?>

Drag options to blanks, or click blank then click option'

Aint|string

Bstring

Cint

Dfloat

Attempts:

3 left

💡 Hint

Common Mistakes

Using different types for parameter and return.

Using only one type instead of union.

Using unrelated types like float.

The function accepts int|string and returns int|string as a union type.

5fill in blank

hard

Fill all three blanks to create a function that accepts int|string|null and returns string|int|null.

PHP

<?php
function processValue([1] $value): [2] {
    if ($value === null) {
        return null;
    }
    if (is_int($value)) {
        return (string)$value;
    }
    return strlen($value);
}

/** @var [3] $result */
$result = processValue(123);
?>

Drag options to blanks, or click blank then click option'

Aint|string|null

Bstring|int|null

Dstring|null

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up order of types in unions.

Not including null when needed.

Using only one type instead of union.

The function parameter uses int|string|null, the return type is string|int|null, and the variable is declared with int|string|null.

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