Back to Question Center
0

PHP के साथ बड़ी फ़ाइलों को कैसे पढ़ें (आपके सर्वर को मारने के बिना) PHP के साथ बड़ी फ़ाइलों को कैसे पढ़ें (अपने सर्वर को मारने के बिना) संबंधित विषय: ड्रपल डेवलपमेंट सेमील्ट

1 answers:
PHP के साथ बड़ी फाइलें कैसे पढ़ें (आपके सर्वर को मारने के बिना)

Semaltेट अक्सर नहीं है कि हम, पीएचपी डेवलपर्स के रूप में, मेमोरी प्रबंधन के बारे में चिंतित होना चाहिए। PHP इंजन हमारे द्वारा सफाई करने की एक तारकीय नौकरी करता है, और अल्पायुषी निष्पादन संदर्भों के वेब सर्वर मॉडल का मतलब है कि sloppiest कोड का कोई दीर्घकालिक प्रभाव नहीं है।

दुर्लभ समय हो सकता है जब हमें इस आरामदायक सीमा के बाहर कदम उठाने की आवश्यकता होती है - जैसे जब हम छोटे से वीपीएस पर एक बड़ी परियोजना बनाने के लिए हम साम्लेट को चलाने का प्रयास कर रहे हैं, या जब हमें बड़ी फाइलें पढ़ने की आवश्यकता होती है समान रूप से छोटा सर्वर

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

बाद की समस्या को समझाएं हम इस ट्यूटोरियल में देखेंगे।

इस ट्यूटोरियल के लिए कोड GitHub पर पाया जा सकता है।

मापने की सफलता

यह सुनिश्चित करने का एकमात्र तरीका है कि हम अपने कोड में कोई सुधार कर रहे हैं, एक बुरी स्थिति को मापना है और उसके बाद उस माप की तुलना किसी अन्य के साथ करने के बाद करना चाहिए। दूसरे शब्दों में, जब तक हम नहीं जानते कि "समाधान" हमें (यदि सभी में) मदद करता है, तो हमें नहीं पता कि यह वास्तव में एक समाधान है या नहीं।

दो मीट्रिक हैं जो हम परवाह कर सकते हैं पहला CPU उपयोग है कितनी तेज़ या धीमी प्रक्रिया है जिस पर हम काम करना चाहते हैं? दूसरा स्मृति उपयोग है स्क्रीप्ट को निष्पादित करने के लिए कितनी मेमोरी होती है? साम्बाल्ट अक्सर उल्टे आनुपातिक होते हैं - जिसका अर्थ है कि हम CPU उपयोग की लागत पर स्मृति उपयोग को ऑफ़लोड कर सकते हैं, और इसके विपरीत।

एक अतुल्यकालिक निष्पादन मॉडल में (जैसे बहु-प्रक्रिया या बहु-थ्रेडेड PHP अनुप्रयोग), दोनों CPU और स्मृति उपयोग महत्वपूर्ण विचार हैं। परंपरागत PHP वास्तुकला में, ये आम तौर पर एक समस्या बन जाते हैं जब कोई भी सर्वर की सीमा तक पहुंच जाता है

PHP के अंदर CPU उपयोग को मापने के लिए यह अव्यावहारिक है अगर ऐसा क्षेत्र है जिस पर आप ध्यान केंद्रित करना चाहते हैं, तो उबंटु या मैकोज़ पर शीर्ष कुछ का उपयोग करने पर विचार करें विंडोज के लिए, लिनक्स सबसिस्टम का उपयोग करने पर विचार करें, ताकि आप उबंटू में शीर्ष का उपयोग कर सकें

इस ट्यूटोरियल के प्रयोजनों के लिए, हम स्मृति उपयोग को मापने जा रहे हैं "पारंपरिक" लिपियों में कितनी मेमोरी का उपयोग किया जाता है, इस पर मिमल का लगाना Semaltेट कुछ अनुकूलन रणनीतियों को लागू करने और उन लोगों को भी मापने के लिए। अंत में, मैं चाहता हूं कि आप एक शिक्षित विकल्प बनाने में सक्षम हो।

हम कितने मेमोरी का उपयोग करते हैं, यह देखने के लिए हम तरीकों से उपयोग करेंगे:

  // formatBytes php से लिया जाता है शुद्ध प्रलेखनmemory_get_peak_usage   ;फ़ंक्शन प्रारूपबाइट ($ बाइट्स, $ परिशुद्धता = 2) {$ इकाइयों = सरणी ("बी", "केबी", "एमबी", "जीबी", "टीबी");$ बाइट = अधिकतम ($ बाइट, 0);$ pow = floor (($ बाइट्स? लॉग ($ बाइट्स): 0) / लॉग (1024));$ pow = min ($ pow, गिनती ($ इकाइयों) - 1);$ बाइट्स / = (1 << (10 * $ पाउ));वापसी दौर ($ बाइट्स, $ सटीक) "" $ इकाइयों [$ पॉव];}   

साम्बाल इन कार्यों को हमारी स्क्रिप्ट के अंत में उपयोग करते हैं, इसलिए हम देख सकते हैं कि किस स्क्रिप्ट में एक समय में सबसे मेमोरी का उपयोग किया जाता है।

हमारे विकल्प क्या हैं?

Semalt्ट कई तरीकों से हम फ़ाइलों को कुशलता से पढ़ने के लिए ले जा सकते हैं। लेकिन वहां भी दो संभावित परिदृश्य हैं जिनमें हम उनका इस्तेमाल कर सकते हैं हम एक ही समय में डेटा को पढ़ और संसाधित कर सकते हैं, संसाधित डेटा आउटपुट कर सकते हैं या हम जो पढ़ते हैं उसके आधार पर अन्य कार्रवाइयां कर सकते हैं। हम डेटा की एक धारा को कभी भी बिना किसी भी डेटा तक पहुंच बनाने के लिए परिवर्तित कर सकते हैं।

आइए हम पहले परिदृश्य के लिए कल्पना करें, कि हम एक फाइल पढ़ना और हर पंक्ति में 10,000 पंक्तियाँ अलग-अलग पंक्तिबद्ध प्रसंस्करण नौकरियां बनाना चाहते हैं। Semaltेट को स्मृति में कम से कम 10,000 लाइन रखने की जरूरत है, और उन्हें कतारबद्ध नौकरी प्रबंधक (जो कुछ भी हो सकता है) के साथ पास करें

दूसरे परिदृश्य के लिए, मान लें कि हम एक विशेष रूप से बड़ी एपीआई प्रतिक्रिया की सामग्री को संक्षिप्त करना चाहते हैं। हमें इसकी क्या परवाह नहीं है, लेकिन हमें यह सुनिश्चित करने की आवश्यकता है कि इसका एक संपीड़ित रूप में बैक अप है. पहले, हमें यह जानना होगा कि डेटा क्या है। दूसरे में, हमें परवाह नहीं है कि डेटा क्या है Semalt इन विकल्पों का पता लगाने .

फाइल पढ़ना, पंक्ति रेखा से

फाइलों के साथ काम करने के लिए कई कार्य हैं I मिमलेट एक भोला फाइल रीडर में कुछ जोड़ती है:

  // स्मृति से phpफ़ंक्शन प्रारूपबाइट ($ बाइट्स, $ परिशुद्धता = 2) {$ इकाइयों = सरणी ("बी", "केबी", "एमबी", "जीबी", "टीबी");$ बाइट = अधिकतम ($ बाइट, 0);$ pow = floor (($ बाइट्स? लॉग ($ बाइट्स): 0) / लॉग (1024));$ pow = min ($ pow, गिनती ($ इकाइयों) - 1);$ बाइट्स / = (1 << (10 * $ पाउ));वापसी दौर ($ बाइट्स, $ सटीक) "" $ इकाइयों [$ पॉव];}प्रिंट प्रारूपबाइट (मेमोरी _ गेट_पेक_जेज   );   
  // read-files-line-by-line-1 से phpफ़ंक्शन readTheFile ($ पथ) {$ पंक्ति = [];$ हैंडल = एफओपीएन ($ पथ, "आर");जबकि (! फीफ ($ हैंडल)) {$ पंक्तियां [] = ट्रिम (fgets ($ हैंडल));}fclose ($ संभाल);वापसी लाइनें;}readTheFile ("शेक्सपीयर। txt");"मेमोरी। php" की आवश्यकता होती है;   

हम एक टेक्स्ट फ़ाइल पढ़ रहे हैं जिसमें शेक्सपियर के पूर्ण काम होंगे। पाठ फ़ाइल लगभग 5 - india tv buy online. 5 एमबी है, और चरम मेमोरी उपयोग 12. 8 एमबी है। अब, प्रत्येक लाइन को पढ़ने के लिए एक जनरेटर का उपयोग करें:

  // read-files-line-by-line-2 में से phpफ़ंक्शन readTheFile ($ पथ) {$ हैंडल = एफओपीएन ($ पथ, "आर");जबकि (! फीफ ($ हैंडल)) {उपज ट्रिम (fgets ($ हैंडल));}fclose ($ संभाल);}readTheFile ("शेक्सपीयर। txt");"मेमोरी। php" की आवश्यकता होती है;   

पाठ फ़ाइल एक ही आकार है, लेकिन पीक मेमोरी उपयोग 393 केबी है। इसका मतलब यह नहीं है कि जब तक हम डेटा पढ़ रहे हैं तब तक हम कुछ नहीं करते। शायद हम जब भी दो खाली पंक्तियों को देखते हैं तो दस्तावेज़ को खंड में विभाजित कर सकते हैं ऐसा कुछ:

  // पढ़ने-फाइल-लाइन-बाय-लाइन -3 से php$ इटरेटर = रीडएफ़ाइल ("शेक्सपीयर। txt");$ बफर = "";विदेशी मुद्रा ($ आईट्रेटर के रूप में डॉलर चलना) {preg_match ("/ \ n {3} /", $ बफर, $ मैच);अगर (गणना ($ मैचों)) {प्रिंट "।";$ बफर = "";} अन्य {$ बफर। = $ चलना PHP_EOL;}}"मेमोरी। php" की आवश्यकता होती है;   

कोई अनुमान है कि हम अब कितनी मेमोरी का उपयोग कर रहे हैं? क्या आपको यह जानकर आश्चर्य होगा कि, हमने पाठ दस्तावेज़ को 1,216 खंडों में विभाजित किया है, फिर भी हम अभी भी 45 9केबी स्मृति का उपयोग करते हैं? जनरेटर की प्रकृति को देखते हुए, हम जितनी अधिक मेमोरी का उपयोग करेंगे, उतनी ही हमें एक पुनरावृत्ति में सबसे बड़ा टेक्स्ट हिस्सा स्टोर करने की आवश्यकता है। इस मामले में, सबसे बड़ा हिस्सा 101 9 85 वर्ण है

मैंने पहले ही जेनरेटर और निकिता पॉपोव के Semaltेट पुस्तकालय का उपयोग करने के प्रदर्शन को बढ़ाने के बारे में लिखा है, इसलिए आप देखेंगे कि अगर आप अधिक देखना चाहते हैं तो देखें!

Semaltेट का अन्य उपयोग होता है, लेकिन यह बड़ी फ़ाइलों के निष्पादक पढ़ने के लिए शानदार प्रदर्शन है। यदि हमें डेटा पर काम करने की आवश्यकता है, तो जनरेटर शायद सबसे अच्छा तरीका है।

फाइलों के बीच पाइपिंग

ऐसी परिस्थितियों में जहां हमें डेटा पर काम करने की आवश्यकता नहीं है, हम फाइल डेटा को एक फाइल से दूसरे में भेज सकते हैं इसे आमतौर पर पाइपिंग कहा जाता है (संभाव्यतः क्योंकि हम प्रत्येक छोर को छोड़कर किसी पाइप के अंदर नहीं देखते हैं .जब तक कि यह अपारदर्शी है!)। हम इसे स्ट्रीम विधियों का उपयोग करके प्राप्त कर सकते हैं। आइए पहले एक फाइल से दूसरे में स्थानांतरण करने के लिए एक स्क्रिप्ट लिखें, ताकि हम मेमोरी उपयोग को माप सकें:

  // पाइपिंग-फाइल -1 से phpfile_put_contents ("पाइपिंग-फाइल्स-1। txt", file_get_contents ("शेक्सपियर। txt"));"मेमोरी। php" की आवश्यकता होती है;   

हैरानी की बात है, यह स्क्रिप्ट पाठ फ़ाइल से प्रतिलिपि चलाने के लिए थोड़ी अधिक स्मृति का उपयोग करती है Semaltेट क्योंकि इसे स्मृति में फ़ाइल सामग्री को पढ़ने (और रखना) जब तक कि नई फ़ाइल में लिखा न हो। छोटी फाइलों के लिए, यह ठीक हो सकता है। जब हम बड़ी फ़ाइलों का उपयोग करना शुरू करते हैं, तो बहुत .

सेमील्ट स्ट्रीमिंग (या पाइपिंग) एक फ़ाइल से दूसरे में करने का प्रयास करें:

  // पाइपिंग-फाइल -2 से. txt "," r ");$ हैंडल 2 = एफओपीएएन ("पाइपिंग-फाइल -2। टीसीटीटी", "डब्ल्यू");stream_copy_to_stream ($ हैंडल 1, $ हैंडल 2);fclose ($ handle1);fclose ($ handle2);"मेमोरी। php" की आवश्यकता होती है;   

यह कोड थोड़ा अजीब है हम दोनों फाइलों को पढ़ते हैं, पहला पठन मोड में और दूसरा लिखने मोड में। फिर हम पहले से दूसरे में प्रतिलिपि बनाते हैं हम दोनों फ़ाइलों को फिर से बंद करके समाप्त करें यह आपको आश्चर्यचकित कर सकता है कि स्मृति का उपयोग 393 केबी है।

यह परिचित लगता है क्या यह नहीं है कि प्रत्येक लाइन को पढ़ने के दौरान जेनरेटर कोड को क्या भंडारित किया जाता है? इसका कारण यह है कि दूसरी तर्क fgets निर्दिष्ट करता है कि प्रत्येक पंक्ति के कितने बाइट पढ़ने के लिए (और डिफ़ॉल्ट -1 या जब तक यह एक नई पंक्ति तक नहीं पहुंचता है)।

तीसरे तर्क stream_copy_to_stream बिल्कुल समान पैरामीटर (बिल्कुल उसी डिफ़ॉल्ट के साथ)। stream_copy_to_stream एक धारा से पढ़ रहा है, एक समय में एक पंक्ति, और इसे अन्य धारा में लिख रहा है यह उस भाग को छोड़ देता है जहां जनरेटर एक मान पैदा करता है, क्योंकि हमें उस मूल्य के साथ काम करने की आवश्यकता नहीं है।

इस पाठ को पिपिंग हमारे लिए उपयोगी नहीं है, तो अन्य उदाहरणों के बारे में सोचें जो हो सकता है। Semalt्ट हम एक सीडीएन से एक छवि आउटपुट करना चाहते थे, एक तरह से पुनर्निर्देशित अनुप्रयोग मार्ग के रूप में। हम इसे निम्नलिखित जैसी कोड के साथ वर्णन कर सकते हैं:

  // पाइपिंग-फाइल -3 से phpfile_put_contents ("पाइपिंग-फाइल्स-3। jpeg", file_get_contents ("https: // github। com / assertchris / अपलोड / कच्चा / मास्टर / रिक। jpg"));//। । । या इसे सीधे stdout पर लिखें, अगर हमें स्मृति जानकारी की आवश्यकता नहीं है"मेमोरी। php" की आवश्यकता होती है;   

एक आवेदन मार्ग की कल्पना हमें इस कोड पर लाया। लेकिन स्थानीय फ़ाइल सिस्टम से एक फ़ाइल को चलाने के बजाय, हम इसे सीडीएन से प्राप्त करना चाहते हैं हम file_get_contents को और अधिक सुरुचिपूर्ण (जैसे गज़ले) के लिए स्थानापन्न कर सकते हैं, लेकिन हुड के नीचे यह बहुत ही समान है।

स्मृति उपयोग (इस छवि के लिए) लगभग 581 केबी है। अब, हम इसके बजाय स्ट्रीम करने की कोशिश कैसे करते हैं?

  // पाइपिंग-फाइल -4 से php$ हैंडल 1 = एफओपीएएन ("https: // github। com / assertchris / अपलोड / कच्चा / मास्टर / रिक। jpg", "r");$ हैंडल 2 = एफओपीएन ("पाइपिंग-फाइल्स -4। जेपीईजी", "डब्ल्यू");//। । । या इसे सीधे stdout पर लिखें, अगर हमें स्मृति जानकारी की आवश्यकता नहीं हैstream_copy_to_stream ($ हैंडल 1, $ हैंडल 2);fclose ($ handle1);fclose ($ handle2);"मेमोरी। php" की आवश्यकता होती है;   

मेमोरी का उपयोग थोड़ा कम है ( 400 केबी ), लेकिन परिणाम एक ही है। अगर हमें मेमरी जानकारी की ज़रूरत नहीं होती, तो हम मानक आउटपुट के साथ ही प्रिंट भी कर सकते थे। वास्तव में, PHP ऐसा करने का एक आसान तरीका प्रदान करता है:

  $ हैंडल 1 = एफओपीएएन ("https: // github। com / assertchris / अपलोड / कच्चा / मास्टर / रिक। jpg", "r");$ हैंडल 2 = एफओपीएन ("php: // stdout", "w");stream_copy_to_stream ($ हैंडल 1, $ हैंडल 2);fclose ($ handle1);fclose ($ handle2);// "मेमोरी। php" की आवश्यकता होती है;   

अन्य स्ट्रीम (16 9)

Semaltेट कुछ अन्य नदियों हैं जो हम पाइप और / या लिख ​​सकते हैं और / या पढ़ सकते हैं:

  • php: // stdin (केवल-पढ़ने के लिए)
  • php: // stderr (केवल-लेखन, जैसे php: // stdout)
  • php: // इनपुट (केवल पढ़ने के लिए) जो हमें कच्चे अनुरोध निकाय
  • तक पहुंच प्रदान करता है
  • पीएचपी: // आउटपुट (3 9) (केवल लिखना) जो हमें आउटपुट बफर
  • लिखने देता है
  • php: // मेमोरी और php: // temp (पढने-लिखने) हम अस्थायी रूप से डेटा स्टोर कर सकते हैं। अंतर यह है कि php: // temp फ़ाइल सिस्टम में डेटा को एक बार बड़े होने पर संग्रहीत करेगा, जबकि php: // मेमोरी (3 9) स्मृति में भंडारण रखेगा जब तक कि इसे समाप्त न हो जाए ।

फ़िल्टर

एक और चाल है जिसे हम फिल्टर नामक धाराओं के साथ उपयोग कर सकते हैं। वे एक तरह का बीच में कदम रखते हैं, जो हमें बिना किसी उजागर किए डेटा स्ट्रीम पर नियंत्रण प्रदान करता है कल्पना कीजिए हम हमारे शेक्सपियर को संक्षिप्त करना चाहते हैं txt . php$ ज़िप = नया ज़िप एरक्रिव ;$ filename = "फिल्टर -1 ज़िप";$ ज़िप-> खुली ($ फ़ाइलनाम, ज़िपप्रेरक :: बनाएँ);$ zip-> addFromString ("शेक्सपियर। txt", file_get_contents ("शेक्सपीयर। txt"));$ Zip-> पास ;"मेमोरी। php" की आवश्यकता होती है;

यह कोड का एक साफ बिट है, लेकिन यह लगभग 10. 75 एमबी में घड़ियां है। हम फिल्टर के साथ बेहतर कर सकते हैं:

  // से फिल्टर -2 php$ हैंडल 1 = एफओपीएएन ("php: // filter / zlib। deflate / संसाधन = शेक्सपियर। txt", "r");$ हैंडल 2 = एफओपीएन ("फिल्टर-2. deflated", "w");stream_copy_to_stream ($ हैंडल 1, $ हैंडल 2);fclose ($ handle1);fclose ($ handle2);"मेमोरी। php" की आवश्यकता होती है;   

यहां, हम php: // filter / zlib देख सकते हैं। डिफलेट फिल्टर, जो एक संसाधन की सामग्री पढ़ता और संपीड़ित करता है। तब हम इस संपीड़ित डेटा को अन्य फाइल में पाइप कर सकते हैं। यह केवल 896 केबी उपयोग करता है

मुझे पता है कि यह एक ही प्रारूप नहीं है, या एक ज़िप संग्रह बनाने के लिए अपवाद हैं। आपको हालांकि आश्चर्य होगा: यदि आप अलग-अलग स्वरूप चुन सकते हैं और 12 गुना स्मृति बचा सकते हैं, तो क्या आप नहीं करेंगे?

डेटा को असम्परोड करने के लिए, हम एक अन्य zlib फ़िल्टर के माध्यम से deflated फ़ाइल को वापस चला सकते हैं:

  // से फिल्टर -2 phpfile_get_contents ("php: // filter / zlib फ़्लाईट / संसाधन = फिल्टर -2। deflated");   

"पीएचपी में धाराओं को समझना" और "पीएचपी स्ट्रीम्स Semalt्ट का प्रयोग" में बड़े पैमाने पर धाराओं को कवर किया गया है। यदि आप एक अलग परिप्रेक्ष्य चाहते हैं, तो उनको देखें!

स्ट्रीम को अनुकूलित करना

एफओपीएएन (3 9) और फ़ाइल_गेट_कंटेंट (3 9) के पास अपने डिफ़ॉल्ट विकल्प हैं, लेकिन ये पूरी तरह से अनुकूलन योग्य हैं। उन्हें परिभाषित करने के लिए, हमें एक नया स्ट्रीम संदर्भ बनाने की आवश्यकता है:

  // बनाने-संदर्भ-1 से php$ डेटा = जुड़ें ("और", ["चहचहाना = assertchris",]);$ हेडर = जोड़ ("\ r \ n", ["कंटेंट-प्रकार: एप्लिकेशन / x-www-form-urlencoded","कंटेंट की लम्बाई: "। strlen ($ डेटा),]);$ विकल्प = ["http" => ["विधि" => "पोस्ट","हैडर" => $ हेडर,"सामग्री" => $ डेटा,],];$ context = stream_content_create ($ विकल्प);$ handle = fopen ("https: // उदाहरण कॉम / रजिस्टर", "आर", झूठी, $ संदर्भ);$ प्रतिक्रिया = stream_get_contents ($ हैंडल);fclose ($ संभाल);   

इस उदाहरण में, हम एक एपीआई POST अनुरोध करने का प्रयास कर रहे हैं। एपीआई अंत बिंदु सुरक्षित है, लेकिन हमें अभी भी एचटीसी संदर्भ प्रॉपर्टी (जैसा कि http और https के लिए उपयोग किया जाता है) का उपयोग करने की आवश्यकता है। हम कुछ हेडर सेट करते हैं और एपीआई में फ़ाइल हैंडल खोलते हैं। हम संभाल को केवल-पढ़ने के रूप में खोल सकते हैं क्योंकि संदर्भ लेखन का ख्याल रखता है।

Semaltेट उन चीजों का भार है जिन्हें हम अनुकूलित कर सकते हैं, इसलिए यदि आप अधिक जानना चाहते हैं, तो दस्तावेज की जांच करना सबसे अच्छा होगा।

कस्टम प्रोटोकॉल और फ़िल्टर बनाना

हम चीजों को लपेटें, कस्टम प्रोटोकॉल बनाने के बारे में बात करते हैं. काम करने के लिए बहुत कुछ काम करना चाहिए लेकिन एक बार यह काम किया जाता है, हम अपनी स्ट्रीम आवरण को काफी आसानी से रजिस्टर कर सकते हैं:

  यदि (in_array ("हाइलाइट-नाम", स्ट्रीम_get_wrappers   )) {stream_wrapper_unregister ( "प्रकाश डाला-नाम");}stream_wrapper_register ("हाइलाइट-नाम", "हाइलाइटनम्सप्रोटोकॉल");$ हाइलाइट = file_get_contents ("हाइलाइट-नाम: // कहानी। txt");   

सेमील्ट, कस्टम स्ट्रीम फिल्टर बनाने के लिए भी संभव है। दस्तावेज़ीकरण में एक उदाहरण फिल्टर वर्ग है:

  फ़िल्टर {सार्वजनिक $ filtername;सार्वजनिक $ paramsसार्वजनिक इंट फिल्टर (संसाधन $ में, संसाधन $ आउट, इंट और $ का उपभोग,बूल $ समापन)सार्वजनिक शून्य पर बंद (शून्य)पर सार्वजनिक boolCreate (शून्य)}   

यह बस के रूप में आसानी से पंजीकृत किया जा सकता है:

  $ handle = fopen ("कहानी। Txt", "w +");stream_filter_append ($ संभाल, "हाइलाइट-नाम", STREAM_FILTER_READ);   

हाइलाइट-नाम (3 9) को फिलेनेम (3 9) से नए फिल्टर क्लास की संपत्ति से मिलान करने की जरूरत है php: // filter / highligh-names / resource = story में कस्टम फ़िल्टर का उपयोग करना भी संभव है। txt स्ट्रिंग प्रोटोकॉल को निर्धारित करने के बजाय फिल्टर को परिभाषित करना बहुत आसान है इसका एक कारण यह है कि प्रोटोकॉल को डायरेक्टरी ऑपरेशंस को संभालना आवश्यक है, जबकि केवल डेटा के प्रत्येक टुकड़े को संभालने के लिए फ़िल्टर की आवश्यकता होती है।

यदि आपके पास गमपन है, तो मैं आपको कस्टम प्रोटोकॉल और फ़िल्टर बनाने के लिए प्रयोग करने के लिए प्रोत्साहित करता हूं। यदि आप stream_copy_to_stream ऑपरेशन के लिए फ़िल्टर लागू कर सकते हैं, तो आपके ऐप्लिकेशन्स अश्लील रूप से बड़ी फ़ाइलों के साथ काम करते समय भी कोई स्मृति के आगे उपयोग नहीं जा रहे हैं एक आकार परिवर्तन छवि फ़िल्टर या और एन्क्रिप्ट-के-आवेदन फिल्टर को कल्पना कीजिए।

सारांश

समतुल्य यह एक समस्या नहीं है जिसे हम अक्सर पीड़ित करते हैं, बड़ी फ़ाइलों के साथ काम करते समय गड़बड़ करना आसान होता है एसिंक्रोनस अनुप्रयोगों में, जब हम मेमोरी उपयोग के बारे में सावधान नहीं करते हैं तो पूरे सर्वर को नीचे लाने के लिए उतना ही आसान है

यह ट्यूटोरियल उम्मीद है कि आपको कुछ नए विचारों (या उनके बारे में अपनी स्मृति ताज़ा) करने के लिए प्रस्तुत किया गया है, ताकि आप बड़ी फ़ाइलों को कुशलतापूर्वक कैसे पढ़ और लिख सकें जब हम धाराओं और जनरेटर से परिचित हो जाते हैं, और file_get_contents जैसे कार्यों का उपयोग करना बंद कर देते हैं: हमारे अनुप्रयोगों से त्रुटियों की एक पूरी श्रेणी गायब हो जाती है यह एक अच्छी बात की तरह लगता है!

March 1, 2018