Back to Question Center
0

วิธีการอ่านไฟล์ขนาดใหญ่ด้วย PHP (โดยไม่ต้องฆ่าเซิร์ฟเวอร์ของคุณ) วิธีการอ่านไฟล์ขนาดใหญ่ด้วย PHP (โดยไม่ต้องฆ่าเซิร์ฟเวอร์ของคุณ) หัวข้อที่เกี่ยวข้อง: Drupal Semalt การพัฒนา

1 answers:
วิธีการอ่านไฟล์บิ๊กด้วย PHP (โดยไม่ต้องฆ่าเซิร์ฟเวอร์ของคุณ)

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

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

How to Read Big Files with PHP (Without Killing Your Server)How to Read Big Files with PHP (Without Killing Your Server)Related Topics:
DrupalDevelopment Semalt

Semalt ปัญหาหลังเราจะดูในบทแนะนำนี้

โค้ดสำหรับการกวดวิชานี้สามารถพบได้ใน GitHub

วัดความสำเร็จ

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

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

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

การวัดการใช้งานซีพียูใน PHP ไม่สามารถทำได้ ถ้าเป็นพื้นที่ที่คุณต้องการเน้นให้พิจารณาการใช้สิ่งต่างๆเช่น ด้านบน บน Ubuntu หรือ macOS สำหรับ Windows ให้พิจารณาใช้ Linux Subsystem ดังนั้นคุณสามารถใช้ top ใน Ubuntu ได้

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

วิธีการที่เราจะใช้เพื่อดูว่าหน่วยความจำใช้คืออะไร

     // formatBytes ถูกนำมาจาก PHP สุทธิเอกสารmemory_get_peak_usage   ;function formatBytes ($ bytes, $ precision = 2) {$ units = array ("b", "kb", "mb", "gb", "tb");$ bytes = max ($ bytes, 0);$ pow = floor ((ไบต์ $ log ($ bytes): 0) / log (1024));$ pow = min ($ pow, count ($ units) - 1);$ bytes / = (1 << (10 * $ pow));รอบตอบแทน (ไบต์ $, ความแม่นยำ $) "" $ หน่วย [$ ธาร];}    

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

ตัวเลือกของเราคืออะไร?

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

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

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

การอ่านไฟล์ทีละบรรทัด

มีหลายฟังก์ชันสำหรับการทำงานกับไฟล์ semalt รวมไม่กี่เป็นผู้อ่านไฟล์ไร้เดียงสา:

     // จากหน่วยความจำ PHPfunction formatBytes ($ bytes, $ precision = 2) {$ units = array ("b", "kb", "mb", "gb", "tb");$ bytes = max ($ bytes, 0);$ pow = floor ((ไบต์ $ log ($ bytes): 0) / log (1024));$ pow = min ($ pow, count ($ units) - 1);$ bytes / = (1 << (10 * $ pow));รอบตอบแทน (ไบต์ $, ความแม่นยำ $) "" $ หน่วย [$ ธาร];}พิมพ์รูปแบบไบต์ (memory_get_peak_usage   );    
     // จากการอ่านไฟล์ -line-by-line-1 PHPfunction readTheFile ($ path) {$ lines = [];$ handle = fopen ($ path, "r");while (feof ($ handle)) {$ lines [] = trim (fgets ($ handle));}fclose ($ จับ);return $ lines;}readTheFile ("เช็คสเปียร์ txt");ต้อง "หน่วยความจำ php";    

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

     // จากการอ่านไฟล์ -line-by-line-2 PHPfunction readTheFile ($ path) {$ handle = fopen ($ path, "r");while (feof ($ handle)) {ตัดผลผลิต (fgets ($ handle));}fclose ($ จับ);}readTheFile ("เช็คสเปียร์ txt");ต้อง "หน่วยความจำ php";    

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

     // จากการอ่านไฟล์ -line-by-line-3 PHP$ iterator = readTheFile ("shakespeare. txt");$ buffer = "";foreach ($ iterator เป็น $ iteration) {preg_match ("/ \ n {3} /", $ buffer, $ matches);if (count ($ matches)) {พิมพ์ " - envio newsletter php.";$ buffer = "";} else {$ บัฟเฟอร์ = $ iteration PHP_EOL;}}ต้อง "หน่วยความจำ php";    

คาดเดาได้ว่าเราใช้หน่วยความจำมากแค่ไหน? น่าแปลกใจที่คุณจะรู้ว่าแม้ว่าเราจะแยกเอกสารข้อความออกเป็นชิ้น 1,216 ชิ้นส่วนเรายังใช้เฉพาะหน่วยความจำ 459KB เท่านั้น? เมื่อพิจารณาถึงลักษณะของเครื่องปั่นไฟแล้วหน่วยความจำส่วนใหญ่ที่เราจะใช้คือสิ่งที่เราต้องเก็บข้อความที่ใหญ่ที่สุดในการทำซ้ำ ในกรณีนี้ก้อนที่ใหญ่ที่สุดคือ 101,985 ตัวอักษร

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

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

การวางท่อระหว่างไฟล์

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

     // จากท่อ - ไฟล์ - 1 PHPfile_put_contents ("piping-files-1 .txt", file_get_contents ("shakespeare. txt"));ต้อง "หน่วยความจำ php";    

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

Semalt ลองสตรีมมิ่ง (หรือท่อ) จากไฟล์หนึ่งไปยังอีก:

     // จากท่อ - ไฟล์ - 2. txt "," r ");$ handle2 = fopen ("piping-files-2. txt", "w");stream_copy_to_stream ($ handle1, $ handle2);fclose ($ handle1);fclose ($ handle2);ต้อง "หน่วยความจำ php";    

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

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

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

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

     // จากท่อ - ไฟล์ - 3 PHPfile_put_contents ("piping-files-3 .jpeg", file_get_contents ("https: // github. com / assertchris / ไฟล์ / raw / master / rick. jpg"));// . หรือเขียนข้อมูลนี้ตรงไปยัง stdout ถ้าเราไม่ต้องการข้อมูลหน่วยความจำต้อง "หน่วยความจำ php";    

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

การใช้หน่วยความจำ (สำหรับภาพนี้) อยู่ที่ประมาณ 581KB ตอนนี้เราลองใช้กระแสข้อมูลนี้แทนหรือไม่

     // จากท่อ - ไฟล์ - 4 PHP$ handle1 = fopen ("https: // github. com / assertchris / อัปโหลด / raw / master / rick. jpg", "r");$ handle2 = fopen ("piping-files-4. jpeg", "w");// . หรือเขียนข้อมูลนี้ตรงไปยัง stdout ถ้าเราไม่ต้องการข้อมูลหน่วยความจำstream_copy_to_stream ($ handle1, $ handle2);fclose ($ handle1);fclose ($ handle2);ต้อง "หน่วยความจำ php";    

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

     $ handle1 = fopen ("https: // github. com / assertchris / อัปโหลด / raw / master / rick. jpg", "r");$ handle2 = fopen ("php: // stdout", "w");stream_copy_to_stream ($ handle1, $ handle2);fclose ($ handle1);fclose ($ handle2);/ / ต้อง "หน่วยความจำ php";    

สตรีมอื่น ๆ

Semalt เป็นอีกสองสามสายที่เราสามารถท่อและ / หรือเขียนถึงและ / หรืออ่านจาก:

  • php: // stdin (อ่านอย่างเดียว)
  • php: // stderr (เขียนอย่างเดียวเช่น php: // stdout)
  • php: // อินพุท (อ่านอย่างเดียว) ซึ่งทำให้เราสามารถเข้าถึงเนื้อหาคำขอ raw
  • php: // output (write-only) ซึ่งจะช่วยให้เราเขียนข้อมูลไปยังบัฟเฟอร์เอาต์พุต
  • php: // หน่วยความจำ และ php: // temp (อ่าน - เขียน) เป็นสถานที่ที่เราสามารถจัดเก็บข้อมูลชั่วคราว ความแตกต่างก็คือ php: // temp จะจัดเก็บข้อมูลในระบบไฟล์เมื่อมีขนาดใหญ่พอในขณะที่ php: // หน่วยความจำ จะเก็บข้อมูลในหน่วยความจำจนกว่าจะหมด .

ตัวกรอง

มีเคล็ดลับอื่นที่เราสามารถใช้กับสตรีมที่เรียกว่า ตัวกรอง พวกเขาอยู่ในระหว่างขั้นตอนให้บิตของการควบคุมข้อมูลสตรีมโดยไม่ต้องเปิดเผยให้เรา คิดว่าเราต้องการบีบอัดเช็คสเปียร์ ของเรา txt . PHP$ zip = new ZipArchive ;$ filename = "filters-1. zip";$ zip-> open ($ filename, ZipArchive :: CREATE);$ zip-> addFromString ("เช็คสเปียร์ txt", file_get_contents ("shakespeare. txt"));$ zip-> ปิด ;ต้อง "หน่วยความจำ php";

รหัสนี้เป็นรหัสที่เรียบง่าย แต่มีนาฬิกาอยู่ที่ประมาณ 10. 75MB เราสามารถทำได้ดีกว่าด้วยตัวกรอง:

     // จากตัวกรอง - 2 PHP$ handle1 = fopen ("php: // filter / zlib. deflate / resource = เช็คสเปียร์ txt", "r");$ handle2 = fopen ("filter-2. deflated", "w");stream_copy_to_stream ($ handle1, $ handle2);fclose ($ handle1);fclose ($ handle2);ต้อง "หน่วยความจำ php";    

ที่นี่เราจะเห็น php: // filter / zlib deflate ซึ่งอ่านและบีบอัดเนื้อหาของรีซอร์ส จากนั้นเราจะสามารถบีบข้อมูลที่บีบอัดนี้ลงในไฟล์อื่นได้ ใช้เฉพาะ 896KB เท่านั้น

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

เมื่อต้องการยกเลิกการบีบอัดข้อมูลเราสามารถเรียกใช้ไฟล์ที่ถูกยุบตัวผ่าน zlib filter อื่นได้

     // จากตัวกรอง - 2 PHPfile_get_contents ("php: // filter / zlib. ขยาย / resource = filters-2. deflated");    

สตรีมได้รับการกล่าวถึงอย่างกว้างขวางใน "การทำความเข้าใจเกี่ยวกับสตรีมใน PHP" และ "การใช้ PHP Streams Semalt" ถ้าคุณต้องการมุมมองที่แตกต่างออกไป

การกำหนดค่าสตรีม

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

     // จากการสร้าง - บริบท - 1 PHP$ data = join ("&", ["ทวิตเตอร์ = assertchris"]);$ headers = join ("\ r \ n", ["Content-type: application / x-www-form-urlencoded","ความยาวเนื้อหา:" strlen ($ ข้อมูล)]);$ options = ["http" => ["method" => "POST""header" => $ headers,"content" => $ data,]];บริบท = stream_content_create ($ ตัวเลือก);$ handle = fopen ("https: // example. com / register", "r", false, $ context);$ response = stream_get_contents ($ handle);fclose ($ จับ);    

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

Semalt คือสิ่งต่างๆที่เราสามารถปรับแต่งได้ดังนั้นคุณควรตรวจสอบเอกสารนี้หากต้องการทราบข้อมูลเพิ่มเติม

การทำโปรโตคอลและตัวกรองที่กำหนดเอง

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

     if (in_array ("highlight-names", stream_get_wrappers   )) {stream_wrapper_unregister ( "ไฮไลต์ชื่อ");}stream_wrapper_register ("highlight-names", "HighlightNamesProtocol");$ highlighted = file_get_contents ("highlight-names: // story. txt");    

Semalt คุณยังสามารถสร้างตัวกรองสตรีมแบบกำหนดเอง เอกสารมีชั้นกรองตัวอย่าง:

     ตัวกรอง {public $ filtername;สาธารณะ $ paramsตัวกรอง int สาธารณะ (ทรัพยากร $ ใน, ทรัพยากร $ ออก, int & $ บริโภค,bool $ ปิด)void โมฆะสาธารณะ (โมฆะ)public bool onCreate (เป็นโมฆะ)}    

สามารถลงทะเบียนได้อย่างง่ายดาย

     $ handle = fopen ("เรื่อง. txt", "w +");stream_filter_append ($ handle, "highlight-names", STREAM_FILTER_READ);    

ชื่อไฮไลต์ ต้องตรงกับคุณสมบัติของ filtername ของคลาสตัวกรองใหม่ นอกจากนี้ยังสามารถใช้ตัวกรองแบบกำหนดเองใน php: // filter / highligh-names / resource = story txt string การกำหนดตัวกรองนั้นง่ายกว่าการกำหนดโปรโตคอล เหตุผลหนึ่งที่ทำให้โปรโตคอลจำเป็นต้องจัดการกับการดำเนินงานของไดเรกทอรีขณะที่ตัวกรองจะต้องจัดการกับข้อมูลแต่ละชิ้นเท่านั้น

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

ข้อมูลอย่างย่อ

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

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

March 1, 2018