ऑपरेटर से पहले / बाद में लाइन ब्रेक [बंद]

Question

जबकि Sun's Java कोड कन्वेंशन ऑपरेटर से पहले लाइन ब्रेक लगाने का सुझाव देता है जबकि कई अन्य दिशानिर्देश इससे असहमत हैं। मुझे कोई स्पष्ट पेशेवरों और विपक्ष नहीं दिखते हैं, तो क्या इन शैलियों में से किसी एक का उपयोग करने के फायदे हैं?

String longVarName = a + b + c + d +
          e + f;

बनाम

String longVarName = a + b + c + d
          + e + f;

Comments

क्या आप दोनों सम्मेलनों को दिखाते हुए एक सरल कोड उदाहरण पोस्ट कर सकते हैं?

— माइकल

पहले मैं कुछ इस तरह का उपयोग करके स्थिति से बचने की कोशिश करूंगा: download.oracle.com/javase/1.4.2/docs/api/java/lang/…

— जॉब

लिंक टूट गया है।

— फ्लोरियन एफ

Answer 1

मैं इसे एक पंक्ति पर छोड़ता हूं और इरादा-परिवर्तनशील चर नामों (और कार्यों) के संदर्भ में पठनीयता के बारे में सोचता हूं।

एक बार जब यह गन्दा हो जाता है तो यह रिफ्लेक्टर का समय होता है :

• नाम बदलें
• नए संस्करण / कार्य परिचय

उदाहरण

subtotal = price * (100 + tax_ratio) / 100`

बनाम

tax = price * tax_ratio / 100
subtotal = price + tax

Comments

बाईं ओर का सूत्र गलत है। यह price * (100 + tax_ratio) / 100या तो या सिर्फ होना चाहिए price * (1 + tax_ratio), यह इस बात पर निर्भर करता है कि tax_ratioप्रतिशत में है या आंशिक है।

— रफ़लविंड

इस सवाल का जवाब नहीं है। इस प्रकार के उत्तरों के खिलाफ एक कानून होना चाहिए।

— एडवर्ड डिसूजा

@ एडवर्ड डीसूजा मुझे वही लगता है। लेकिन जवाब क्यों स्वीकार किया गया?

— रूडी विवर्स

@RudyVissers उत्तर को गहरे स्तर पर हल करता है। यह पहली जगह में लाइन ब्रेक की आवश्यकता की समस्या को हल करता है। उस दृष्टिकोण से, ओपी इसे अपनी समस्या का उत्तर मान सकता है, लेकिन यह अभी भी समुदाय विकि होने के परिप्रेक्ष्य से उचित नहीं है।

— एडवर्ड डिसूजा

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

— कामिल टॉमकिंक

Answer 2

मैं पठनीयता का तर्क होने की कल्पना कर सकता हूं

result = longidentifier +
   short -
   alittlelonger -
   c;

बनाम

result = longidentifier
   + short
   - alittlelonger
   - c;

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

Comments

उन स्थितियों के लिए जहां ऑपरेटर महत्वपूर्ण हैं (जैसे गणित के भाव और ऐसे) मैं नंबर दो को चुनूंगा, क्योंकि, जैसा कि आपने कहा, यह बहुत अधिक पठनीय है। लेकिन स्ट्रिंग्स के लिए मैं पहला विकल्प चुनूंगा, क्योंकि ऑपरेटर "अर्थहीन" हैं। वे तार को एक साथ लाने के अलावा कुछ नहीं करते हैं, और क्योंकि तार महत्वपूर्ण बिट हैं, फिर मैं पहले विकल्पों को पसंद करूंगा।

— निकोलस एच।

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

— जल्‍दी से जल्‍दी से

Answer 3

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

सबसे सामान्य शैली जो मैंने देखी है वह सवाल में दूसरी शैली है। इनकी सूची के लिए नीचे देखें:

Google स्टाइल गाइड :

जब एक गैर-असाइनमेंट ऑपरेटर में एक लाइन टूट जाती है तो प्रतीक से पहले ब्रेक आ जाता है।

सन कोडिंग कन्वेंशन :

एक ऑपरेटर से पहले तोड़ो

चेकस्टाइल ऑपरेटर लपेटें चेक का डिफ़ॉल्ट मान nl है:

ऑपरेटर को एक नई लाइन पर होना चाहिए

Comments

स्पष्टता के लिए मेरा जवाब अपडेट किया गया + सूर्य का कोडिंग सम्मेलन।

— छत

google.github.io/styleguide/javaguide.html (उत्तर में लिंक टूटा हुआ है)

— मार्टिन फफ़र

Answer 4

कोड में मैं ऑपरेटर के बाद ब्रेक लगाना चाहता हूं:

foo = some_long_expression() +
      some_other_long_expression();

यहाँ कि एक पंक्ति के अंत में झूलने वाला ऑपरेटर पाठक के लिए एक बड़ा सुराग है कि कोड जारी है। जिन भाषाओं में स्टेटमेंट टर्मिनेटर नहीं होते हैं, वह झूलने वाला ऑपरेटर कंपाइलर / दुभाषिया के लिए पर्याप्त सुराग के रूप में काम कर सकता है जो कोड जारी रहता है (अन्यथा मुझे कुछ बदसूरत कंटीन्यूअस लाइन कंस्ट्रक्शन का उपयोग करना होगा)।

उस अभिव्यक्ति का दस्तावेजीकरण करते समय (यदि उसे प्रलेखन की आवश्यकता है), मैं ऑपरेटर के सामने विराम लगाता हूं।

Comments

कम से कम कुछ भाषाएँ (जैसे पायथन) एक अनुगामी बाइनरी ऑपरेटर को संकेत के रूप में नहीं लेती हैं कि लाइन जारी है, लेकिन अधिक की आवश्यकता है। ध्यान दें कि आमतौर पर पार्न्स के अंदर की नई संख्याओं की गणना नहीं की जाती है, इसलिए आपको एक स्पष्ट (और त्रुटि-प्रवण) लाइन निरंतरता चरित्र की आवश्यकता नहीं है।

Answer 5

जब तक आप सुसंगत रहते हैं, तब तक पता है कि कोई वास्तविक फायदा नहीं है। कोड मर्ज और सफेद स्थान पर विचार करते समय यह विशेष रूप से महत्वपूर्ण है।

Answer 6

मेरा मानना ​​है कि रेखा को उस कथन के पार्स ट्री में उच्चतम प्रतीक के साथ शुरू करना चाहिए जिसे आप तोड़ना चाहते हैं। यह उस ऑपरेटर को उजागर करता है जो अभिव्यक्ति में सबसे महत्वपूर्ण है। यही कारण है कि आपने एक पंक्ति की शुरुआत में एक और रखा और पिछली पंक्ति के अंत में नहीं।

निम्नलिखित उदाहरण में, बाएं मार्जिन को स्कैन करते हुए, आप कथन की संरचना को OR के 3 अभिव्यक्तियों के रूप में देखते हैं।

if (ch>='A' && ch<='Z'
    || ch>='a' && ch<='z'
    || ch>='0' && ch<='9')
{...}

नीचे, || ऑपरेटरों को कम हाइलाइट किया जाता है। यह कम स्पष्ट है यह एक || अभिव्यक्ति के। खासकर अगर रेखाएं अलग-अलग लंबाई की थीं।

if (ch>='A' && ch<='Z' ||
    ch>='a' && ch<='z' ||
    ch>='0' && ch<='9')
{...}

और सिर्फ संदर्भ के लिए, यह बहुत गलत है। || ऑपरेटरों को उजागर नहीं किया जाता है।

if ( ch>='A' && ch<='Z' || ch>='a'
     && ch<='z' || ch>='0' && ch<='9')
{...}

मैं रेखा की शुरुआत में भी कॉमा डालना पसंद करता हूं, भले ही मैं शायद ही कभी देखता हूं। मैं साझा कोड पर ऐसा करने से बचता हूं।

var note:Object =
    { key: key
    , type: 'P'
    , text: someLongProcedureCallGettingTheUserInitials()
       + ": " + getTheTextThatWasTyped()
    };

Answer 7

लंबे अंकगणितीय समीकरणों के लिए, मैं आमतौर पर दो चीजों में से एक करता हूं।

एक ही लाइन पर सब कुछ छोड़ दो:

foo = bar + baz - fizz + buzz + alpha - beta;

मैं आमतौर पर केवल जोड़ और घटाव वाले समीकरणों के लिए ऐसा करता हूं , मुझे गुणन और विभाजन के साथ एक टाइपो बनाना बहुत आसान लगता है जो ऑपरेटर के दायरे को गंभीर रूप से गड़बड़ कर सकता है।

दूसरा प्रारूप जो मैं उपयोग कर रहा हूं वह प्रगतिशील ऑपरेटर है:

foo = bar;
foo += baz;
foo -= fizz;
foo += buzz;
foo /= alpha - beta;
foo *= spiff;

जब तक इसे ध्यान देने योग्य तरीके से प्रदर्शन में सुधार करने के लिए साबित नहीं किया जा सकता है, तब तक मुझे इसे एक पंक्ति में छोटा करने का कोई कारण नहीं दिखता है। इसके अतिरिक्त, जहां कहीं भी चल रहा है, उसकी कोई अस्पष्टता नहीं है, /और *ऑपरेटरों के लिए एक कोष्ठक को विस्थापित करने का मौका कम है ।

Answer 8

लाइन की शुरुआत में कॉन्सेटेशन कैरेक्टर (या कोई भी ऑपरेटर) रखने से पठनीयता में सुधार होता है। हम प्रत्येक पंक्ति की शुरुआत पर ध्यान केंद्रित करके कोड को स्कैन करते हैं। जब एक ऑपरेटर के साथ एक लाइन शुरू होती है, तो पाठक यह बता सकता है कि उस चरित्र को स्कैन करके लाइन पिछले कथन का एक निरंतरता है।

लंबी गणितीय अभिव्यक्तियां हमेशा टाइपसेट होती हैं ताकि प्रत्येक नई पंक्ति एक ऑपरेटर के साथ शुरू हो। कोई कारण नहीं है कि कोड को इस सम्मेलन का पालन नहीं करना चाहिए।

Answer 9

एक पंक्ति पर अभिव्यक्ति छोड़ें, और अगर यह बहुत लंबा हो जाता है, तो इसे छोटे अभिव्यक्तियों में तोड़ दें:

days = ((year * months_per_year) + month) * days_per_month + day

हो जाता है:

months = year * months_per_year + month
days = months * days_per_month + day

यदि यह संभव नहीं है, तो मुझे ऑपरेटर के सामने टूटने के लिए अधिक पठनीय लगता है, और ऑपरेटर सीधे पिछले असाइनमेंट से नीचे शुरू होता है (इसे नीचे चर पर रखकर मुझे सोचना पड़ता है और पुनरावृत्ति करना पड़ता है, जो कि लक्ष्य को देखते हुए कष्टप्रद है। चीजों को पढ़ना आसान बनाना है):

random = years * months_per_year 
         + month * days_per_month 
         + day * hours_per_day 
         + hour * minutes_per_hour 
         + minute * seconds_per_minute 
         + second

Comments

यह उत्तर कुछ भी नया नहीं जोड़ता है जो पहले ही कहा जा चुका है।

— मार्टिज़न पीटर्स