આધુનિક PHP ફંક્શન પરિમાણો, રીટર્ન મૂલ્યો અને ક્લાસ પ્રોપર્ટીઝ પર પ્રકાર ઘોષણાઓ સપોર્ટ કરે છે — અને તેમને કઠોરતાથી લાગુ કરવા માટે declare(strict_types=1) સપોર્ટ કરે છે। એક સાથે તેઓ PHP માં સ્થિર-પ્રકારનાં ભાષાઓની સુરક્ષાનો મોટો ભાગ લાવે છે, જે બગ્સને તાતી પકડે છે.
{
= ;
? = ;
{
->balance += ;
}
{
->balance;
}
}
તમે પરિમાણો, રીટર્ન મૂલ્યો અને ક્લાસ પ્રોપર્ટીઝ ટાઇપ કરી શકો છો. પ્રકારોમાં સ્કેલર્સ (int, float, string, bool), ક્લાસ/ઇન્ટરફેસ, array, ?Type (nullable), અને void શામેલ છે.
function process(int|string $id): User|null { } // union type — int OR string
function handle(Countable&Iterator $x): void { } // intersection (PHP 8.1) — BOTH
function get(): static { } // return the called class's type
function nothing(): never { } // never returns (throws/exits, PHP 8.1)
PHP 8 એ યુનિયન પ્રકારો (int|string), ઇન્ટરસેક્શન પ્રકારો અને વિશેષ રીટર્ન પ્રકારો (static, never) ઉમેર્યા.
<?php
declare(strict_types=1); // MUST be the first statement in the file
function add(int $a, int $b): int { return $a + $b; }
add(5, 3); // ✅ 8
add("5", 3); // ❌ TypeError — strict_types REJECTS the string (no coercion)
WITHOUT strict_types (default "coercive" mode):
add("5", 3) → "5" is silently coerced to int 5 → returns 8 (lenient, can hide bugs)
WITH strict_types=1:
add("5", 3) → TypeError immediately (must pass the exact declared type)
declare(strict_types=1) હળવાશ ધરાવતી જબરદસ્તીથી કઠોર અમલીકરણમાં સ્વિચ કરે છે — PHP પ્રકાર બંધબેસતનો નકાર કરે છે તેને સામેથી ચુપચાપ રૂપાંતર કરવાને બદલે. આ બંધબેસતાં જે બગ્સ છુપી શકાય તે પકડે છે.
પ્રકાર ઘોષણાઓ અને કઠોર પ્રકારો મજબૂત, જાળવણીયોગ્ય આધુનિક PHP લખવા માટે મહત્વપૂર્ણ છે, અને તેઓ ભાષાના આશુપ્તિ-પ્રકારના મૂળથી આગળ એક મોટો વિકાસ પ્રતિનિધિત્વ કરે છે.
પરિમાણો, રીટર્ન્સ અને પ્રોપર્ટીઝ પર પ્રકાર ઘોષણાઓ કોડને સ્વ-દસ્તાવેજીકરણ બનાવે છે (સહીઓ સ્પષ્ટપણે અપેક્ષાઓ બताવે છે) અને PHP ને આપોઆપ પ્રકાર ભૂલો પકડવા દે છે, જ્યારે આધુનિક ઉમેરણો (યુનિયન પ્રકારો, nullable પ્રકારો) સહીઓને સચોટ બનાવે છે.
સૌથી મહત્વપૂર્ણ અભ્યાસ છે declare(strict_types=1): તે PHP ને હળવાશ ધરાવતી જબરદસ્તીથી (જ્યાં `