การเขียน Function Php: คู่มือแก้ปัญหาการใช้เครื่องหมาย

การเขียนฟังก์ชัน PHP

ภาษา PHP เป็นภาษาโปรแกรมที่นิยมใช้งานอย่างแพร่หลายในการพัฒนาเว็บไซต์ และฟังก์ชันเป็นส่วนสำคัญที่ช่วยให้เราสามารถเขียนโค้ดที่สามารถใช้ซ้ำได้ และจัดการกับข้อมูลและตัวแปรต่างๆได้อย่างมีประสิทธิภาพ

ในบทความนี้เราจะพูดถึงเกี่ยวกับการเขียนฟังก์ชันในภาษา PHP รวมถึงการประกาศฟังก์ชัน, การรับค่าพารามิเตอร์ในฟังก์ชัน, การส่งค่ากลับจากฟังก์ชัน, การใช้งานตัวแปรภายในฟังก์ชัน, การทำงานกับอาร์เรย์ในฟังก์ชัน, การสร้างฟังก์ชันที่ไม่มีการรับค่าพารามิเตอร์, การใช้งานฟังก์ชันในภายในฟังก์ชัน, และการเรียกใช้ฟังก์ชันจากฟังก์ชันอื่น นอกจากนี้ยังรวมถึงวิธีการนำฟังก์ชันไปใช้ในโปรแกรมที่แยกออกมาเป็นไฟล์ที่แตกต่างกันด้วย

### การประกาศฟังก์ชัน

ใน PHP เราสามารถประกาศฟังก์ชันได้โดยใช้คีย์เวิร์ด `function` ตามด้วยชื่อของฟังก์ชันที่เราต้องการ ตัวอย่างการประกาศฟังก์ชันใน PHP แสดงดังต่อไปนี้:

“`php
function myFunction() {
// โค้ดของฟังก์ชันที่นี่
}
“`

### การรับค่าพารามิเตอร์ในฟังก์ชัน

เราสามารถรับค่าพารามิเตอร์เข้ามาในฟังก์ชันใน PHP ได้โดยการประกาศตัวแปรภายในวงเล็บเหลี่ยมในหน้าประกาศฟังก์ชัน ตัวอย่างเช่น:

“`php
function addNumbers($num1, $num2) {
$sum = $num1 + $num2;
echo “ผลลัพธ์คือ ” . $sum;
}
“`

ในตัวอย่างข้างบน เราประกาศฟังก์ชัน `addNumbers` ที่รับค่าพารามิเตอร์ `$num1` และ `$num2` และนำมาบวกกัน เมื่อฟังก์ชันถูกเรียกใช้ ก็จะแสดงผลลัพธ์ของผลรวมออกมา

### การส่งค่ากลับจากฟังก์ชัน

เราสามารถส่งค่ากลับจากฟังก์ชันใน PHP โดยใช้คีย์เวิร์ด `return` ตามด้วยค่าที่เราต้องการส่งกลับ ตัวอย่างเช่น:

“`php
function addNumbers($num1, $num2) {
$sum = $num1 + $num2;
return $sum;
}

$result = addNumbers(5, 10);
echo “ผลลัพธ์คือ ” . $result;
“`

ในตัวอย่างข้างบน เราสร้างฟังก์ชัน `addNumbers` ที่รับค่า `$num1` และ `$num2` และนำมาบวกกัน แล้วส่งผลลัพธ์กลับด้วยคีย์เวิร์ด `return` จากนั้นเราเรียกฟังก์ชัน `addNumbers(5, 10)` เพื่อแสดงผลลัพธ์ออกมา

### การใช้งานตัวแปรภายในฟังก์ชัน

เราสามารถใช้งานตัวแปรภายในฟังก์ชันใน PHP ได้เช่นเดียวกับการใช้งานตัวแปรภายนอกฟังก์ชัน ตัวอย่างเช่น:

“`php
function myFunction() {
$name = “John”;
echo “สวัสดีคุณ ” . $name;
}
“`

ในตัวอย่างข้างบน เรากำหนดค่าของตัวแปร `$name` เป็น “John” ภายในฟังก์ชัน `myFunction` และใช้งานตัวแปรนี้เพื่อแสดงผลลัพธ์ออกมา

### การทำงานกับอาร์เรย์ในฟังก์ชัน

เราสามารถทำงานกับอาร์เรย์ภายในฟังก์ชันใน PHP ได้เช่นเดียวกับที่เราทำได้ภายนอกฟังก์ชัน ตัวอย่างเช่น:

“`php
function sumArray($numbers) {
$sum = 0;
foreach ($numbers as $number) {
$sum += $number;
}
return $sum;
}

$array = [1, 2, 3, 4, 5];
$result = sumArray($array);
echo “ผลรวมของอาร์เรย์คือ ” . $result;
“`

ในตัวอย่างข้างบน เราสร้างฟังก์ชัน `sumArray` ที่รับค่าอาร์เรย์ `$numbers` และทำการบวกค่าในอาร์เรย์ทุกตัวกันทีละตัว แล้วส่งผลลัพธ์กลับด้วยคีย์เวิร์ด `return` ในที่นี้เราใช้งานฟังก์ชัน `sumArray` เพื่อหาผลรวมของอาร์เรย์ `[1, 2, 3, 4, 5]` แล้วแสดงผลลัพธ์ออกมา

### การสร้างฟังก์ชันที่ไม่มีการรับค่าพารามิเตอร์

ในบางกรณี เราอาจต้องการสร้างฟังก์ชันที่ไม่ต้องการรับค่าพารามิเตอร์เข้ามา แต่แทนที่จะรับค่าเข้ามา เราสามารถใช้ตัวแปร global ในการเข้าถึงตัวแปรจากภายนอกฟังก์ชันได้ ตัวอย่างเช่น:

“`php
function myFunction() {
global $name;
echo “สวัสดีคุณ ” . $name;
}

$name = “John”;
myFunction();
“`

ในตัวอย่างข้างบน เรากำหนดค่าของตัวแปร `$name` เป็น “John” ภายนอกฟังก์ชัน `myFunction` แล้วใช้งานตัวแปรนี้ในฟังก์ชันนั้น

### การใช้งานฟังก์ชันในภายในฟังก์ชัน

เราสามารถใช้งานฟังก์ชันภายในฟังก์ชันใน PHP ได้โดยเรียกใช้ฟังก์ชันด้วยชื่อฟังก์ชัน ตัวอย่างเช่น:

“`php
function myFunction() {
echo “เรียกใช้งานฟังก์ชันอื่น”;
}

function mainFunction() {
myFunction();
}

mainFunction();
“`

ในตัวอย่างข้างบน เราสร้างฟังก์ชัน `myFunction` ที่แสดงข้อความว่า “เรียกใช้งานฟังก์ชันอื่น” และฟังก์ชัน `mainFunction` ที่เรียกใช้งานฟังก์ชัน `myFunction` ด้วยตนเอง การเรียกใช้งาน `mainFunction` จะเรียกใช้งาน `myFunction` และแสดงข้อความออกมา

### การนำฟังก์ชันไปใช้ในโปรแกรมที่แยกออกมาเป็นไฟล์ที่แตกต่างกัน

ในกรณีที่เรามีโปรแกรมที่แยกออกเป็นไฟล์ที่แตกต่างกัน เราสามารถนำฟังก์ชันที่เราเขียนไว้ในไฟล์นึง มาใช้งานในไฟล์อื่นๆ ได้โดยการใช้คำสั่ง `require` หรือ `include` ตามด้วยชื่อไฟล์ที่ต้องการนำเข้า ตัวอย่างเช่น:

“`php
// functions.php
function myFunction() {
echo “ฟังก์ชันที่นำไปใช้ในไฟล์อื่น”;
}

// index.php
require ‘functions.php’;

myFunction();
“`

ในตัวอย่างข้างบน เรากำหนดฟังก์ชัน `myFunction` ในไฟล์ `functions.php` แล้วนำไฟล์นี้มาใช้งานในไฟล์ `index.php` ด้วยคำสั่ง `require ‘functions.php’` และเรียกใช้ฟังก์ชัน `myFunction` ในไฟล์ `index.php` วิธีนี้ช่วยให้เราสามารถใช้งานฟังก์ชันที่เราเขียนไว้ในไฟล์อื่นๆ ได้อย่างสะดวกและยืดหยุ่น

### การเรียกใช้ Function JavaScript จาก PHP

ในกรณีที่เราต้องการเรียกใช้ฟังก์ชัน JavaScript จาก PHP เราสามารถเรียกใช้ฟังก์ชัน JavaScript ได้โดยใช้สคริ

PHP เรียกใช้ Function JavaScript

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

การเรียกใช้ฟังก์ชั่น JavaScript จาก PHP มีหลายวิธี ซึ่งแต่ละวิธีก็มีข้อดีและข้อเสียที่แตกต่างกัน ขึ้นอยู่กับวัตถุประสงค์และความต้องการของโปรเจกต์ที่เรากำลังพัฒนา

วิธีแรกที่เรามาเจอบ่อยครั้งคือการเรียกใช้ JavaScript โดยตรงผ่านทางสคริปต์แท็กใน PHP ใช้วิธีนี้ง่าย และมักใช้ในกรณีที่ต้องการเรียกใช้ฟังก์ชั่น JavaScript บนเว็บเพจที่สร้างโดย PHP โดยสามารถทำได้ด้วยตัวอย่างโค้ดดังนี้

“`php
“; echo “functionName();”; //เรียกใช้ฟังก์ชั่น JavaScript echo ““;
?>
“`

วิธีที่สองคือการใช้ฟังก์ชั่น `echo` โดยกำหนดพารามิเตอร์ให้เป็นโค้ด JavaScript ตรงกลาง ในที่นี้เราสามารถเรียกใช้ตัวแปร PHP ได้ตรงนี้ด้วย หากต้องการส่งค่าผ่านตัวแปร PHP ไปยังฟังก์ชั่น JavaScript จะต้องใช้เครื่องหมายคำตอบ `.` ซึ่งเป็นตัวดำเนินการการต่อข้อความในภาษา PHP อย่างไรก็ตาม เมื่อโค้ด JavaScript เรียกใช้งานกันเสร็จสิ้นแล้ว คุณต้องใช้เครื่องหมาย `;` สั่งให้ PHP ปิดสคริปต์ วิธีการดังกล่าวอยู่ในรูปแบบดังตัวอย่างนี้

“`php
“; echo “var myVariable = ‘” . $variableFromPHP . “‘;”; echo “functionName(myVariable);”; //เรียกใช้ฟังก์ชั่น JavaScript echo ““;
?>
“`

วิธีที่สามเป็นการใช้คำสั่ง `header()` ใน PHP เพื่อสร้างส่วนหัวของโค้ด JavaScript เราสามารถกำหนดประเภทเอกสารให้เป็น JavaScript และเรียกใช้ฟังก์ชั่น JavaScript ได้โดยตรง ตัวอย่างโค้ดดังนี้

“`php

functionName(); //เรียกใช้ฟังก์ชั่น JavaScript
“`

วิธีที่สี่เป็นการใช้ AJAX (Asynchronous JavaScript and XML) ซึ่งเป็นเทคนิคในการเรียกใช้งาน JavaScript ที่ทำให้การสื่อสารกับเว็บเซิร์ฟเวอร์เป็นเรื่องง่าย การใช้ AJAX ให้เรียกใช้ฟังก์ชั่น JavaScript สามารถดำเนินการได้ทันทีโดยไม่ต้องโหลดหน้าเว็บใหม่ ซึ่งผลลัพธ์ที่ได้จะอัปเดตแบบเรียลไทม์ โดยอธิบายวิธีการนี้เนื้อหาจะยาวเพียงพอที่จะเขียนโค้ดตัวอย่าง ดังตัวอย่างนี้

“`javascript

“`

เมื่อส่งคำขอ AJAX ไปยังไฟล์ `ajax_function.php` คำตอบที่ส่งกลับจะเป็นโค้ด JavaScript ที่รันการเรียกใช้งานฟังก์ชั่น `functionName()` และส่งค่ากลับมาได้ตามที่ต้องการ

คำถามที่พบบ่อย

1. การเรียกใช้ JavaScript จาก PHP มีประโยชน์อย่างไร?
การเรียกใช้งาน JavaScript จาก PHP มีประโยชน์หลายเรื่อง เช่น:
– ช่วยให้คุณสามารถทำงานร่วมกับ JavaScript ที่ใช้งานตามคำสั่งของคุณ
– ช่วยให้คุณสามารถสร้างและปรับแต่งเว็บไซต์ที่สอดคล้องกับความต้องการของคุณ
– ช่วยให้คุณสามารถยกระดับประสิทธิภาพและประสิทธิผลของเว็บไซต์ของคุณ

2. วิธีการเรียกใช้ JavaScript จาก PHP ในส่วนไหนของโค้ดได้บ้าง?
คุณสามารถเรียกใช้งาน JavaScript จาก PHP ได้ทั้งในส่วนของตัวอย่างโค้ด PHP, หน้าเว็บทั้งหมด หรือไฟล์ JavaScript ที่เรียกขึ้นที่หัวข้อ `script` ในหน้า PHP บางครั้งคุณอาจต้องใช้ AJAX เพื่อเรียกใช้ฟังก์ชั่น JavaScript ในเว็บเพจโดยไม่ต้องโหลดหน้าใหม่

3. จะส่งค่าจาก PHP ไปยังฟังก์ชัน JavaScript ได้อย่างไร?
คุณสามารถส่งค่าจากภาษา PHP ไปยังฟังก์ชัน JavaScript ได้โดยกำหนดค่าให้กับตัวแปร JavaScript ในโค้ด PHP และเรียกใช้งานฟังก์ชั่น JavaScript โดยใช้ตัวแปรดังกล่าวในเป็นพารามิเตอร์

4. การเรียกใช้ JavaScript จาก PHP มีข้อจำกัดอะไรบ้าง?
การเรียกใช้ JavaScript จาก PHP อาจมีข้อจำกัดบางประการ เช่น:
– การเรียกใช้สคริปต์ JavaScript จาก PHP สามารถจะทำเมื่อหน้าเว็บไซต์ที่ต้องการใช้งาน JavaScript ถูกโหลดเสร็จสิ้นแล้วเท่านั้น
– ในบางกรณีการเรียกใช้งาน JavaScript จาก PHP อาจจะมีปัญหาต่อความปลอดภัยและความคงเสียด้วย (เช่น ชาวสร้างสเป็กที่ขัดแย้งกัน)

สรุป
การเรียกใช้ JavaScript จากภาษา PHP เป็นเทคนิคที่มีประโยชน์หลายประการในการพัฒนาเว็บไซต์ วิธีการที่เหมาะสมในการเรียกใช้งาน JavaScript จาก PHP ขึ้นอยู่กับความต้องการของโปรเจกต์และลักษณะการทำงานที่คุณต้องการให้กับเว็บไซต์ของคุณ

หนึ่งในความสำเร็จที่ใหญ่ที่สุดของ PHP คือความสามารถในการประกาศฟังก์ชัน โดยฟังก์ชันเป็นบล็อกของโค้ดที่ใช้ในการแยกการกระทำเป็นส่วนย่อยที่ใช้ซ้ำได้ในโค้ด PHP ที่เราเขียน การใช้ฟังก์ชันช่วยให้การเขียนโค้ดเป็นระเบียบและนำมาใช้ซ้ำได้ง่าย เราสามารถประกาศฟังก์ชันใน PHP โดยใช้คีย์เวิร์ด “function” ตามด้วยชื่อของฟังก์ชันและกำหนดพารามิเตอร์ที่จำเป็นต่อฟังก์ชัน ในบทความนี้เราจะทำความรู้จักกับ Function PHP ทั้งหมด การประกาศ, การใช้งานและคุณสมบัติของฟังก์ชัน ไปเริ่มกันเลย!

การประกาศฟังก์ชัน
หากเราต้องการประกาศฟังก์ชันใน PHP จะต้องใช้คีย์เวิร์ด “function” นำหน้า ตามด้วยชื่อฟังก์ชันที่ต้องการ และเปิด-ปิดวงเล็บ( ) และเราสามารถกำหนดพารามิเตอร์ที่ฟังก์ชันต้องการรับเข้ามาได้ในวงเล็บเหล่านั้น ดูตัวอย่างรูปแบบการประกาศฟังก์ชัน PHP ด้านล่างนี้:

“`php
function functionName(parameter1, parameter2, …, parameterN) {
// function body
// statements to be executed
return x; // optional
}
“`

ในตัวอย่างข้างต้น บรรทัดแรกเป็นการประกาศฟังก์ชัน โดยมีชื่อว่า “functionName” ฟังก์ชันในตัวอย่างนี้อาจรับพารามิเตอร์แบบต่างๆ ที่ถูกต้องสูงสุด N ตัว ฟังก์ชันสามารถมีคำสั่งหรือตัวแปรที่ต้องการภายในฟังก์ชันได้ โดยสามารถมีการทำงานกับข้อมูลภายนอกที่เข้ามาผ่านพารามิเตอร์ได้ ตามสิ่งที่ต้องการ การประกาศคำสั่งภายในฟังก์ชันนั้นจะอยู่ภายในบล็อกของฟังก์ชัน

การเรียกใช้ฟังก์ชัน
เมื่อฟังก์ชันถูกประกาศแล้ว เราสามารถเรียกใช้ฟังก์ชันได้โดยการเรียกชื่อของฟังก์ชันที่เรากำหนดไว้ตามด้วยวงเล็บเปิด-ปิด พร้อมกับระบุค่าของพารามิเตอร์ (หากมีการระบุ) พารามิเตอร์ของฟังก์ชันสามารถเป็นการส่งข้อมูลเข้ามาสู่ฟังก์ชัน เพื่อให้ฟังก์ชันทำงานด้วยข้อมูลนั้นตามสิ่งที่ต้องการ ต่อไปคือตัวอย่างการเรียกใช้ฟังก์ชัน PHP ที่เราประกาศไว้ด้านบน:

“`php
functionName(argument1, argument2, …, argumentN);
“`

ฟังก์ชันที่เรียกใช้จะทำงานและส่งค่ากลับ (return) หากมีคำสั่ง return อยู่ในฟังก์ชันนั้น ซึ่งค่าที่ส่งกลับจะกลายเป็นค่าเอาเลยหลังจากเรียกใช้ฟังก์ชัน

คุณสมบัติของฟังก์ชัน
ฟังก์ชันใน PHP มีคุณสมบัติที่น่าสนใจหลายอย่าง ทำให้เราสามารถใช้และจัดการฟังก์ชันได้อย่างสมบูรณ์แบบ นี่คือคุณสมบัติที่เราควรทราบเกี่ยวกับฟังก์ชันใน PHP:

1. การส่งค่ากลับ (Return Value)
การส่งค่ากลับในฟังก์ชัน PHP ทำโดยใช้คำสั่ง return ซึ่งสามารถใส่อาร์กิวเมนต์ได้หนึ่งหรือไม่ก็ได้ ในการที่ฟังก์ชันจะส่งค่ากลับได้ เราต้องใช้คำสั่ง return ด้วยตัวแปรหรือค่าที่เราต้องการส่งกลับไปยังส่วนที่เรียกใช้ฟังก์ชันนั้น

2. การรับข้อมูลเข้าภายในฟังก์ชัน
เราสามารถรับข้อมูลเข้าภายในฟังก์ชันได้โดยนำพารามิเตอร์มารับข้อมูล แล้วทำการประมวลผลบางอย่างจากข้อมูลนั้น

3. การใช้ตัวแปรที่เป็นตัวละครในฟังก์ชัน
เราสามารถใช้ตัวแปรที่เป็นตัวละครรวมถึงสตริงในฟังก์ชันได้ตามสิ่งที่เราต้องการ สัญลักษณ์ที่ใช้ในฟังก์ชันอาจเป็นตัวแปรตามหลังเครื่องหมาย $ เพื่อให้วินิจฉัยว่าเป็นตัวแปร

4. การใช้ตัวแปรที่เป็นแบบฉากหรือท้องถิ่น
หากต้องการใช้ตัวแปรที่ถูกประกาศในส่วนต่างๆของโค้ด PHP ที่ต้องการให้ฟังก์ชันรับเอาเข้ามาสำหรับการประมวลผล เราจำเป็นต้องประกาศตัวแปรเป็นแบบฉากหรือท้องถิ่นโดยใช้คำสั่ง global ภายในฟังก์ชันก่อนที่จะเรียกใช้ตัวแปรนั้น

5. ฟังก์ชันแบบไม่สารพัด
หากภายในฟังก์ชันไม่มีความจำเป็นต้องใช้พารามิเตอร์ที่ถูกส่งเข้ามาทำงาน เราสามารถประกาศฟังก์ชันแบบที่ไม่รับพารามิเตอร์ของฟังก์ชันได้ แต่ต้องมีวงเล็กของวงเล็บครอบอยู่เสมอ

6. ฟังก์ชันแบบตั้งชื่อมาตรฐาน
รูปแบบการตั้งชื่อของฟังก์ชันที่ถูกต้องเป็นไปตามรูปแบบนี้: lowercase ชื่อของฟังก์ชันและคั่นแต่ละคำด้วยเส้นใต้ “_”

7. ฟังก์ชันแบบได้รับจำนวนไม่แน่นอนของพารามิเตอร์
เราสามารถสร้างฟังก์ชันที่รับพารามิเตอร์ไม่แน่นอนได้โดยการใช้คีย์เวิร์ด “…” โดยฟังก์ชันที่รับพารามิเตอร์นี้จะได้สิทธิ์ในการเข้าถึงพารามิเตอร์ดังกล่าวผ่านการใช้งานที่ชื่อว่า “func_num_args”, “func_get_arg” และ “func_get_args”

การควบคุมตัวอย่างฟังก์ชัน
ในฟังก์ชัน PHP นอกจากการรับพารามิเตอร์และการคืนค่าผ่านคำสั่ง return เรายังสามารถควบคุมทรัพยากรหรือชีวิตและพฤติกรรมของฟังก์ชันได้อีกด้วย นี่คือเครื่องมือที่สำคัญที่เราสามารถใช้ได้ในการควบคุมการทำงานของฟังก์ชัน:

1. การใช้รูปแบบชนิดข้อมูล
นอกจากการประกาศพารามิเตอร์ที่ต้องรับเข้ามาด้วยชนิดข้อมูลที่เฉพาะเจาะจง แทนที่จะประกาศเป็นดาต้าชนิดที่แน่นอนเสมอ เราสามารถใช้ชนิดข้อมูลใน PHP เพื่อใช้ในการตรวจสอบว่าชนิดข้อมูลที่ถูกส่งเข้ามาเข้ากันได้หรือไม่ก่อนที่เราจะทำงาน

2. การส่งค่าผ่านทางการอ้างอิง
การส่งค่าผ่านทางการอ้างอิงจะช่วยให้เราสามารถเปลี่ยนค่าของตัวแปรภายนอกฟังก์ชันได้โดยที่ไม่ต้องส่งค่ากลับจากฟังก์ชัน เราสามารถส่งตัวแปรที่ต้องการแก้ไขให้กับฟังก์ชัน และทำการแก้ไขค่าของตัวแปรนั้นภายในฟังก์ชันได้โดยทันที

3. การบริหารจัดการข้อผิดพลาด
เมื่อเกิดข้อผิดพลาดในฟังก์ชัน เราสามารถใช้คำสั่ง “throw” เพื่อสร้างข้อผิดพลาดและลักษณะการจัดการข้อผิดพลาดในฟังก์ชันนั้นได้ นอกจากนี้เรายังสามารถใช้คำสั่ง “try” และ “catch” เพื่อจัดการและหยุดการทำงานเมื่อข้อผิดพลาดเกิดขึ้น

การสร้างฟังก์ชันเพิ่มเติมใน PHP
PHP มีฟังก์ชันมากมายที่สามารถใช้งานในโปรแกรม PHP ของเราได้ ฟังก์ชันเหล่านี้แบ่งออกเป็นหมวดหมู่ต่างๆ เช่น ฟังก์ชันสตริง, ฟังก์ชันเวลา, ฟังก์ชันแสดงผล, ฟังก์ชันคณิตศาสตร์ เป็นต้น ฟังก์ชันเหล่านี้มีไว้สำหรับการใช้งานที่เป็นที่นิยมในการเขียนโปรแกรม PHP ดังนั้นเราสามารถค้นหาฟังก์ชันที่ต้องการจากเอกสาร APIs ของ PHP และนำมาใช้ในการเขียนโปรแกรมของเรา

FAQs (คำถามที่พบบ่อย

พบ 37 ภาพที่เกี่ยวข้องกับหัวข้อ การเขียน function php.