รู้เบื้องต้นเกี่ยวกับลูกแพร์: ใช้ลูกแพร์เพื่อเขียนโปรแกรม php ถัดไปของคุณ
เนื้อหา:
ลูกแพร์คืออะไร
ทำไมต้องใช้ลูกแพร์?
ลูกแพร์สามารถให้ประโยชน์อะไรกับฉันได้บ้าง?
กฎการเข้ารหัสลูกแพร์เริ่มใช้ลูกแพร์
สรุปแหล่งข้อมูลที่เกี่ยวข้องและการแนะนำผู้เขียน
แพนฟาน (กะลาสีเรือกลางคืน) ( [email protected] )
Beijing Saidi.com Information Technology Co., Ltd.
ในเดือนมิถุนายน ปี 2001 คุณอาจเป็นผู้เชี่ยวชาญด้าน PHP อยู่แล้ว และได้เขียนโค้ดที่ยอดเยี่ยมมากมาย แต่ถ้าคุณต้องการเพิ่มมันเข้าไปในโปรเจ็กต์ปัจจุบันของคุณตอนนี้ มันจะยากไหม? เพื่อนของคุณต้องการใช้โค้ดของคุณเป็นโมดูลในโครงการของเขา แต่คุณพบว่าคุณใช้รูปแบบการเขียนโค้ดที่แตกต่างไปจากเดิมอย่างสิ้นเชิง ปล่อยให้เขาปรับตัวหรือเขียนมันใหม่!
โปรดติดตามฉันและเขียนโปรแกรม PHP ของคุณโดยใช้มาตรฐานลูกแพร์ โปรแกรมของคุณจะมีพลังมากขึ้น โปรแกรมและรหัสของคุณจะถูกรวมเข้ากับรหัสของผู้เชี่ยวชาญคนอื่น ๆ ได้อย่างง่ายดาย Pear เปรียบเสมือน cpan สำหรับ Like perl มันจะทำให้ php สร้างพลังงานที่สูงขึ้น
คู่อะไร
Pear เป็นตัวย่อของส่วนขยาย php และพื้นที่เก็บข้อมูลแอปพลิเคชัน เป็นที่เก็บโค้ดสำหรับส่วนขยายและแอปพลิเคชัน PHP พูดง่ายๆ ก็คือ pear คือ cpan ของ PHP
ทำไมต้องใช้ลูกแพร์?
PHP เป็นภาษาสคริปต์ที่ยอดเยี่ยม กระชับ และมีประสิทธิภาพ ด้วยการเปิดตัว 4.0 ผู้คนจำนวนมากขึ้นเรื่อยๆ ใช้มันเพื่อพัฒนาเว็บไซต์แบบไดนามิก อาจกล่าวได้ว่า PHP ได้กลายเป็นหนึ่งในภาษาการพัฒนาอินเทอร์เน็ตที่ดีที่สุด โดยเฉพาะสำหรับเว็บไซต์เหล่านั้น นักพัฒนาที่ต้องการสามารถพัฒนาแอปพลิเคชันธุรกิจขนาดเล็กและขนาดกลางได้อย่างรวดเร็วและมีประสิทธิภาพ PHP คือภาษาที่คุณเลือก อย่างไรก็ตาม ด้วยจำนวนแอปพลิเคชัน PHP ที่เพิ่มขึ้น ทำให้ขาดมาตรฐานที่เป็นหนึ่งเดียวและการจัดการที่มีประสิทธิภาพสำหรับแอปพลิเคชันเหล่านี้ ดังนั้นจึงเป็นเรื่องยากสำหรับชุมชน PHP ที่จะแบ่งปันโค้ดและแอปพลิเคชันของกันและกันอย่างสะดวกสบายเช่นเดียวกับผู้คนในชุมชน Perl เนื่องจาก PHP ขาดความสามารถในการแชร์โค้ดและแอปพลิเคชันเช่น Cpan ฐานโค้ดแบบรวมเพื่อจัดประเภทและจัดการโมดูลโค้ดแอปพลิเคชัน (ใครก็ตามที่คุ้นเคยกับ Perl จะรู้ดีว่า cpan เป็นคลังโมดูลส่วนขยาย Perl ขนาดใหญ่ โมดูลแอปพลิเคชันที่เขียนสามารถจัดอยู่ในหมวดหมู่ที่เหมาะสมได้ ไดเร็กทอรีภายใต้ cpan และบุคคลอื่นสามารถนำมาใช้ซ้ำได้ง่ายมาก แน่นอนว่าคุณต้องปฏิบัติตามหลักเกณฑ์เมื่อเขียนโมดูลแอปพลิเคชันด้วย)
ด้วยเหตุนี้ ลูกแพร์จึงเกิดขึ้น และเริ่มตั้งแต่ 4.04 เป็นต้นไป มันถูกแจกจ่ายด้วยแกน PHP
ลูกแพร์สามารถให้ประโยชน์อะไรกับฉันได้บ้าง?
1. ตามที่กล่าวไว้ข้างต้น pear จัดการฐานโค้ดแอปพลิเคชัน pear ตามหมวดหมู่ที่กำหนด รหัส pear ของคุณสามารถจัดเป็นไดเร็กทอรีที่เหมาะสม และบุคคลอื่นสามารถดึงข้อมูลและแบ่งปันผลลัพธ์ของคุณได้อย่างง่ายดาย
2. Pear ไม่ได้เป็นเพียงที่เก็บโค้ดเท่านั้น แต่ยังเป็นมาตรฐานอีกด้วย การใช้มาตรฐานนี้ในการเขียนโค้ด PHP ของคุณจะช่วยเพิ่มความสามารถในการอ่านและการนำโปรแกรมของคุณกลับมาใช้ใหม่ได้ และลดโอกาสที่จะเกิดข้อผิดพลาด
3. Pear สร้างเฟรมเวิร์กให้กับคุณโดยจัดให้มี 2 คลาสเพื่อใช้ฟังก์ชันต่างๆ เช่น ตัวทำลายและการตรวจจับข้อผิดพลาด คุณสามารถใช้ฟังก์ชันเหล่านี้ผ่านการสืบทอด
กฎการเข้ารหัสสำหรับลูกแพร์
กฎการเขียนโค้ดของ Pear ประกอบด้วยกฎการเยื้อง โครงสร้างการควบคุม การเรียกใช้ฟังก์ชัน คำจำกัดความของฟังก์ชัน ความคิดเห็น ที่มีโค้ด แท็ก PHP บล็อกความคิดเห็นในส่วนหัวของไฟล์ แท็ก CVS ตัวอย่าง URL และการตั้งชื่อค่าคงที่ นี่เป็นการแนะนำโดยย่อ:
กฎการเยื้อง:
คุณต้องใช้ช่องว่าง 4 ช่องในแพร์เพื่อเยื้องโค้ด และอย่าใช้แท็บ หากคุณใช้ vim ให้ใส่การตั้งค่าต่อไปนี้ใน ~/.vimrc ของคุณ:
ตั้งค่าแท็บขยาย
ตั้งค่าความกว้างกะ=4
set tabstop=4
หากคุณใช้ emacs/xemacs คุณจะต้องตั้งค่า indent-tabs-mode เป็น nil
แต่ถ้าคุณต้องการใช้ (x)emacs เพื่อแก้ไขไฟล์ php เหมือนฉัน ฉันขอแนะนำอย่างยิ่งให้คุณติดตั้ง php-mode เพื่อว่าเมื่อคุณเขียนโค้ดลูกแพร์ มันจะปรับรูปแบบการเยื้องของคุณโดยอัตโนมัติ คุณสมบัติที่ดีมาก ๆ อีกมากมาย คุณสามารถดาวน์โหลด php-mode เวอร์ชันล่าสุดได้จากรายการทรัพยากร
โครงสร้างการควบคุม:
โครงสร้างการควบคุมที่กล่าวถึงในที่นี้ได้แก่: ถ้าเป็น while switch เป็นต้น สำหรับโครงสร้างการควบคุม ควรมีช่องว่างหลังคีย์เวิร์ด (เช่น if สำหรับ ..) แล้วตามด้วยวงเล็บควบคุม เพื่อไม่ให้สับสนกับการเรียกใช้ฟังก์ชัน นอกจากนี้ คุณควรลองใช้วงเล็บปีกกา {} ให้ครบถ้วนที่สุด แม้ว่าจะเป็นทางเลือกทางวากยสัมพันธ์ก็ตาม วิธีนี้จะป้องกันความสับสนหรือข้อผิดพลาดเชิงตรรกะเมื่อคุณต้องการเพิ่มบรรทัดโค้ดใหม่ในอนาคต นี่คือตัวอย่าง:
ถ้า ((เงื่อนไข 1) && (เงื่อนไข 2)) {
คำชี้แจง 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);
คำจำกัดความของฟังก์ชัน:
คำจำกัดความของฟังก์ชันเป็นไปตามแบบแผน "หนึ่งปีกกาจริง":
ฟังก์ชั่นเชื่อมต่อ(&$dsn, $persistent = false)
-
ถ้า (is_array($dsn)) {
$dsninfo = &$dsn;
} อื่น {
$dsninfo = db::parsedsn($dsn);
-
ถ้า (!$dsninfo || !$dsninfo['phptype']) {
กลับ $this->raiseerror();
-
กลับเป็นจริง;
}
ดังที่แสดงไว้ข้างต้น พารามิเตอร์ทางเลือกควรอยู่ท้ายรายการพารามิเตอร์ และพยายามส่งคืนค่าฟังก์ชันที่มีความหมายเสมอ
เกี่ยวกับความคิดเห็น:
สำหรับเอกสารประกอบคลาสออนไลน์ ควรแปลงได้โดย phpdoc เช่นเดียวกับ javadoc phpdoc ก็เป็นแอปพลิเคชั่นลูกแพร์เช่นกัน สำหรับรายละเอียดเพิ่มเติม คุณสามารถไปที่ http://www.phpdoc.de/ เพื่อดูมัน นอกเหนือจากเอกสารประกอบการเรียนออนไลน์แล้ว ขอแนะนำให้คุณใช้ความคิดเห็นที่ไม่ใช่เอกสารประกอบเพื่ออธิบายโค้ดของคุณ เมื่อคุณเห็นโค้ด คุณจะคิดว่า: โอ้ ฉันไม่คิดว่าคุณจำเป็นต้องอธิบายมันอย่างละเอียดในเอกสารประกอบ . ถ้าอย่างนั้น คุณควรให้ความคิดเห็นง่ายๆ กับโค้ดนี้เพื่อป้องกันไม่ให้คุณลืมวิธีการทำงาน สำหรับรูปแบบความคิดเห็น c's /* */ และ c++'s // ใช้ได้ทั้งคู่ อย่างไรก็ตาม อย่าใช้วิธี # comment ของ perl หรือเชลล์
ประกอบด้วยรหัส:
เมื่อใดก็ตามที่คุณต้องการรวมไฟล์คลาสโดยไม่มีเงื่อนไข คุณต้องใช้ need_once เมื่อคุณต้องการรวมไฟล์คลาสแบบมีเงื่อนไข คุณต้องใช้ include_once เพื่อให้แน่ใจว่าไฟล์ที่คุณต้องการรวมจะถูกรวมเพียงครั้งเดียว และ 2 คำสั่งทั้งสองนี้ แชร์รายการไฟล์เดียวกัน ดังนั้นคุณไม่ต้องกังวลว่าทั้งสองจะสับสน เมื่อ need_once รวมไฟล์แล้ว include_once จะไม่รวมไฟล์เดียวกันอีก และในทางกลับกัน
มาร์กอัปโค้ด PHP:
ใช้ <?php ?> เพื่อกำหนดโค้ด PHP ของคุณแทนการใช้ <?> เสมอ ซึ่งช่วยให้มั่นใจได้ถึงความเข้ากันได้ของลูกแพร์และอำนวยความสะดวกในการย้ายข้ามแพลตฟอร์ม
ประกาศความคิดเห็นในส่วนหัวของไฟล์:
สำหรับไฟล์โค้ด PHP ทั้งหมดที่ต้องรวมอยู่ในรุ่น pear core คุณต้องเพิ่มคำสั่งความคิดเห็นต่อไปนี้ที่จุดเริ่มต้นของไฟล์:
/* vim: ตั้งค่าแท็บขยาย tab=4 shiftwidth=4: */
// +-------------------------------------------------- --- ----------------------+
// |.php เวอร์ชัน 4.0 |
// +-------------------------------------------------- --- ----------------------+
// |. ลิขสิทธิ์ (c) 1997, 1998, 1999, 2000, 2001 กลุ่ม php |
// +-------------------------------------------------- --- ----------------------+
// | ไฟล์ต้นฉบับนี้อยู่ภายใต้ใบอนุญาต php เวอร์ชัน 2.0, |
// | ที่มาพร้อมกับแพ็คเกจนี้ในลิขสิทธิ์ไฟล์และเป็น |
// | สามารถดูได้ที่ |
// |http://www.php.net/license/2_02.txt |
// | หากคุณไม่ได้รับสำเนาใบอนุญาต php และไม่สามารถ |
// |. รับได้ทางเวิลด์ไวด์เว็บ, กรุณาส่งบันทึกไปที่ |
// |[email protected] เพื่อให้เราสามารถส่งสำเนาให้คุณทางไปรษณีย์ได้ทันที
// +-------------------------------------------------- --- ----------------------+
// |. ผู้แต่ง: ผู้แต่งต้นฉบับ |
// |. ชื่อของคุณ |
// +-------------------------------------------------- --- ----------------------+
-
// $id$
สำหรับไฟล์ที่ไม่ได้อยู่ในฐานโค้ด pear core ขอแนะนำให้คุณมีบล็อกความคิดเห็นที่คล้ายกันที่ตอนต้นของไฟล์ ซึ่งระบุถึงลิขสิทธิ์ ข้อตกลง ผู้แต่ง ฯลฯ ในเวลาเดียวกัน modeline ของ vim จะถูกเพิ่มในบรรทัดแรกด้วย เพื่อให้สามารถรักษาสไตล์โค้ดของ pear เป็นกลุ่มได้
แท็ก CVS:
ดังที่แสดงไว้ด้านบน ให้เพิ่มแท็ก CVS ID ลงในแต่ละไฟล์ หากไฟล์ที่คุณแก้ไขหรือแก้ไขไม่มีแท็กนี้ โปรดเพิ่มหรือแทนที่ด้วยนิพจน์ที่คล้ายกันในไฟล์ต้นฉบับ (เช่น "แก้ไขครั้งล่าสุด")
ตัวอย่าง URL:
คุณสามารถอ้างถึง RFC 2606 และใช้ " http://www.example.com " เป็นตัวอย่าง URL ทั้งหมด
การตั้งชื่อคงที่:
ค่าคงที่ควรเขียนเป็นตัวพิมพ์ใหญ่เมื่อเป็นไปได้ และเพื่อให้เข้าใจง่ายขึ้น ให้ใช้ขีดล่างเพื่อแยกแต่ละคำ ในเวลาเดียวกัน คุณควรใส่คำนำหน้าชื่อแพ็กเกจหรือชื่อคลาสที่มีค่าคงที่อยู่ ตัวอย่างเช่น ค่าคงที่ในคลาส bug ควรเริ่มต้นด้วย bug_ ข้างต้นเป็นกฎการเข้ารหัสของลูกแพร์ สำหรับกฎการเข้ารหัสโดยละเอียด โปรดดูคำอธิบายของไฟล์ coding_standard ในลูกแพร์ เพื่อให้เข้าใจกฎการเขียนโค้ดเหล่านี้ได้ดีขึ้น คุณยังสามารถอ้างอิงถึงโค้ดของโมดูล pear core ที่มีอยู่ได้
เริ่มใช้ลูกแพร์
ลูกแพร์
การใช้ pear เป็นเรื่องง่าย คุณเพียงแค่ต้องกำหนดโปรแกรม pear ของคุณเองดังนี้:
need_once "pear.php";
คลาส your_class_name ขยายลูกแพร์ {
คำจำกัดความของชั้นเรียนของคุณ...
-
แน่นอนว่าคุณต้องปฏิบัติตามกฎการเขียนโค้ดลูกแพร์ที่กล่าวถึงข้างต้น จากนั้นคุณจึงจะสามารถนำสิ่งที่คุณต้องการทำไปใช้ในชั้นเรียนของคุณได้ ต่อไป เราจะมาพูดถึงมันกัน จริงๆ แล้ว pear มี 2 คลาสที่กำหนดไว้ล่วงหน้าให้เรา:
ลูกแพร์: นี่คือคลาสพื้นฐานของลูกแพร์ และส่วนขยายลูกแพร์ทั้งหมดจะต้องสืบทอดและสืบทอดมาจากคลาสนั้น
pear_error: คลาสพื้นฐานของการจัดการข้อผิดพลาดของแพร์ คุณสามารถเลือกรับคลาสการจัดการข้อผิดพลาดของคุณเองได้
โดยทั่วไป คุณไม่ควรสร้างอินสแตนซ์ของลูกแพร์โดยตรง แต่ได้รับคลาสใหม่ด้วยตัวเอง จากนั้นจึงสร้างอินสแตนซ์ของคลาสใหม่นี้ ในฐานะคลาสพื้นฐาน ลูกแพร์มอบฟังก์ชันที่มีประโยชน์บางอย่างให้กับเรา ฟังก์ชันที่สำคัญที่สุดคือตัวทำลายและตัวทำลายการจัดการข้อผิดพลาด
PHP รองรับคอนสตรัคเตอร์ แต่ไม่รองรับ destructor อย่างไรก็ตาม PHP มีฟังก์ชัน register_shutdown_function() ซึ่งสามารถเรียกกลับฟังก์ชันที่ลงทะเบียนไว้ก่อนที่สคริปต์จะสิ้นสุดลง ดังนั้น pear จึงใช้ฟีเจอร์นี้เพื่อสร้างการจำลองของ destructor หากคุณมีคลาสย่อยของแพร์ เรียกว่า mypear ดังนั้นในคลาส mypear คุณสามารถกำหนดฟังก์ชันได้ ชื่อฟังก์ชันจะเป็นเครื่องหมายขีดล่างบวกกับชื่อคลาสของคุณ _mypear() ฟังก์ชันนี้คือตัวทำลายของคลาสนี้ อย่างไรก็ตาม destructor นี้แตกต่างจาก destructor ใน C ++ มันจะไม่ถูกดำเนินการเมื่อวัตถุถูกลบ แต่เมื่อสคริปต์สิ้นสุดลง ท้ายที่สุดแล้ว นี่เป็นเพียงการจำลอง เนื่องจากมีการใช้ register_shutdown_function() ข้อมูลที่พิมพ์ออกมาจะไม่ถูกส่งกลับไปยังเบราว์เซอร์ในตัวทำลายของคุณ นอกจากนี้ ใน Constructor ของคุณ คุณต้องเรียก Constructor ของคลาสพาเรนต์ เนื่องจาก PHP จะไม่เรียก Constructor ของคลาสพาเรนต์โดยอัตโนมัติ และ Destructor จะต้องลงทะเบียนในตัวสร้างของ Pear Source รหัส:
<รหัส>
ฟังก์ชั่นลูกแพร์ () {
ถ้า (method_exists($this, "_".get_class($this))) {
ทั่วโลก $_pear_destructor_object_list;
$_pear_destructor_object_list[] = &$นี่;
-
ถ้า ($ นี้ -> _debug) {
printf("ตัวสร้างลูกแพร์ถูกเรียก, 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
ออบเจ็กต์ข้อผิดพลาดในลูกแพร์ไม่ได้จำกัดรูปแบบเอาต์พุตเฉพาะ มันสามารถจับข้อผิดพลาดได้โดยไม่ต้องส่งคืนข้อมูลมากเกินไปให้กับผู้ใช้ หรือสามารถเรียกฟังก์ชันการจัดการข้อผิดพลาดพิเศษกลับคืนมาได้ แม้ว่าจะส่งออกข้อมูลข้อผิดพลาดก็ตาม คุณถูกบังคับให้ใช้รูปแบบ html คุณสามารถส่งออกรูปแบบ xml, csv หรือรูปแบบอื่น ๆ ที่คุณกำหนดได้เอง คุณจะต้องได้รับคลาสใหม่จาก pear_error จากนั้นสร้างและ "โยน" คลาสใหม่นี้ที่ เวลาที่เหมาะสม
การจัดการข้อผิดพลาดอย่างง่าย:
ใน pear การจัดการข้อผิดพลาดที่ง่ายที่สุดคือการ "โยน" ข้อผิดพลาด คุณเพียงแค่สร้างและส่งคืนวัตถุ pear_error นี่เป็นตัวอย่างง่ายๆ:
<รหัส>
ฟังก์ชั่น myconnect($host = "localhost", $port = 1080)
-
$fp = fsockopen($host, $port, $errno, $errstr);
ถ้า (!is_resource($fp)) {
ส่งคืน pear_error ใหม่ ($errstr, $errno);
-
กลับ $fp;
-
$sock = เชื่อมต่อของฉัน();
ถ้า (ลูกแพร์ :: iserror ($ ถุงเท้า)) {
พิมพ์ "ข้อผิดพลาดในการเชื่อมต่อ: ".$sock->getmessage()"<br>n"
-
</code>
ดังที่แสดงในโค้ดด้านบน หลังจากรันโค้ดชิ้นหนึ่งที่อาจก่อให้เกิดข้อผิดพลาด คุณต้องใช้ pear's iserror เพื่อตรวจสอบว่ามีข้อผิดพลาดหรือไม่ และคุณสามารถใช้ getmessage ของ pear_error เพื่อรับข้อความแสดงข้อผิดพลาดล่าสุด หมายเหตุ: อย่าลืมใช้ pear::iserror ในสถานที่สำคัญ
ใช้การยกข้อผิดพลาด
หลังจาก php4.0.5 ลูกแพร์มี 2 ฟังก์ชั่นเพิ่มเติม:
seterrorhandling($โหมด, $options = null)
Raiseerror($message = null, $code = null, $mode = null,$options = null, $userinfo = null)
แบบแรกสามารถตั้งค่าโหมดการจัดการข้อผิดพลาดเริ่มต้นของ pear และแบบหลังเป็นฟังก์ชัน wrapper ที่ส่งคืน pear_error object ซึ่งแตกต่างจากการสร้างและส่งคืนวัตถุ pear_error โดยตรงเล็กน้อย หากคุณละเว้นพารามิเตอร์เช่น $mode และ $options มันจะใช้ค่าเริ่มต้นเพื่อสร้างวัตถุ pear_error คุณสามารถใช้ seterrorhandling() เพื่อปรับแต่งค่าเริ่มต้นเหล่านี้ได้ .
ลูกแพร์_ข้อผิดพลาด
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: ส่งกลับคำอธิบายสตริงโดยละเอียดของออบเจ็กต์ปัจจุบัน รวมถึงโหมดการจัดการข้อผิดพลาด ระดับ ข้อมูลข้อผิดพลาด รหัสข้อผิดพลาด ฟังก์ชันติดต่อกลับที่เกี่ยวข้อง ฯลฯ
สรุปการแนะนำลูกแพร์จบลงแล้ว โดยสรุป หากคุณต้องการใช้ส่วนขยายของลูกแพร์ คุณต้องทำดังนี้:
need_once "pear.php"
ใช้คลาส your_pear_extend ขยายลูกแพร์{} เพื่อกำหนดคลาสใหม่ของคุณ
ในตัวสร้างคลาสของคุณ ให้เรียกตัวสร้างคลาสแพร์แพร์:
ฟังก์ชั่น your_pear_extend{
$นี่->ลูกแพร์();
-
}
หากจำเป็น ให้กำหนด destructor ของคุณ _your_pear_extend
หากจำเป็น ให้รับคลาสการจัดการข้อผิดพลาดของคุณเองจาก pear_error เพื่อตั้งค่าโหมดการจัดการข้อผิดพลาดและทริกเกอร์ข้อผิดพลาดเมื่อเหมาะสม
หลังจากรันโค้ดที่อาจสร้างข้อผิดพลาดแล้ว ให้ใช้ pear::iserror($obj) เพื่อบันทึกข้อผิดพลาดที่เกี่ยวข้อง
ใช้ฟังก์ชันการทำงานของคุณเอง
ใน pear core รุ่นล่าสุดของ php4.05 มีโมดูลแอปพลิเคชันที่ยอดเยี่ยมมากมายอยู่แล้ว เช่น: phpdoc, cache, html... แน่นอนว่าเมื่อเทียบกับ cpan แล้ว pear เพิ่งเริ่มต้นและต้องการบุคลากรจากชุมชน php ด้วยความพยายามร่วมกันของเราในการปรับปรุงและปรับปรุง php จะมีประสิทธิภาพมากขึ้นเรื่อยๆ
ทรัพยากรที่เกี่ยวข้อง
ลูกแพร์โฮมเพจ
หน้าแรกของ php.php
หน้าแรกของ phpdoc ซึ่งสามารถสร้างเอกสาร API ที่คล้ายกับ javadoc จากซอร์สโค้ดแอปพลิเคชันลูกแพร์ของคุณ
php-mode สำหรับ xemacs/emacs ให้การสนับสนุนไวยากรณ์ PHP สำหรับ emacs/xemacs และสามารถรองรับรูปแบบโค้ดลูกแพร์ได้เป็นอย่างดี
หน้าแรกของ vim ซึ่งเป็นโปรแกรมแก้ไขที่ดีมาก รองรับ php ได้ดีเช่นกัน