ਤੁਸੀਂ ਕਿਵੇਂ ਕਿਸਮਾਂ ਅਤੇ ਪੂਰਵ-ਨਿਰਧਾਰਤ ਮੁੱਲਾਂ ਦੇ ਨਾਲ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ?

Question

Accepted Answer

PHP ਫੰਕਸ਼ਨ `function` ਕੀਵਰਡ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਆਧੁਨਿਕ PHP **type declarations** ਨੂੰ parameters ਅਤੇ return ਮੁੱਲਾਂ ਉੱਤੇ, **default values**, ਅਤੇ variadic parameters ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ — ਜੋ ਫੰਕਸ਼ਨ ਨੂੰ ਵਧੇਰੇ ਮਜ਼ਬੂਤ ਅਤੇ ਆਤਮ-ਦਸਤਾਵੇਜ਼ ਬਣਾਉਂਦਾ ਹੈ।

## 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 ਕਿਸਮਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਦਿੰਦੇ ਹਨ — bugs ਨੂੰ ਫੜਦੇ ਹਨ ਅਤੇ ਉਦੇਸ਼ ਨੂੰ ਦਸਤਾਵੇਜ਼ ਕਰਦੇ ਹਨ। Default ਮੁੱਲ parameters ਨੂੰ 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) ਕਈ ਕਿਸਮਾਂ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ — ਜੋ signatures ਨੂੰ precise ਬਣਾਉਂਦੇ ਹਨ।

## 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 mismatched types ਨੂੰ ਅਸਵੀਕਾਰ ਕਰਦਾ ਹੈ ਖਾਮੋਸ਼ੀ ਨਾਲ coerce ਕਰਨ ਦੀ ਬਜਾਏ, ਜੋ bugs ਨੂੰ ਫੜਨ ਲਈ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਆਧੁਨਿਕ ਪ੍ਰਥਾ ਹੈ।

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਆਧੁਨਿਕ PHP ਫੰਕਸ਼ਨ definitions ਨੂੰ ਸਮਝਨਾ — ਖਾਸ ਕਰਕੇ **type declarations** — ਮਜ਼ਬੂਤ, maintainable ਕੋਡ ਲਿਖਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਅਤੇ ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ PHP ਆਪਣੇ loosely-typed ਸ਼ੁਰੂਆਤ ਤੋਂ ਕਿੰਨਾ ਵਿਕਸਤ ਹੋਇਆ ਹੈ।

Typed parameters ਅਤੇ return ਮੁੱਲ (plus nullable ਅਤੇ union types) ਫੰਕਸ਼ਨ ਨੂੰ self-documenting ਬਣਾਉਂਦੇ ਹਨ ਅਤੇ PHP ਨੂੰ type errors ਫੜਨ ਦਿੰਦੇ ਹਨ, ਜਦਕਿ default ਅਤੇ named arguments ਅਤੇ variadics flexible, readable signatures ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।

ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਆਧੁਨਿਕ ਪ੍ਰਥਾ ਹੈ **`declare(strict_types=1)`**, ਜੋ strict type checking ਨੂੰ enforce ਕਰਦਾ ਹੈ (mismatches ਨੂੰ ਅਸਵੀਕਾਰ ਕਰਦਾ ਹੈ ਖਾਮੋਸ਼ੀ ਨਾਲ coerce ਕਰਨ ਦੀ ਬਜਾਏ) — bugs ਨੂੰ ਜਲਦੀ ਫੜਨ ਅਤੇ reliable ਕੋਡ ਲਿਖਣ ਲਈ ਮੁੱਖ tool ਹੈ।

ਭਲੀ-ਭਾਤੀ typed functions ਨੂੰ defaults ਦੇ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਸਿੱਖਣਾ, ਅਤੇ strict types ਦੀ ਵਰਤੋਂ ਕਰਨਾ, professional ਆਧੁਨਿਕ PHP development ਲਈ ਰੋਜ਼ਮਰਾਹ ਦੀ ਜਾਣਕਾਰੀ ਹੈ, solid, type-safe ਕੋਡ ਨੂੰ ਪੁਰਾਣੇ PHP ਦੀ loosely-typed ਸ਼ੈਲੀ ਤੋਂ ਵੱਖ ਕਰਦਾ ਹੈ।