दिलचस्प पोस्ट
ड्रॉएबल संसाधनों का उपयोग करना टुकड़ा के अंदर Google मानचित्र V2 का उपयोग कैसे करें? C # का उपयोग करके FTP पर फ़ाइल अपलोड करें कैसे MSTest के साथ RowTest करने के लिए? एचटीएमएल 5 कैनवास में छवि कैसे अपलोड करें कैसे पुराने स्थापना का पता लगाने और हटाने की पेशकश? बाइट ऑर्डर मार्क (बीओएम) के बिना पाठ फ़ाइलें लिखें? "पाठ-सजावट" और "छद्म तत्व" के बाद, पुनरीक्षित एक सेलेरी कार्य में स्क्रैपी मकड़ियों चल रहा है java: एक वर्ग में सभी चर नाम प्राप्त करें QCompleter कस्टम समापन नियम सभी एसडीके लाइसेंसों को स्वचालित रूप से स्वीकार करें तृतीय पक्ष वेब सेवा के माध्यम से क्लाइंट आईपी पता प्राप्त करें एंड्रॉइड ऐप फ़ॉरबेज अधिसूचना प्राप्त नहीं कर रहा है जब ऐप्प को बहु-कार्य ट्रे से रोक दिया जाता है ऑपरेशन पूरा नहीं किया जा सका। (com.facebook.sdk त्रुटि 2.) ios6

पाठ फ़ाइलों को एक नई पंक्ति के साथ समाप्त क्यों करना चाहिए?

मैं मानता हूँ कि यहां हर किसी को यह जानकारी है कि सभी पाठ फ़ाइलों को एक नई लाइन के साथ समाप्त होना चाहिए। मैं वर्षों से इस "नियम" के बारे में जानता हूं लेकिन मैं हमेशा आश्चर्यचकित हूं – क्यों?

Solutions Collecting From Web of "पाठ फ़ाइलों को एक नई पंक्ति के साथ समाप्त क्यों करना चाहिए?"

चूंकि POSIX मानक एक रेखा को परिभाषित करता है :

3.206 लाइन
शून्य या अधिक गैर- <newline> वर्णों के साथ-साथ एक टर्मिनल <newline> वर्ण का अनुक्रम

इसलिए, नई लाइन में समाप्त होने वाली रेखाएं वास्तविक रेखा नहीं माना जाता है। इसीलिए कुछ कार्यक्रमों में फ़ाइल की अंतिम पंक्ति को संसाधित करने में समस्याएं होती हैं यदि यह नई लाइन समाप्त नहीं होती है

टर्मिनल एमुलेटर पर कार्य करते समय इस दिशानिर्देश का कम से कम एक कठिन लाभ होता है: सभी यूनिक्स उपकरण इस सम्मेलन की अपेक्षा करते हैं और इसके साथ काम करते हैं। उदाहरण के लिए, जब cat साथ फाइलों को cat , तो न्यूलाइन द्वारा समाप्त की गई फ़ाइल को बिना एक से अलग प्रभाव पड़ता है:

 $ more a.txt foo$ more b.txt bar $ more c.txt baz $ cat *.txt foobar baz 

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

निरंतरता के लिए, इस नियम का पालन करने में बहुत मददगार है – अन्यथा ऐसा करने से डिफ़ॉल्ट यूनिक्स टूल्स के साथ काम करते समय अतिरिक्त कार्य किया जाएगा।

अब, गैर-पॉसिक्स आज्ञाकारी प्रणालियों पर (आजकल जो अधिकतर विंडोज हैं), मुद्दा विवादास्पद है: फ़ाइलें आम तौर पर एक नई रेखा के साथ समाप्त नहीं होती हैं, और एक पंक्ति की (अनौपचारिक) परिभाषा उदाहरण के लिए "टेक्स्ट जो कि न्यूलाइनों से अलग होती है" (जोर पर ध्यान दें) यह पूरी तरह से वैध है। हालांकि, संरचित डेटा (जैसे प्रोग्रामिंग कोड) के लिए यह न्यूनतम रूप से अधिक जटिल पार्सिंग करता है: इसका आम तौर पर मतलब है कि पार्सर को फिर से लिखना होगा। यदि कोई पार्सर मूल रूप से POSIX परिभाषा के साथ दिमाग में लिखा गया था, तो पार्सर की बजाय टोकन स्ट्रीम को संशोधित करना आसान हो सकता है – दूसरे शब्दों में, इनपुट के अंत में एक "कृत्रिम नयालाइन" टोकन जोड़ें।

प्रत्येक पंक्ति को एक नई पंक्ति में समाप्त कर दिया जाना चाहिए, जिसमें अंतिम एक भी शामिल है। कुछ कार्यक्रमों में फ़ाइल की अंतिम पंक्ति को संसाधित करने में समस्याएं होती हैं यदि यह नई लाइन समाप्त नहीं होती है

जीसीसी इस बारे में चेतावनी देता है क्योंकि यह फ़ाइल को संसाधित नहीं कर सकता है, लेकिन क्योंकि यह मानक के हिस्से के रूप में है

सी भाषा मानक कहते हैं कि एक स्रोत फ़ाइल जो खाली नहीं है, वह एक नए-लाइन वाले चरित्र में समाप्त हो जाएगी, जो किसी बैकस्लैश वर्ण द्वारा तत्काल पहले नहीं किया जाएगा।

चूंकि यह "होगा" खंड है, इसलिए हमें इस नियम के उल्लंघन के लिए निदान संदेश छोड़ना होगा।

यह एएनएसआई सी 1989 मानक के खंड 2.1.1.2 में है। आईएसओ सी 1999 मानक (और संभवत: आईएसओ सी 1990 मानक) की धारा 5.1.1.2।

संदर्भ: जीसीसी / जीएनयू मेल संग्रह ।

यह जवाब राय के बजाय तकनीकी जवाब देने का एक प्रयास है।

यदि हम पीओएसआईआईसीआई के शुद्धवादियों बनना चाहते हैं, तो हम एक पंक्ति को परिभाषित करते हैं:

शून्य या अधिक गैर- <newline> वर्णों के साथ-साथ एक टर्मिनल <newline> वर्ण का अनुक्रम

स्रोत: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_206

एक अपूर्ण रेखा के रूप में:

फ़ाइल के अंत में एक या अधिक गैर- <newline> वर्णों का अनुक्रम।

स्रोत: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_195

एक टेक्स्ट फाइल के रूप में:

एक फ़ाइल जिसमें शून्य या अधिक पंक्तियों में व्यवस्थित वर्ण शामिल हैं लाइनों में NUL वर्ण नहीं होते हैं और कोई भी <LINE_MAX} बाइट्स लंबाई में, <newline> वर्ण सहित, से अधिक नहीं हो सकता। यद्यपि POSIX.1-2008 पाठ फ़ाइलों और बाइनरी फ़ाइलों (आईएसओ सी मानक देखें) के बीच भेद नहीं करता है, लेकिन कई यूटिलिडी केवल पाठ फ़ाइलों पर काम करते समय ही अनुमानित या अर्थपूर्ण आउटपुट का उत्पादन करते हैं। मानक उपयोगिताओं, जिनके पास ऐसी प्रतिबंध हैं, हमेशा अपने एसटीडीआईएन या INPUT FILES अनुभागों में "पाठ फ़ाइलें" निर्दिष्ट करते हैं।

स्रोत: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_397

एक स्ट्रिंग के रूप में:

बाइट्स के निकटतम अनुक्रम द्वारा समाप्त और पहली नल बाइट सहित।

स्रोत: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_396

इसके बाद से, हम यह जान सकते हैं कि एक बार हम संभावित रूप से किसी भी तरह के मुद्दों का सामना करेंगे, यदि हम फ़ाइल की एक रेखा या एक फ़ाइल के रूप में एक फ़ाइल के रूप में धारण करते हैं (एक पाठ फ़ाइल शून्य का एक संगठन है या अधिक पंक्तियां, और एक पंक्ति जिसे हमें पता है उसे एक <newline> के साथ समाप्त करना होगा)।

मामले में केस: wc -l filename

wc मैनुअल से हम पढ़ते हैं:

एक पंक्ति को <newline> वर्ण द्वारा सीमांकित अक्षरों की एक स्ट्रिंग के रूप में परिभाषित किया गया है

जावास्क्रिप्ट, एचटीएमएल, और सीएसएस फाइलों का क्या असर है कि वे पाठ फाइल हैं?

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

परिणामस्वरूप, हम अपेक्षाकृत आश्वस्त हो सकते हैं कि ईओएफ पर ईओएल आवेदन स्तर पर लगभग कोई नकारात्मक प्रभाव नहीं पड़ेगा – भले ही यह यूनिक्स ओएस पर चल रहा हो।

इस समय हम आत्मविश्वास से कह सकते हैं कि क्लाइंट-साइड पर जेएस, एचटीएमएल, सीएसएस के साथ काम करते वक्त ईओएफ पर ईओएल छोड़ने से सुरक्षित है। दरअसल, हम यह बता सकते हैं कि इन फ़ाइलों में से किसी को भी कम करना, जिसमें कोई भी <newline> सुरक्षित नहीं है।

हम इसे एक कदम आगे बढ़ा सकते हैं और कह सकते हैं कि जहां तक ​​नोडजेएस का संबंध है, वह भी POSIX मानक का पालन नहीं कर सकता है कि यह गैर-पॉसिक्स अनुरूप वातावरण में चलाया जा सकता है।

तब हम साथ क्या छोड़े गए हैं? सिस्टम स्तर टूलिंग

इसका मतलब ये है कि केवल ऐसे मुद्दे हैं जो उपकरण के साथ हैं, जो अपनी कार्यशीलता को पॉसिक्स (जैसे wc में दिखाए गए एक पंक्ति की परिभाषा) के शब्दों के अनुसार पालन करने का प्रयास करते हैं।

फिर भी, सभी गोले अपने आप को POSIX का पालन नहीं करेंगे। उदाहरण के लिए बास POSIX व्यवहार के लिए डिफ़ॉल्ट नहीं है इसे सक्षम करने के लिए एक स्विच है: POSIXLY_CORRECT

ईओएल के मूल्य पर विचार के लिए खाद्य <newline>: http://www.rfc-editor.org/EOLstory.txt

टूलींग ट्रैक पर बने रहना, सभी व्यावहारिक उद्देश्यों और उद्देश्यों के लिए, इस पर विचार करें:

आइए एक फाइल के साथ काम करते हैं जिसमें ईओएल नहीं है I इस फ़ाइल को इस उदाहरण में लिखना कोई ईओएल के साथ एक न्यूनतम जावास्क्रिप्ट है।

 curl http://cdnjs.cloudflare.com/ajax/libs/AniJS/0.5.0/anijs-min.js -o x.js curl http://cdnjs.cloudflare.com/ajax/libs/AniJS/0.5.0/anijs-min.js -o y.js $ cat x.js y.js > z.js -rw-r--r-- 1 milanadamovsky 7905 Aug 14 23:17 x.js -rw-r--r-- 1 milanadamovsky 7905 Aug 14 23:17 y.js -rw-r--r-- 1 milanadamovsky 15810 Aug 14 23:18 z.js 

ध्यान दें cat फ़ाइल का आकार वास्तव में अपने व्यक्तिगत भागों का योग है अगर जावास्क्रिप्ट फाइलों के संयोजन में जेएस फाइलों की चिंता है, तो प्रत्येक जावास्क्रिप्ट फ़ाइल को सेमी-कोलन के साथ शुरू करना होगा।

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

cat का man केवल ईओएफ तक इनपुट पढ़ने का उल्लेख करता है, न कि <newline>। ध्यान दें कि cat का -n स्विच लाइन के रूप में एक गैर- <newline> समाप्त लाइन (या अपूर्ण रेखा ) को प्रिंट भी करेगा – यह है कि गणना 1 से शुरू होती है ( man अनुसार)।

-n 1 से शुरू होने वाले आउटपुट लाइनों की संख्या

अब जब हम समझते हैं कि कैसे पॉसिक्स एक रेखा को परिभाषित करता है, तो यह व्यवहार अस्पष्ट या वास्तव में, गैर-अनुपालन हो जाता है

किसी दिए गए उपकरण के उद्देश्य और अनुपालन को समझना एओएल के साथ फाइलों को समाप्त करना कितना महत्वपूर्ण है यह निर्धारित करने में मदद करेगा। सी, सी ++, जावा (जेएआरएस) आदि में … कुछ मानदंड वैधता के लिए एक नई लाइन को निर्देशित करेंगे – जेएस, एचटीएमएल, सीएसएस के लिए ऐसा कोई मानक नहीं है।

उदाहरण के लिए, wc -l filename का उपयोग करने के बजाय कोई awk '{x++}END{ print x}' filename , और बाकी का यह आश्वासन दिया गया है कि कार्य की सफलता को किसी फ़ाइल द्वारा खतरे में नहीं लाया जा सकता है, जिसे हम उस प्रक्रिया को करना चाहते हैं जिसे हमने नहीं लिखा है ( जैसे कि एक तीसरी पार्टी की पुस्तकालय, जैसे कि minified जेएस हम curl डी) – जब तक कि हमारे इरादे वास्तव में POSIX अनुरूप अर्थों में लाइनों की गणना करने के लिए नहीं था।

निष्कर्ष

वास्तविक जीवन उपयोग के मामलों में बहुत कुछ होगा, जहां कुछ पाठ फ़ाइलों जैसे जेएस, एचटीएमएल, और सीएसएस के लिए ईओएफ को ईओपी छोड़ना एक नकारात्मक प्रभाव पड़ता है – अगर बिल्कुल भी। अगर हम <newline> उपस्थित होने पर भरोसा करते हैं, तो हम केवल उन फाइलों के लिए हमारी टूलिंग की विश्वसनीयता सीमित कर रहे हैं, जिन्हें हम लेखक करते हैं और तीसरी पार्टी फ़ाइलों द्वारा पेश की गई संभावित त्रुटियों तक खुद को खोलते हैं।

कहानी का नैतिक: इंजीनियर टूलिंग जिस पर ईओएफ पर ईओएल पर निर्भर रहने की कमजोरी नहीं है।

उपयोग मामलों को पोस्ट करने के लिए स्वतंत्र महसूस करें क्योंकि वे जेएस, एचटीएमएल और सीएसएस पर आवेदन करते हैं, जहां हम जांच कर सकते हैं कि ईओएल के लंघन के कारण प्रतिकूल प्रभाव पड़ता है।

यह बीच में अंतर से संबंधित हो सकता है:

  • पाठ फ़ाइल (प्रत्येक पंक्ति को अंत के लाइन में समाप्त होना चाहिए)
  • बाइनरी फ़ाइल (बोलने के लिए कोई वास्तविक "लाइन" नहीं है, और फ़ाइल की लंबाई को संरक्षित किया जाना चाहिए)

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

साथ ही, एक संपादक लोड की जांच कर सकता है कि फाइल को एंड-लाइन में समाप्त होता है, इसे अपने स्थानीय विकल्प 'ईओएल' में बचाता है, और इसका इस्तेमाल करता है कि फाइल लिखते समय

कुछ साल पहले (2005), कई संपादकों (जेडडीई, ईक्लिप्स, स्काईट, …) ने "भूल" किया कि अंतिम ईओएल, जो बहुत सराहना नहीं की गई थी ।
इतना ही नहीं, लेकिन उन्होंने कहा कि अंतिम ईओएल गलत तरीके से व्याख्या की, 'एक नई पंक्ति शुरू करें' के रूप में, और वास्तव में दूसरी पंक्ति प्रदर्शित करने लगती है जैसे कि वह पहले से मौजूद है
यह एक 'उचित' पाठ फ़ाइल के साथ एक अच्छी तरह से व्यवहार वाला पाठ संपादक जैसे विम के साथ बहुत ही दृश्यमान था, इसके ऊपर के संपादकों में से एक में खोलने की तुलना में। यह फ़ाइल की असली अंतिम पंक्ति के नीचे एक अतिरिक्त पंक्ति प्रदर्शित की गई। आप कुछ ऐसा देखते हैं:

 1 first line 2 middle line 3 last line 4 

कुछ उपकरण यह उम्मीद करते हैं उदाहरण के लिए, wc इस की अपेक्षा करता है:

 $ echo -n "Line not ending in a new line" | wc -l 0 $ echo "Line ending with a new line" | wc -l 1 

असल में ऐसे कई प्रोग्राम हैं जो फाइलों को सही तरीके से संसाधित नहीं करेंगे यदि उन्हें अंतिम ईओएल ईओएफ नहीं मिलता है।

जीसीसी आपको इस बारे में चेतावनी देता है क्योंकि सी मानक के हिस्से के रूप में इसकी अपेक्षा की जाती है। (खंड 5.1.1.2 जाहिरा तौर पर)

"फ़ाइल के अंत में कोई नयालाइन नहीं" संकलक चेतावनी

यह बहुत शुरुआती दिनों से उत्पन्न होता है जब सरल टर्मिनलों का उपयोग किया जाता था। नए अक्षरों को स्थानांतरित डेटा के 'फ्लश' को ट्रिगर करने के लिए इस्तेमाल किया गया था।

आज, नई लाइन चार की आवश्यकता नहीं है। ज़रूर, कई ऐप्स अभी भी समस्याएं हैं यदि नई लाइन नहीं है, लेकिन मुझे लगता है कि उन क्षुधा में एक बग के बारे में सोचता हूं।

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

संभवत: बस कुछ पार्सिंग कोड होने की उम्मीद थी

मुझे यकीन नहीं है कि मैं इसे "शासन" मानता हूं, और निश्चित रूप से ऐसा कुछ नहीं है जो मैं धार्मिक रूप से पालन करता हूं सबसे समझदार कोड पता चलेगा कि पिछली लाइन पर एक नई लाइन के बिना-या-बिना पाठ (एन्कोडिंग सहित) लाइन-बाय-लाइन (लाइन अंत की कोई भी पसंद)

वास्तव में – यदि आप एक नई रेखा के साथ समाप्त होते हैं: क्या (सिद्धांत में) ईओएल और ईओएफ के बीच एक खाली अंतिम पंक्ति है? विचार करने के लिए एक …

फाइलों के अंत में नई लाइनों की कमी के साथ एक व्यावहारिक प्रोग्रामिंग समस्या भी है: read बैश में निर्मित (मुझे अन्य read क्रियान्वयन के बारे में नहीं पता) अपेक्षा के अनुरूप काम नहीं करता है:

 printf $'foo\nbar' | while read line do echo $line done 

यह केवल foo प्रिंट करता है! इसका कारण यह है कि जब read जाता है, आखिरी पंक्ति का सामना करता है, तो वह सामग्री को $line लिखती है, लेकिन रिटर्न निकास कोड 1 देता है क्योंकि यह ईओएफ पर पहुंच गया है। यह while लूप को तोड़ता है, इसलिए हम echo $line भाग तक कभी नहीं पहुंचते हैं। यदि आप इस स्थिति को संभालना चाहते हैं, तो आपको निम्न कार्य करना होगा:

 while read line || [ -n "${line-}" ] do echo $line done < <(printf $'foo\nbar') 

वह है, echo करते read अगर फ़ाइल के अंत में एक गैर-रिक्त पंक्ति के कारण read विफल हो जाता है स्वाभाविक रूप से, इस मामले में इनपुट में एक अतिरिक्त नई लाइन होगी जो इनपुट में नहीं थी।

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

इसलिए, कारण हैं:

  1. क्योंकि इस तरह से POSIX इसे परिभाषित करता है
  2. क्योंकि कुछ उपकरण इसे बिना या इसके बिना "दुर्व्यवहार" की अपेक्षा करते हैं उदाहरण के लिए, यदि कोई न्यूलाइन के साथ समाप्त नहीं होता है तो wc -l अंतिम "रेखा" की गणना नहीं करेगा
  3. क्योंकि यह सरल और सुविधाजनक है यूनिक्स पर, cat बस काम करती है और यह जटिलता के बिना काम करती है। यह प्रत्येक फ़ाइल के बाइट्स की प्रतिलिपि बनाता है, बिना किसी व्याख्या के लिए। मुझे नहीं लगता कि cat बराबर एक डॉस है। copy a+bc का उपयोग फाइल b की पहली पंक्ति के साथ फ़ाइल की आखिरी पंक्ति को मर्ज करने के लिए खत्म हो जाएगा
  4. क्योंकि शून्य लाइनों की एक फ़ाइल (या धारा) को एक खाली रेखा की फ़ाइल से अलग किया जा सकता है

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

क्यों चाहिए (पाठ) फ़ाइलें एक नई पंक्ति के साथ समाप्त होती हैं?

साथ ही कई लोगों द्वारा व्यक्त की गई, क्योंकि:

  1. कई कार्यक्रम अच्छी तरह से व्यवहार नहीं करते, या इसके बिना असफल होते हैं।

  2. यहां तक ​​कि एक प्रोग्राम को अच्छी तरह से संभालते हुए कार्यक्रमों में '\n' समाप्त होने '\n' कमी है, उपकरण की कार्यक्षमता उपयोगकर्ता की अपेक्षाओं को पूरा नहीं कर सकती है – जो इस कोने के मामले में स्पष्ट नहीं हो सकती।

  3. कार्यक्रम शायद ही कभी अंतिम '\n' (मुझे किसी के बारे में नहीं पता) को अस्वीकार करना है।


फिर भी यह अगले सवाल भी पूछता है:

एक नई लाइन के बिना पाठ फ़ाइलों के बारे में क्या कोड करना चाहिए?

  1. सबसे महत्वपूर्ण – कोड लिखना न मानें जो पाठ फ़ाइल मान लेती है एक नई लाइन के साथ समाप्त होती है मान लें कि किसी फ़ाइल को किसी प्रारूप के अनुरूप डेटा भ्रष्टाचार, हैकर हमलों और दुर्घटनाओं की ओर जाता है। उदाहरण:

     // Bad code while (fgets(buf, sizeof buf, instream)) { // What happens if there is no \n, buf[] is truncated leading to who knows what buf[strlen(buf) - 1] = '\0'; // attempt to rid trailing \n ... } 
  2. यदि अंतिम अनुगामी '\n' की आवश्यकता है, तो उपयोगकर्ता को इसकी अनुपस्थिति और कार्रवाई की गई चेतावनी दें। IOWs, फ़ाइल के प्रारूप को मान्य करें। नोट: इसमें अधिकतम रेखा की लंबाई, वर्ण एन्कोडिंग, आदि की सीमा शामिल हो सकती है।

  3. स्पष्ट रूप से परिभाषित करें, दस्तावेज, संहिता के अंतिम संहिता '\n' का संभाल।

  4. जितना संभव हो, उतनी न करें, एक फ़ाइल उत्पन्न करें , अंत में '\n' का अभाव है।

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

हालांकि मेरा मानना ​​है कि नियम सी कम्पाइलर से लिया गया है जिसमें न्यूलाइन की आवश्यकता है। और जैसा कि "फ़ाइल के अंत में कोई नई पंक्ति नहीं" संकलक चेतावनी पर बताया गया है, # शामिल एक नई पंक्ति को नहीं जोड़ देगा

मैंने वर्षों से यह सोचकर खुद को सोचा है लेकिन आज मैं एक अच्छी वजह से आया था।

प्रत्येक पंक्ति पर रिकॉर्ड के साथ एक फ़ाइल की कल्पना करें (उदा: एक CSV फ़ाइल) और यह कि कंप्यूटर फाइल के अंत में रिकॉर्ड लिख रहा था। लेकिन यह अचानक दुर्घटनाग्रस्त हो गया। आखिरी पंक्ति जी थी? (नहीं एक अच्छी स्थिति)

लेकिन अगर हम हमेशा अंतिम पंक्ति को समाप्त करते हैं, तो हम जानते होंगे (बस जांच लें कि अंतिम पंक्ति समाप्त हो गई है)। अन्यथा हमें संभवत: हर बार आखिरी पंक्ति को त्यागना होगा, बस सुरक्षित होना चाहिए।

कल्पना कीजिए कि फ़ाइल को संसाधित किया जा रहा है, जबकि फ़ाइल अभी भी दूसरी प्रक्रिया से उत्पन्न हो रही है।

इसके साथ ऐसा करना पड़ सकता है? एक झंडे जो इंगित करता है कि फाइल संसाधित करने के लिए तैयार है।

मैं व्यक्तिगत रूप से स्रोत कोड फ़ाइलों के अंत में नई लाइनें पसंद करता हूं

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

आईएमएचओ, यह व्यक्तिगत शैली और राय की बात है

पुराने दिनों में, मैंने उस नई लाइन को नहीं रखा था 14.4 के मॉडेम के माध्यम से सहेजा गया एक चरित्र अधिक गति का मतलब है।

बाद में, मैं उस नई लाइन को डाल दिया ताकि बदलाव + डाउनारो का उपयोग करके अंतिम पंक्ति को चुनना आसान हो।