PHP เป็นภาษาการเขียนโปรแกรมเครือข่ายที่มีประสิทธิภาพ เนื่องจากข้อดีของการเขียนที่ยืดหยุ่นและการทำงานที่รวดเร็ว จึงกลายเป็นภาษาที่ต้องการสำหรับโปรแกรมเมอร์เว็บอย่างรวดเร็ว การสำรวจที่เชื่อถือได้เมื่อไม่นานมานี้แสดงให้เห็นว่า 31.6% ของเว็บไซต์ใช้ PHP เป็นภาษาโปรแกรมฝั่งเซิร์ฟเวอร์หลัก
อย่างไรก็ตาม การเป็นผู้เชี่ยวชาญด้านการเขียนโปรแกรม PHP ไม่ใช่เรื่องง่าย มันไม่ได้เป็นสิ่งที่หลาย ๆ คนจินตนาการไว้ ตราบใดที่คุณสามารถเขียนโค้ดง่ายๆ สองสามโค้ดเพื่อแก้ไขปัญหาที่ซับซ้อนได้ คุณก็คือผู้เชี่ยวชาญด้านการเขียนโปรแกรม PHP อย่างแท้จริง แนวทางสามประการต่อไปนี้เป็นแนวทางที่โปรแกรมเมอร์ PHP ที่เป็นผู้ใหญ่ควรปฏิบัติตามในการเขียนโปรแกรมเป็นอันดับแรก
1. ความเกียจคร้านเป็นสีทอง
2. เขียนโค้ดที่สวยงาม
3. ไล่ตามความเร็วของการเขียนโปรแกรม ไม่ใช่ความเร็วของการเขียนโปรแกรม
1. ความเกียจคร้านเป็นสีทอง
คุณเป็นโปรแกรมเมอร์ที่ขี้เกียจหรือเปล่า? ความคิดนี้แปลกมาก! เพราะคนที่ยุ่งที่สุดในโลกน่าจะเป็นโปรแกรมเมอร์คอมพิวเตอร์ แต่เป็นเพราะโปรแกรมเมอร์ยุ่งเกินไปจึงควรเรียนรู้ที่จะขี้เกียจเมื่อเขียนโปรแกรม
สำหรับโปรแกรมเมอร์ มีสองวิธีที่ขี้เกียจ: ขั้นแรก ใช้โค้ดโปรแกรมสำเร็จรูปของผู้อื่นอย่างกล้าหาญ และรวมโค้ดเหล่านี้เข้ากับโปรแกรมหรือโครงการของคุณเอง ประการที่สองคือการเขียนโค้ดที่มีประโยชน์เพื่อสร้างไลบรารีฟังก์ชันซึ่งสามารถนำมาใช้ได้อย่างง่ายดายในการเขียนโปรแกรมในอนาคต ซึ่งจะช่วยประหยัดเวลาในการทำงานซ้ำ ๆ ได้มากและทำให้คุณขี้เกียจน้อยลงโดยธรรมชาติ
วิธีขี้เกียจทั้งสองนี้เหมาะมากสำหรับโปรแกรมเมอร์ PHP
ประการแรก PHP คือภาษาที่เกิดและเติบโตในสภาพแวดล้อมที่เสรีและเปิดกว้าง มีโปรแกรมเมอร์หลายพันคนทั่วโลกที่มุ่งมั่นอย่างต่อเนื่องเพื่อความสมบูรณ์แบบของ PHP และพวกเขาก็ยินดีที่จะแบ่งปันความเฉลียวฉลาดและโค้ดที่พวกเขาเขียนกับผู้อื่น คุณสามารถค้นหาโค้ดโปรแกรมดีๆ มากมายได้ทุกวันจากเว็บไซต์ PHP รายชื่ออีเมล และกลุ่มข่าวสาร การพูดแบบนี้ ฉันไม่ได้สนับสนุนให้คุณรอทั้งวันเพื่อให้คนอื่นเขียนโค้ดให้คุณ แต่คุณสามารถ "ยืนอยู่บนไหล่ของคนเก่ง" และส่งเสริม "การใช้หลักคำสอน" ได้อย่างเต็มที่ ช่วยคุณประหยัดเงินได้มาก ประการที่สอง ใน PHP คุณสามารถสร้างไลบรารีฟังก์ชันของคุณเองได้อย่างง่ายดาย ซึ่งสามารถช่วยคุณประหยัดปัญหามากมายในการเขียนโปรแกรมในอนาคต
ผู้เขียนด้านล่างนี้จะแนะนำฟังก์ชันทั่วไปหลายประการให้กับคุณ ฟังก์ชันบางส่วนเหล่านี้มาจากโครงการโอเพ่นซอร์สบนอินเทอร์เน็ต และบางส่วนได้รับการคัดเลือกจากรายชื่อผู้รับจดหมาย หากคุณสามารถเพิ่มลงในห้องสมุดของคุณเองได้ ไม่ช้าก็เร็วคุณจะพบว่าตัวเองได้รับประโยชน์จากสิ่งเหล่านั้น
1. ฟังก์ชั่นการประมวลผลฐานข้อมูลทั่วไป
เมื่อเปรียบเทียบกับฟังก์ชั่น CGI อื่นๆ ข้อดีอย่างหนึ่งของ PHP ก็คือมีความสามารถในการประมวลผลฐานข้อมูลที่ทรงพลังมาก อย่างไรก็ตาม ใน PHP ฟังก์ชันเฉพาะบางอย่างใช้เพื่อจัดการฐานข้อมูลที่แตกต่างกัน และไม่มีฟังก์ชันการประมวลผลฐานข้อมูลทั่วไป สิ่งนี้จะช่วยลดความสามารถในการพกพาโค้ดโปรแกรมได้อย่างมาก ซึ่งยังนำความไม่สะดวกมาสู่เพื่อนในการเขียนโปรแกรมมือใหม่อีกด้วย
บนอินเทอร์เน็ต โปรแกรมเมอร์จำนวนมากได้แก้ไขปัญหานี้ด้วยการห่อหุ้มคลาส พวกเขาเขียนฟังก์ชันแบบครบวงจรเพื่อจัดการฐานข้อมูลยอดนิยม ไม่ว่าจะเป็น Mysql ซึ่งได้รับความนิยมในโลก Linux หรือ SqlServer ซึ่งได้รับความนิยมอย่างกว้างขวางบนแพลตฟอร์ม Windows โดยส่วนตัวแล้วฉันชอบใช้ฟังก์ชันเหล่านี้มาก เพราะคุณสามารถใช้ฟังก์ชันง่ายๆ บางอย่าง เช่น "query" และ "next_record" ได้โดยตรง โดยไม่ต้องคำนึงถึงเรื่องที่ซับซ้อน เช่น การเชื่อมต่อฐานข้อมูลและตัวจัดการฐานข้อมูล ไม่ต้องพูดถึงว่าคุณกำลังใช้ฐานข้อมูลใด .
หากคุณต้องการฟังก์ชันเหล่านี้ คุณสามารถรับได้โดยไปที่ URL ต่อไปนี้:
http://phplib.netuse.de/
http://phpclasses.UpperDesign.com/browse.html/package/20
http://phpdb.linuxbox.com/
http://www.phpchina.com
2. ฟังก์ชั่นการดีบักแบบแปรผัน
การดีบักของโปรแกรม PHP เป็นเรื่องที่น่าปวดหัวมาโดยตลอด มันไม่มีสภาพแวดล้อมการคอมไพล์และการดีบักแบบรวมเช่นภาษาระดับสูงเช่น VB และก็ไม่มี ความสามารถในการใช้ในโปรแกรม PHP เช่น Perl ทำงานโดยตรงภายใต้สภาพแวดล้อม Linux หรือ DOS ที่จริงแล้ว เราสามารถทำการดีบัก PHP ให้เสร็จสิ้นได้โดยใช้คำสั่ง echo อย่างยืดหยุ่น
ฟังก์ชั่นต่อไปนี้ทำให้คุณสามารถตรวจสอบประเภทและค่าของตัวแปรในโปรแกรมได้ตลอดเวลา
ฟังก์ชั่น ss_array_as_string (&$array, $column = 0) {
$str = "อาร์เรย์(n";
ในขณะที่(รายการ($var, $val) = แต่ละ($array)){
สำหรับ (＄i = 0; $i < $column＋1; $i＋＋){
$str .= " ";
-
＄str .= ＄var. ==> ;
$str .= ss_as_string($val, $column+1)" n";
-
สำหรับ (＄i = 0; $i < $column; $i＋＋){
$str .= " ";
-
กลับ $str.);
-
ฟังก์ชั่น ss_object_as_string (&$ object, $column = 0) {
ถ้า (ว่าง (＄ object->ชื่อคลาส)) {
กลับ "$วัตถุ";
} อื่น {
$str = $object->ชื่อคลาส"( n";
ในขณะที่ (list(,$var) = แต่ละอัน($object->persistent_slots)) {
สำหรับ (＄i = 0; $i < $column; $i＋＋){
$str .= " ";
-
ทั่วโลก$$var;
＄str .= ＄var. ==> ;
$str .= ss_as_string($$var, คอลัมน์+1)" n";
-
สำหรับ (＄i = 0; $i < $column; $i＋＋){
$str .= " ";
-
กลับ $str.);
-
-
ฟังก์ชั่น ss_as_string (&$thing, $column = 0) {
ถ้า (is_object($สิ่ง)) {
กลับ ss_object_as_string(＄สิ่งของ, ＄คอลัมน์);
-
elseif (is_array($สิ่ง)) {
return ss_array_as_string(＄สิ่ง, $column);
-
elseif (is_double(＄สิ่ง)) {
กลับ "สองเท่า(".$thing.")";
-
elseif (is_long(＄สิ่ง)) {
กลับ "Long(".＄thing.")";
-
elseif (is_string(＄สิ่ง)) {
กลับ "String(".$thing.")";
-
อื่น {
กลับ "ไม่ทราบ(".$thing.")";
-
}
เมื่อจำเป็น เพียงเพิ่มโค้ดต่อไปนี้ลงในโปรแกรมเพื่อดูประเภทและค่าของตัวแปร (รวมถึงอาร์เรย์และอ็อบเจ็กต์) ที่ใช้ในโปรแกรม:
echo ss_as_string(＄my_variable);
โดยใช้คำสั่งต่อไปนี้ เราจะสามารถดูค่าของตัวแปรทั้งหมดในโปรแกรมได้โดยตรง:
echo ss_as_string($GLOBALS);
3. ฟังก์ชั่นที่ควบคุมข้อมูลบันทึก
อีกวิธีที่สำคัญในการดีบักโปรแกรม PHP คือการดูข้อมูลบันทึก หากคุณสามารถควบคุมระดับของข้อมูลบันทึกและเนื้อหาที่แสดงของข้อมูลบันทึกได้อย่างง่ายดาย จะทำให้การดีบักโปรแกรมสะดวกยิ่งขึ้น ฟังก์ชันต่อไปนี้สามารถใช้ฟังก์ชันนี้ได้อย่างง่ายดาย
$ss_log_level = 0;
$ss_log_filename = /tmp/ss-log;
$ss_log_levels = อาร์เรย์(
ไม่มี => 0,
ข้อผิดพลาด => 1,
ข้อมูล => 2,
ตรวจแก้จุดบกพร่อง => 3);
ฟังก์ชั่น ss_log_set_level ($ระดับ = ข้อผิดพลาด) {
$ss_log_level ทั่วโลก;
$ss_log_level = $ระดับ;
-
ฟังก์ชั่น ss_log (＄ระดับ $ข้อความ) {
$ss_log_level ทั่วโลก, $ss-log-ชื่อไฟล์;
ถ้า ($ss_log_levels[$ss_log_level] < $ss_log_levels[$level]) {
//อย่าแสดงข้อมูลบันทึก
กลับเท็จ;
-
$fd = fopen($ss_log_filename, "a+");
fputs(＄fd, $level. - [.ss_timestamp_pretty().] - .$message"n");
fclose(＄fd);
กลับเป็นจริง;
-
ฟังก์ชั่น ss_log_reset () {
$ss_log_filename ทั่วโลก;
@unlink($ss_log_filename);
}
ในฟังก์ชันข้างต้น มีตัวแปรระดับบันทึกสี่ตัว เมื่อรันโปรแกรม PHP ข้อมูลบันทึกสามารถบันทึกและแสดงเฉพาะเมื่อระดับบันทึกต่ำกว่าค่าระดับที่ตั้งไว้เท่านั้น ตัวอย่างเช่น เพิ่มคำสั่งต่อไปนี้ลงในโปรแกรม:
ss_log_set_level(INFO);
จากนั้น เมื่อรันโปรแกรม PHP เฉพาะข้อมูล LOG ระดับ ERROR และ INFO เท่านั้นที่สามารถบันทึกและแสดงได้ และข้อมูลระดับ DEBUG จะถูกละเว้น นอกจากนี้เรายังสามารถตั้งค่าเนื้อหาข้อมูลที่แสดงด้วยข้อความต่อไปนี้:
ss_log(ข้อผิดพลาด, "ข้อผิดพลาดระดับการทดสอบ");
ss_log(INFO, "ข้อมูลระดับการทดสอบ");
ss_log(DEBUG, "testing level DEBUG");
คุณยังสามารถใช้คำสั่งต่อไปนี้เพื่อล้างข้อมูล LOG ได้ตลอดเวลา:
ss_log_reset();
4. ฟังก์ชั่นทดสอบความเร็ว
เพื่อเพิ่มประสิทธิภาพโค้ดเราจำเป็นต้องมีวิธีการที่สามารถทดสอบเวลาทำงานของโค้ดเพื่อเลือกโค้ดที่เหมาะสมที่สุด ฟังก์ชันต่อไปนี้สามารถทดสอบเวลาที่ต้องใช้ในการรันโค้ด:
ฟังก์ชัน ss_timing_start (＄name = default) {
$ss_timing_start_times ทั่วโลก;
$ss_timing_start_times[$name] = ระเบิด( , ไมโครไทม์());
-
ฟังก์ชั่น ss_timing_stop ($ ชื่อ = ค่าเริ่มต้น) {
$ss_timing_stop_times ทั่วโลก;
$ss_timing_stop_times[$name] = ระเบิด(, ไมโครไทม์());
-
ฟังก์ชั่น ss_timing_current ($ ชื่อ = ค่าเริ่มต้น) {
ทั่วโลก $ss_timing_start_times, $ss_timing_stop_times;
ถ้า (!isset($ss_timing_start_times[$name])) {
กลับ 0;
-
ถ้า (!isset($ss_timing_stop_times[$name])) {
$stop_time = ระเบิด(, ไมโครไทม์());
-
อื่น {
$stop_time = $ss_timing_stop_times[$ชื่อ];
-
$current = $stop_time[1] - $ss_timing_start_times[$name][1];
$current += $stop_time[0] - $ss_timing_start_times[$name][0];
ส่งคืน $ปัจจุบัน;
}
ตอนนี้เราสามารถตรวจสอบเวลาดำเนินการของโค้ดใดๆ ได้อย่างง่ายดาย เรายังสามารถใช้ตัวจับเวลาหลายตัวพร้อมกันได้ เราเพียงแค่ต้องตั้งค่าพารามิเตอร์ที่แตกต่างกันเป็นชื่อของตัวจับเวลาเมื่อใช้ฟังก์ชันข้างต้น
5. การดีบักและเพิ่มประสิทธิภาพการทำงานของฐานข้อมูล
สำหรับฐานข้อมูล ความเร็วในการทำงานถือเป็นสิ่งสำคัญ แม้ว่าหนังสือและบทความจำนวนมากจะสอนวิธีการเรียกใช้ฐานข้อมูลอย่างรวดเร็ว แต่วิธีการทั้งหมดจะต้องได้รับการทดสอบในทางปฏิบัติ ต่อไป เราจะรวมฟังก์ชัน Query() ในไลบรารีฟังก์ชัน PHPLib และฟังก์ชันที่แนะนำด้านบนเพื่อเขียนฟังก์ชัน Query() ใหม่ เมื่อเปรียบเทียบกับฟังก์ชันเดิม ฟังก์ชันนี้จะเพิ่มฟังก์ชันตรวจสอบเวลาทำงาน
แบบสอบถามฟังก์ชัน ($Query_String, $halt_on_error = 1) {
$นี่->เชื่อมต่อ();
ss_timing_start();
$this->Query_ID = @mysql_query($Query_String,$this->Link_ID);
ss_timing_stop();
ss_log(INFO, ss_timing_current().Secs - .$Query_String);
$นี่->แถว = 0;
$นี่->ผิดพลาด =mysql_errno();
$this->ข้อผิดพลาด =mysql_error();
ถ้า (＄halt_on_error && !＄นี่->Query_ID) {
$this->halt("SQL ไม่ถูกต้อง: ".$Query_String);
-
ส่งคืน $this->Query_ID;
}
2. เขียนโค้ดที่สวยงาม
1. แยกโปรแกรม back-end ออกจากโปรแกรม front-end
เมื่อเขียนโปรแกรม PHP โค้ดบางส่วนจะใช้ในการประมวลผลธุรกรรมบางอย่าง เช่น ฐานข้อมูลปฏิบัติการ การดำเนินการทางคณิตศาสตร์ เป็นต้น ในขณะที่โค้ดอื่นๆ รหัสมีไว้สำหรับการประมวลผลธุรกรรมเท่านั้น ผลลัพธ์จะปรากฏขึ้น เช่น โค้ด PHP บางตัวที่ใช้คำสั่ง echo เพื่อแสดงผลลัพธ์ในรูปแบบ HTML บนเว็บเบราว์เซอร์ และโค้ด HTML เหล่านั้นที่ฝังอยู่ในโปรแกรม PHP โดยตรง ก่อนอื่น เราควรแยกความแตกต่างระหว่างโค้ดทั้งสองประเภทนี้อย่างชัดเจน โดยเรียกโค้ดแบบแรกว่าเป็นโปรแกรมเบื้องหลังและแบบหลังเป็นโปรแกรมส่วนหน้า
เนื่องจาก PHP เป็นภาษาโปรแกรมแบบฝัง กล่าวคือ โค้ด PHP ทั้งหมดสามารถฝังอยู่ในโค้ด HTML ได้ ซึ่งช่วยเพิ่มความสะดวกสบายในการเขียนโปรแกรม อย่างไรก็ตาม หากสิ่งต่าง ๆ รุนแรงเกินไป จะต้องกลับกัน หากคุณผสมโค้ด PHP และโค้ด HTML ในโปรแกรมขนาดยาว มันจะทำให้โปรแกรมยุ่งเหยิงและไม่เอื้ออำนวยต่อการบำรุงรักษาและการอ่านโปรแกรม ดังนั้นเราจึงจำเป็นต้องย้ายโค้ด PHP ที่ผสมอยู่ในโค้ด HTML ในโปรแกรมเหล่านี้ให้มากที่สุดเท่าที่จะเป็นไปได้ ห่อหุ้มโค้ดเหล่านี้ให้เป็นฟังก์ชันในไฟล์พิเศษ จากนั้นใช้คำสั่ง include ในโค้ด HTML เพื่อรวมไฟล์เหล่านี้ในตำแหน่งที่เหมาะสม เพียงเรียกใช้ฟังก์ชันเหล่านี้
แนวทางหนึ่งทำให้ทั้งโค้ด HTML และโค้ด PHP ง่ายและอ่านง่าย ในทางกลับกัน เนื่องจากโค้ด HTML จำเป็นต้องได้รับการอัปเดตอย่างต่อเนื่อง วิธีการแยกนี้จึงสามารถรับประกันได้ว่าโปรแกรมพื้นหลังจะไม่ถูกทำลาย .
โปรแกรมแบ็คเอนด์ต่างจากโปรแกรมส่วนหน้าตรงที่มีความเสถียร โครงสร้าง และไม่ค่อยมีการเปลี่ยนแปลง ดังนั้น จึงควรได้รับการออกแบบและจัดการอย่างระมัดระวัง ในความเป็นจริง คุ้มค่าที่จะลงทุนเวลามากมายในการออกแบบโปรแกรมเดสก์ท็อป "ปลูกต้นไม้ตอนนี้แล้วเพลิดเพลินไปกับร่มเงาในภายหลัง" คุณจะสามารถใช้โปรแกรมพื้นหลังที่คุณเขียนตอนนี้ในงานออกแบบในอนาคตได้อย่างง่ายดาย
2. การใช้ไฟล์รวมอย่างยืดหยุ่น
ดังที่ได้กล่าวไว้ข้างต้น โปรแกรมพื้นหลังควรถูกจัดเรียงเป็นชุดของไฟล์รวม ไฟล์ที่รวมไว้สามารถโหลดแบบไดนามิกได้เมื่อจำเป็นผ่านคำสั่ง include หรือสามารถโหลดล่วงหน้าโดยอัตโนมัติได้โดยใช้คำสั่ง auto_prepend_file ในไฟล์ php.ini
หากคุณใช้วิธีหลังแม้ว่าคุณจะได้รับประโยชน์ทันที แต่ก็มีข้อบกพร่องบางประการที่ควรค่าแก่การเอาใจใส่ของเรา โค้ดต่อไปนี้แสดงให้เราเห็นว่าต้องใช้เวลานานแค่ไหนในการแยกวิเคราะห์ไฟล์รวมขนาดใหญ่:
need(timing.inc);
ss_timing_start();
รวม(test.inc);
ss_timing_stop();
เสียงสะท้อน
.ss_timing_current()
?>
ในโค้ดด้านบน test.inc เป็นไฟล์รวม 1,000 บรรทัด ผลการทำงานแสดงว่าใช้เวลา 0.6 วินาทีในการแยกวิเคราะห์ไฟล์นี้ สำหรับเว็บไซต์ขนาดใหญ่ ความเร็วนี้ถือว่าไม่สำคัญ
ข้อเสียอีกประการหนึ่งของการใช้ไฟล์รวมคือหากเกิดข้อผิดพลาดในคำสั่งในไฟล์ โปรแกรม PHP ของเว็บไซต์ทั้งหมดจะไม่สามารถทำงานได้ ดังนั้นใช้มันอย่างระมัดระวัง
ในความเป็นจริง ด้วยการประมวลผลไฟล์ include เพียงเล็กน้อย ไฟล์ include จะสามารถแยกวิเคราะห์ได้เมื่อจำเป็นเท่านั้น โค้ดต่อไปนี้ทำให้ไฟล์ abc.inc ถูกแยกวิเคราะห์เมื่อโปรแกรมต้องการเท่านั้น:
if (defined(__LIBA_INC)) return;
กำหนด(__LIBA_INC, 1);
-
* รหัส...
-
?>
3. ใช้วิธีการเขียนโปรแกรมเชิงวัตถุ
PHP ก็เป็นภาษาเชิงวัตถุเช่นกัน วิธีการเขียนโปรแกรมเชิงวัตถุเป็นวิธีการออกแบบซอฟต์แวร์ที่ได้รับการยอมรับอย่างสูงจากโปรแกรมเมอร์ที่เก่งกาจ ข้อดีคือการห่อหุ้มวัตถุในการเขียนโปรแกรม ในโค้ดก่อนหน้านี้ เราใช้วิธีเชิงวัตถุ ตัวอย่างเช่น เมื่อจัดการฐานข้อมูล เราได้รวมฟังก์ชัน query() ไว้ในคลาสฐานข้อมูล ซึ่งอำนวยความสะดวกในการจัดการโค้ดเป็นอย่างมาก และเพิ่มความสามารถในการอ่านของโปรแกรม
3. ดำเนินการตามความเร็วของโปรแกรมมากกว่าความเร็วของการเขียนโปรแกรม
ในการสร้างเว็บไซต์ ความเร็วในการรันโปรแกรมและความเร็วในการดาวน์โหลดหน้าเว็บเป็นปัจจัยสำคัญที่กำหนดความสำเร็จหรือความล้มเหลว ในฐานะเว็บโปรแกรมเมอร์ คุณควรให้ความสำคัญกับความเร็วในการรันโค้ดของคุณให้มากขึ้น หลายวิธีที่แนะนำด้านล่างล้วนปรับปรุงความเร็วในการรันโค้ดเป็นองศาที่แตกต่างกัน
1. ใช้โค้ด HTML ที่ฝังแทนคำสั่ง echo ของ PHP
เนื่องจาก PHP เป็นภาษาการเขียนโปรแกรมเว็บแบบฝัง โค้ด HTML และโค้ด PHP จึงสามารถฝังซึ่งกันและกันได้ อย่างไรก็ตาม โปรแกรมเมอร์จำนวนมากกังวลว่าการใช้ "" มากเกินไปเพื่อฝังโค้ด PHP ในโค้ด HTML จะเรียกล่าม PHP หลายครั้ง ซึ่งจะลดความเร็วในการรันโค้ด PHP ดังนั้นพวกเขาจึงควรใช้คำสั่ง echo ของ PHP เพื่อส่งออกโค้ด HTML แทน โดยตรง ใช้โค้ด HTML แต่ความจริงมันตรงกันข้ามเลย หน้า PHP แต่ละหน้าจะเรียกตัวแปล PHP เพียงครั้งเดียวเพื่อตีความโค้ด PHP ทั้งหมด ดังนั้น การฝังโค้ด PHP เมื่อจำเป็นเท่านั้น และโดยส่วนใหญ่แล้วการใช้โค้ด HTML โดยตรงเพื่อป้อนผลลัพธ์จะไม่เพียงแต่ไม่ลดความเร็วในการรันของโปรแกรมเท่านั้น เนื่องจากการแยกวิเคราะห์คำสั่ง echo ลดลง ความเร็วในการรันโค้ดจึงมักจะได้รับการปรับปรุงให้ดีขึ้น
โค้ดต่อไปนี้แสดงให้เห็นถึงข้อสรุปของเรา ในโค้ดนี้ เราใช้ฟังก์ชันทดสอบเวลาที่แนะนำไปก่อนหน้านี้
ใช้ str-replace แทน ereg-replace
โปรแกรมเมอร์ที่เคยชินกับการเขียนโปรแกรมในภาษา Perl มักจะเต็มใจที่จะใช้ ereg_replace เพื่อแทนที่สตริง เนื่องจากการใช้ ereg_replace ใน PHP นั้นคล้ายคลึงกับการใช้การจับคู่รูปแบบใน Perl อย่างไรก็ตาม โค้ดต่อไปนี้พิสูจน์ว่าการใช้ str_replace แทน ereg_replace จะปรับปรุงความเร็วในการรันโค้ดได้อย่างมาก
ทดสอบความเร็วในการรันของ str_replace และ ereg_replace
//โค้ดนี้ทดสอบความเร็วในการรันของ str_replace
เน้น; ?>
สำหรับ (＄i=0; ＄i<1000; ＄i＋＋) {
str_replace(i>, b>, $string)
-
?>
//โค้ดนี้ทดสอบความเร็วในการทำงานของ ereg_replace
สำหรับ (＄i=0; ＄i<1000; ＄i＋＋) {
ereg_replace(<([/]＊)i>, <1b>, $string)
-
-
//พิมพ์
ข้อสรุปผลลัพธ์
โดยใช้เวลา str_replace -
ถึงเวลาใช้ ereg_pattern -
รันโค้ดด้านบน ผลลัพธ์คือ:
ถึงเวลาใช้ str_replace - 0.089757
เวลาที่จะใช้ ereg_pattern - 0.248881
จากผลการรัน เราจะเห็นว่าการใช้ str_replace แทน ereg_replace เนื่องจากฟังก์ชันการแทนที่สตริงช่วยปรับปรุงความเร็วในการรันของโค้ดได้อย่างมาก
3. ให้ความสนใจกับเครื่องหมายคำพูดแบบสตริง
PHP เช่นเดียวกับภาษาโปรแกรมอื่นๆ มากมาย สามารถใช้เครื่องหมายคำพูดคู่ ("") เพื่ออ้างอิงสตริงหรือเครื่องหมายคำพูดเดี่ยว () แต่ใน PHP หากคุณใช้เครื่องหมายคำพูดคู่เพื่ออ้างอิงสตริง ตัวแยกวิเคราะห์ PHP จะวิเคราะห์ก่อนว่ามีการอ้างอิงถึงตัวแปรในสตริงหรือไม่ หากมีตัวแปรตัวแปรนั้นจะแทนที่ตัวแปรนั้น หากเป็นเครื่องหมายคำพูดเดี่ยว ก็ไม่ซับซ้อนมากนัก - สตริงทั้งหมดที่อยู่ในเครื่องหมายคำพูดเดี่ยวจะแสดงโดยตรง แน่นอนว่าในการเขียนโปรแกรม PHP การใช้เครื่องหมายคำพูดเดี่ยวเพื่ออ้างอิงตัวแปรสตริงจะเร็วกว่าการใช้เครื่องหมายคำพูดคู่
4. หลีกเลี่ยงการใช้การดำเนินการร่วมกันในฐานข้อมูล
เมื่อเปรียบเทียบกับภาษาการเขียนโปรแกรมเว็บอื่นๆ ฟังก์ชันฐานข้อมูลของ PHP มีประสิทธิภาพมาก อย่างไรก็ตาม การรันฐานข้อมูลใน PHP ยังคงเป็นเรื่องที่กินเวลามากและต้องใช้แรงงานมาก ดังนั้น ในฐานะเว็บโปรแกรมเมอร์ คุณต้องลดการดำเนินการสืบค้นฐานข้อมูลและสร้างดัชนีที่เหมาะสมสำหรับฐานข้อมูล อีกสิ่งหนึ่งที่น่าสังเกตคือเมื่อใช้ PHP เพื่อดำเนินการฐานข้อมูล พยายามอย่าใช้การดำเนินการร่วมกันของตารางข้อมูลหลายตาราง แม้ว่าการดำเนินการร่วมกันจะปรับปรุงฟังก์ชันการสืบค้นของฐานข้อมูลได้ แต่ก็เพิ่มภาระบนเซิร์ฟเวอร์อย่างมาก
เพื่ออธิบายปัญหานี้ เราสามารถดูตัวอย่างง่ายๆ ด้านล่าง
เราสร้างตารางข้อมูลสองตาราง foo และ big_foo ในฐานข้อมูล ในตารางข้อมูล foo มีเพียงช่องเดียวเท่านั้น ซึ่งมีตัวเลขธรรมชาติทั้งหมดตั้งแต่ 1 ถึง 1,000 ตารางข้อมูล big_foo มีเพียงช่องเดียวเท่านั้น แต่ประกอบด้วยตัวเลขธรรมชาติทั้งหมดตั้งแต่ 1 ถึง 1,000,000 ดังนั้น ในแง่ของขนาด big_foo จะเท่ากับ foo เมื่อรวมกับตัวมันเอง
$db->query("select * from foo");
0.032273 วินาที
$db->next_record();
0.00048999999999999 วินาที
$db->query("ใส่ค่า foo (NULL)");
0.019506 วินาที
$db->query("select * from foo as a, foo as b");
17.280596 วินาที
$db－>query("select ＊ จาก foo as a, foo as b โดยที่ a.id > b.id");
14.645251 วินาที
$db－>query("select ＊ จาก foo as a, foo as b โดยที่ a.id = b.id");
0.041269 วินาที
$db－>query("select * from big_foo");
25.393672 วินาที
จากผลการดำเนินการข้างต้น เราพบว่าความเร็วในการรวมตารางข้อมูล 2 ตารางที่มี 1,000 บันทึกนั้นไม่ได้เร็วกว่าการดำเนินการแยกตารางข้อมูลขนาดใหญ่ที่มี 1,000,000 บันทึกมากนัก
5. ให้ความสนใจกับความแตกต่างระหว่าง include และ need
ในการเขียนโปรแกรม PHP include() และ need() มีฟังก์ชันเหมือนกัน แต่มีความแตกต่างบางประการในการใช้งาน include() เป็นฟังก์ชันการรวมแบบมีเงื่อนไข ในขณะที่ need() คือ มีฟังก์ชันที่ไม่มีเงื่อนไข ตัวอย่างเช่น ในตัวอย่างต่อไปนี้ หากตัวแปร $somgthing เป็นจริง ไฟล์ somefile จะถูกรวมไว้ด้วย:
if($something){
รวม("somefile");
}
แต่ไม่ว่า $something จะใช้ค่าอะไรก็ตาม โค้ดต่อไปนี้จะรวมไฟล์ somefile ไว้ในไฟล์:
if($something){
ต้องการ("ไฟล์บางไฟล์");
}
ตัวอย่างที่น่าสนใจต่อไปนี้แสดงให้เห็นถึงความแตกต่างระหว่างฟังก์ชันทั้งสองนี้
$i = 1;
ในขณะที่ (＄i < 3) {
ต้องการ("somefile.$i");
$i++;
}
ในโค้ดนี้ โปรแกรมจะรวมไฟล์เดียวกันทุกครั้งที่วนซ้ำ แน่นอนว่านี่ไม่ใช่ความตั้งใจเดิมของโปรแกรมเมอร์ จากโค้ดนี้ เราจะเห็นว่าโค้ดนี้หวังว่าจะรวมไฟล์ที่แตกต่างกันในแต่ละลูป หากคุณต้องการทำให้ฟังก์ชันนี้สมบูรณ์ คุณต้องเปลี่ยนไปใช้ฟังก์ชัน include():
$i = 1;
ในขณะที่ (＄i < 3) {
รวม("somefile.＄i");
$i++;
}
6. ให้ความสนใจกับความแตกต่างระหว่าง echo และ print โดย
พื้นฐานแล้วฟังก์ชันของ echo และ print ใน PHP นั้นเหมือนกัน แต่มีความแตกต่างเล็กน้อยระหว่างทั้งสอง คุณสามารถใช้ print เป็นฟังก์ชันปกติในโค้ด PHP ได้ ตัวอย่างเช่น หลังจากรันโค้ดต่อไปนี้ ค่าของตัวแปร $res จะเป็น 1
$ret = print "Hello World";
ซึ่งหมายความว่า print สามารถใช้ในนิพจน์ที่ซับซ้อนบางอย่างได้ แต่ echo ไม่สามารถทำได้ ในทำนองเดียวกัน คำสั่ง echo จะรันเร็วกว่าคำสั่ง print ในโค้ดเล็กน้อย เนื่องจากคำสั่ง echo ไม่จำเป็นต้องส่งคืนค่าใดๆ