คุณนิยามฟังก์ชันพร้อมการระบุชนิด (type) และค่าเริ่มต้น (default) อย่างไร?

Question

Accepted Answer

ฟังก์ชันใน PHP นิยามด้วยคีย์เวิร์ด `function` PHP สมัยใหม่รองรับ **type declarations** บนพารามิเตอร์และค่าที่ส่งคืน, **ค่าเริ่มต้น (default values)** และพารามิเตอร์แบบ variadic ซึ่งทำให้ฟังก์ชันมีความแข็งแกร่งและอธิบายตัวเองได้ดียิ่งขึ้น

## ฟังก์ชันพื้นฐานพร้อม 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`) ทำให้ PHP ตรวจสอบชนิดของอาร์กิวเมนต์และค่าที่ส่งคืน ช่วยดักจับบั๊กและบอกเจตนาของโค้ด ส่วนค่าเริ่มต้นทำให้พารามิเตอร์เป็นแบบ 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) อนุญาตให้เป็นได้หลายชนิด ทำให้ลายเซ็นของฟังก์ชัน (signature) มีความแม่นยำ

## 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 เป็นแบบเข้มงวด PHP จะปฏิเสธชนิดที่ไม่ตรงกันแทนที่จะแปลงให้เงียบ ๆ ซึ่งเป็นแนวปฏิบัติสมัยใหม่ที่แนะนำสำหรับการดักจับบั๊ก

## ทำไมจึงสำคัญ

การเข้าใจการนิยามฟังก์ชันใน PHP สมัยใหม่ โดยเฉพาะ **type declarations** มีความสำคัญต่อการเขียนโค้ดที่แข็งแกร่งและดูแลรักษาง่าย และสะท้อนให้เห็นว่า PHP ได้พัฒนาไปไกลแค่ไหนจากต้นกำเนิดที่เป็น loosely-typed

พารามิเตอร์และค่าส่งคืนที่มีการระบุชนิด (รวมถึง nullable และ union types) ทำให้ฟังก์ชันอธิบายตัวเองได้และทำให้ PHP ดักจับ type error ได้ ส่วนค่าเริ่มต้น, named arguments และ variadics มอบ signature ที่ยืดหยุ่นและอ่านง่าย

แนวปฏิบัติสมัยใหม่ที่สำคัญที่สุดคือ **`declare(strict_types=1)`** ซึ่งบังคับใช้การตรวจสอบชนิดแบบเข้มงวด (ปฏิเสธชนิดที่ไม่ตรงแทนที่จะแปลงให้เงียบ ๆ) เป็นเครื่องมือสำคัญในการดักจับบั๊กตั้งแต่เนิ่น ๆ และเขียนโค้ดที่น่าเชื่อถือ

การรู้วิธีนิยามฟังก์ชันที่มีชนิดชัดเจนพร้อมค่าเริ่มต้น และการใช้ strict types เป็นความรู้พื้นฐานสำหรับการพัฒนา PHP สมัยใหม่ในระดับมืออาชีพ ซึ่งแยกแยะโค้ดที่ปลอดภัยด้านชนิดออกจากสไตล์ loosely-typed ของ PHP ยุคเก่า