How do you define functions with types and defaults?

Question

Accepted Answer

PHP functions are defined with the `function` keyword. Modern PHP supports **type declarations** on parameters and return values, **default values**, and variadic parameters — making functions more robust and self-documenting.

## Basic functions with type declarations

```php
<?php
// modern PHP — typed parameters and a typed return
function add(int $a, int $b): int {
    return $a + $b;
}

function greet(string $name, string $greeting = "Hello"): string {  // default value
    return "$greeting, $name";
}

greet("Ann");              // "Hello, Ann"
greet("Ann", "Hi");        // "Hi, Ann"
```

Type declarations (`int $a`, `: int` return type) make PHP check argument and return types — catching bugs and documenting intent. Default values make parameters optional.

## Nullable types and union types (PHP 8+)

```php
function find(?int $id): ?User {        // ? = nullable (int|null, User|null)
    return $id ? lookup($id) : null;
}

function process(int|string $input): void {   // union type — int OR string (PHP 8)
    // ...
}
```

`?Type` allows null; **union types** (`int|string`, PHP 8) allow several types — making signatures precise.

## Variadic and named arguments

```php
function sum(int ...$numbers): int {     // variadic — any number of int args
    return array_sum($numbers);
}
sum(1, 2, 3);            // 6

// named arguments (PHP 8) — pass by parameter name, skip optional ones
greet(name: "Ann", greeting: "Hey");
```

## Strict types (recommended)

```php
<?php
declare(strict_types=1);    // at the top of the file — enforce STRICT type checking

add("5", 3);   // ❌ TypeError with strict_types (without it, "5" would coerce to 5)
```

`declare(strict_types=1)` makes type declarations strict — PHP rejects mismatched types instead of silently coercing them, which is the recommended modern practice for catching bugs.

## Why it matters

Understanding modern PHP function definitions — especially **type declarations** — is important for writing robust, maintainable code, and reflects how far PHP has evolved from its loosely-typed origins.

Typed parameters and return values (plus nullable and union types) make functions self-documenting and let PHP catch type errors, while default and named arguments and variadics provide flexible, readable signatures.

The most important modern practice is **`declare(strict_types=1)`**, which enforces strict type checking (rejecting mismatches rather than silently coercing them) — a key tool for catching bugs early and writing reliable code.

Knowing how to define well-typed functions with defaults, and using strict types, is everyday knowledge for professional modern PHP development, distinguishing solid, type-safe code from the loosely-typed style of older PHP.