php - used - html tags list




उपयोग करने के लिए इतनी बुरी आवश्यकता क्यों है? (10)

आप ओली के वैकल्पिक और __autoload () शामिल का उपयोग करके परीक्षण करते हैं; और एपीसी स्थापित कुछ की तरह इसका परीक्षण करें।

मुझे लगातार गति की चीजों का उपयोग करने पर संदेह है।

बेहतर PHP कोडिंग प्रथाओं के बारे में जो कुछ भी मैंने पढ़ा है, वह कहता है कि गति की वजह से require_once उपयोग न करें।

ऐसा क्यों है?

require_once के समान काम करने का उचित / बेहतर तरीका क्या है? यदि यह मायने रखता है, तो मैं PHP5 का उपयोग कर रहा हूं।


आपके द्वारा शामिल की गई फ़ाइल को सुनिश्चित करने के लिए *_once() फ़ंक्शंस प्रत्येक मूल निर्देशिका को स्टेटस करता है जो पहले से ही शामिल नहीं है। यह मंदी के कारण का हिस्सा है।

मैं बेंचमार्किंग के लिए Siege जैसे उपकरण का उपयोग करने की सलाह देता हूं। आप सभी सुझाए गए तरीकों का प्रयास कर सकते हैं और प्रतिक्रिया समय की तुलना कर सकते हैं।

टेक यूनिवर्स पर require_once() पर अधिक।


क्या आप हमें इन कोडिंग प्रथाओं के लिए कोई लिंक दे सकते हैं जो इससे बचने के लिए कहते हैं? जहां तक ​​मेरा संबंध है, यह एक पूर्ण गैर-मुद्दा है । मैंने स्रोत कोड को स्वयं नहीं देखा है, लेकिन मुझे लगता है कि include और include_once बीच एकमात्र अंतर यह है कि include_once उस फ़ाइल नाम को सरणी में जोड़ता है और प्रत्येक बार सरणी पर चेक करता है। उस सरणी को सॉर्ट करना आसान होगा, इसलिए इसे खोजना ओ (लॉग एन) होना चाहिए, और यहां तक ​​कि एक मध्यम-बड़े पैमाने पर एप्लिकेशन में केवल दो दर्जन शामिल होंगे।


चीजों को करने का एक बेहतर तरीका ऑब्जेक्ट उन्मुख दृष्टिकोण का उपयोग करना और __autoload() उपयोग करना है।


मुझे लगता है कि पीईएआर दस्तावेज में, आवश्यकताएं, requ_once, include और include_once की आवश्यकता है। मैं उस दिशानिर्देश का पालन करता हूं। आपका आवेदन अधिक स्पष्ट होगा।


मेरी व्यक्तिगत राय यह है कि require_once (या include_once) का उपयोग खराब अभ्यास है क्योंकि अगर आप पहले से ही उस फ़ाइल को शामिल करते हैं और डबल शामिल फाइलों की त्रुटियों को दबाते हैं तो आपके लिए आवश्यक जांच होती है जिसके परिणामस्वरूप घातक त्रुटियां होती हैं (जैसे कार्यों / कक्षाओं / आदि की डुप्लिकेट घोषणा)। ।

आपको पता होना चाहिए कि आपको फ़ाइल शामिल करने की आवश्यकता है या नहीं।


यह उस कार्य का उपयोग नहीं कर रहा है जो खराब है। समग्र कोड बेस में, इसका उपयोग कैसे और कब किया जाए, इसकी गलत समझ है। मैं शायद थोड़ा और संदर्भ जोड़ूंगा जो संभावित रूप से गलत धारणा को समझता है:

लोगों को यह नहीं सोचना चाहिए कि requ_once धीमा कार्य है। आपको अपना कोड एक या दूसरे तरीके से शामिल करना होगा। require_once() बनाम require() की गति मुद्दा नहीं है। यह प्रदर्शन बाधाओं के बारे में है जो इसे अंधाधुंध उपयोग करने के परिणामस्वरूप हो सकता है। यदि संदर्भ के लिए व्यापक रूप से विचार किए बिना उपयोग किया जाता है, तो यह बड़ी मेमोरी अपशिष्ट या अपशिष्ट कोड का कारण बन सकता है।

मैंने जो देखा है वह वास्तव में बुरा है, जब विशाल मोनोलिथिक ढांचे सभी गलत तरीकों से विशेष रूप से जटिल ऑब्जेक्ट ओरिएंटेड वातावरण में require_once() उपयोग करते हैं।

कई पुस्तकालयों में देखी गई प्रत्येक कक्षा के शीर्ष पर require_once() का उपयोग करने का उदाहरण लें:

require_once("includes/usergroups.php");
require_once("includes/permissions.php");
require_once("includes/revisions.php");
class User{
  //user functions
}

तो User वर्ग को सभी 3 अन्य वर्गों का उपयोग करने के लिए डिज़ाइन किया गया है। काफी उचित! लेकिन अब क्या होगा यदि कोई विज़िटर साइट ब्राउज़ कर रहा है और यहां तक ​​कि लॉग इन नहीं किया गया है और फ्रेमवर्क लोड करता है: require_once("includes/user.php"); प्रत्येक अनुरोध के लिए।

इसमें 1 + 3 अनावश्यक कक्षाएं शामिल हैं जो कभी भी उस विशेष अनुरोध के दौरान उपयोग नहीं की जाएंगी। इस प्रकार 5 एमबी या उससे कम के विपरीत 40 एमबी प्रति अनुरोध का उपयोग करके ब्लोटेड फ्रेमवर्क समाप्त हो जाते हैं।

अन्य तरीकों से इसका दुरुपयोग किया जा सकता है, जब एक वर्ग का पुन: उपयोग कई अन्य लोगों द्वारा किया जाता है! मान लें कि आपके पास लगभग 50 वर्ग हैं जो helper कार्यों का उपयोग करते हैं। यह सुनिश्चित करने के लिए कि जब वे लोड होते हैं तो उन कक्षाओं के लिए helpers उपलब्ध हैं, आपको मिलता है:

require_once("includes/helpers.php");
class MyClass{
  //Helper::functions();//etc..
}

यहां कुछ भी गलत नहीं है। हालांकि यदि एक पृष्ठ अनुरोध 15 समान वर्गों को शामिल करने के लिए होता है। आप require_once 15 बार चल रहे हैं, या एक अच्छे दृश्य के लिए:

require_once("includes/helpers.php");
require_once("includes/helpers.php");
require_once("includes/helpers.php");
require_once("includes/helpers.php");
require_once("includes/helpers.php");
require_once("includes/helpers.php");
require_once("includes/helpers.php");
require_once("includes/helpers.php");
require_once("includes/helpers.php");
require_once("includes/helpers.php");
require_once("includes/helpers.php");
require_once("includes/helpers.php");
require_once("includes/helpers.php");
require_once("includes/helpers.php");
require_once("includes/helpers.php");

Require_once () का उपयोग उन अनावश्यक लाइनों को पार्स करने के शीर्ष पर 14 बार उस फ़ंक्शन को चलाने के लिए तकनीकी रूप से प्रभाव को प्रभावित करता है। इसी तरह की समस्या के साथ केवल 10 अन्य अत्यधिक उपयोग किए जाने वाले वर्गों के साथ, यह इस तरह के व्यर्थ पुनरावर्तक कोड की 100+ लाइनों के लिए जिम्मेदार हो सकता है।

इसके साथ, यह संभवतः उपयोग करने के लायक require("includes/helpers.php"); इसके बजाय, आपके ऐप या ढांचे के बूटस्ट्रैप पर। लेकिन चूंकि सब कुछ सापेक्ष है, यह सब निर्भर करता है कि helpers क्लास के वजन बनाम उपयोग आवृत्ति आवश्यकता_ऑन require_once() की 15-100 लाइनों को बचाने के लायक है। लेकिन अगर किसी दिए गए अनुरोध पर helpers फ़ाइल का उपयोग न करने की संभावना कोई नहीं है, तो निश्चित रूप से इसकी require आपके मुख्य वर्ग में होनी चाहिए। प्रत्येक वर्ग में अलग-अलग आवश्यकताएं संसाधनों का अपशिष्ट बन जाती हैं।

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


यह धागा मुझे क्रिंग करता है, क्योंकि पहले से ही "समाधान पोस्ट किया गया" है, और यह सभी उद्देश्यों और उद्देश्यों के लिए गलत है। आइए गणना करें:

  1. PHP में परिभाषा वास्तव में महंगा है। आप इसे देख सकते हैं या स्वयं परीक्षण कर सकते हैं, लेकिन PHP में वैश्विक स्थिरता को परिभाषित करने का एकमात्र प्रभावी तरीका एक एक्सटेंशन के माध्यम से है। (कक्षा स्थिरांक वास्तव में बहुत सभ्य प्रदर्शन के अनुसार हैं, लेकिन यह एक महत्वपूर्ण मुद्दा है, 2)

  2. यदि आप require_once() उचित रूप से उपयोग कर रहे हैं, यानी, कक्षाओं को शामिल करने के लिए, आपको परिभाषित करने की भी आवश्यकता नहीं है; बस class_exists('Classname') । यदि आपके द्वारा शामिल की गई फ़ाइल में कोड शामिल है, यानी आप इसे प्रक्रियात्मक फैशन में उपयोग कर रहे हैं, तो बिल्कुल कोई कारण नहीं है कि आपके लिए require_once() आवश्यक हो; प्रत्येक बार जब आप उस फ़ाइल को शामिल करते हैं जिसे आप उपरोक्त कॉल करने के लिए मानते हैं।

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

अब, एक प्रवेश: इस सामान का परीक्षण करना मुश्किल है, क्योंकि यह निष्पादन समय के इतने कम खाते के लिए जिम्मेदार है।

यहां सवाल है जिसके बारे में आपको सोचना चाहिए: एक सामान्य नियम के रूप में, PHP में महंगा है, क्योंकि हर बार जब दुभाषिया एक को हिट करता है तो उसे पार्स मोड में वापस स्विच करना होता है, ऑपकोड उत्पन्न होता है, और फिर वापस कूदना पड़ता है। यदि आपके पास 100+ शामिल हैं, तो इसका निश्चित रूप से प्रदर्शन प्रभाव होगा। Require_once का उपयोग या उपयोग करने का कारण यह एक महत्वपूर्ण सवाल है क्योंकि यह ऑपोड कैश के लिए जीवन को मुश्किल बनाता है। इसके लिए एक स्पष्टीकरण यहां पाया जा सकता है, लेकिन यह क्या उबलता है कि:

  • यदि पार्स समय के दौरान, आप जानते हैं कि अनुरोध के पूरे जीवन के लिए आपको कौन सी फाइलों की आवश्यकता होगी, उन लोगों की require() जो बहुत शुरुआत में हैं और ओपोड कैश आपके लिए बाकी सब कुछ संभाल लेगा।

  • यदि आप एक ऑपोड कैश नहीं चला रहे हैं, तो आप एक कठिन जगह पर हैं। आपके सभी को एक फ़ाइल में शामिल करना (विकास के दौरान ऐसा न करें, केवल उत्पादन में) निश्चित रूप से पार्स समय की सहायता कर सकते हैं, लेकिन यह दर्द है, और आपको यह भी पता होना चाहिए कि आप वास्तव में क्या करेंगे निवेदन।

  • Autoload बहुत सुविधाजनक है, लेकिन धीमा, इस कारण से कि प्रत्येक बार एक समावेशन किया जाता है, तो ऑटोलोड लोड को चलाना पड़ता है। व्यावहारिक रूप से, मैंने पाया है कि एक अनुरोध के लिए कई विशेष फ़ाइलों को स्वत: लोड करने से कोई समस्या नहीं होती है, लेकिन आपको अपनी सभी फ़ाइलों को स्वत: लोड नहीं करना चाहिए।

  • यदि आपके पास शायद 10 शामिल हैं (यह लिफाफा गणना का एक बहुत पीछे है), यह सब वैंकिंग इसके लायक नहीं है: बस अपने डेटाबेस प्रश्नों या कुछ अनुकूलित करें।


हां, यह सादे ओल 'की आवश्यकता से थोड़ा महंगा है ()। मुझे लगता है कि बिंदु यह है कि यदि आप डुप्लिकेट के लिए पर्याप्त रूप से व्यवस्थित अपने कोड को व्यवस्थित नहीं रख सकते हैं, तो * _once () फ़ंक्शंस का उपयोग न करें, क्योंकि यह आपको कुछ चक्र बचाएगा।

लेकिन _once () फ़ंक्शंस का उपयोग करना आपके ऐप को मारने वाला नहीं है। असल में, इसे अपने शामिल करने के लिए इसे एक बहाना के रूप में उपयोग न करें । कुछ मामलों में, इसका उपयोग अभी भी अपरिहार्य है, और यह एक बड़ा सौदा नहीं है।


require_once और include_once दोनों की आवश्यकता है कि सिस्टम पहले से ही शामिल / आवश्यक होने का लॉग रखता है। प्रत्येक *_once कॉल का मतलब है कि लॉग को जांचना। तो निश्चित रूप से वहां कुछ अतिरिक्त काम किया जा रहा है लेकिन पूरे ऐप की गति को कम करने के लिए पर्याप्त है?

... मुझे वास्तव में संदेह है ... जब तक कि आप वास्तव में पुराने हार्डवेयर पर नहीं हैं या इसे बहुत कुछ नहीं कर रहे हैं।

यदि आप हजारों *_once कर रहे हैं, तो आप खुद को हल्का फैशन में कर सकते हैं। सरल ऐप्स के लिए, बस यह सुनिश्चित करना कि आपने इसे केवल एक बार शामिल किया है, लेकिन यदि आप अभी भी त्रुटियों को फिर से परिभाषित कर रहे हैं, तो आप ऐसा कुछ कर सकते हैं:

if (!defined('MyIncludeName')) {
    require('MyIncludeName');
    define('MyIncludeName', 1);
}

मैं व्यक्तिगत रूप से *_once बयान के साथ *_once लेकिन मूर्खतापूर्ण मिलियन पास बेंचमार्क पर, आप दोनों के बीच एक अंतर देख सकते हैं:

                php                  hhvm
if defined      0.18587779998779     0.046600103378296
require_once    1.2219581604004      3.2908599376678

10-100 × hhvm साथ धीमा और यह उत्सुक है कि hhvm में hhvm धीमी गति से hhvm । दोबारा, यह आपके कोड के लिए केवल प्रासंगिक है यदि आप हजारों बार *_once चला रहे हैं।

<?php // test.php

$LIMIT = 1000000;

$start = microtime(true);

for ($i=0; $i<$LIMIT; $i++)
    if (!defined('include.php')) {
        require('include.php');
        define('include.php', 1);
    }

$mid = microtime(true);

for ($i=0; $i<$LIMIT; $i++)
    require_once('include.php');

$end = microtime(true);

printf("if defined\t%s\nrequire_once\t%s\n", $mid-$start, $end-$mid);
<?php // include.php

// do nothing.




require-once