Nullable types in functions in PHP - Deep Dive

Overview - Nullable types in functions

What is it?

Nullable types in functions allow a function parameter or return value to accept either a specific type or null. This means you can explicitly say a value can be, for example, an integer or nothing at all. It helps make your code clearer about when a value might be missing or optional. Nullable types are written by adding a question mark before the type name.

Why it matters

Without nullable types, developers often use unclear ways to handle missing values, like special numbers or empty strings, which can cause bugs and confusion. Nullable types make it clear when a value can be absent, improving code safety and readability. This clarity helps prevent errors and makes it easier to maintain and understand code, especially in larger projects.

Where it fits

Before learning nullable types, you should understand basic PHP types and function declarations. After nullable types, you can explore union types and strict typing for even more precise code. Nullable types are a step towards writing safer and more expressive PHP functions.

Mental Model

Core Idea

Nullable types let a function accept or return either a specific type or no value (null), making optional or missing data explicit.

Think of it like...

It's like a parking spot that can hold a car of a certain size or be empty; the spot is designed to accept either a car or nothing at all.

Function Parameter or Return Type
┌─────────────────────────────┐
│ ?Type means:                │
│ ┌───────────────┐           │
│ │ Specific Type │ or null   │
│ └───────────────┘           │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Basic PHP function types

Concept: Functions can specify the type of their parameters and return values.

Result

5

Understanding how to declare types in functions is the foundation for using nullable types later.

2

Foundation

What is null in PHP?

Concept: Null represents the absence of a value in PHP.

Result

No value here

Knowing what null means helps you understand why nullable types are useful.

3

Intermediate

Declaring nullable parameters

🤔Before reading on: do you think adding a question mark before a type allows null values or changes the type itself? Commit to your answer.

Concept: Adding a question mark before a type in a function parameter means it can accept that type or null.

Result

Hello, Alice! Hello, guest!

Knowing that ?string means string or null helps you write functions that handle optional inputs clearly.

4

Intermediate

Nullable return types

🤔Before reading on: do you think nullable return types allow returning null only, or both null and the declared type? Commit to your answer.

Concept: Functions can declare that they return either a specific type or null by using a question mark before the return type.

'Alice', 2 => 'Bob']; return $users[$id] ?? null; } echo findUser(1); // Alice echo findUser(3); // (prints nothing because null) ?>

Result

Alice

Understanding nullable return types helps you signal when a function might not find or produce a value.

5

Intermediate

Nullable types with default null values

Concept: You can combine nullable types with default null parameters to make arguments optional.

Result

Welcome, guest! Welcome, John!

Using nullable types with default null values makes your functions flexible and clear about optional inputs.

6

Advanced

Nullable types and strict typing

🤔Before reading on: do you think nullable types behave differently when strict typing is enabled? Commit to your answer.

Concept: Nullable types work with PHP's strict typing mode to enforce type safety while allowing null values.

Result

Age is 25 Age not provided

Knowing how nullable types interact with strict typing helps prevent subtle bugs and enforces clear contracts.

7

Expert

Nullable types and type coercion surprises

🤔Before reading on: do you think PHP automatically converts null to other types when nullable types are declared? Commit to your answer.

Concept: PHP may coerce null to other types in weak typing mode, which can cause unexpected behavior even with nullable types.

Result

NULL

Understanding PHP's type coercion nuances prevents bugs when using nullable types in weak typing mode.

Under the Hood

When PHP runs a function with nullable types, it checks if the value is either null or matches the declared type. This check happens at runtime if strict typing is enabled, otherwise PHP may try to convert values. Nullable types are implemented by allowing the internal type check to accept null as a valid value alongside the declared type.

Why designed this way?

Nullable types were introduced to make code more explicit and safer by clearly showing when null is allowed. Before nullable types, developers used loose conventions that led to bugs. The question mark syntax was chosen for its simplicity and clarity, fitting PHP's gradual typing approach.

Function Call
┌───────────────┐
│ Input Value   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Type Check    │
│ ?Type means:  │
│ Accept null or│
│ the Type      │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Function Body │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does declaring a nullable type mean the function always returns null? Commit to yes or no.

Common Belief: If a function has a nullable return type, it always returns null sometimes.

Reality: Nullable return types mean the function can return null, but it doesn't have to; it may always return a value of the declared type.

Why it matters: Assuming nullable means always null can cause unnecessary checks or misunderstandings about function behavior.

Quick: Can you pass any type to a nullable typed parameter? Commit to yes or no.

Common Belief: Nullable types accept any type because null is allowed.

Reality: Nullable types accept only the declared type or null, not any type.

Why it matters: Passing wrong types leads to runtime errors, so understanding this prevents bugs.

Quick: Does adding a question mark before a type change the type to a new type? Commit to yes or no.

Common Belief: The question mark creates a new type different from the original.

Reality: The question mark only allows null in addition to the original type; it does not create a new type.

Why it matters: Misunderstanding this can confuse type declarations and lead to incorrect assumptions about type behavior.

Quick: In weak typing mode, does nullable type declaration prevent type coercion? Commit to yes or no.

Common Belief: Nullable types stop PHP from converting other types to the declared type.

Reality: In weak typing mode, PHP may still coerce values like empty strings to integers even with nullable types.

Why it matters: Relying on nullable types alone for type safety can cause subtle bugs if strict typing is not enabled.

Expert Zone

1

Nullable types combined with union types allow very flexible and precise function signatures.

2

In PHP 8.1+, readonly properties can be nullable, adding complexity to object immutability.

3

Nullable types interact with PHP's type variance rules, affecting inheritance and interface implementation.

When NOT to use

Avoid nullable types when a value should never be missing; instead, use exceptions or default values. For multiple possible types, prefer union types over nullable types alone.

Production Patterns

Nullable types are commonly used for optional parameters, database fields that may be missing, and functions that may not find a result. They improve API clarity and reduce bugs by making nullability explicit.

Connections

Optional parameters

Nullable types often work with optional parameters to allow missing arguments.

Understanding nullable types clarifies how optional parameters can be typed safely and explicitly.

Union types

Nullable types are a special case of union types combining a type with null.

Knowing nullable types helps grasp the broader concept of union types for flexible typing.

Database NULL values

Nullable types in PHP correspond to NULL values in databases representing missing data.

Recognizing this connection helps developers handle data consistently between PHP code and databases.

Common Pitfalls

#1 Passing a wrong type to a nullable parameter causes runtime errors.

Wrong approach:

Correct approach:

Root cause:

Misunderstanding that nullable means any type is allowed, not just the declared type or null.

#2 Assuming nullable return type means function can return any type or null.

Wrong approach:

Correct approach:

Root cause:

Confusing nullable with allowing any type instead of the declared type or null.

#3 Using nullable types without strict typing enabled, expecting strict type checks.

Wrong approach:

Correct approach:

Root cause:

Not enabling strict typing leads to unexpected type coercion despite nullable declarations.

Key Takeaways

Nullable types explicitly allow a function parameter or return value to be a specific type or null, improving code clarity.

They are declared by adding a question mark before the type, like ?int or ?string.

Nullable types help handle optional or missing data safely and clearly in PHP functions.

Understanding nullable types prevents common bugs related to unexpected null or wrong types.

Using nullable types with strict typing enabled ensures the best type safety and predictable behavior.