ใช้ PEAR เพื่อเขียนโปรแกรม PHP ของคุณ

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

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

กฎการเยื้อง:
PEAR ต้องใช้ช่องว่าง 4 ช่องเพื่อเยื้องโค้ด และไม่มีการใช้ TAB หากคุณใช้ VIM ให้ใส่การตั้งค่าต่อไปนี้ใน ~/.vimrc: set expandtab
ตั้งค่าความกว้างกะ=4
ตั้งค่าแท็บสต็อป=4
หากคุณใช้ Emacs/XEmacs คุณจะต้องตั้งค่า indent-tabs-mode เป็น nil

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

โครงสร้างการควบคุม:
โครงสร้างการควบคุมที่กล่าวถึงในที่นี้ได้แก่: ถ้าเป็น while switch เป็นต้น สำหรับโครงสร้างการควบคุม ควรมีช่องว่างหลังคีย์เวิร์ด (เช่น if สำหรับ ..) แล้วตามด้วยวงเล็บควบคุม เพื่อไม่ให้สับสนกับการเรียกใช้ฟังก์ชัน นอกจากนี้ คุณควรลองใช้วงเล็บปีกกา {} ให้ครบถ้วนที่สุด แม้ว่าจะเป็นทางเลือกทางวากยสัมพันธ์ก็ตาม วิธีนี้จะป้องกันความสับสนหรือข้อผิดพลาดเชิงตรรกะเมื่อคุณต้องการเพิ่มบรรทัดโค้ดใหม่ในอนาคต นี่คือตัวอย่าง: if ((condition1) && (condition2)) {
คำชี้แจง 1;
}esleif ((เงื่อนไข 3) || (เงื่อนไข 4)) {
คำชี้แจง 2;
}อื่น {
คำชี้แจง 3;
-

การเรียกใช้ฟังก์ชัน:
สำหรับการเรียกใช้ฟังก์ชัน ไม่ควรมีช่องว่างระหว่างชื่อฟังก์ชันและวงเล็บเปิด ( () สำหรับพารามิเตอร์ฟังก์ชัน ควรมีการแยกช่องว่างเดียวกันระหว่างเครื่องหมายจุลภาคคั่นและพารามิเตอร์ถัดไป และไม่ควรมีช่องว่างระหว่างเครื่องหมายสุดท้าย พารามิเตอร์และวงเล็บปิด ด้านล่างเป็นการเรียกใช้ฟังก์ชันมาตรฐาน $result = foo($param1, $param2, $param3);
การเขียนที่ผิดปกติ:
$result=foo ($param1,$param2,$param3);
$result=foo( $param1,$param2, $param3 );

นอกจากนี้ หากคุณต้องการกำหนดผลลัพธ์ที่ส่งคืนของฟังก์ชัน จะต้องมีช่องว่างระหว่างเครื่องหมายเท่ากับและตัวแปรที่กำหนด ในเวลาเดียวกัน หากเป็นชุดคำสั่งที่เกี่ยวข้องกัน คุณจะต้องเพิ่มช่องว่างที่เหมาะสมเพื่อจัดแนว พวกเขาเช่นนี้ ：$result1 = $foo($param1, $param2, $param3);
$var2 = $foo($param3);
$var3 = $foo($param4, $param5);

คำจำกัดความของฟังก์ชัน:
คำจำกัดความของฟังก์ชันเป็นไปตามแบบแผน "หนึ่งวงเล็บปีกกาจริง": function Connect(&$dsn, $persistent = false){
ถ้า (is_array($dsn)) {
$dsninfo = &&dsn;
} อื่น {
$dsninfo = DB::parseDSN($dsn);
-
ถ้า (!$dsninfo || !$dsninfo['phptype']) {
ส่งคืน $this->raiseError();
-
กลับเป็นจริง;
-
ดังที่แสดงไว้ข้างต้น พารามิเตอร์ทางเลือกควรอยู่ท้ายรายการพารามิเตอร์ และพยายามส่งคืนค่าฟังก์ชันที่มีความหมายเสมอ

เกี่ยวกับความคิดเห็น:
สำหรับเอกสารประกอบคลาสออนไลน์ ควรแปลงได้โดย PHPDoc เช่นเดียวกับ JavaDoc PHPDoc ยังเป็นแอปพลิเคชัน PEAR สำหรับรายละเอียดเพิ่มเติม คุณสามารถไปที่ http://www.phpdoc.de/ เพื่อดู นอกเหนือจากเอกสารประกอบการเรียนออนไลน์แล้ว ขอแนะนำให้คุณใช้ความคิดเห็นที่ไม่ใช่เอกสารประกอบเพื่ออธิบายโค้ดของคุณ เมื่อคุณเห็นโค้ด คุณจะคิดว่า: โอ้ ฉันไม่คิดว่าคุณจำเป็นต้องอธิบายมันอย่างละเอียดในเอกสารประกอบ . ถ้าอย่างนั้น คุณควรให้ความคิดเห็นง่ายๆ กับโค้ดนี้เพื่อป้องกันไม่ให้คุณลืมวิธีการทำงาน สำหรับแบบฟอร์มแสดงความคิดเห็น C's /* */ และ C++'s // อย่างไรก็ตาม อย่าใช้วิธี # comment ของ Perl หรือเชลล์

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

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

ประกาศความคิดเห็นในส่วนหัวของไฟล์:
สำหรับไฟล์โค้ด PHP ทั้งหมดที่ต้องรวมอยู่ใน PEAR core release คุณต้องเพิ่มคำสั่งความคิดเห็นต่อไปนี้ที่จุดเริ่มต้นของไฟล์: /* vim: set expandtab tabstop=4 shiftwidth=4: */
// +-------------------------------------------------- --- ----------------------+
// |. PHP เวอร์ชัน 4.0 |
// +-------------------------------------------------- --- ----------------------+
// |. ลิขสิทธิ์ (c) 1997, 1998, 1999, 2000, 2001 PHP Group |
// +-------------------------------------------------- --- ----------------------+
// | ไฟล์ต้นฉบับนี้อยู่ภายใต้ใบอนุญาต PHP เวอร์ชัน 2.0, |
// | ที่มาพร้อมกับแพ็คเกจนี้ในไฟล์ LICENSE และคือ |
// | สามารถดูได้ที่ |
// |. http://www.php.net/license/2_02.txt |
// | หากคุณไม่ได้รับสำเนาใบอนุญาต PHP และไม่สามารถ |
// |. รับได้ทางเวิลด์ไวด์เว็บ, กรุณาส่งบันทึกไปที่ |
// |[email protected] เพื่อให้เราสามารถส่งสำเนาให้คุณทางไปรษณีย์ได้ทันที
// +-------------------------------------------------- --- ----------------------+
// |. ผู้แต่ง: ผู้แต่งต้นฉบับ |
// |. ชื่อของคุณ |
// +-------------------------------------------------- --- ----------------------+
-
// $รหัส$
สำหรับไฟล์ที่ไม่ได้อยู่ในฐานโค้ดหลัก PEAR ขอแนะนำให้คุณมีบล็อกความคิดเห็นที่คล้ายกันเช่นนี้ที่ตอนต้นของไฟล์ ซึ่งระบุถึงลิขสิทธิ์ ใบอนุญาต ผู้แต่ง ฯลฯ ในเวลาเดียวกัน ให้เพิ่ม MODELINE ของ VIM ในบรรทัดแรก เพื่อให้สามารถรักษารูปแบบโค้ดของ PEAR ไว้ใน VIM ได้

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

ตัวอย่าง URL:
คุณสามารถปฏิบัติตาม RFC 2606 และใช้ " www.example.com " เป็นตัวอย่าง URL ทั้งหมด

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

เริ่มต้นกับ PEAR

การใช้ PEAR นั้นง่ายมาก คุณเพียงแค่ต้องกำหนดโปรแกรม PEAR ของคุณเองดังนี้: need_once "PEAR.php";
คลาส your_class_name ขยาย PEAR {
คำจำกัดความของชั้นเรียนของคุณ...
-

แน่นอนว่าคุณต้องปฏิบัติตามกฎการเขียนโค้ด PEAR ที่กล่าวถึงข้างต้น จากนั้นคุณจึงจะสามารถนำสิ่งที่คุณต้องการทำไปใช้ในชั้นเรียนได้ ต่อไป เราจะมาหารือกัน ในความเป็นจริง PEAR มีคลาสที่กำหนดไว้ล่วงหน้า 2 คลาส: PEAR: นี่คือคลาสพื้นฐานของ PEAR และส่วนขยาย PEAR ทั้งหมดจะต้องสืบทอดและสืบทอดจากคลาสนั้น PEAR_Error: คลาสฐานการจัดการข้อผิดพลาดของ PEAR คุณสามารถเลือกรับคลาสการจัดการข้อผิดพลาดของคุณเองได้

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

ตัวทำลาย

PHP รองรับคอนสตรัคเตอร์ แต่ไม่รองรับ destructors อย่างไรก็ตาม PHP มีฟังก์ชัน register_shutdown_function() ซึ่งสามารถเรียกกลับฟังก์ชันที่ลงทะเบียนไว้ก่อนที่สคริปต์จะสิ้นสุดลง ดังนั้น PEAR จึงใช้ประโยชน์จากฟีเจอร์นี้เพื่อสร้างการจำลองของ destructor หากคุณมีคลาสย่อยของ PEAR ที่เรียกว่า mypear ดังนั้นในคลาส mypear คุณสามารถกำหนดฟังก์ชันได้ ชื่อฟังก์ชันจะเป็นเครื่องหมายขีดล่างบวกกับชื่อคลาสของคุณ _mypear() ฟังก์ชันนี้คือตัวทำลายของคลาสนี้ อย่างไรก็ตาม destructor นี้แตกต่างจาก destructor ใน C ++ มันจะไม่ถูกดำเนินการเมื่อวัตถุถูกลบ แต่เมื่อสคริปต์สิ้นสุดลง ท้ายที่สุดแล้ว นี่เป็นเพียงการจำลอง เนื่องจากมีการใช้ register_shutdown_function() ข้อมูลที่พิมพ์ออกมาจะไม่ถูกส่งกลับไปยังเบราว์เซอร์ในตัวทำลายของคุณ นอกจากนี้ ใน Constructor ของคุณ คุณต้องเรียก Constructor ของคลาสพาเรนต์ เนื่องจาก PHP จะไม่เรียก Constructor ของคลาสพาเรนต์โดยอัตโนมัติ และ Destructor จำเป็นต้องลงทะเบียนใน Constructor ของ PEAR เรามาดูกัน PEAR ซอร์สโค้ด: ฟังก์ชัน PEAR() {
ถ้า (method_exists($this, "_".get_class($this))) {
ทั่วโลก $_PEAR_destructor_object_list;
$_PEAR_destructor_object_list[] = &นี่;
-
ถ้า ($ นี้ -> _debug) {
printf("เรียกตัวสร้าง PEAR, class=%sn",
get_class($นี้));
-
-
ฟังก์ชั่น _PEAR_call_destructors() {
ทั่วโลก $_PEAR_destructor_object_list;
ถ้า (is_array($_PEAR_destructor_object_list) && ขนาดของ($_PEAR_destructor_object_list)) {
รีเซ็ต($_PEAR_destructor_object_list);
ในขณะที่ (รายการ($k, $objref) = แต่ละ($_PEAR_destructor_object_list)) {
$destructor = "_".get_class($objref);
ถ้า (method_exists($objref, $destructor)) {
$objref->$destructor();
-
-
//ล้างรายการวัตถุที่ลงทะเบียน
//ป้องกันการโทรซ้ำ
$_PEAR_destructor_object_list = array();
-
-
register_shutdown_function("_PEAR_call_destructors");

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

ในบรรทัดสุดท้ายของโค้ดใน PEAR.php ให้เรียก register_shutdown_function("_PEAR_call_destructors") เพื่อลงทะเบียน _PEAR_call_destructors เพื่อที่เมื่อสคริปต์ถูกเรียกใช้งาน PHP จะเรียกฟังก์ชันนี้กลับมา เมื่อใช้ destructor คุณสามารถทำงาน "aftercare" ที่จำเป็นก่อนออกหลังจากประมวลผลคำขอของผู้ใช้ ตัวอย่างทั่วไปคือคุณสามารถปิดไฟล์ที่เปิดอยู่ ยกเลิกการเชื่อมต่อจากฐานข้อมูล และจัดเก็บข้อมูลบางอย่างไว้ในดิสก์ เป็นต้น

การจัดการข้อผิดพลาด
PEAR ช่วยให้คุณสามารถจัดการกับข้อผิดพลาดได้หลายวิธี คุณไม่เพียงแต่ส่งคืนรหัสข้อผิดพลาดหรือข้อมูลข้อผิดพลาดเท่านั้น แต่คุณยังสามารถส่งคืนวัตถุ PEAR_Error หรือวัตถุข้อผิดพลาดใหม่ที่ได้มาจาก PEAR_Error

ออบเจ็กต์ข้อผิดพลาดใน PEAR ไม่ได้จำกัดรูปแบบเอาต์พุตเฉพาะ มันสามารถจับข้อผิดพลาดได้โดยไม่ต้องส่งคืนข้อมูลมากเกินไปให้กับผู้ใช้ หรือสามารถเรียกฟังก์ชันการจัดการข้อผิดพลาดพิเศษกลับคืนมาได้ แม้ว่าจะส่งออกข้อมูลข้อผิดพลาดก็ตาม คุณถูกบังคับให้ใช้รูปแบบ HTML คุณสามารถส่งออกรูปแบบ XML, CSV หรือรูปแบบอื่น ๆ ที่กำหนดด้วยตัวเอง คุณจะต้องได้รับคลาสใหม่จาก PEAR_Error จากนั้นสร้างและ "โยน" คลาสใหม่นี้ที่ เวลาที่เหมาะสม

การจัดการข้อผิดพลาดอย่างง่าย:
ใน PEAR การจัดการข้อผิดพลาดที่ง่ายที่สุดคือการ "โยน" ข้อผิดพลาด คุณเพียงแค่สร้างและส่งกลับวัตถุ PEAR_Error นี่คือตัวอย่างง่ายๆ: function myconnect($host = "localhost", $port = 1080){
$fp = fsockopen($host, $port, $errno, $errstr);
ถ้า (!is_resource($fp)) {
ส่งคืน PEAR_Error ใหม่ ($errstr, $errno);
-
กลับ $fp;
-
$sock = เชื่อมต่อของฉัน();
ถ้า (ลูกแพร์ :: isError ($ ถุงเท้า)) {
พิมพ์ "ข้อผิดพลาดในการเชื่อมต่อ: ".$sock->getMessage()"n"
-
ดังที่แสดงในโค้ดด้านบน หลังจากรันโค้ดบางส่วนที่อาจก่อให้เกิดข้อผิดพลาด คุณต้องใช้ isError ของ PEAR เพื่อตรวจสอบว่ามีข้อผิดพลาดหรือไม่ และคุณสามารถใช้ getMessage ของ PEAR_Error เพื่อรับข้อความแสดงข้อผิดพลาดล่าสุด

และ RaiseError

ในจุดสำคัญ

หลังจาก PHP4.0.5 แล้ว PEAR มี 2 ฟังก์ชันเพิ่มเติม:
setErrorHandling($mode, $options = null)
RaiseError($message = null, $code = null, $mode = null,$options = null, $userinfo = null)
แบบแรกสามารถตั้งค่าโหมดการจัดการข้อผิดพลาดเริ่มต้นของ PEAR และแบบหลังเป็นฟังก์ชัน wrapper ที่ส่งคืนออบเจ็กต์ PEAR_Error ซึ่งจะแตกต่างเล็กน้อยจากการสร้างและส่งคืนออบเจ็กต์ PEAR_Error โดยตรง หากละเว้นพารามิเตอร์ เช่น $mode และ $options สร้างวัตถุ PEAR_Error นี้โดยใช้ค่าเริ่มต้น ซึ่งคุณสามารถปรับแต่งได้โดยใช้ setErrorHandling()

PEAR_ข้อผิดพลาด
PEAR_Error เป็นคลาสพื้นฐานของอ็อบเจ็กต์ข้อผิดพลาดของ PEAR โดยทั่วไปแล้ว คุณสามารถสร้างอินสแตนซ์ของ PEAR_Error ได้โดยตรง วิธีการสร้างคือ: $error = new PEAR_Error($message, $code, $mode, $options, $ userinfo );

$message คือข้อความแสดงข้อผิดพลาดของคุณ $code คือหมายเลขข้อผิดพลาดของข้อผิดพลาด และพารามิเตอร์สามตัวสุดท้ายมีความสัมพันธ์กันอย่างใกล้ชิด:
$mode: เป็นโหมดการจัดการข้อผิดพลาด ซึ่งสามารถเป็นค่าคงที่ต่อไปนี้:
PEAR_ERROR_RETURN: ส่งคืนเฉพาะวัตถุข้อผิดพลาด (โหมดเริ่มต้น)
PEAR_ERROR_PRINT: พิมพ์ข้อความแสดงข้อผิดพลาดนี้ในฟังก์ชัน build แต่โปรแกรมปัจจุบันจะยังคงทำงานต่อไป
PEAR_ERROR_TRIGGER: ใช้ trigger_error() ของ PHP เพื่อทริกเกอร์ข้อผิดพลาด หากคุณได้ตั้งค่าฟังก์ชันการจัดการข้อผิดพลาด หรือคุณตั้งค่าระดับการจัดการข้อผิดพลาดของ PHP เป็น E_USER_ERROR โปรแกรมปัจจุบันจะถูกยกเลิก
PEAR_ERROR_DIE: พิมพ์ข้อผิดพลาดแล้วออก โปรแกรมจะหยุดทำงาน
PEAR_ERROR_CALLBACK: ใช้ฟังก์ชันหรือวิธีการโทรกลับเพื่อจัดการกับข้อผิดพลาดปัจจุบันและโปรแกรมจะหยุดทำงาน
$options: พารามิเตอร์นี้ใช้งานได้เฉพาะเมื่อ $mode คือ PEAR_ERROR_TRIGGER และ PEAR_ERROR_CALLBACK หากเป็น PEAR_ERROR_TRIGGER $options จะต้องเป็นหนึ่งในสามค่าคงที่ E_USER_NOTICE, E_USER_WARNING หรือ E_USER_ERROR ซึ่งสอดคล้องกับค่าของ trigger_error ใน PHP ถ้า $mode เป็น PEAR_ERROR_CALLBACK $options อาจเป็นสตริงที่มีชื่อของฟังก์ชันที่จะเรียกกลับ หรืออาร์เรย์ที่มี 2 องค์ประกอบ ตามลำดับคือตัวแปรอ็อบเจ็กต์และสตริง (ระบุวิธีการที่จะเรียก)
$userinfo: เก็บข้อมูลผู้ใช้เพิ่มเติม คุณสามารถใส่ข้อมูลการดีบักที่เกี่ยวข้องได้ที่นี่

มีวิธีการบางอย่างที่ใช้กันทั่วไปใน PEAR_Error ซึ่งไม่ได้อธิบายไว้ในเอกสารประกอบ PHP โดยแสดงไว้ที่นี่:

int getMode: ส่งคืนโหมดการจัดการข้อผิดพลาดปัจจุบัน จำนวนเต็ม
string getMessage: ส่งกลับข้อความแสดงข้อผิดพลาดปัจจุบันที่สมบูรณ์ สตริง
mix getCallback: ส่งคืนข้อมูลการโทรกลับปัจจุบัน ซึ่งอาจเป็นชื่อของฟังก์ชันที่ถูกเรียกกลับ หรืออาร์เรย์ของ (อ็อบเจ็กต์ วิธีการ)
int getCode: ส่งกลับรหัสข้อผิดพลาดจำนวนเต็ม
string getType: ส่งคืนประเภทที่ไม่ถูกต้องซึ่งเป็นชื่อคลาสปัจจุบัน สตริง
string getUserInfo: ส่งคืนข้อมูลผู้ใช้เพิ่มเติม สตริง
string getDebugInfo: เนื้อหาเหมือนกับด้านบน
string toString: ส่งกลับคำอธิบายสตริงโดยละเอียดของออบเจ็กต์ปัจจุบัน รวมถึงโหมดการจัดการข้อผิดพลาด ระดับ ข้อมูลข้อผิดพลาด รหัสข้อผิดพลาด ฟังก์ชันติดต่อกลับที่เกี่ยวข้อง ฯลฯ

สรุป

การแนะนำ PEAR สิ้นสุดลงแล้ว โดยสรุป หากคุณต้องการสร้างแอปพลิเคชันส่วนขยาย PEAR คุณต้องทำดังนี้:

need_once "PEAR.php"
ใช้คลาส your_pear_extend ขยาย PEAR{} เพื่อกำหนดคลาสใหม่ของคุณ
ใน Constructor ของคลาสของคุณ ให้เรียก Constructor ของคลาสพาเรนต์ PEAR: function your_pear_extend{
$นี่->ลูกแพร์();
-
}

หากจำเป็น ให้กำหนด destructor ของคุณ _your_pear_extend
หากจำเป็น ให้รับคลาสการจัดการข้อผิดพลาดของคุณเองจาก PEAR_Error เพื่อตั้งค่าโหมดการจัดการข้อผิดพลาดและทริกเกอร์ข้อผิดพลาดเมื่อเหมาะสม
หลังจากรันโค้ดที่อาจสร้างข้อผิดพลาดแล้ว ให้ใช้ PEAR::isError($obj) เพื่อบันทึกข้อผิดพลาดที่เกี่ยวข้อง
ใช้ฟังก์ชันการทำงานของคุณเอง
ในรุ่นหลักของ PEAR มีโมดูลแอปพลิเคชันที่ยอดเยี่ยมมากมายอยู่แล้ว เช่น PHPDoc, Cache และ HTML