आप लंबी लाइनों को विभाजित करना चाहते हैं?

Question

लंबी लाइनों मैन्युअल लपेटकर के लिए, एक लाइन को तोड़ने के लिए स्थानों को चुनने के लिए अपने व्यक्तिगत अनुमानी क्या है?

इस लाइन है बहुत लंबा मानते हुए, जहां आप इसे तोड़ने के लिए और वरीयता का यह क्या आदेश सकता है?

double var = GetContext()->CalculateValue(element, 10.0); 

अधिकांश लोगों को प्रति पंक्ति पैरामीटर को अलग करने के बारे में सहमत हैं:

double var = GetContext()->CalculateValue(element, 
              10.0); 

किसी को भी एक प्रारंभिक कोष्ठक में तोड़ करता है?

double var = GetContext()->CalculateValue(
           element, 10.0); 

लेकिन यह कैसे एक dereferencing ऑपरेटर (या .) के साथ मुक्केबाज़ी:

double var = GetContext() 
       ->CalculateValue(element, 10.0); 

या क्या तुम:

double var = GetContext()-> 
       CalculateValue(element, 10.0); 

असाइनमेंट ऑपरेटर के लिए किसी भी प्रकार भिन्न है?

double var = 
    GetContext()->CalculateValue(element, 10.0); 

या

double var 
    = GetContext()->CalculateValue(element, 10.0); 

किसी भी दूसरों?

आपके सिस्टम प्रक्रियात्मक है, तो आप इस तरह का जवाब दे: अल्पविराम

पर

1. पैरामीटर नाम एक -> या . ऑपरेटर
2. से पहले एक असाइनमेंट ऑपरेटर के बाद

या बस कुछ उदाहरण कोड पोस्ट करें!
बोनस पॉइंट यदि आप अकादमिक रूप से अपने ब्रेकिंग फैसले को औचित्य साबित कर सकते हैं।

Answer 1

मैं बाध्यकारी आदेश की शक्ति में विभाजन, पंक्ति के अंत के लिए निकटतम पहले बनाने के लिए पसंद करते हैं। तो आपके उदाहरणों में मैं = चिह्न पर विभाजित होगा। यदि इससे भी मार्जिन गिरा मैं कम से विभाजित हैं ->

एक लाइन बंटवारे के विचार पाठकों के लाभ (के बाद से संकलन कम परवाह सकता है) के लिए पूरी तरह है। मुझे लगता है कि मानसिक रूप से तार्किक समूहों में टूटे हुए कोड के मानसिक रूप से टुकड़े टुकड़े करना आसान है।

Answer 2

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

double var = GetContext()-> 
      CalculateValue(element, 10.0); 

मैं कभी नहीं किया गया है:

Answer 3

मैं मापदंडों

Answer 4

अपने विशिष्ट उदाहरण में से प्रत्येक में तो कोष्ठकों खोलने पर तोड़ने के एक प्रशंसक मैं व्यक्तिगत रूप से चौथे एक के साथ जाना चाहते हैं हूँ कड़ाई से परिभाषित कोड स्वरूपण मानकों का एक प्रशंसक, मूल नियम से हमेशा किसी के कोड को प्रारूपित करने के लिए ताकि यह समझ में आता है (विशेष रूप से किसी को जो इसे नहीं लिखता) और पढ़ने में आसान है। कोई भी व्यापक रूप से व्यापक नियम "हमेशा इस पर एक लाइन ब्रेक डालें या उस पंक्ति में एक पंक्ति डालें" या यहां तक ​​कि "हमेशा इस नाम या उस नामकरण योजना के साथ चर नाम दें" बस मेरे साथ सही नहीं बैठता है। मुझे लगता है कि यह लंबे समय तक अच्छा से ज्यादा नुकसान करता है।

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

(ठीक है, कि एक शेख़ी का एक सा में बदल गया हो सकता है। मेरे क्षमायाचना। लेकिन बात बनी हुई है।)

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

Answer 5

इस लाइन के लिए:

double var = GetContext()->CalculateValue(element, 10.0, foo);

मैं पहली पैरामीटर के बाद linke टूट जाएगा, तो उसके बाद तत्वों लाइन अप शुरू करने जहां पहले पैरामीटर शुरू कर दिया है, लेकिन अगली पंक्ति:

double var = GetContext()->CalculateValue(element, 
              10.0, foo); 

यदि दूसरी पंक्ति बहुत लंबी हो जाती है, तो एक तिहाई बनाओ और इसी तरह।