😂 🥑 💘 HTML फ़ाइल रेंडरिंग: स्काईेंग द्वारा शुरुआती के लिए पुस्तक ReactPHP का एक अध्याय 🙏🏼 😿 👩🏼‍🚀

स्काईेंग मोबाइल ऐप बैकएंड डेवलपर सर्गेई ज़ूक अच्छी किताबें लिखना जारी रखता है। इस बार उन्होंने एक PHP-mastering दर्शकों के लिए रूसी में एक पाठ्यपुस्तक जारी की। मैंने सर्गेई को अपनी पुस्तक से एक उपयोगी आत्मनिर्भर अध्याय साझा करने और हाबरा पाठकों को छूट कोड देने के लिए कहा। नीचे दोनों है।

सबसे पहले, आपको बताते हैं कि पिछले अध्यायों में हम क्या रुके थे।

हमने अपने सरल HTTP सर्वर को PHP में लिखा है। हमारे पास मुख्य index.php फ़ाइल है - स्क्रिप्ट जो सर्वर शुरू करती है। यहां उच्चतम-स्तरीय कोड है: हम एक ईवेंट लूप बनाते हैं, HTTP सर्वर के व्यवहार को कॉन्फ़िगर करते हैं और लूप शुरू करते हैं:

 use React\Http\Server; use Psr\Http\Message\ServerRequestInterface; $loop = React\EventLoop\Factory::create(); $router = new Router(); $router->load('routes.php'); $server = new Server( function (ServerRequestInterface $request) use ($router) { return $router($request); } ); $socket = new React\Socket\Server(8080, $loop); $server->listen($socket); $loop->run();

अनुरोधों को रूट करने के लिए, सर्वर एक राउटर का उपयोग करता है:

 // src/Router.php use Psr\Http\Message\ServerRequestInterface; use React\Http\Response; class Router { private $routes = []; public function __invoke(ServerRequestInterface $request) { $path = $request->getUri()->getPath(); echo "Request for: $path\n"; $handler = $this->routes[$path] ?? $this->notFound($path); return $handler($request); } public function load($filename) { $routes = require $filename; foreach ($routes as $path => $handler) { $this->add($path, $handler); } } public function add($path, callable $handler) { $this->routes[$path] = $handler; } private function notFound($path) { return function () use ($path) { return new Response( 404, ['Content-Type' => 'text/html; charset=UTF-8'], "No request handler found for $path" ); }; } }

रूट्स से। routes.php फ़ाइल को routes.php में लोड किया जाता है। अब यहां केवल दो मार्गों की घोषणा की गई है:

 use React\Http\Response; use Psr\Http\Message\ServerRequestInterface; return [ '/' => function (ServerRequestInterface $request) { return new Response( 200, ['Content-Type' => 'text/plain'], 'Main page' ); }, '/upload' => function (ServerRequestInterface $request) { return new Response( 200, ['Content-Type' => 'text/plain'], 'Upload page' ); }, ];

अब तक, सब कुछ सरल है, और हमारा अतुल्यकालिक अनुप्रयोग कई फाइलों में फिट बैठता है।

हम अधिक "उपयोगी" चीजों को पास करते हैं। एक सादे पाठ के दो शब्दों के उत्तर जो हमने पिछले अध्यायों में प्राप्त करने के लिए सीखे थे, बहुत आकर्षक नहीं लगते। हमें कुछ वास्तविक वापस करने की आवश्यकता है, जैसे कि HTML पृष्ठ।

तो, हम इस HTML को कहाँ रखते हैं? बेशक, आप वेब पेज की सामग्री को रूट फाइल के अंदर हार्डकोड कर सकते हैं:

 // routes.php return [ '/' => function (ServerRequestInterface $request) { $html = <<<HTML <!DOCTYPE html> <html lang=”en”> <head> <meta charset=”UTF-8”> <title>ReactPHP App</title> </head> <body> Hello, world </body> </html> HTML; return new Response( 200, ['Content-Type' => 'text/html'], $html ); }, '/upload' => function (ServerRequestInterface $request) { return new Response( 200, ['Content-Type' => 'text/plain'], 'Upload page' ); }, ];

लेकिन ऐसा मत करो! आप प्रस्तुति (HTML पृष्ठ) के साथ व्यावसायिक तर्क (रूटिंग) को नहीं मिला सकते हैं। क्यों? कल्पना करें कि आपको HTML कोड में कुछ बदलने की आवश्यकता है, उदाहरण के लिए, बटन का रंग। और किस फाइल को बदलना होगा? router.php साथ फाइल करें। अजीब लगता है, है ना? बटन का रंग बदलने के लिए रूटिंग में परिवर्तन करें ...

इसलिए, हम अकेले मार्गों को छोड़ देंगे, और HTML पृष्ठों के लिए हम एक अलग निर्देशिका बनाएंगे। परियोजना की जड़ में, एक नई निर्देशिका जोड़ें जिसे पृष्ठ कहा जाता है। फिर इसके अंदर हम index.html फ़ाइल बनाते हैं। यह हमारा मुख्य पृष्ठ होगा। यहाँ इसकी सामग्री हैं:

 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>ReactPHP App</title> <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.1/css/bootstrap.min.css" > </head> <body> <div class="container"> <div class="row"> <form action="/upload" method="POST" class="justify-content-center"> <div class="form-group"> <label for="text">Text</label> <textarea name="text" id="text" class="form-control"> </div> <button type="submit" class="btn btn-primary">Submit</button> </form> </div> </div> </body> </html>

पृष्ठ काफी सरल है, इसमें केवल एक तत्व है - फ़ॉर्म। अंदर के फॉर्म में टेक्स्ट बॉक्स और सबमिट करने के लिए एक बटन है। हमारे पेज को अच्छा बनाने के लिए मैंने बूटस्ट्रैप शैलियों को भी जोड़ा।

फाइलें पढ़ना। कैसे नहीं करना है

सबसे सरल दृष्टिकोण अनुरोध हैंडलर के अंदर फ़ाइल की सामग्री को पढ़ना और उस सामग्री को प्रतिक्रिया निकाय के रूप में वापस करना है। कुछ इस तरह:

 // routes.php return [ '/' => function (ServerRequestInterface $request) { return new Response( 200, ['Content-Type' => 'text/html'], file_get_contents('pages/index.html') ); }, // ... ];

और वैसे, यह काम करेगा। आप इसे स्वयं आज़मा सकते हैं: सर्वर को पुनरारंभ करें और अपने ब्राउज़र में पृष्ठ http://127.0.0.1:8080/ को पुनः लोड करें।

तो यहाँ क्या गलत है? और ऐसा क्यों न करें? संक्षेप में, क्योंकि फ़ाइल सिस्टम धीमा होने लगे तो समस्याएँ होंगी।

ब्लॉकिंग और नॉन-ब्लॉकिंग कॉल

मुझे दिखाते हैं कि "ब्लॉकिंग" कॉल से मेरा क्या मतलब है, और अनुरोध हैंडलर में ब्लॉक कोड होने पर क्या हो सकता है। प्रतिक्रिया ऑब्जेक्ट वापस करने से पहले, sleep() कॉल जोड़ें sleep() फ़ंक्शन:

 // routes.php return [ '/' => function (ServerRequestInterface $request) { sleep(10); return new Response( 200, ['Content-Type' => 'text/html'], file_get_contents('pages/index.html') ); }, '/upload' => function (ServerRequestInterface $request) { return new Response( 200, ['Content-Type' => 'text/plain'], 'Upload page' ); }, ];

यह HTML पेज की सामग्री के साथ प्रतिक्रिया वापस करने से पहले 10 सेकंड के लिए अनुरोध हैंडलर को फ्रीज कर देगा। कृपया ध्यान दें कि हमने /upload पते के लिए हैंडलर को नहीं छुआ है। sleep(10) फ़ंक्शन को कॉल करके, मैं किसी प्रकार के अवरुद्ध ऑपरेशन के निष्पादन का अनुकरण करता हूं।

तो हमारे पास क्या है? जब ब्राउज़र पृष्ठ / अनुरोध करता है, तो हैंडलर 10 सेकंड प्रतीक्षा करता है और फिर HTML पृष्ठ को वापस करता है। जब हम /upload पता खोलते हैं, तो उसके हैंडलर को तुरंत स्ट्रिंग 'अपलोड पेज' के साथ प्रतिक्रिया वापस देनी चाहिए।

अब देखते हैं कि वास्तव में क्या होता है। हमेशा की तरह, हम सर्वर को पुनरारंभ करते हैं। अब, कृपया अपने ब्राउज़र में एक और विंडो खोलें। पता बार में, http://127.0.0.1:8080/upload दर्ज करें, लेकिन इस पृष्ठ को तुरंत न खोलें। इस पते को अभी के लिए एड्रेस बार में छोड़ दें। फिर पहली ब्राउज़र विंडो पर जाएं और उसमें पृष्ठ http://127.0.0.1:8080/ खोलें। जबकि यह पृष्ठ लोड हो रहा है (याद रखें कि ऐसा करने में 10 सेकंड लगेंगे), जल्दी से दूसरी विंडो पर जाएं और पता बार में छोड़े गए पते को लोड करने के लिए "एंटर" दबाएं ( http://127.0.0.1:8080/upload ) ।

हमें क्या मिला? हाँ, पता /, जैसा कि अपेक्षित है, लोड होने में 10 सेकंड लगते हैं। लेकिन, आश्चर्यजनक रूप से, दूसरे पृष्ठ को लोड करने में समान समय लगा, हालांकि हमने इसमें कोई sleep() कॉल नहीं जोड़ा था। किसी भी विचार क्यों ऐसा हुआ?

ReactPHP एक ही धागे में चलती है। ऐसा लग सकता है कि एक अतुल्यकालिक अनुप्रयोग में, कार्यों को समानांतर में निष्पादित किया जाता है, लेकिन वास्तव में ऐसा नहीं है। समानांतरवाद का भ्रम घटनाओं के एक चक्र द्वारा बनाया जाता है जो लगातार विभिन्न कार्यों के बीच स्विच करता है और उन्हें निष्पादित करता है। लेकिन एक निश्चित समय पर, केवल एक कार्य हमेशा किया जाता है। इसका मतलब यह है कि अगर इनमें से कोई एक कार्य बहुत लंबा हो जाता है, तो यह ईवेंट लूप को ब्लॉक कर देगा, जो नए ईवेंट को पंजीकृत करने और उनके लिए हैंडलर को कॉल करने में सक्षम नहीं होगा। और वह अंततः पूरे आवेदन के "ठंड" की ओर जाता है, यह बस अतुल्यकालिक खो देगा।

ठीक है, लेकिन इसका file_get_contents('pages/index.h') कॉलिंग से क्या file_get_contents('pages/index.h') ? यहाँ समस्या यह है कि हम फाइल सिस्टम को सीधे एक्सेस कर रहे हैं। अन्य ऑपरेशनों की तुलना में, जैसे मेमोरी या कंप्यूटिंग के साथ काम करना, फाइल सिस्टम के साथ काम करना बेहद धीमा हो सकता है। उदाहरण के लिए, यदि फ़ाइल बहुत बड़ी हो गई है, या डिस्क स्वयं धीमी है, तो फ़ाइल को पढ़ने में कुछ समय लग सकता है और, परिणामस्वरूप, ईवेंट लूप को ब्लॉक करें।

मानक सिंक्रोनस मॉडल में, अनुरोध-प्रतिक्रिया कोई समस्या नहीं है। यदि क्लाइंट ने ऐसी फ़ाइल का अनुरोध किया है जो बहुत भारी है, तो यह फ़ाइल डाउनलोड होने तक प्रतीक्षा करेगी। इस तरह का भारी अनुरोध अन्य ग्राहकों को प्रभावित नहीं करता है। लेकिन हमारे मामले में, हम एक अतुल्यकालिक घटना उन्मुख मॉडल के साथ काम कर रहे हैं। हमने एक HTTP सर्वर लॉन्च किया है जिसे लगातार आने वाले अनुरोधों को संसाधित करना होगा। यदि एक अनुरोध को पूरा होने में बहुत अधिक समय लगता है, तो इससे अन्य सभी सर्वर क्लाइंट प्रभावित होंगे।

एक नियम के रूप में, याद रखें:

आप कभी भी ईवेंट लूप को ब्लॉक नहीं कर सकते।

तो, फिर हम फाइल को अतुल्यकालिक रूप से कैसे पढ़ते हैं? और यहाँ हम दूसरे नियम पर आते हैं:

जब एक अवरुद्ध ऑपरेशन से बचा नहीं जा सकता है, तो इसे बच्चे की प्रक्रिया में कांटा जाना चाहिए और मुख्य धागे में अतुल्यकालिक निष्पादन जारी रखना चाहिए।

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

बाल प्रक्रिया

एक अतुल्यकालिक आवेदन में फाइल सिस्टम के साथ सभी संचार बाल प्रक्रियाओं में किया जाना चाहिए। एक ReactPHP आवेदन में बाल प्रक्रियाओं का प्रबंधन करने के लिए, हमें एक और "चाइल्ड प्रोसेस" घटक स्थापित करना होगा। यह घटक आपको चाइल्ड प्रोसेस के अंदर किसी भी सिस्टम कमांड को चलाने के लिए ऑपरेटिंग सिस्टम के फंक्शन्स तक पहुँचने की अनुमति देता है। इस घटक को स्थापित करने के लिए, प्रोजेक्ट के रूट में एक टर्मिनल खोलें और निम्न कमांड चलाएँ:

composer require react/child-process

विंडोज संगतता

विंडोज ऑपरेटिंग सिस्टम में, STDIN, STDOUT और STDERR थ्रेड्स ब्लॉक हो रहे हैं, जिसका मतलब है कि चाइल्ड प्रोसेस कंपोनेंट सही तरीके से काम नहीं कर पाएगा। इसलिए, यह घटक मुख्य रूप से केवल निक्स सिस्टम पर काम करने के लिए डिज़ाइन किया गया है। यदि आप विंडोज सिस्टम पर प्रोसेस क्लास का ऑब्जेक्ट बनाने की कोशिश करते हैं, तो एक अपवाद फेंक दिया जाएगा। लेकिन घटक लिनक्स (डब्ल्यूएसएल) के लिए विंडोज सबसिस्टम के तहत काम कर सकता है। यदि आप विंडोज के तहत इस घटक का उपयोग करने का इरादा रखते हैं, तो आपको डब्ल्यूएसएल को स्थापित करना होगा।

अब हम बच्चे की प्रक्रिया के अंदर किसी भी शेल कमांड को निष्पादित कर सकते हैं। routes.php फ़ाइल खोलें, और फिर / मार्ग के लिए हैंडलर बदलें। React\ChildProcess\Process वर्ग का एक ऑब्जेक्ट बनाएँ, और एक कमांड के रूप में, मौजूदा निर्देशिका की सामग्री प्राप्त करने के लिए इसे पास करें:

 // routes.php use Psr\Http\Message\ServerRequestInterface; use React\ChildProcess\Process; use React\Http\Response; return [ '/' => function (ServerRequestInterface $request) { $childProcess = new Process('ls'); return new Response( 200, ['Content-Type' => 'text/html'], file_get_contents('pages/index.html') ); }, // ... ];

फिर हमें start() विधि को कॉल करके प्रक्रिया शुरू करने की आवश्यकता है। पकड़ यह है कि start() विधि को इवेंट लूप ऑब्जेक्ट की आवश्यकता होती है। लेकिन routes.php में। routes.php फ़ाइल में हमारे पास यह ऑब्जेक्ट नहीं है। हम index.php . index.php से सीधे अनुरोध हैंडलर के मार्गों पर ईवेंट लूप कैसे पास करते हैं? इस समस्या का हल "निर्भरता इंजेक्शन" है।

निर्भरता इंजेक्शन

इसलिए, हमारे मार्गों में से एक को काम करने के लिए एक इवेंट लूप की आवश्यकता है। हमारे आवेदन में, केवल एक घटक मार्गों के अस्तित्व के बारे में जानता है - Router वर्ग। यह पता चला है कि मार्गों के लिए एक इवेंट लूप प्रदान करना उनकी जिम्मेदारी है। दूसरे शब्दों में, राउटर को ईवेंट लूप की आवश्यकता होती है, या यह ईवेंट लूप पर निर्भर करता है। हम कोड में इस निर्भरता को स्पष्ट रूप से कैसे व्यक्त करते हैं? बिना किसी ईवेंट लूप को पास किए बिना राउटर बनाना भी असंभव कैसे हो सकता है? बेशक, Router वर्ग के निर्माता के माध्यम से। Router.php खोलें और Router वर्ग में कंस्ट्रक्टर जोड़ें:

 use Psr\Http\Message\ServerRequestInterface; use React\EventLoop\LoopInterface; use React\Http\Response; class Router { private $routes = []; /** * @var LoopInterface */ private $loop; public function __construct(LoopInterface $loop) { $this->loop = $loop; } // ... }

कंस्ट्रक्टर के अंदर, पास किए गए इवेंट लूप को निजी $loop प्रॉपर्टी में सहेजें। यह निर्भरता इंजेक्शन है जब हम वर्ग को उन वस्तुओं के साथ प्रदान करते हैं जो इसे बाहर काम करने की आवश्यकता होती है।

अब जब हमारे पास यह नया निर्माता है, तो हमें राउटर के निर्माण को अपडेट करने की आवश्यकता है। index.php फ़ाइल खोलें और उस रेखा को सही करें जहां हम Router क्लास का ऑब्जेक्ट बनाते हैं:

 // index.php $loop = React\EventLoop\Factory::create(); $router = new Router($loop); $router->load('routes.php');

हो गया। routes.php वापस जाएँ। जैसा कि आप शायद पहले ही अनुमान लगा चुके हैं, यहां हम निर्भरता इंजेक्शन के साथ एक ही विचार का उपयोग कर सकते हैं और हमारे क्वेरी हैंडलर्स के लिए दूसरे पैरामीटर के रूप में एक इवेंट लूप जोड़ सकते हैं। पहला कॉलबैक बदलें और दूसरा तर्क जोड़ें: एक वस्तु जो LoopInterface लागू LoopInterface :

 // routes.php use Psr\Http\Message\ServerRequestInterface; use React\EventLoop\LoopInterface; use React\ChildProcess\Process; use React\Http\Response; return [ '/' => function (ServerRequestInterface $request, LoopInterface $loop) { $childProcess = new Process('ls'); $childProcess->start($loop); return new Response( 200, ['Content-Type' => 'text/html'], file_get_contents('pages/index.html') ); }, '/upload' => function (ServerRequestInterface $request) { return new Response( 200, ['Content-Type' => 'text/plain'], 'Upload page' ); }, ];

अगला, हमें चाइल्ड प्रोसेस की start() विधि में लूप को पास करना होगा। और हैंडलर को इवेंट लूप कहां मिलता है? और यह पहले से ही राउटर के अंदर निजी $loop संपत्ति में संग्रहीत है। हैंडलर कहे जाने पर हमें बस इसे पास करने की आवश्यकता है।

__invoke() Router क्लास खोलें और __invoke() विधि को अपडेट करें, अनुरोध हैंडलर कॉल में दूसरा तर्क जोड़ते हुए:

 public function __invoke(ServerRequestInterface $request) { $path = $request->getUri()->getPath(); echo "Request for: $path\n"; $handler = $this->routes[$path] ?? $this->notFound($path); return $handler($request, $this->loop); }

वह सब है! यह शायद पर्याप्त निर्भरता इंजेक्शन है । घटनाओं के चक्र की एक बड़ी यात्रा हुई, है ना? index.php फ़ाइल से Router वर्ग तक, और फिर Router वर्ग से routes.php । कॉलबैक के अंदर सही से फ़ाइल दर्ज करें।

तो, यह पुष्टि करने के लिए कि बाल प्रक्रिया अपने गैर-अवरुद्ध जादू को करेगी, चलो सरल ls को भारी ping 8.8.8.8 साथ बदलें। सर्वर को पुनरारंभ करें और दो अलग-अलग विंडो में दो पृष्ठ खोलने के लिए फिर से प्रयास करें। सबसे पहले, http://127.0.0.1:8080/ , और फिर /upload । दोनों पृष्ठ जल्दी से खुलते हैं, बिना किसी देरी के, हालांकि पृष्ठभूमि में पहले हैंडलर में ping कमांड निष्पादित होता है। इसका मतलब है कि इसका मतलब है कि हम किसी भी महंगे ऑपरेशन (उदाहरण के लिए, बड़ी फ़ाइलों को संसाधित करने वाले) को मुख्य एप्लिकेशन को अवरुद्ध किए बिना कांटा कर सकते हैं।

धागे का उपयोग करके बच्चे की प्रक्रिया और प्रतिक्रिया को बांधें

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

हम बच्चे की प्रक्रिया के साथ कैसे संवाद कर सकते हैं? हमारे मामले में, हमारे पास एक रनिंग ls है जो वर्तमान निर्देशिका की सामग्री को प्रदर्शित करता है। हमें यह निष्कर्ष कैसे मिलता है, और फिर इसे उत्तर शरीर को भेजें? संक्षिप्त उत्तर है: सूत्र।

प्रक्रियाओं के बारे में थोड़ी बात करते हैं। आपके द्वारा निष्पादित की जाने वाली कोई भी शेल कमांड में तीन डेटा स्ट्रीम हैं: STDIN, STDOUT और STDERR। मानक आउटपुट और इनपुट के लिए स्ट्रीम, त्रुटियों के लिए प्लस स्ट्रीम। उदाहरण के लिए, जब हम ls निष्पादित करते हैं, तो इस कमांड का परिणाम सीधे STDOUT (टर्मिनल स्क्रीन पर) को भेजा जाता है। इसलिए, अगर हमें किसी प्रक्रिया का आउटपुट प्राप्त करने की आवश्यकता है, तो आउटपुट स्ट्रीम तक पहुंच आवश्यक है। और यह नाशपाती के नाशपाती के रूप में आसान है। प्रतिक्रिया ऑब्जेक्ट बनाने में, file_get_contents() कॉल को $childProcess->stdout :

 return new Response( 200, ['Content-Type' => 'text/plain'], $childProcess->stdout );

सभी बच्चों की प्रक्रियाओं में तीन गुण होते हैं जो stdio धाराओं से संबंधित होते हैं: stdout , stdin और stderr । हमारे मामले में, हम वेब पेज पर प्रक्रिया के आउटपुट को प्रदर्शित करना चाहते हैं। Response क्लास के कंस्ट्रक्टर में एक स्ट्रिंग के बजाय, हम तीसरे तर्क के रूप में एक स्ट्रीम पास करते हैं। Response क्लास काफी स्मार्ट है यह महसूस करने के लिए कि उसने स्ट्रीम प्राप्त की और उसी के अनुसार प्रक्रिया की।

इसलिए, हमेशा की तरह, हम सर्वर को रिबूट करते हैं और देखते हैं कि हमने क्या किया है। ब्राउज़र में पेज http://127.0.0.1:8080/ खोलें: आपको प्रोजेक्ट रूट फ़ोल्डर की फ़ाइलों की सूची http://127.0.0.1:8080/ चाहिए।

अंतिम चरण कुछ अधिक उपयोगी के साथ ls को बदलना है। हमने इस अध्याय को file_get_contents() फ़ंक्शन का उपयोग करके pages/index.html फ़ाइल को रेंडर करके शुरू किया है। अब, हम इस फ़ाइल को बिल्कुल अतुल्यकालिक रूप से पढ़ सकते हैं, बिना इस चिंता के कि यह हमारे आवेदन को अवरुद्ध कर देगा। ls को cat pages/index.html बदलें।

यदि आप cat परिचित नहीं हैं, तो इसका उपयोग फ़ाइलों को संक्षिप्त करने और आउटपुट करने के लिए किया जाता है। अधिकतर, इस कमांड का उपयोग किसी फाइल को पढ़ने और उसकी सामग्री को मानक आउटपुट में करने के लिए किया जाता है। cat pages/index.html कमांड cat pages/index.html फ़ाइल को पढ़ता है और इसकी सामग्री को STDOUT में प्रिंट करता है। और हम पहले से ही प्रतिक्रिया निकाय के रूप में stdout भेज रहे हैं। यहां routes.php का अंतिम संस्करण है। routes.php फाइल:

 // routes.php use Psr\Http\Message\ServerRequestInterface; use React\EventLoop\LoopInterface; use React\ChildProcess\Process; use React\Http\Response; return [ '/' => function (ServerRequestInterface $request, LoopInterface $loop) { $childProcess = new Process('cat pages/index.html'); $childProcess->start($loop); return new Response( 200, ['Content-Type' => 'text/html'], $childProcess->stdout ); }, '/upload' => function (ServerRequestInterface $request) { return new Response( 200, ['Content-Type' => 'text/plain'], 'Upload page' ); }, ];

नतीजतन, यह सब कोड केवल एक कॉल को file_get_contents() फ़ंक्शन में बदलने के लिए आवश्यक था। निर्भरता इंजेक्शन, एक घटना लूप ऑब्जेक्ट को पारित करना, बच्चे की प्रक्रियाओं को जोड़ना, और थ्रेड्स के साथ काम करना। यह सब केवल एक फ़ंक्शन कॉल को बदलने के लिए है। क्या यह इसके लायक था? उत्तर: हां, यह इसके लायक था। जब कुछ ईवेंट लूप को ब्लॉक कर सकता है, और फ़ाइल सिस्टम निश्चित रूप से हो सकता है, तो सुनिश्चित करें कि यह अंततः ब्लॉक करेगा, और सबसे inopportune क्षण में।

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

हाबरा पाठक इस लिंक पर डिस्काउंट में पूरी किताब खरीद सकते हैं।

और हम आपको याद दिलाते हैं कि हम हमेशा शांत डेवलपर्स की तलाश में हैं ! आओ, हम मजे करते हैं!