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

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

วิธีกำหนดเวลาดำเนินการสคริปต์ใน php.ini

ปัญหานี้แก้ไขได้อย่างง่ายดายโดยใช้ฟังก์ชันสำหรับการทำงานกับวันที่และเวลา ได้แก่ ฟังก์ชันในตัว microtime() ซึ่งส่งคืนจำนวนวินาทีที่ผ่านไปตั้งแต่เที่ยงคืนของวันที่ 01/01/1970 ด้วยการเรียกใช้ฟังก์ชันนี้สองครั้ง เราสามารถคำนวณเวลาที่ผ่านไประหว่างการโทรได้:

หากคุณรันสคริปต์ ผลลัพธ์จะเป็นดังนี้:

เวลาดำเนินการสคริปต์: 0.00059400000000001

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

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

เมื่อทำการดีบั๊กสคริปต์ ปัจจัยบังคับที่ต้องคำนึงถึงก่อนคือ เวลาดำเนินการสคริปต์- และในบทความสั้น ๆ นี้ ฉันจะแสดงวิธีที่ดีและเรียบง่ายมาก วิธีค้นหาเวลาดำเนินการของสคริปต์.

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

$start = ไมโครไทม์(จริง);
$รวม = 0;
สำหรับ ($i = 0; $i< 100000; $i++) $sum += $i;
echo "เวลาดำเนินการสคริปต์: ".(microtime(true) - $start);
?>

ผลที่ตามมาเราจะเห็นว่า เวลาดำเนินการสคริปต์จะเป็นเช่นนี้: " 0.014652967453 “.ถ้าปัดเศษแล้วนี่. 0.015 วินาที นี่คือเวลาดำเนินการของสคริปต์

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

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

ฉันคิดว่ามันง่ายที่นี่ แต่ฉันขอแนะนำอย่างยิ่งให้คุณใช้วิธีการคำนวณเวลานี้ ตัวอย่างเช่น ตอนที่ฉันแก้ไขการทำงานของเครื่องยนต์ซึ่งเป็นที่ตั้งของไซต์นี้ ฉันเร่งการทำงานของมันไปเกือบหมด 2 ครั้ง

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

ทำไมต้องวัดในการเขียนโปรแกรม?

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

ลองจินตนาการดูสักหน่อย ลองจินตนาการว่ามีกลไก "เขียนเอง" อยู่บ้าง ซึ่งนักพัฒนาได้ "อัปโหลด" ไปยังโฮสติ้งที่ดีและเปิดตัวเว็บไซต์ของเขา (ตามนั้น) แต่ด้วยเหตุผลบางประการ การโหลดทรัพยากรทางฝั่งผู้ใช้จึงช้ามาก

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

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

คุณสมบัติ PHP

ฉันเรียกมันว่าเป็นหนึ่งในภาษาการเขียนโปรแกรมที่สะดวกที่สุดมาโดยตลอด เพื่อติดตามเวลาทำงานของโค้ด นักพัฒนาไม่จำเป็นต้องเขียน “talmuds” ยาวๆ เพื่อดักจับแต่ละบรรทัดของสคริปต์ เทคโนโลยีนี้ใช้เครื่องมือพิเศษหลายอย่าง ฟังก์ชันหลักคือฟังก์ชัน microtime() มันจะส่งคืนเวลา (เป็นมิลลิวินาที) ที่ผ่านไปตั้งแต่ต้นปี 1970 สิ่งที่เรียกว่า "จุดเริ่มต้นของยุค Unix" หากคุณส่งพารามิเตอร์ get_as_float ไปยังฟังก์ชันที่มีค่า true ก็จะส่งคืนช่วงเวลาในรูปแบบวินาทีทั้งหมดและเศษส่วนมิลลิวินาที

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

"; $last=microtime(true); $value=$last-$first; echo "สคริปต์ถูกเรียกใช้งานใน: ".$value; ?>

การเปลี่ยนเวลาทำงานของโค้ด

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

ซึ่งหมายความว่าในการตั้งค่าพารามิเตอร์ max_execution_time ถูกตั้งค่าเป็นค่าเริ่มต้น (30 วินาที) มาเพิ่มเวลาดำเนินการสูงสุดของสคริปต์ใน PHP 3 เท่า

ตอนนี้เราไม่ได้รับข้อความแสดงข้อผิดพลาดใดๆ

การดำเนินการเบื้องหลังของสคริปต์ใน PHP โดยไม่มี crontab

• การพัฒนาเว็บไซต์

ฉันสับสนกับการเขียน daemon ใน PHP เหล่านั้น. สคริปต์ที่จะดำเนินการบางอย่างตามจำนวนครั้งที่กำหนดในจำนวนชั่วโมงที่กำหนดในเวลาสุ่ม (สุ่มเสมอ) และทั้งหมดนี้โดยไม่ต้องใช้ cron

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

ความคิดแรกคือการปิดการใช้งานการจำกัดเวลาดำเนินการสคริปต์ ต้องห้ามโดยเจ้าภาพ

แนวคิดที่สองคือการทำซ้ำคำขอ Ajax เป็นระยะ (ใช่ อย่างน้อยหนึ่งครั้งต่อวินาที) โดยใช้ JavaScript - เป็นไปไม่ได้ (ความต้องการของลูกค้า)

ความจริงแล้วปรากฎว่าไม่ควรเปิดเบราว์เซอร์และไม่ควรใช้ cron และสคริปต์ควรทำงานโดยไม่คำนึงถึงผู้ใช้อย่างไม่มีกำหนด โดยปกติแล้วควรโหลดระบบให้น้อยที่สุด

1. ซองบุหรี่ กลางคืน Google เอกสาร หนังสือ คู่มือ….
ไปที่ 1…

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

ภารกิจ_2:
ทำงานหลังจากปิดเบราว์เซอร์

ภารกิจ_3:
อย่าหยุดทำงานหลังจากหมดเวลาดำเนินการสคริปต์แล้ว

ภารกิจ_4:
ดำเนินการบางอย่างในเวลาที่เหมาะสม

ดังนั้น…
เราเขียนข้อมูลเริ่มต้นในการกำหนดค่า:

Session_start(); // เริ่มเซสชั่น $num_starts = 120; // จำนวนสคริปต์ที่ทำงานในช่วงเวลา $hours = 1; // จำนวนชั่วโมงในการรันสคริปต์ $num_starts ครั้ง $time_sec = $ชั่วโมง*3600; // จำนวนวินาทีในรอบการเปิดตัว $time_to_start = array(); // จริงๆ แล้ว อาร์เรย์ที่มีเวลาเปิดตัวign_user_abort(1); // ละเว้นการสูญเสียการเชื่อมต่อกับเบราว์เซอร์

ต่อไป เราจะเขียนฟังก์ชันที่จะช่วยสร้างเวลาเริ่มต้น
ในนั้นเราสร้างตัวเลขสุ่มตั้งแต่ 0 ถึงจำนวนวินาทีในช่วงเวลาเดิม
/****** * @desc สร้างช่วงเวลาระหว่างการเปิดตัว */ function add_time2start() ( global $time_sec, $time_to_start; $new_time = time()+rand(0, $time_sec); if (!in_array($new_time, $time_to_start)) ( // ถ้าไม่มีเวลาดังกล่าว ในอาร์เรย์ - เพิ่ม $time_to_start = $new_time; ) else ( add_time2start(); // หากมีเวลาดังกล่าวอยู่แล้ว ให้สร้างใหม่อีกครั้ง ) )

$เค = 1; ถ้า ($_SESSION["num_st"] == "" || $_SESSION["num_st"][$num_starts-1]< time()) { // проверка, что в сессию не записаны данные и что эти данные не устарели. do { add_time2start($k); $k++; } while ($k < = $num_starts); sort($time_to_start, SORT_NUMERIC); $_SESSION["num_st"] = $time_to_start; }

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

ดังนั้น... เราคำนวณข้อมูลเวลาเริ่มต้น:

$start_time = ไมโครไทม์(); // ค้นหาเวลาเปิดตัวสคริปต์ $start_array = explode(" ",$start_time); // แยกวินาทีและมิลลิวินาที $start_time = $start_array; // รับเวลาเริ่มต้นของสคริปต์ $max_exec = ini_get("max_execution_time"); //รับเวลาทำงานสูงสุดที่เป็นไปได้ของสคริปต์
จริงๆแล้วเป็นวงจร ความคิดเห็นในรหัส

Do( $nowtime = time(); // เวลาปัจจุบัน ///// หากเวลาปัจจุบันอยู่ในอาร์เรย์ที่มีเวลาในการเรียกใช้สคริปต์...... if (in_array($nowtime, $_SESSION["num_st"]) ) ( // เราเชื่อมต่อซ็อกเก็ตกับไฟล์ด้วยเนื้อหาหลักของการกระทำ $http = fsockopen("test.ru",80); /// ในขณะเดียวกันเราก็ถ่ายโอนข้อมูลเซสชันและเวลาที่มัน ควรใช้งานได้ fputs($http, "GET http://test .ru/exec.php?".session_name()."=".session_id()."&nowtime=$nowtime HTTP/1.0\r\n"); fputs($http, "Host: test.ru\r\ n"); fputs($http, "\r\n"); fclose($http); ) // ดำเนินการตามที่ระบุ // ค้นหา เวลาปัจจุบันเพื่อตรวจสอบว่าจะดำเนินการวนซ้ำหรือรีสตาร์ท $now_time = microtime( ); $now_array = explode(" ",$now_time); $now_time = $now_array; // ลบเวลาเริ่มต้นจากเวลาปัจจุบัน $exec_time = $now_time - $start_time+$exec_time; /// ช้าลงเป็นครั้งที่สอง (1000000); // การหยุดสคริปต์ที่ทำงานอยู่เบื้องหลัง ฉันไม่ได้คิดวิธีอื่นถ้า (file_exists("stop.txt" )) ออก; //ตรวจสอบเวลาทำงาน หากเหลือเวลาน้อยกว่า 5 วินาทีจนกว่าจะสิ้นสุดสคริปต์ เราจะสิ้นสุดวงจร ) ในขณะที่($exec_time< ($max_exec - 5));

ถ้าเวลาที่อนุญาตกำลังจะสิ้นสุดลง เราก็จะเสร็จสิ้นวงจรและเรียกใช้สคริปต์เดียวกันอย่างปลอดภัยในกระบวนการอื่น ๆ (เราจะเก็บไว้ภายใน 5 วินาทีอย่างแน่นอน)

// เรียกใช้สคริปต์เดียวกันกับกระบวนการใหม่และยุติอันปัจจุบัน $http = fsockopen("test.ru",80); fputs($http, "GET http://test.ru/index.php?".session_name()."=".session_id()."&bu=$max_exec HTTP/1.0\r\n"); fputs($http, "โฮสต์: test.ru\r\n"); fputs($http, "\r\n"); fclose($http);

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

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

ขอให้เป็นวันที่ดีเพื่อนร่วมงาน!

วันนี้ฉันตัดสินใจพูดถึงหัวข้อต่างๆ เช่น เวลาดำเนินการของสคริปต์ PHP และคำจำกัดความ

ฉันจะไม่บอกว่าความต้องการนี้เกิดขึ้นทุกวัน แต่ในบางครั้งในทางปฏิบัติ สถานการณ์เกิดขึ้นเมื่อคุณต้องการเวลาทำงานของสคริปต์ PHP

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

และบางครั้งผู้จัดการและลูกค้าจำเป็นต้องใช้ตัวเลขเหล่านี้ซึ่งต้องการทราบว่าจะใช้เวลานานแค่ไหนในการดำเนินการเฉพาะในโค้ด

ดังนั้นฉันจึงตัดสินใจเขียนบันทึกสั้น ๆ นี้ โดยฉันตัดสินใจร่างขั้นตอนการดำเนินการในสถานการณ์ที่คล้ายคลึงกัน

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

เวลาดำเนินการของสคริปต์ PHP - อัลกอริธึมการกำหนด

ขั้นตอนการดำเนินการของเราจะง่ายมาก:

1. กำหนดเวลาเซิร์ฟเวอร์ปัจจุบันในโค้ด PHP ก่อนดำเนินการตามที่ระบุในสคริปต์
2. หลังจากรันสคริปต์แล้ว เราจะค้นหาเวลาของเซิร์ฟเวอร์อีกครั้ง
3. เมื่อใช้ PHP เราคำนวณความแตกต่างของเวลาระหว่างความสมบูรณ์ของสคริปต์และการเริ่มต้น

ค่าผลลัพธ์คือเวลาดำเนินการของสคริปต์ PHP ซึ่งสามารถนำมาพิจารณาระหว่างการปรับให้เหมาะสมเพิ่มเติมและการดำเนินการอื่น ๆ

เวลาทำงานของสคริปต์ PHP - การใช้อัลกอริทึม

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

ทำไมความแม่นยำเช่นนี้?

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

นอกจากนี้เมื่อคำนึงถึงไมโครวินาทีในการคำนวณจะส่งผลต่อความแม่นยำของการคำนวณในทิศทางที่เป็นบวก

เพื่อสาธิตเรื่องราวทางทฤษฎีของฉัน ฉันเขียนสคริปต์ง่ายๆ ที่คำนวณเวลารันของลูปว่างด้วยการวนซ้ำ 30,000,000 ครั้ง (ฉันตัดสินใจใช้มากกว่านี้เพื่อความชัดเจน):

ฟังก์ชัน PHP microtime() มีเพียงพารามิเตอร์เดียวเท่านั้น get_as_floatเมื่อระบุค่าแล้ว จริงคุณสามารถรับเวลา PHP ปัจจุบันเป็นวินาทีนับตั้งแต่ยุค Unix ด้วยความแม่นยำระดับไมโครวินาที

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

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

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

ด้วยเหตุนี้ การก่อสร้างต่อไปนี้จึงส่งข้อความกลับมา สคริปต์ถูกดำเนินการใน 2.0000510215759 วินาที:

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

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

รอบ(ไมโครไทม์(จริง) - $start, 2);

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

นี่เป็นการสรุปข้อมูลวันนี้เกี่ยวกับวิธีการกำหนดเวลาดำเนินการของสคริปต์ PHP

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