ฟังก์ชันทำงานอย่างไรใน php.ini การเรียกใช้ฟังก์ชันผ่านตัวแปร

ดังนั้น, ฟังก์ชั่น (ฟังก์ชั่น) บนคืออะไรPHP?

ฟังก์ชัน (ฟังก์ชัน)นี่เป็นโปรแกรมขนาดเล็กที่ดำเนินการบางอย่างที่เป็นประโยชน์และให้ผลลัพธ์ที่เสร็จสิ้น
ลองดูแผนผัง:

เรามาลองเขียนมินิโปรแกรมโดยใช้เทมเพลตฟังก์ชันสำเร็จรูปกัน
เทมเพลตฟังก์ชันพร้อม:

สมมติว่าเราต้องเขียนฟังก์ชันที่สามารถคำนวณผลรวมของตัวเลข 5 และ 2 ได้ เราดูเทมเพลตและเขียน:

มาทำลายรหัสกันเถอะ
function suma() เป็นฟังก์ชันที่ชื่อ suma ;
เสียงสะท้อน 5+2; - ในเนื้อความของฟังก์ชั่นเราระบุว่าต้องรวมตัวเลข 5 และ 2 เข้าด้วยกัน (5 + 2) ;
ผลรวม(); - เรียกใช้ฟังก์ชัน การเรียกใช้ฟังก์ชันหมายถึงการดำเนินการ นั่นคืองาน 5 + 2 จะต้องเสร็จสิ้นและให้ผลลัพธ์ 7 .

ทีนี้มาลองพิจารณาฟังก์ชั่นเป็นขั้นตอนกัน

ขั้นตอนในการสร้างฟังก์ชันใน PHP

เวทีฉัน. การสร้างฟังก์ชัน
จำเทมเพลตฟังก์ชันที่เสร็จแล้ว:

นี่คือวิธีการสร้างฟังก์ชันใน PHP
มาเขียนข้อความในเนื้อความของฟังก์ชันกัน " ฉันดีใจที่ได้พบคุณในเว็บไซต์บล็อก».
อย่าลืม: เราเขียนข้อความผ่าน .

"; } ?>

ตอนนี้เราต้องเรียกใช้ฟังก์ชัน "site()"

เวทีII. กำลังเรียกใช้ฟังก์ชันสำเร็จรูปบนPHP
ฟังก์ชันนี้ถูกสร้างขึ้นและควรดำเนินการแล้ว ในการดำเนินการและส่งออกฟังก์ชัน การระบุ “ชื่อฟังก์ชัน (); »

เว็บไซต์();

มันจะมีลักษณะดังนี้:

"; ) เว็บไซต์ (); ?>

คุณยังสามารถทำได้ดังนี้:

"; ) ?> ข้อความมากมาย…..ข้อความเพียบ....

ป้อนที่อยู่ในเบราว์เซอร์:

ผลลัพธ์:

ฟังก์ชั่น PHP พร้อมอาร์กิวเมนต์

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

ดังนั้นฉันจึงสร้างฟังก์ชันที่เรียกว่า "ไซต์" ในพารามิเตอร์ (ที่มีวงเล็บ) ฉันได้เขียนสองตัวแปร $a และ $b คั่นด้วยเครื่องหมายจุลภาค

ไซต์ฟังก์ชัน ($a , $b )

$a และ $b เป็นสองอาร์กิวเมนต์
echo "$a + $b = "; - ที่นี่ฉันนำข้อความไปที่จอภาพ ผลลัพธ์: 5 + 5 =
เสียงสะท้อน $a + $b; - ที่นี่ฉันบอกฟังก์ชันว่าควรรวมตัวแปร $a และ $b เข้าด้วยกัน
ไซต์ (15, 5); - เรียกว่าฟังก์ชัน ข้อควรสนใจ: ในวงเล็บ ฉันได้ระบุสองอาร์กิวเมนต์ (15, 5) ที่ตัวแปร $a และ $b กำลังรออยู่ ตัวแปร $a จะได้รับอาร์กิวเมนต์แรก - 15 , $b - ตัวที่สอง 5

สำหรับผู้ที่ไม่เข้าใจว่าข้อโต้แย้งถูกแทนที่ที่ไหนและในลำดับใด นี่คือรูปแบบ:

นี่คือรหัสที่เสร็จแล้ว:

บันทึกเป็น "function.php" ในโฟลเดอร์ "test-1" ของเซิร์ฟเวอร์ในเครื่อง (ดูบทที่ 1)

ป้อนที่อยู่ในเบราว์เซอร์:

https://localhost/test-1/function.php

ผลลัพธ์:

ผมขอทำให้ฟังก์ชันซับซ้อนขึ้นเล็กน้อยและทำให้น่าสนใจยิ่งขึ้น ฉันจะเพิ่มที่อยู่บล็อกลงในอาร์กิวเมนต์และเขียนชื่อลิงก์

ฟังก์ชันที่เรียกว่า “site” จะได้รับอาร์กิวเมนต์ https://site/ ในตัวแปร $link และตัวแปร $title จะได้รับข้อความลิงก์ - “ บล็อกไซต์ - การสร้างไซต์!»

รหัสสำเร็จรูป:

บันทึกเป็น "function.php" ในโฟลเดอร์ "test-1" ของเซิร์ฟเวอร์ในเครื่อง (ดูบทที่ 1)

ป้อนที่อยู่ในเบราว์เซอร์

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

ไวยากรณ์พื้นฐานสำหรับการใช้ (หรือเรียก) ฟังก์ชันดังแสดงด้านล่าง:

Function_name(expression_1, expression_2, ... ,expression_n)

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

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

PHP มีฟังก์ชันในตัวนับร้อย ตัวอย่างทั้งหมดด้านล่างนี้เป็นการเรียกใช้ฟังก์ชันในตัวของ PHP ที่ถูกต้อง:

เรียกใช้ฟังก์ชัน PHP ในตัว สี่เหลี่ยม (9); // เรียกใช้ฟังก์ชันสแควร์รูทซึ่ง // ส่งผลให้ค่า 3 แรนด์ (10, 10 + 10); // ส่งกลับตัวเลขสุ่มตั้งแต่ 10 ถึง 20 strlen ("มีอักขระ 24 ตัวในสตริงนี้"); // ส่งคืนค่า 24 pi(); // ส่งคืนค่าโดยประมาณของตัวเลข "pi"

ทุกการเรียกใช้ฟังก์ชันคือนิพจน์ PHP ดังนั้น (เช่นเดียวกับนิพจน์อื่น ๆ ) มีเพียงสองเหตุผลที่คุณอาจต้องการรวมการเรียกใช้ฟังก์ชันในโค้ดของคุณ: เพื่อรับค่าที่ส่งคืนหรือเพื่อสร้างผลข้างเคียง

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

รหัส PHP $my_pi = pi();

อีกทางเลือกหนึ่งคือผลลัพธ์สามารถซ้อนในนิพจน์ที่ซับซ้อนมากขึ้นได้ ดังในตัวอย่างต่อไปนี้:

รหัส PHP $ประมาณ = sqrt($ประมาณ) * sqrt($ประมาณ);

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

ผลลัพธ์ของการเรียกใช้ฟังก์ชันอาจเป็นประเภทใดก็ได้ ดังนั้นอาร์เรย์จึงถูกใช้อย่างกว้างขวางเพื่อคืนค่าหลายค่าจากฟังก์ชันในครั้งเดียว

กำหนดฟังก์ชั่นของคุณเอง

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

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

คำจำกัดความของฟังก์ชันมีรูปแบบดังต่อไปนี้:

ชื่อฟังก์ชัน ($argument-1, $argument-2, ..) ( statement-1; statement-2; ... )

ซึ่งหมายความว่าคำจำกัดความของฟังก์ชันประกอบด้วยสี่ส่วนต่อไปนี้:

คำสำคัญ การทำงาน.

ชื่อที่จะกำหนดให้กับฟังก์ชัน

รายการพารามิเตอร์ฟังก์ชัน - ชื่อตัวแปรที่นำหน้าด้วยเครื่องหมายดอลลาร์ คั่นด้วยเครื่องหมายจุลภาค (พารามิเตอร์อาจถูกละเว้น)

ฟังก์ชั่นร่างกาย- ชุดโอเปอเรเตอร์ที่อยู่ในวงเล็บปีกกา

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

ต่อไปนี้คือข้อมูลสรุปของการดำเนินการที่เกิดขึ้นเมื่อเรียกใช้ฟังก์ชันที่ผู้ใช้กำหนด:

ตัวแปล PHP ค้นหาฟังก์ชันตามชื่อ (หากยังไม่ได้กำหนดฟังก์ชัน จะเกิดข้อผิดพลาดขึ้น)

ตัวแปล PHP แทนที่ค่าของพารามิเตอร์การโทร (หรือพารามิเตอร์จริง) สำหรับตัวแปรในรายการพารามิเตอร์ของคำจำกัดความ (หรือพารามิเตอร์ที่เป็นทางการ)

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

ตัวอย่างการกำหนดฟังก์ชัน

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

รหัส PHP $ลิตร_1 = 1.0; $price_1 = 1.59; $liters_2 = 1.5; $price_2 = 2.09; $per_liter_1 = $price_1 / $liters_1; $per_liter_2 = $price_2 / $liters_2; ถ้า ($per_liter_1< $per_liter_2) print("Первая сделка лучше!

")

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

รหัส PHP // ฟังก์ชั่นการกำหนดฟังก์ชัน better_deal ($amount_1, $amount_2, $price_1, $price_2) ( $per_amount_1 = $price_1 / $amount_1; $per_amount_2 = $price_2 / $amount_2; // คืนค่าบางส่วนจากผลตอบแทนของฟังก์ชัน ($ per_amount_1< $per_amount_2); } $liters_1 = 1.0; $price_1 = 1.59; $liters_2 = 1.5; $price_2 = 2.09; // Вызов функции в условном операторе if (better_deal($liters_1, $liters_2, $price_1, $price_2)) print("Первая сделка лучше!
"); else print ("เทรดที่สองดีกว่า!
")

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

แม้ว่าเวอร์ชันที่แก้ไขซึ่งใช้ฟังก์ชันจะมีโค้ดมากกว่าเวอร์ชันดั้งเดิม แต่เวอร์ชันนี้มีข้อดีสองประการ: อย่างแรก ฟังก์ชันนี้ใช้ได้หลายครั้ง (ซึ่งจะลดจำนวนโค้ดโดยรวม) และประการที่สอง หากจำเป็น ให้เปลี่ยน อัลกอริธึมการคำนวณก็จะเพียงพอที่จะทำการเปลี่ยนแปลงในที่เดียว

อีกทางเลือกหนึ่งคือการรวมข้อความแสดงผลลัพธ์โดยตรงในฟังก์ชัน (ดังที่แสดงด้านล่าง) หากการเปรียบเทียบราคาที่ใช้เพื่อแสดงข้อมูลเกี่ยวกับตัวเลือกการซื้อที่ทำกำไรได้มากกว่าเท่านั้น:

รหัส PHP // ฟังก์ชั่นการกำหนดฟังก์ชัน better_deal ($amount_1, $amount_2, $price_1, $price_2) ( $per_amount_1 = $price_1 / $amount_1; $per_amount_2 = $price_2 / $amount_2; // ไม่มีค่าส่งคืนจากฟังก์ชัน // แต่ มีการดำเนินการบางอย่างหาก ($per_amount_1< $per_amount_2) print("Первая сделка лучше!
"); else print ("เทรดที่สองดีกว่า!
"); ) // เรียกใช้ฟังก์ชัน better_deal(1.0, 1.5, 1.59, 2.09);

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

ใช้พารามิเตอร์น้อยลง

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

หากจำนวนของพารามิเตอร์จริงที่ส่งผ่านน้อยกว่าจำนวนพารามิเตอร์ที่เป็นทางการ ล่าม PHP จะถือว่าพารามิเตอร์ที่เป็นทางการที่ว่างเปล่าเสมือนว่าพารามิเตอร์เหล่านั้นเป็นตัวแปรที่ไม่ได้กำหนด แต่ด้วยการตั้งค่าปกติสำหรับเปิดใช้งานการรายงานข้อผิดพลาดใน PHP5 จะมีข้อความเตือนแสดงขึ้นในหน้าต่างเบราว์เซอร์ด้วย

ตามค่าเริ่มต้น ระบบการรายงานข้อผิดพลาดใน PHP5 ได้รับการกำหนดค่าให้แสดงข้อมูลเกี่ยวกับข้อผิดพลาดทุกประเภท ยกเว้นการแจ้งเตือน ขั้นตอนการแก้จุดบกพร่องซึ่งเป็นเงื่อนไขข้อผิดพลาดที่ร้ายแรงน้อยที่สุดที่ระบบตรวจพบ เหตุผลแสดงข้อความเตือนสำหรับพารามิเตอร์น้อยเกินไปที่ส่งผ่านไปยังฟังก์ชัน เนื่องจากสถานการณ์นี้ถือว่าจำเป็นต้องมีคำเตือนในระหว่างการดีบัก (คำเตือนในหมวดหมู่นี้รุนแรงที่สุดเป็นอันดับสอง)

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

เปลี่ยนความรุนแรงของข้อผิดพลาดที่ทริกเกอร์ข้อความแสดงข้อผิดพลาดในสคริปต์ชั่วคราวโดยใช้คำสั่งต่อไปนี้:

รหัส PHP error_reporting(E_ALL - (E_NOTICE + E_WARNING));

การใช้คำสั่งดังกล่าวจะป้องกันการพิมพ์ข้อความเตือนการดีบักและรันไทม์จากเวลาที่คำสั่งปรากฏในสคริปต์จนกว่าจะมีคำสั่ง error_reporting() ถัดไป หากมี (ควรสังเกตว่าตัวเลือกนี้เป็นอันตราย เนื่องจากสามารถสร้างข้อความเตือนได้ ไม่เพียงแต่เกี่ยวข้องกับสถานการณ์ที่คุณสนใจ แต่ยังอยู่ภายใต้อิทธิพลของปัญหาอื่นๆ อีกมากมาย)

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

รหัส PHP ... // การเรียกใช้ฟังก์ชันที่มี 2 พารามิเตอร์แทนที่จะเป็น 4 @better_deal(1.0, 1.5);

หน้าที่และขอบเขตของตัวแปร

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

ขอบเขตฟังก์ชัน

แน่นอน กฎสำหรับการกำหนดขอบเขตชื่อตัวแปรนั้นค่อนข้างง่าย และกฎสำหรับชื่อฟังก์ชันการกำหนดขอบเขตนั้นง่ายกว่า PHP5 มีกฎเพียงข้อเดียว: ต้องกำหนดฟังก์ชันเพียงครั้งเดียว (และเพียงครั้งเดียว) ในสคริปต์ที่ใช้ ขอบเขตชื่อฟังก์ชันจะพิจารณาโดยปริยาย ดังนั้นฟังก์ชันที่กำหนดไว้ในสคริปต์จึงพร้อมใช้งานได้ทุกที่ในสคริปต์นั้น แต่เพื่อให้ง่ายต่อการศึกษาโค้ด ขอแนะนำให้กำหนดฟังก์ชันก่อนที่จะเรียกใช้โค้ด

ใน PHP3 สามารถใช้ฟังก์ชันได้หลังจากกำหนดแล้วเท่านั้น ซึ่งหมายความว่าแนวทางการพัฒนาที่ปลอดภัยที่สุดในรุ่นนี้คือการกำหนดฟังก์ชันทั้งหมดตั้งแต่เริ่มต้นของแต่ละสถานการณ์ ก่อนที่จะใช้ฟังก์ชันเหล่านั้นจริงๆ (หรือรวมคำจำกัดความของฟังก์ชันทั้งหมด)

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

รหัส PHP // เรียกใช้ฟังก์ชัน sum() ก่อนกำหนด echo sum(15, 26); ฟังก์ชัน sum($a, $b) ( return $a + $b; )

การเรียกซ้ำ

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

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

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

ซึ่งหมายความว่าตั้งแต่เวอร์ชัน PHP4 จึงสามารถกำหนดได้โดยไม่มีปัญหาใดๆ ฟังก์ชันแบบเรียกซ้ำ(หน้าที่ที่เรียกตัวเองว่า). ตัวอย่างเช่น ดังที่แสดงด้านล่าง คุณสามารถกำหนดฟังก์ชันแบบเรียกซ้ำแล้วเรียกใช้ทันที:

รหัส PHP ฟังก์ชั่น countdown($count) ( if ($count > 0) ( echo "Number $count
"; // Recursion countdown(--$count); ) ) นับถอยหลัง(10);

เป็นผลให้ผลลัพธ์ต่อไปนี้แสดงในหน้าต่างเบราว์เซอร์:

ตัวอย่างการใช้การเรียกซ้ำใน PHP

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

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

ในทำนองเดียวกันโดยไม่มีปัญหาใด ๆ ในการทำงาน ฟังก์ชันแบบเรียกซ้ำร่วมกัน(ฟังก์ชันที่เรียกกันตามลำดับ) ตัวอย่างเช่น การเรียกใช้ฟังก์ชันต่อไปนี้พร้อมคำจำกัดความที่ระบุ:

รหัส PHP ฟังก์ชั่น countdown_first($count) ( if ($count > 0) ( echo "Call countdown_first: $count
"; // เรียกซ้ำกับฟังก์ชันอื่น countdown_second(--$count); ) ) ฟังก์ชั่น countdown_second($count) ( if ($count > 0) ( echo "Call countdown_second: $count
"; // เรียกซ้ำกับฟังก์ชันอื่น countdown_first(--$count); ) ) countdown_first(5);

ส่งผลให้ผลลัพธ์ต่อไปนี้ในหน้าต่างเบราว์เซอร์:

ฟังก์ชันเรียกซ้ำร่วมกัน

จำนวนตัวแปรของพารามิเตอร์

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

• กำหนดฟังก์ชันด้วยพารามิเตอร์เริ่มต้น พารามิเตอร์ใดๆ ที่ขาดหายไปจากการเรียกใช้ฟังก์ชันจะถูกตั้งค่าเป็นค่าเริ่มต้น ดังนั้นจะไม่มีข้อความเตือนเกี่ยวกับพารามิเตอร์ที่จำเป็นที่ขาดหายไป

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

  ใช้ฟังก์ชันที่มีจำนวนตัวแปรของพารามิเตอร์ (func_num_args(), func_get_arg() และ func_get_args())

ส่วนต่อไปนี้จะกล่าวถึงแต่ละตัวเลือกเหล่านี้แยกกัน

ตัวเลือกเริ่มต้น

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

ตัวอย่างเช่น ในฟังก์ชันต่อไปนี้ พารามิเตอร์ทั้งหมดถูกกำหนดด้วยค่าเริ่มต้น:

รหัส PHP function tour_guide($city = "มอสโก", $desc = "มหานครใหญ่", $how_many = "14 ล้าน") ( พิมพ์ (" $เมือง

"); ) tour_guide(); tour_guide("Komarovo"); tour_guide("Komarovo", "หมู่บ้านเล็กๆ"); tour_guide("Komarovo", "หมู่บ้านเล็ก", "40");

หน้าต่างเบราว์เซอร์สร้างผลลัพธ์ที่คล้ายกับต่อไปนี้:

จำนวนตัวแปรของพารามิเตอร์เมื่อเรียกใช้ฟังก์ชัน

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

การใช้อาร์เรย์เพื่อแทนที่หลายพารามิเตอร์

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

ตัวอย่างวิธีการใช้วิธีนี้มีอยู่ในข้อมูลโค้ดต่อไปนี้ มันยังใช้โครงสร้างที่มีประโยชน์อื่นๆ อีกสองสามอย่าง เช่น ตัวดำเนินการ ternary และ associative array (หากคุณยังไม่คุ้นเคยกับอาร์เรย์ ขอแนะนำให้ข้ามตัวอย่างนี้ไปก่อน):

รหัส PHP ฟังก์ชัน tour_brochure($arr) ( $city = isset($arr["city"]) ? $arr["city"] : "Moscow"; $desc = isset($arr["desc"]) ? $arr[ "desc"] : "large urban"; $how_many = isset($arr["how_many"]) ? $arr["how_many"] : "14 ล้าน"; print(" $เมืองนี่คือ $desc ที่ $how_many คนอาศัยอยู่

"); ) // อาร์เรย์ว่างเปล่า tour_brochure(array()); // Array ที่มีค่า ​​$tour = array("city" => "Komarovo", "desc" => "small village", "how_many" = > 40 );tour_brochure($ทัวร์);

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

ใช้หลายตัวเลือก

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

func_num_args() ฟังก์ชั่น

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

func_get_arg() ฟังก์ชั่น

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

func_get_args() ฟังก์ชั่น

ไม่รับพารามิเตอร์และส่งกลับอาร์เรย์ที่มีพารามิเตอร์ทั้งหมดของฟังก์ชันที่เรียกใช้ ดัชนีของอาร์เรย์นี้เริ่มต้นจากศูนย์

ฟังก์ชันทั้งสามนี้สร้างข้อความเตือนเมื่อถูกเรียกนอกเนื้อหาของฟังก์ชัน และ func_get_arg() จะส่งข้อความเตือนเมื่อเรียกด้วยดัชนีที่มากกว่าดัชนีของพารามิเตอร์สุดท้ายที่ส่งผ่าน

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

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

รหัส PHP ฟังก์ชัน Sum() ( $sum = 0; for ($i = 0; $i< func_num_args(); $i++) { $sum += func_get_arg($i); } return $sum; } echo "5 + 120 + 8 = ".Sum(5, 120, 8); echo "
10 - 18 + 104 + 2 = ".Sum(10, -18, 104, 2);

ฟังก์ชัน Sum() ใช้ func_get_arg() เพื่อดึงพารามิเตอร์แต่ละตัวและจำกัดการวนซ้ำโดยใช้ผลลัพธ์ของ func_num_args() ดังนั้นจึงไม่มีการพยายามดึงพารามิเตอร์มากกว่าที่ส่งผ่านจริง

โทรตามมูลค่า

โดยค่าเริ่มต้น ฟังก์ชันที่ผู้ใช้กำหนดเองใน PHP ทำงานแบบ call-by-value ซึ่งหมายความว่าเมื่อส่งพารามิเตอร์ไปยังการเรียกใช้ฟังก์ชัน ตัวแปล PHP จะสร้างสำเนาของค่าของพารามิเตอร์เหล่านั้นเพื่อส่งต่อไปยังฟังก์ชัน ดังนั้นการกระทำใด ๆ ที่ดำเนินการในฟังก์ชันไม่อนุญาตให้เปลี่ยนค่าของพารามิเตอร์จริงที่มีอยู่ในการเรียกใช้ฟังก์ชัน

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

ความแตกต่างที่สำคัญที่สุดอย่างหนึ่งระหว่าง PHP5 และเวอร์ชันก่อนหน้าคือมันส่งผ่านอินสแตนซ์ของอ็อบเจ็กต์อย่างมีประสิทธิภาพโดยการอ้างอิงเสมอ แม้ว่าพารามิเตอร์ประเภทอื่นจะถูกส่งผ่านด้วยค่าก็ตาม นั่นเป็นเพราะว่าใน PHP5 ตัวแปรอ็อบเจ็กต์จะเก็บตัวจัดการให้กับอ็อบเจ็กต์ ไม่ใช่ตัวอ็อบเจ็กต์ ดังนั้นในโหมด pass-by-value ตัวจัดการเองจะถูกคัดลอกจริง ๆ ไม่ใช่อ็อบเจ็กต์พื้นฐาน (จะมีการอธิบายรายละเอียดเพิ่มเติมเกี่ยวกับปัญหานี้ ในส่วนของการเขียนโปรแกรมเชิงวัตถุใน PHP)

ด้านล่างนี้เป็นตัวอย่างของฟังก์ชันง่ายๆ ที่เพิ่มจำนวนที่ส่งไปในพารามิเตอร์ 10:

รหัส PHP \$หมายเลข= $number
"; function add10($a) ( $a += 10; echo "Call function add10() ... , ผลลัพธ์: $a
\$หมายเลข

ดังที่คุณเห็นจากภาพหน้าจอด้านล่าง การเรียกใช้ฟังก์ชันไม่ส่งผลต่อค่าของตัวแปร $number และยังคงเท่ากับ 20:

ส่งผ่านพารามิเตอร์ของฟังก์ชันตามค่า

โทรโดยอ้างอิง

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

หากคุณต้องการกำหนดฟังก์ชันที่ส่งผลกระทบโดยตรงต่อพารามิเตอร์ที่ส่งผ่าน ให้ใส่อักขระเครื่องหมายและข้างหน้าพารามิเตอร์ที่เป็นทางการในนิยามฟังก์ชัน ดังที่แสดงด้านล่าง:

รหัส PHP จำนวน $ = 20; echo "ในตอนแรก \$หมายเลข= $number
"; ฟังก์ชัน add10( &$a) ( $a += 10; echo "ฟังก์ชันการโทร add10() ... , ผลลัพธ์: $a
"; return $a; ) add10($number); echo "ค่า \$หมายเลขหลังจากเรียกใช้ฟังก์ชัน add10(): $number";

ตอนนี้ หลังจากการเรียกใช้ฟังก์ชันเหมือนกันทุกประการ ตัวแปร $number จะถูกเปลี่ยนเป็น 30:

การส่งพารามิเตอร์ฟังก์ชันโดยการอ้างอิง

ในกรณีนี้ พารามิเตอร์ที่เป็นทางการ $a อ้างถึงตัวแปร $number ดังนั้น การแก้ไขในฟังก์ชันจะนำไปสู่การเปลี่ยนแปลงของตัวแปร $number

ตั้งแต่ PHP4 การอ้างอิงตัวแปรสามารถใช้นอกการเรียกใช้ฟังก์ชันได้ โดยทั่วไป การกำหนดการอ้างอิงตัวแปรให้กับตัวแปร (เช่น &$varname) ทำให้ชื่อของตัวแปรทั้งสองกลายเป็นนามแฝงซึ่งกันและกัน แทนที่จะแยกตัวแปรด้วยค่าเดียวกัน พิจารณาตัวอย่าง:

รหัส PHP $name_1 = "อเล็กซานเดอร์"; $name_2 = "อิกอร์"; // ส่งตัวแปรตามค่า $alias_1 = $name_1; // ส่งตัวแปรโดยอ้างอิง $alias_2 = &$name_2; // การเปลี่ยนตัวแปร $alias_1 จะไม่เปลี่ยน $name_1 $alias_1 = "Dmitry"; echo "\$alias_1 = $alias_1, \$name_1 = $name_1

"; // การเปลี่ยนตัวแปร $alias_2 ทำให้เกิดการเปลี่ยนแปลงใน $name_2 // เนื่องจากพวกมันเชื่อมต่อกันผ่านลิงก์ $alias_2 = "Peter"; echo "\$alias_2 = $alias_2, \$name_2 = $name_2

";

ซึ่งส่งผลให้ผลลัพธ์ต่อไปนี้ในหน้าต่างเบราว์เซอร์:

ส่งผ่านตัวแปรโดยอ้างอิง

ตัวแปรเป็นฟังก์ชัน

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

ในแง่หนึ่ง สิ่งนี้ทำให้ฟังก์ชันต่างๆ สามารถใช้เป็นข้อมูลได้ เทคนิคนี้ควรจะคุ้นเคยกับโปรแกรมเมอร์ C ที่มีทักษะ และแม้กระทั่งผู้ใช้มือใหม่ของ Lisp บางรูปแบบ (เช่น Scheme หรือ Common Lisp) โดยเฉพาะอย่างยิ่ง การเรียกใช้ฟังก์ชันสองฟังก์ชันต่อไปนี้จะเทียบเท่ากันโดยสิ้นเชิง:

รหัส PHP ฟังก์ชั่น sum($a, $b) ( return $a + $b; ) echo sum(10, 15)"
"; // ส่งฟังก์ชันไปยังตัวแปรและเรียกมันว่า $var = "sum"; echo $var(12, 14);

เนื่องจากชื่อฟังก์ชันสามารถใช้เป็นสตริงได้ง่ายๆ จึงสามารถใช้เป็นพารามิเตอร์ของฟังก์ชันหรือส่งคืนเป็นผลลัพธ์ของฟังก์ชันได้

การประมวลผลแบบวนซ้ำ 1 2 3 4 5 6 7 8 9 10

เป็นต้น คุณต้องใช้ฟังก์ชัน wrapper ของคุณเองเพื่อให้โครงสร้างด้านบนทำงานกับฟังก์ชันตัวแปรได้

Beispiel #1 การทำงานกับฟังก์ชันผ่านตัวแปร

ฟังก์ชั่นfoo()(
echo "ใน foo()
\n" ;
}

แถบฟังก์ชัน ($arg = "")
{
เสียงก้อง "ใน bar(); อาร์กิวเมนต์คือ "$args "
\n" ;
}

// ฟังก์ชัน wrapper สำหรับ echo
ฟังก์ชัน echoit($string)
{
ก้อง $string ;
}

$func = "ฟู" ;
func(); // เรียกใช้ฟังก์ชัน foo()

$func = "แถบ" ;
$func("ทดสอบ"); // เรียกฟังก์ชัน bar()

$func = "เสียงสะท้อน" ;
$func("ทดสอบ"); // เรียกฟังก์ชัน echoit()
?>

คุณยังสามารถเรียกใช้เมธอดบนอ็อบเจ็กต์โดยใช้ฟังก์ชันตัวแปรของ PHP

Beispiel #2 การเข้าถึงวิธีการเรียนด้วยตัวแปร

คลาสฟู
{
ตัวแปรฟังก์ชัน ()
{
$name = "บาร์" ;
$นี้ -> $name(); // เรียกเมธอด Bar()
}

แถบฟังก์ชัน()
{
echo "นี่คือบาร์" ;
}
}

$foo = ใหม่ Foo();
$funcname = "ตัวแปร" ;
$foo -> $funcname(); // อ้างถึง $foo->Variable()

?>

เมื่อเรียกใช้เมธอดแบบสแตติก การเรียกใช้ฟังก์ชันจะ "แข็งแกร่ง" กว่าตัวดำเนินการเข้าถึงคุณสมบัติสแตติก:

Beispiel #3 ตัวอย่างการเรียกเมธอดตัวแปรที่มีคุณสมบัติสแตติก

คลาสฟู
{
คงที่ $variable = "คุณสมบัติคงที่";
ตัวแปรฟังก์ชันคงที่ ()
{
เสียงก้อง "การเรียกวิธีตัวแปร";
}
}

echo Foo :: $variable ; // สิ่งนี้จะส่งออก "คุณสมบัติคงที่" ตัวแปร $ จะแก้ไขขอบเขตที่ถูกต้อง
$variable = "ตัวแปร" ;
foo :: $variable(); // สิ่งนี้จะเรียก $foo->Variable() โดยการอ่าน $variable จากขอบเขตนี้

?>

ตั้งแต่ PHP 5.4.0 คุณสามารถโทร เรียกได้- ฟังก์ชั่นวางในตัวแปร

ตัวอย่าง #4 ฟังก์ชันที่เรียกได้

คลาสฟู
{
แถบฟังก์ชันคงที่ ()
{
echo "bar\n" ;
}
ฟังก์ชันเบส ()
{
echo "ฐาน\n" ;
}
}

$func = array("Foo" , "บาร์" );
func(); // พิมพ์ "บาร์"
$func = array(ใหม่ Foo , "baz" );
func(); // เอาต์พุต "baz"
$func = "Foo::bar" ;
func(); // พิมพ์ "bar" ใน PHP 7.0.0 ขึ้นไป; ในเวอร์ชันก่อนหน้านี้จะส่งผลให้เกิดข้อผิดพลาดร้ายแรง
?>

ดูสิ่งนี้ด้วย is_callable(), call_user_func(), ตัวแปรตัวแปรและ function_exists().

รายการการเปลี่ยนแปลง

8 ปีที่แล้ว

$wget
$ grep -l "\$\.\.\." php-chunked-xhtml/function.*.html

รายการฟังก์ชันที่ยอมรับอาร์กิวเมนต์ตัวแปร
array_diff_assoc()
array_diff_key()
array_diff_uassoc()
อาร์เรย์ ()
array_intersect_ukey()
array_map()
array_merge()
array_merge_recursive()
array_multisort()
array_push()
array_replace()
array_replace_recursive()
array_unshift()
call_user_func()
call_user_method()
กะทัดรัด()
dba_open()
dba_popen()
เสียงสะท้อน()
forward_static_call()
fprintf()
fscanf()
httprequestpool_construct()
ibase_execute()
ibase_set_event_handler()
ibase_wait_event()
isset()
รายการ()
maxdb_stmt_bind_param()
maxdb_stmt_bind_result()
mb_convert_variables()
newt_checkbox_tree_add_item()
newt_grid_h_close_stacked()
newt_grid_h_stacked()
newt_grid_v_close_stacked()
newt_grid_v_stacked()
newt_win_choice()
newt_win_entries()
newt_win_menu()
newt_win_message()
newt_win_ternary()
หีบห่อ()
พิมพ์f()
register_shutdown_function()
register_tick_function()
session_register()
setlocal()
sprintf()
sscanf()
ยกเลิกการตั้งค่า ()
var_dump()
w32api_deftype()
w32api_init_dtype()
w32api_invoke_function()
wddx_add_vars()
wddx_serialize_vars()
?>

3 ปีที่แล้ว

บันทึกย่อเล็ก ๆ แต่มีประโยชน์ หากคุณกำลังพยายามเรียกใช้ฟังก์ชันสแตติกจากเนมสเปซอื่น คุณต้องใช้เนมสเปซแบบเต็ม แม้ว่าจะมีเนมสเปซระดับบนสุดเหมือนกันก็ตาม ตัวอย่างเช่น หากคุณมีคลาสต่อไปนี้ที่จะโทร:

โครงการเนมสเปซ \ TestClass ;
การทดสอบระดับ (
ฟังก์ชั่นคงที่ funcToCall()(
ส่งคืน "ทดสอบ" ;
}
}
?>
คุณต้องเรียกมันว่า:
โครงการเนมสเปซ \ OtherTestClass ;
คลาส OtherTest(
$func = "\Project\TestClass::funcToCall";
func();
}
}
?>
และไม่:
คลาส OtherTest(
ฟังก์ชันคงที่ callOtherFunc()(
$func = "TestClass::funcToCall" ;
func();
}
}
?>

9 เดือนที่แล้ว

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

const DEBUGME="func";
func($s) ( echo $s. "\n"; )

DEBUGME("abc"); // ส่งผลให้เกิดข้อผิดพลาดทางไวยากรณ์

$โทร = DEBUGME;
$call("abc"); //ทำหน้าที่

แต่คุณสามารถใช้ค่าคงที่เป็นอาร์กิวเมนต์ของฟังก์ชันได้ นี่เป็นวิธีแก้ปัญหาง่ายๆ เมื่อคุณต้องการเรียกใช้ฟังก์ชันค่าคงที่ของตัวแปร:

ฟังก์ชั่นไดนามิก($อะไร, $กับ)
{
$อะไร($กับ);
}
ไดนามิก (DEBUGME, "abc");

สิ่งนี้สมเหตุสมผลสำหรับฉันที่จะซ่อนการเรียกสแตติกของ API และ/หรือแบบยาว (ซับซ้อน)
สนุก!

13 ปีที่แล้ว

หากคุณต้องการเรียกใช้ฟังก์ชันสแตติก (PHP5) ในเมธอดตัวแปร:

สร้างอาร์เรย์ของสองรายการที่รายการที่ 0 เป็นชื่อของคลาสที่จะเรียกใช้ ("ตัวเอง" และ "พาเรนต์" ทำงานด้วย) และรายการที่ 1 เป็นชื่อของฟังก์ชัน โดยทั่วไป ตัวแปร "callback" อาจเป็นสตริง (ชื่อของฟังก์ชัน) หรืออาร์เรย์ (0 => "className", 1 => "functionName")

จากนั้น หากต้องการเรียกใช้ฟังก์ชันนั้น คุณสามารถใช้ call_user_func() หรือ call_user_func_array() ตัวอย่าง:

คลาสเอ (

ป้องกัน $a ;
ป้องกัน $c ;

ฟังก์ชัน __construct()(
$this -> a = array("self" , "a" );
$this -> c = array("ตัวเอง" , "c" );
}

ฟังก์ชันคงที่ a ($name , & $value ) (
echo $name , " => " , $value ++, "\n" ;
}

ฟังก์ชัน b ($name , & $value ) (
call_user_func_array ($นี้ -> a , array($name , & $value ));
}

ฟังก์ชันคงที่ c ($str ) (
echo $str , "\n" ;
}

ฟังก์ชัน d () (
call_user_func_array ($นี้ -> c , func_get_args ());
}

ฟังก์ชัน e () (
call_user_func ($นี้ -> c , func_get_arg (0 ));
}

คลาส B ขยาย A (

ฟังก์ชัน __construct()(
$this -> a = array("พาเรนต์" , "a" );
$this -> c = array("ตัวเอง" , "c" );
}

ฟังก์ชันคงที่ c()(
print_r(func_get_args());
}

ฟังก์ชัน d () (
call_user_func_array ($นี้ -> c , func_get_args ());
}

ฟังก์ชัน e () (
call_user_func ($นี้ -> c , func_get_args ());
}

$a =& ใหม่ A ;
$b =& ใหม่ B ;
$i = 0 ;

A :: a("ดัชนี" , $i );
$a -> b("ดัชนี" , $i );

$a -> c("สตริง");
$a -> d("สตริง");
$a -> e("สตริง");

#ฯลฯ
?>

หมายเหตุ:เวอร์ชันที่ปรับเปลี่ยนได้ของไซต์จะเปิดใช้งาน ซึ่งจะปรับให้มีขนาดเล็กลงของเบราว์เซอร์ของคุณโดยอัตโนมัติและซ่อนรายละเอียดบางอย่างของไซต์เพื่อให้อ่านง่าย ดูมีความสุข!

สวัสดีผู้อ่านบล็อกที่รัก เว็บไซต์บน! ในเราได้เรียนรู้ว่ามีฟังก์ชันใน PHP เราเรียนรู้วิธีสร้างฟังก์ชันของเราเอง ส่งอาร์กิวเมนต์ไปยังฟังก์ชันเหล่านั้น และเรียกใช้เพื่อดำเนินการ ดำเนินธีมของฟังก์ชันใน PHP ต่อไป จำเป็นต้องเน้นสิ่งต่อไปนี้:

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

ฟังก์ชันตามเงื่อนไข

เราสามารถสร้าง (กำหนด อธิบาย) ฟังก์ชั่นได้ ขึ้นอยู่กับเงื่อนไข ตัวอย่างเช่น:

//เรียกฟังก์ชัน sayHi เรียกได้ทุกที่ /*ไม่สามารถเรียกฟังก์ชัน sayGoodbye ได้ที่นี่ เนื่องจากเรายังไม่ได้ตรวจสอบเงื่อนไขและยังไม่ได้เข้าไปใน if construct*/ if($apply)( ฟังก์ชั่น sayGoodbye()( echo "ลาก่อนทุกคน!
"; } } /*ตอนนี้เราสามารถโทรบอกลาได้แล้ว*/
"; }

ผลลัพธ์:

และดูตัวอย่างนี้:

/*และนี่คือสิ่งที่จะเกิดขึ้นถ้าคุณโทรบอกลาที่นี่*/กล่าวลา(); if($apply)( ฟังก์ชั่น sayGoodbye()( echo "ลาก่อนทุกคน!
"; ) ) ฟังก์ชัน sayHi()( echo "สวัสดีทุกคน!
"; }

ผลลัพธ์:

อันที่จริง เท่าที่ฉันทำงาน ฉันไม่เคยเห็นสิ่งนี้ที่ไหนมาก่อน แต่คุณต้องคำนึงถึงความเป็นไปได้ทั้งหมดของภาษา

ฟังก์ชั่นที่ซ้อนกัน

ฟังก์ชันที่ซ้อนกันคือฟังก์ชันที่ประกาศไว้ภายในฟังก์ชันอื่น ตัวอย่าง:

/*คุณไม่สามารถโทรบอกลาที่นี่ได้ เนื่องจากจะปรากฏหลังจากเรียกใช้ฟังก์ชัน sayHi เท่านั้น*/สวัสดี(); /*เรียกใช้ฟังก์ชัน sayHi เรียกได้ทุกที่*/ /*ตอนนี้เราสามารถโทรบอกลาได้แล้ว*/กล่าวลา(); ฟังก์ชั่น sayHi()( echo "สวัสดีทุกคน!
"; function sayGoodbye()( echo "ลาก่อนทุกคน!
"; } }

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

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

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

ใน PHP เทคนิคต่างๆ ที่อธิบายข้างต้นนั้นไม่ค่อยได้ใช้มากนัก พวกมันสามารถเห็นได้บ่อยขึ้น เช่น ใน JavaScript

ขอบเขตตัวแปร

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

ฟังก์ชันใน PHP มีขอบเขตภายใน (ภายในเครื่อง) ของตัวเอง นั่นคือ ตัวแปรทั้งหมดภายในฟังก์ชันจะมองเห็นได้เฉพาะภายในฟังก์ชันนี้เท่านั้น

ดังนั้น อีกครั้ง ทุกอย่างที่อยู่นอกฟังก์ชันคือขอบเขตส่วนกลาง ทุกอย่างที่อยู่ภายในฟังก์ชันคือขอบเขตในเครื่อง ตัวอย่าง:

เรียนผู้เชี่ยวชาญ ความสนใจ คำถาม! คำสั่งสุดท้ายจะส่งออกอะไร ก้อง $name; ?

อย่างที่คุณเห็นเอง เรามี 2 ตัวแปร $nameหนึ่งภายในฟังก์ชัน (ขอบเขตท้องถิ่น) อีกอันอยู่ในโค้ด (ขอบเขตสากล) การกำหนดครั้งสุดท้ายให้กับตัวแปร $nameมันเป็น $name = "รุด เซอร์เกย์";แต่เนื่องจากมันอยู่ในฟังก์ชัน มันจึงอยู่ที่นั่น ในขอบเขตทั่วโลก งานสุดท้ายคือ $name = "อันเดรย์";สิ่งที่เราเห็นจริงเป็นผล

นั่นคือตัวแปรที่เหมือนกันสองตัว แต่ในขอบเขตที่ต่างกันจะไม่ตัดกัน แต่อย่างใด และไม่ส่งผลกระทบซึ่งกันและกัน

ให้ฉันแสดงขอบเขตในรูป:

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

การเข้าถึงตัวแปรโกลบอลจากขอบเขตโลคัล

แต่ถ้าเรายังจำเป็นต้องเข้าถึงตัวแปร $name เดิมจากขอบเขตส่วนกลางจากฟังก์ชัน ไม่ใช่แค่เข้าถึงแต่ต้องเปลี่ยน มี 3 ตัวเลือกหลักสำหรับสิ่งนี้ อันแรกคือการใช้คีย์เวิร์ด ทั่วโลก:

"; ชื่อ $ สากล; /*จากนี้ไปเราหมายถึงตัวแปรโกลบอล $name*/$name = "รุด เซอร์เกย์"; ) $name = "อันเดรย์"; พูดสวัสดี($name); ก้อง $name; // ?

ผลลัพธ์:

แต่วิธีนี้มีค่าลบ เนื่องจากเราเปลี่ยนเป็นตัวแปรโกลบอล $nameเราได้สูญเสีย (เขียนทับ) ตัวแปรท้องถิ่น $name.

วิธีที่สองคือการใช้ PHP superglobal array. ในอาร์เรย์นี้ PHP เองจะใส่ทุกตัวแปรที่เราสร้างขึ้นในขอบเขตส่วนกลางโดยอัตโนมัติ ตัวอย่าง:

$name = "อันเดรย์"; //เหมือนกับ$GLOBALS["name"] = "อันเดรย์";

เพราะเหตุนี้:

"; $GLOBALS["name"] = "Rud Sergey"; ) $name = "Andrey"; sayHi($name); echo $name; // ?

ผลลัพธ์จะเหมือนกับเมื่อใช้คำสำคัญ ทั่วโลก:

ครั้งนี้เท่านั้นที่เราไม่ได้เขียนทับตัวแปรโลคัล นั่นคือ variable $nameภายในฟังก์ชันยังคงเหมือนเดิมและเท่ากับ "แอนดรูว์", แต่ไม่ "รุด เซอร์เกย์".

ส่งผ่านอาร์กิวเมนต์โดยการอ้างอิง

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

ดังนั้น วิธีที่ถูกต้องในการส่งอาร์กิวเมนต์โดยการอ้างอิงใน PHP 5.3 ขึ้นไปมีดังนี้:

ฟังก์ชั่น sayHi(& $name)(

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

และด้วยเหตุนี้เราจึงมี:

//เราไม่ยอมรับค่า แต่เป็นการอ้างอิงถึงค่า echo "สวัสดี ".$name."!
"; $name = "Rud Sergey"; ) $name = "Andrey"; sayHi($name); echo $name; // ?

ผลลัพธ์:

ตัวแปรคงที่

ลองนึกภาพสถานการณ์ต่อไปนี้: เราต้องนับจำนวนครั้งที่เราทักทายทั้งหมด นี่คือสิ่งที่เรากำลังพยายามทำ:

"; $c++; // เพิ่มตัวนับ 1

---

ผลลัพธ์:

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

// เคาน์เตอร์ทำให้คงที่ echo "สวัสดี ".$name."!
"; $c++; // เพิ่มตัวนับ 1 echo "สวัสดีทั้งหมด" . $c . " ครั้งหนึ่ง.

---

"; ) sayHi("Rud Sergey"); sayHi("Andrey"); sayHi("Dmitry");

ผลลัพธ์:

ส่งกลับค่า

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

ผลลัพธ์:

มาทำให้แทนที่จะแสดงบนหน้าจอ มันคืนค่าผลลัพธ์ของการดำเนินการ คีย์เวิร์ด return ใช้สำหรับสิ่งนี้:

ผลลัพธ์:

ตอนนี้เราสามารถใช้มันได้หลายวิธี:

//พิมพ์ผลลัพธ์เสียงสะท้อน "
"; $num = getSquare(5); เสียงสะท้อน $num;

ผลลัพธ์:

ฉันดึงความสนใจของคุณไปที่ความจริงที่ว่าคำสำคัญ กลับไม่เพียงแค่คืนค่า แต่ขัดจังหวะฟังก์ชันอย่างสมบูรณ์ นั่นคือโค้ดทั้งหมดที่อยู่ต่ำกว่าคีย์เวิร์ด กลับไม่เคยได้รับการเติมเต็ม กล่าวอีกนัยหนึ่ง return for functions ก็ใช้งานได้เช่น หยุดพักสำหรับรอบ:

echo "PHP จะไม่ส่งถึงฉัน :(";) echo getSquare(5); //พิมพ์ผลลัพธ์เสียงสะท้อน "
"; $num = getSquare(5); // กำหนดผลลัพธ์ให้กับตัวแปรเสียงสะท้อน $num; // แสดงตัวแปรบนหน้าจอ

ผลลัพธ์:

นั่นคือ กลับเป็นการออกจากฟังก์ชันด้วย สามารถใช้ได้โดยไม่มีค่าส่งคืน เพียงเพื่อประโยชน์ในการออก

ฟังก์ชันแบบเรียกซ้ำ

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

"; if($จำนวน< 20){ // เพื่อให้การเรียกซ้ำไม่สิ้นสุด countPlease(++$จำนวน); // ฟังก์ชัน countPlease เรียกตัวเองว่า) นับกรุณา(1);

ผลลัพธ์:

หากคุณรู้วิธีการทำโดยไม่เรียกซ้ำ ก็ควรทำเช่นนั้น

พิมพ์ PHP ได้ดี (คุณสมบัติประเภท)

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

ผลลัพธ์:

ข้อผิดพลาดร้ายแรงที่ตรวจจับได้: อาร์กิวเมนต์ 1 ส่งผ่านไปยัง countPlease() ต้องเป็นอาร์เรย์ ระบุจำนวนเต็ม เรียกใน /home/index.php ในบรรทัดที่ 7 และกำหนดใน /home/index.php ในบรรทัดที่ 3

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

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

เรียกว่าฟังก์ชันgetEcho

การใช้อาร์กิวเมนต์ความยาวตัวแปร

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

ผลลัพธ์:

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

func_num_args()- ส่งกลับจำนวนอาร์กิวเมนต์ที่ส่งผ่านไปยังฟังก์ชัน
func_get_arg (หมายเลขลำดับ)- ส่งกลับองค์ประกอบจากรายการอาร์กิวเมนต์
func_get_args()- ส่งกลับอาร์เรย์ที่มีอาร์กิวเมนต์ของฟังก์ชัน

"; echo func_get_arg(0) ; ) $age = 22; getEcho("Rud Sergey", $age);

ผลลัพธ์:

บทสรุป

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

หากมีคนต้องการลงมือทำแต่ไม่รู้ว่าต้องทำอย่างไร วิธีที่ดีที่สุดคือการเขียนฟังก์ชัน PHP สำเร็จรูป (ในตัว) ตัวอย่างเช่น คุณสามารถเขียนฟังก์ชัน count() ของคุณเองหรืออะไรก็ได้ อื่นๆ.

ขอบคุณทุกท่านที่ให้ความสนใจ แล้วพบกันใหม่! หากมีบางอย่างไม่ชัดเจน อย่าลังเลที่จะถามคำถามของคุณในความคิดเห็น!

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

มาเขียนตัวอย่างของฟังก์ชันพื้นฐานที่พิมพ์ง่ายๆ กัน " สวัสดีชาวโลก":

ฟังก์ชัน printHello() (
echo "สวัสดีชาวโลก";
}
พิมพ์สวัสดี ();
?>

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

ฟังก์ชัน printHello($str) (
เสียงสะท้อน $str;
}
printHello("สวัสดีชาวโลก!!!");
?>

ที่นี่เราได้สร้างฟังก์ชัน แต่มีพารามิเตอร์ จากนั้นเราแสดงค่าของพารามิเตอร์นี้ผ่าน เสียงก้อง. ตกงาน พิมพ์สวัสดี ()เราเรียกมันและส่งสตริง " สวัสดีชาวโลก!!!" อย่างที่คุณเห็น ทุกอย่างเรียบง่ายที่นี่

และสิ่งสุดท้ายที่ฉันต้องการจะพูดคือเกี่ยวกับพารามิเตอร์เริ่มต้นที่อนุญาต สร้างฟังก์ชันด้วยตัวแปรจำนวนตัวแปร. ฉันเสนอให้แก้ปัญหาต่อไปนี้: สร้างฟังก์ชันที่จะใช้อาร์เรย์เป็นพารามิเตอร์แรก และตัวแปรบูลีนเป็นพารามิเตอร์ที่สอง ( จริงหรือ เท็จ) ซึ่งค่าเริ่มต้นจะเป็น เท็จ:

ฟังก์ชัน printArray ($arr, $bool = false) (
$str = "";
สำหรับ ($i = 0; $i< count($arr); $i++)
$str .= "องค์ประกอบ $i = $arr[$i]
";
ถ้า ($bool) ส่งคืน $str;
เสียงสะท้อน $str;
}
$a = อาร์เรย์ (15, 12, 13, 14);
printArray($a);
$str = printArray($a, จริง);
เสียงสะท้อน $str;
?>

ความหมายมีดังนี้ งานของฟังก์ชันคือสร้างสตริงจากอาร์เรย์ กล่าวคือ เพียงเปลี่ยนอาร์เรย์เป็นประเภทสตริง ในตัวอย่างนี้ สิ่งที่น่าสนใจที่สุดคือพารามิเตอร์ boolซึ่งมีค่าเริ่มต้น ถ้าหล่อน เท็จ(ตามค่าเริ่มต้น นั่นคือ หากไม่มีการระบุค่าอื่นไว้) ระบบจะพิมพ์บรรทัดในเบราว์เซอร์ทันที และหากส่งผ่าน จริง(เช่นเดียวกับในการเรียกใช้ฟังก์ชันที่สอง) จากนั้นสตริงจะถูกส่งกลับ ( ส่งคืน $str) การทำงาน. นี่เป็นตัวอย่างง่ายๆสำหรับ การสร้างฟังก์ชันด้วยพารามิเตอร์เริ่มต้น.