మీరు టైప్‌లు మరియు డిఫాల్ట్‌లతో ఫంక్షన్‌లను ఎలా నిర్వచిస్తారు?

Question

Accepted Answer

PHP ఫంక్షన్‌లు `function` కీవర్డ్‌తో నిర్వచించబడతాయి. ఆధునిక PHP పారామీటర్‌లు మరియు రిటర్న్ విలువలపై **type declarations**, **default values**, మరియు variadic parameters‌ను సపోర్ట్ చేస్తుంది — ఇది ఫంక్షన్‌లను మరింత robust మరియు self-documenting చేస్తుంది.

## 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) PHP‌ను argument మరియు return types‌ను చెక్ చేయడానికి చేస్తుంది — bugs‌ను క్యాచ్ చేయడం మరియు intent‌ను డాక్యుమెంట్ చేయడం. Default values పారామీటర్‌లను optional చేస్తుంది.

## Nullable types మరియు 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` null‌ను అనుమతిస్తుంది; **union types** (`int|string`, PHP 8) అనేక types‌ను అనుమతిస్తుంది — సంతకాలను ఖచ్చితమైనవిగా చేస్తుంది.

## Variadic మరియు 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 (సిఫారసు చేయబడింది)

```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)` type declarations‌ను strict చేస్తుంది — PHP సమ్మతిలేని types‌ను తీసిపుచ్చుకుంటుంది, అది silent coercing‌కు బదులుగా, ఇది bugs‌ను క్యాచ్ చేయడానికి సిఫారసు చేయబడిన ఆధునిక ప్రాక్టీస్.

## ఇది ఎందుకు విషయం

ఆధునిక PHP ఫంక్షన్ నిర్వచనాలను అర్థం చేసుకోవడం — ముఖ్యంగా **type declarations** — robust, maintainable code‌ను రాయడానికి ముఖ్యమైనది, మరియు PHP దాని loosely-typed మూలాలనుండి ఎంత దూరం ఎలుగుబంటిందో ప్రతిబింబిస్తుంది.

Typed parameters మరియు return values (plus nullable మరియు union types) ఫంక్షన్‌లను self-documenting చేస్తాయి మరియు PHP‌ను type errors‌ను క్యాచ్ చేయడానికి అనుమతిస్తుంది, అయితే default మరియు named arguments మరియు variadics flexible, readable signatures‌ను అందిస్తాయి.

సবচేటి ముఖ్యమైన ఆధునిక ప్రాక్టీస్ **`declare(strict_types=1)`**, ఇది strict type checking‌ను ప్రతిఫలిస్తుంది (silent coercing‌కు బదులుగా mismatches‌ను తిరస్కరించడం) — bugs‌ను ముందుగా క్యాచ్ చేయడం మరియు reliable code‌ను రాయడానికి ఒక key tool.

Well-typed functions‌తో defaults‌తో ఎలా నిర్వచించాలో మరియు strict types‌ను ఉపయోగించాలో తెలుసుకోవడం, professional ఆధునిక PHP development‌ కోసం everyday knowledge, solid, type-safe code‌ను పాతైన PHP‌ యొక్క loosely-typed style నుండి వేరుగా చేస్తుంది.