Unafafanua vipi functions zenye types na defaults?

Question

Accepted Answer

Functions za PHP hufafanuliwa kwa neno la msingi `function`. PHP ya kisasa inasaidia **type declarations** kwenye parameters na return values, **default values**, na variadic parameters — na hivyo kuzifanya functions kuwa imara zaidi na zinazojieleza zenyewe.

## Functions za msingi zenye 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`, return type `: int`) hufanya PHP iangalie types za argument na return — kunasa bugs na kueleza nia. Default values huzifanya parameters kuwa za hiari.

## Nullable types na 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` huruhusu null; **union types** (`int|string`, PHP 8) huruhusu types kadhaa — na hivyo kufanya signatures kuwa sahihi.

## Variadic na 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 (inapendekezwa)

```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)` huzifanya type declarations kuwa strict — PHP hukataa types zisizolingana badala ya kuzibadilisha kimyakimya, jambo ambalo ni mazoea ya kisasa yanayopendekezwa kwa kunasa bugs.

## Kwa nini ni muhimu

Kuelewa ufafanuzi wa functions za PHP za kisasa — hasa **type declarations** — ni muhimu kwa kuandika code imara na inayoweza kudumishwa, na kunaonyesha jinsi PHP imekua mbali kutoka asili yake ya loosely-typed.

Typed parameters na return values (pamoja na nullable na union types) huzifanya functions kujieleza zenyewe na huruhusu PHP kunasa type errors, huku default na named arguments na variadics zikitoa signatures zinazonyumbulika na zinazosomeka.

Mazoea muhimu zaidi ya kisasa ni **`declare(strict_types=1)`**, ambayo hulazimisha strict type checking (kukataa types zisizolingana badala ya kuzibadilisha kimyakimya) — chombo muhimu cha kunasa bugs mapema na kuandika code ya kuaminika.

Kujua jinsi ya kufafanua functions zenye types nzuri pamoja na defaults, na kutumia strict types, ni ujuzi wa kila siku kwa maendeleo ya kitaalamu ya PHP ya kisasa, ukitofautisha code thabiti na salama kitype na mtindo wa loosely-typed wa PHP ya zamani.