તમે પ્રકાર અને ડિફોલ્ટ સાથે કાર્યો કેવી રીતે વ્યાખ્યાયિત કરો છો?

Question

Accepted Answer

PHP ફંક્શનો `function` કીવર્ડ સાથે વ્યાખ્યાયિત કરવામાં આવે છે. આધુનિક PHP પરિમાણો અને પરત મૂલ્યો પર **પ્રકાર ઘોષણા**, **ડિફોલ્ટ મૂલ્યો**, અને variadic પરિમાણોને સમર્થન આપે છે — કાર્યોને વધુ મજબૂત અને સ્વ-દસ્તાવેજ બનાવે છે।

## પ્રકાર ઘોષણા સાથે મૂળ કાર્યો

```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"
```

પ્રકાર ઘોષણા (`int $a`, `: int` પરત પ્રકાર) PHP ને દલીલ અને પરત પ્રકારો તપાસવા દે છે — બગ્સ પકડવા અને હેતુ દસ્તાવેજ કરવા. ડિફોલ્ટ મૂલ્યો પરિમાણોને વૈકલ્પિક બનાવે છે.

## શૂન્ય-સક્ષમ પ્રકાર અને યુનિયન પ્રકાર (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 ને મંજૂરી આપે છે; **યુનિયન પ્રકાર** (`int|string`, PHP 8) ઘણા પ્રકારોને મંજૂરી આપે છે — હસ્તાક્ષર ચોક્કસ બનાવે છે.

## Variadic અને નામ આપેલ દલીલો

```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");
```

## કાઠોર પ્રકાર (સુପારિશ)

```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)` પ્રકાર ઘોષણાને કાઠોર બનાવે છે — PHP બેમેળ પ્રકારોને ને અવગણીને સ્વીકાર કરવાને બદલે નકારી કાઢે છે, જે બગ્સ પકડવા માટે આધુનિક ભલમણી પધ્ધતિ છે.

## તે શા માટે મહત્વપૂર્ણ છે

આધુનિક PHP કાર્ય વ્યાખ્યાઓ સમજવું — ખાસ કરીને **પ્રકાર ઘોષણા** — મજબૂત, જાળવણીશીલ કોડ લખવા માટે મહત્વપૂર્ણ છે, અને તે પ્રતિબિંબિત કરે છે કે PHP તેના આખી-ધીમું-પ્રકાર મૂળ પરથી કેટલો વિકાસ પામ્યો છે.

ટાઇપ કરેલ પરિમાણો અને પરત મૂલ્યો (વત્તા શૂન્ય-સક્ષમ અને યુનિયન પ્રકાર) કાર્યોને સ્વ-દસ્તાવેજ બનાવે છે અને PHP ને પ્રકાર ભૂલો પકડવા દે છે, જ્યારે ડિફોલ્ટ અને નામ આપેલ દલીલો અને variadics લવચીક, વાંચનીય હસ્તાક્ષર પ્રદાન કરે છે.

સૌથી મહત્વપૂર્ણ આધુનિક અભ્યાસ **`declare(strict_types=1)`** છે, જે કાઠોર પ્રકાર તપાસ લાગુ કરે છે (ગૌણ રીતે coerce કરવાને બદલે બેમેળ અસ્વીકાર કરે છે) — બગ્સને પહેલાથી પકડવા અને વિશ્વસનીય કોડ લખવા માટે મુખ્ય સાધન.

યોગ્ય-પ્રકાર કાર્યોને ડિફોલ્ટ સાથે વ્યાખ્યાયિત કરવું જાણવું, અને કાઠોર પ્રકાર વાપરવો, વ્યાવસાયિક આધુનિક PHP વિકાસ માટે રોજમર્રાનું જ્ઞાન છે, મજબૂત, પ્રકાર-સુરક્ષિત કોડને પરાણીય PHP ના આખી-ધીમું-પ્રકાર શૈલીથી અલગ પાડે છે.