සියලුම පෙළ ලිපිගොනු නව රේඛාවකින් අවසන් විය යුතුය යන කියමන මෙහි සිටින සෑම කෙනෙකුටම හුරුපුරුදු යැයි මම සිතමි. මම වසර ගණනාවක් තිස්සේ මෙම "රීතිය" ගැන දැන සිටියත් මම නිතරම කල්පනා කළෙමි - ඇයි?
සියලුම පෙළ ලිපිගොනු නව රේඛාවකින් අවසන් විය යුතුය යන කියමන මෙහි සිටින සෑම කෙනෙකුටම හුරුපුරුදු යැයි මම සිතමි. මම වසර ගණනාවක් තිස්සේ මෙම "රීතිය" ගැන දැන සිටියත් මම නිතරම කල්පනා කළෙමි - ඇයි?
Answers:
නිසා බව ය වන එම POSIX සම්මත අර්ථ දක්වන්නේ කෙසේද මාර්ගය :
- 3.206 පේළිය
- <Newline> නොවන අක්ෂරවල ශුන්ය හෝ වැඩි ගණනක් සහ අවසන් වන <newline> අක්ෂර අනුක්රමයක්.
එබැවින්, නව රේඛා අක්ෂරයකින් අවසන් නොවන රේඛා සැබෑ රේඛා ලෙස නොසැලකේ. අළුත් රේඛාවක් අවසන් නොකළේ නම් සමහර වැඩසටහන් වල ගොනුවේ අවසාන පේළිය සැකසීමේ ගැටළු ඇත.
ටර්මිනල් ඉමුලේටරයක වැඩ කිරීමේදී මෙම මාර්ගෝපදේශයට අවම වශයෙන් එක් දුෂ්කර වාසියක් ඇත: සියලුම යුනික්ස් මෙවලම් මෙම සම්මුතිය අපේක්ෂා කරන අතර ඒ සමඟ වැඩ කරයි. නිදසුනක් ලෙස, ලිපිගොනු සමඟ සංයුක්ත කරන විට cat
, නව රේඛාවකින් අවසන් කරන ලද ගොනුවක් නොමැතිව එකකට වඩා වෙනස් බලපෑමක් ඇති කරයි:
$ more a.txt
foo
$ more b.txt
bar$ more c.txt
baz
$ cat {a,b,c}.txt
foo
barbaz
තවද, පෙර උදාහරණයෙන් පෙන්නුම් කරන පරිදි, විධාන රේඛාවේ ගොනුව පෙන්වන විට (උදා more
) , නව අවසන් කළ ගොනුවක් නිවැරදි දර්ශනයකට හේතු වේ. නුසුදුසු ලෙස අවසන් කරන ලද ගොනුවක් අතුගා දැමිය හැකිය (දෙවන පේළිය).
අනුකූලතාව සඳහා, මෙම රීතිය අනුගමනය කිරීම ඉතා ප්රයෝජනවත් වේ - වෙනත් ආකාරයකින් කිරීමෙන් පෙරනිමි යුනික්ස් මෙවලම් සමඟ කටයුතු කිරීමේදී අමතර වැඩක් සිදු වේ.
ඒ ගැන වෙනස් ලෙස සිතන්න: රේඛා නව රේඛාවෙන් අවසන් නොවන්නේ නම්, cat
ප්රයෝජනවත් වැනි විධානයන් සෑදීම වඩා දුෂ්කර ය: එවැනි ගොනු සංයුක්ත කිරීමට ඔබ විධානයක් කරන්නේ කෙසේද?
b.txt
හා c.txt
?ඇත්ත වශයෙන්ම මෙය විසඳිය හැකි නමුත් ඔබ භාවිතය cat
වඩාත් සංකීර්ණ කළ යුතුය (ස්ථානීය විධාන රේඛා තර්ක එකතු කිරීමෙන්, උදා cat a.txt --no-newline b.txt c.txt
), සහ දැන් විධානය එක් එක් ගොනුවට වඩා එය වෙනත් ලිපිගොනු සමඟ අලවන ආකාරය පාලනය කරයි. මෙය නිසැකවම පාහේ පහසු නැත.
… නැතහොත් අවසන් කිරීමට වඩා ඉදිරියට ගෙන යා යුතු රේඛාවක් සලකුණු කිරීම සඳහා ඔබ විශේෂ සෙන්ඩිනල් චරිතයක් හඳුන්වා දිය යුතුය. හොඳයි, දැන් ඔබ ප්රතිලෝමව හැර (පොසික්ස් හි ඇති තත්වයටම හිර වී ඇත) (රේඛා අවසන් කිරීමේ අක්ෂරයට වඩා රේඛීය අඛණ්ඩතාව).
දැන්, POSIX නොවන අනුකූල පද්ධතිවල (වර්තමානයේ බොහෝ දුරට වින්ඩෝස්), කාරණය වැදගත් ය: ලිපිගොනු සාමාන්යයෙන් නව රේඛාවකින් අවසන් නොවන අතර, රේඛාවක (අවිධිමත්) අර්ථ දැක්වීම උදාහරණයක් ලෙස “නව රේඛා මගින් වෙන් කරන ලද පෙළ ” විය හැකිය. (අවධාරණය සටහන් කරන්න). මෙය සම්පූර්ණයෙන්ම වලංගු වේ. කෙසේ වෙතත්, ව්යුහාත්මක දත්ත සඳහා (උදා: ක්රමලේඛන කේතය) එය විග්රහ කිරීම අවම වශයෙන් වඩාත් සංකීර්ණ කරයි: සාමාන්යයෙන් එයින් අදහස් කරන්නේ විග්රහ කරන්නන් නැවත ලිවිය යුතු බවයි. විග්රහකය මුලින් ලියා ඇත්තේ POSIX අර්ථ දැක්වීම මනසේ තබාගෙන නම්, එය පාර්සර්ට වඩා ටෝකන ප්රවාහය වෙනස් කිරීම පහසු වනු ඇත - වෙනත් වචන වලින් කිවහොත්, ආදානයේ අවසානයට “කෘතිම නව රේඛාවක්” ටෝකනයක් එක් කරන්න.
cat
ප්රයෝජනවත් හා ස්ථාවර ආකාරයකින් කර්තෘ මෙවලම් වලට වඩා දුෂ්කර කරයි .
සෑම පේළියක්ම අවසන් රේඛාව ඇතුළුව නව රේඛා අක්ෂරයකින් අවසන් කළ යුතුය. සමහර වැඩසටහන් වලට නව රේඛාවක් අවසන් නොවන්නේ නම් ගොනුවේ අවසාන පේළිය සැකසීමේ ගැටළු ඇත.
එය නිසා ගල්ෆ් නොවේ ඒ ගැන අනතුරු අඟවයි නොහැකි ගොනුව සැකසීමට, නමුත් එය නිසා යුතු සම්මත කොටසක් ලෙස.
සී භාෂා ප්රමිතිය පවසන්නේ හිස් නොවන ප්රභව ගොනුවක් නව රේඛා අක්ෂරයකින් අවසන් වන අතර එය බැක්ස්ලෑෂ් අක්ෂරයකට පෙර නොවිය යුතු බවයි.
මෙය “විය යුතු” වගන්තියක් බැවින්, මෙම රීතිය උල්ලං for නය කිරීම සඳහා අප විසින් රෝග විනිශ්චය පණිවිඩයක් විමෝචනය කළ යුතුය.
මෙය ANSI C 1989 ප්රමිතියේ 2.1.1.2 වගන්තියේ ඇත. ISO C 1999 ප්රමිතියේ 5.1.1.2 වගන්තිය (සහ බොහෝ විට ISO C 1990 ප්රමිතිය ද විය හැකිය).
යොමුව: GCC / GNU තැපැල් ලේඛනාගාරය .
wc -l
නව රේඛාවක් අවසන් නොකළහොත් ගොනුවේ අවසාන පේළිය ගණන් නොගනී. එසේම, cat
පළමු ගොනු අවසන් රේඛාව නව පේළියකට යොමු කිරීමේ අක්ෂරය අවසන් නැති නම් එකක් බවට ඉදිරි ගොනුවේ පළමු පෙළ සමග ගොනු අවසන් රේඛාව එකතු වනු ඇත. නව රේඛා පරිසීමකය ලෙස සොයන ඕනෑම වැඩසටහනකට මෙය අවුල් කිරීමේ හැකියාවක් ඇත.
cat
සහ හැර wc
)
මෙම පිළිතුර මතයට වඩා තාක්ෂණික පිළිතුරක් ලබා ගැනීමේ උත්සාහයකි.
අපට පොසික්ස් පිරිසිදු කරන්නන් වීමට අවශ්ය නම්, අපි රේඛාවක් අර්ථ දක්වන්නේ:
<Newline> නොවන අක්ෂරවල ශුන්ය හෝ වැඩි ගණනක් සහ අවසන් වන <newline> අක්ෂර අනුක්රමයක්.
මුලාශ්රය: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_206
අසම්පූර්ණ රේඛාවක් ලෙස:
ගොනුවේ අවසානයේ ඇති <Newline> නොවන අක්ෂර එකක් හෝ වැඩි ගණනක අනුක්රමයකි.
මූලාශ්රය: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_195
පෙළ ගොනුවක්:
පේළි ශුන්ය හෝ වැඩි ගණනකට සංවිධානය කර ඇති ගොනුවක්. රේඛාවල NUL අක්ෂර අඩංගු නොවන අතර <newline> අක්ෂරය ද ඇතුළුව දිග {LINE_MAX} බයිට් ඉක්මවා යා නොහැක. POSIX.1-2008 පෙළ ලිපිගොනු සහ ද්විමය ලිපිගොනු අතර වෙනස හඳුනා නොගත්තද (ISO C ප්රමිතිය බලන්න), බොහෝ උපයෝගිතා නිපදවන්නේ පෙළ ගොනුවල ක්රියාත්මක වන විට පුරෝකථනය කළ හැකි හෝ අර්ථවත් ප්රතිදානයක් පමණි. එවැනි සීමාවන් ඇති සම්මත උපයෝගිතා සෑම විටම ඒවායේ STDIN හෝ INPUT FILES අංශවල "පෙළ ගොනු" නියම කරයි.
මූලාශ්රය: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_397
නූලක් ලෙස:
පළමු ශුන්ය බයිට් එක ඇතුළුව සහ අවසන් කරන ලද බයිට් අනුක්රමික අනුක්රමයකි.
මූලාශ්රය: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_396
මෙම එතැන් සිට, අප විසින් කරනු එකම අවස්ථාව ලබාගත හැක්කේ හැකි කරුණු කිසිවක් වර්ගය මුහුණ අපි සංකල්පය සමග ගනුදෙනු නම් වේ රේඛාව ලෙස ගොනුවක් හෝ ගොනු වල පෙළ ගොනුවක් (අ සිද්ධියක් බව පෙළ ගොනුවක් ශුන්ය සංවිධානයක් වන හෝ වැඩි පේළි, සහ අප දන්නා රේඛාවක් <newline> සමඟ අවසන් විය යුතුය).
කාරණය : wc -l filename
.
සිට wc
අත්ෙපොත අප කියවන:
රේඛාවක් අර්ථ දැක්වෙන්නේ <newline> අක්ෂරයකින් වෙන් කරන ලද අක්ෂර මාලාවක් ලෙස ය.
ජාවාස්ක්රිප්ට්, HTML, සහ CSS ලිපිගොනු ඒවා පෙළ ලිපිගොනු බවට පත්වීමෙන් ඇඟවෙන්නේ කුමක්ද?
බ්රව්සර්, නවීන IDEs සහ වෙනත් ඉදිරිපස යෙදුම් වල EOF හි EOL මඟ හැරීමේ ගැටළු නොමැත. යෙදුම් ගොනු නිසි ලෙස විග්රහ කරනු ඇත. සියලුම මෙහෙයුම් පද්ධති POSIX ප්රමිතියට අනුකූල නොවිය යුතු බැවින්, OS නොවන මෙවලම් (උදා: බ්රව්සර්) POSIX ප්රමිතියට (හෝ ඕනෑම OS මට්ටමේ ප්රමිතියකට) අනුව ලිපිගොනු හැසිරවීම ප්රායෝගික නොවේ.
එහි ප්රති As ලයක් වශයෙන්, EOF හි EOL යෙදුම් මට්ටමින් කිසිදු negative ණාත්මක බලපෑමක් ඇති නොකරනු ඇතැයි අපට සාපේක්ෂව විශ්වාස කළ හැකිය - එය යුනික්ස් මෙහෙයුම් පද්ධතියක් මත ක්රියාත්මක වන්නේ නම් නොසලකා.
මෙම අවස්ථාවෙහිදී, සේවාදායකයාගේ පැත්තෙන් JS, HTML, CSS සමඟ ගනුදෙනු කිරීමේදී EOF හි EOL මඟ හැරීම ආරක්ෂිත බව අපට විශ්වාසයෙන් කිව හැකිය. ඇත්ත වශයෙන්ම, <newline> අඩංගු නොවන මෙම ලිපිගොනු වලින් එකක් අවම කිරීම ආරක්ෂිත බව අපට ප්රකාශ කළ හැකිය.
අපට මෙය තවත් එක් පියවරක් ඉදිරියට ගෙන යා හැකි අතර, NodeJS සම්බන්ධයෙන් ගත් කල, එයද POSIX ප්රමිතියට අනුගත විය නොහැකි අතර එය POSIX නොවන අනුකූල පරිසරයන් තුළ ක්රියාත්මක කළ හැකිය.
එවිට අපට ඉතිරිව ඇත්තේ කුමක්ද? පද්ධති මට්ටමේ මෙවලම්.
මෙයින් අදහස් වන්නේ පැනනැඟිය හැකි එකම ගැටළුව වන්නේ පොසික්ස් හි අර්ථ නිරූපණයට අනුගත වීමට උත්සාහ කරන මෙවලම් (උදා: පෙන්වා ඇති පරිදි රේඛාවක අර්ථ දැක්වීම wc
).
එසේ වුවද, සියලුම ෂෙල් වෙඩි ස්වයංක්රීයව පොසික්ස් වලට අනුගත නොවනු ඇත. උදාහරණයක් ලෙස බෑෂ් POSIX හැසිරීමට පෙරනිමි නොවේ. එය සක්රීය කිරීම සඳහා ස්විචයක් ඇත : POSIXLY_CORRECT
.
EOL හි වටිනාකම පිළිබඳ සිතීමට ආහාර <newline>: https://www.rfc-editor.org/old/EOLstory.txt
සියලු ප්රායෝගික අභිප්රායන් සහ අරමුණු සඳහා මෙවලම් ධාවන පථයේ රැඳී සිටීම, අපි මෙය සලකා බලමු:
EOL නොමැති ගොනුවක් සමඟ වැඩ කරමු. මෙම උදාහරණයේ ඇති ගොනුව EOL නොමැති කුඩා ජාවාස්ක්රිප්ට් එකකි.
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
පිළිබඳ cat
පමණක් EOF ආදානය කළ නොහැකි <නව පේළියකට යොමු කිරීමේ අක්ෂරය> කියවීම සඳහන් කර ඇත. බව සටහන -n
පිළිබඳ ස්විචය cat
ද නොවන <නව පේළියකට යොමු කිරීමේ අක්ෂරය> අවසන් රේඛාව (හෝ මුද්රණය ඇත අසම්පූර්ණ රේඛාව ලෙස) මාර්ගය - හි ගණන් ආරම්භ සිද්ධියක් බව 1 (අනුව man
.)
-n නිමැවුම් රේඛා අංක 1 සිට ආරම්භ කරන්න.
POSIX විසින් රේඛාවක් නිර්වචනය කරන්නේ කෙසේදැයි දැන් අපට වැටහී ඇති හෙයින් , මෙම හැසිරීම නොපැහැදිලි හෝ සැබවින්ම අනුකූල නොවන බවට පත්වේ.
දී ඇති මෙවලමක අරමුණ සහ අනුකූලතාවය අවබෝධ කර ගැනීම EOL සමඟ ලිපිගොනු අවසන් කිරීම කෙතරම් තීරණාත්මකද යන්න තීරණය කිරීමට උපකාරී වේ. C, C ++, Java (JARs) යනාදියෙහි ... සමහර ප්රමිතීන් වලංගුභාවය සඳහා නව රේඛාවක් නියම කරනු ඇත - JS, HTML, CSS සඳහා එවැනි ප්රමිතියක් නොමැත.
නිදසුනක් ලෙස, wc -l filename
එකක් භාවිතා කිරීම වෙනුවට කළ හැකි අතර awk '{x++}END{ print x}' filename
, අප විසින් ලියන ලද ක්රියාවලියක් සැකසීමට අවශ්ය විය හැකි ගොනුවකින් කර්තව්යයේ සාර්ථකත්වය අනතුරට ලක් නොවන බවට සහතික වන්න (උදා: අපි අවම කළ JS වැනි තෙවන පාර්ශවීය පුස්තකාලයක් curl
) - අපගේ හැර පොසික්ස් අනුකූල අර්ථයෙන් රේඛා ගණනය කිරීම සැබවින්ම අභිප්රාය විය .
නිගමනය
JS, HTML, සහ CSS වැනි ඇතැම් පෙළ ලිපිගොනු සඳහා EOF හි EOL මඟ හැරීම negative ණාත්මක බලපෑමක් ඇති කරන සැබෑ ජීවිත භාවිත අවස්ථා ඉතා අල්පය. අපි <Newline> පැමිණීම මත විශ්වාසය තබන්නේ නම්, අපි අපගේ මෙවලම් වල විශ්වසනීයත්වය සීමා කරන්නේ අප විසින් ලියන ලද ලිපිගොනු වලට පමණක් වන අතර තෙවන පාර්ශවීය ලිපිගොනු මඟින් හඳුන්වා දිය හැකි දෝෂ වලට අපව විවෘත කරමු.
කතාවේ සදාචාරය: EOF හි EOL මත යැපීමේ දුර්වලතාවයක් නොමැති ඉංජිනේරු මෙවලම්.
JS, HTML සහ CSS වලට අදාළ වන පරිදි භාවිත අවස්ථා පළ කිරීමට නිදහස්ව සිටින්න, එහිදී EOL මඟ හැරීම අහිතකර බලපෑමක් ඇති කරන්නේ කෙසේදැයි අපට පරීක්ෂා කළ හැකිය.
එය අතර වෙනස හා සම්බන්ධ විය හැකිය :
සෑම පේළියක්ම පේළියේ අවසානයකින් අවසන් වන්නේ නම්, උදාහරණයක් ලෙස, පෙළ ලිපිගොනු දෙකක් සමපාත කිරීමෙන් පළමු ධාවනයේ අවසාන පේළිය දෙවන පේළියේ පළමු පේළියට ඇතුළත් වේ.
ප්ලස්, සංස්කාරකයෙකුට ගොනුව අවසන් රේඛාවෙන් අවසන් වේද, එහි දේශීය විකල්පය වන 'ඉයෝල්' තුළ සුරකිනු ඇත්ද, ගොනුව ලිවීමේදී එය භාවිතා කරයිද යන්න පරීක්ෂා කළ හැකිය.
මීට වසර කිහිපයකට පෙර (2005) බොහෝ කතුවරුන් (ZDE, Eclipse, Scite, ...) එම අවසාන EOL "අමතක" කර ඇති අතර එය එතරම් අගය නොකළේය .
එපමණක් නොව, ඔවුන් එම අවසාන EOL වැරදි ලෙස අර්ථකථනය කළේ, 'නව රේඛාවක් ආරම්භ කරන්න' ලෙස වන අතර, ඇත්ත වශයෙන්ම වෙනත් පේළියක් දැනටමත් පවතින ආකාරයට ප්රදර්ශනය කිරීමට පටන් ගනී.
ඉහත සංස්කාරක වලින් එකක් විවෘත කිරීමට සාපේක්ෂව vim වැනි හොඳින් හැසිරෙන පෙළ සංස්කාරකයක් සහිත 'නිසි' පෙළ ගොනුවක් සමඟ මෙය ඉතා පැහැදිලිව දැකගත හැකි විය. එය ගොනුවේ සැබෑ අන්තිම පේළියට පහළින් අතිරේක පේළියක් පෙන්වයි. ඔබ මේ වගේ දෙයක් දකිනවා:
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
wc
නොකරන බව කෙනෙකුට පැවසිය හැකිය .
wc -l
මුද්රණය කිරීමට 1
අවස්ථා දෙකෙහිදීම, නමුත් සමහර අය දෙවන නඩුව මුද්රණය කළ යුතු කියන්න පුළුවන් 2
.
\n
/ යුනික්ස් මෙන් රේඛීය බෙදුම්කරුවෙකු ලෙස නොව රේඛීය ටර්මිනේටරයක් ලෙස සිතන්නේ නම් , දෙවන නඩුව 2 මුද්රණය කිරීම අපේක්ෂා කිරීම නියත වශයෙන්ම පිස්සුවකි.
මූලික EOL EOF නොලැබුනේ නම් ගොනු නිවැරදිව සකසනු නොලබන බොහෝ වැඩසටහන් තිබේ.
G ප්රමිතියෙහි කොටසක් ලෙස අපේක්ෂා කරන බැවින් GCC ඔබට මේ ගැන අනතුරු අඟවයි. (5.1.1.2 වගන්තිය පෙනෙන පරිදි)
වෙනම භාවිත නඩුවක්: ඔබේ පෙළ ගොනුව අනුවාදය පාලනය කරන විට (මෙම අවස්ථාවේදී එය විශේෂයෙන්ම git යටතේ වුවද එය අනෙක් අයටද අදාළ වේ). ගොනුවේ අවසානයට අන්තර්ගතය එකතු කර ඇත්නම්, කලින් පේළියේ අවසන් පේළිය නව රේඛා අක්ෂරයක් ඇතුළත් කිරීම සඳහා සංස්කරණය කරනු ලැබේ. මෙයින් අදහස් කරන්නේ blame
එම පේළිය අවසන් වරට සංස්කරණය කළේ කවදාදැයි සොයා බැලීමට ගොනුව ඇතුලත් කිරීමෙන් පෙළ එකතු කිරීමක් පෙන්වනු ඇති බවයි.
\n
) වෙනුවට "නව රේඛා" හඳුනා ගැනීම සඳහා වෙනස සහ දොස් යාවත්කාලීන කළ යුතුය . ගැටළුව විසඳා ඇත.
මෙය ආරම්භ වන්නේ සරල පර්යන්ත භාවිතා කළ මුල් අවධියේ සිට ය. මාරු කරන ලද දත්තවල 'ෆ්ලෂ්' අවුලුවාලීමට නව රේඛා ප්රස්ථාරය භාවිතා කරන ලදී.
අද, නව රේඛා ප්රස්ථාරය තවදුරටත් අවශ්ය නොවේ. නව රේඛාව නොමැති නම් බොහෝ යෙදුම් වලට තවමත් ගැටලු ඇති බව විශ්වාසයි, නමුත් එම යෙදුම්වල දෝෂයක් ලෙස මම සලකමි.
කෙසේ වෙතත් ඔබට නව රේඛාව අවශ්ය වන පෙළ ගොනු ආකෘතියක් තිබේ නම් , ඔබට සරල දත්ත සත්යාපනය ඉතා ලාභදායී වේ: ගොනුව අවසන් වන්නේ නව රේඛාවක් නොමැති රේඛාවකින් නම්, ගොනුව කැඩී ඇති බව ඔබ දන්නවා. එක් එක් පේළිය සඳහා එක් අමතර බයිට් එකක් පමණක් ඇති විට, ඔබට ඉහළ නිරවද්යතාවයකින් හා කැඩුණු ලිපිගොනු හඳුනාගත හැකිය.
ඉහත ප්රායෝගික හේතු වලට අමතරව, යුනික්ස් (තොම්සන්, රිචී සහ වෙනත්) හි ආරම්භකයින් හෝ ඔවුන්ගේ බහුකාර්ය පූර්වගාමීන් රේඛා බෙදුම්කරුවන්ට වඩා රේඛීය ටර්මිනේටර් භාවිතා කිරීමට න්යායාත්මක හේතුවක් ඇති බව වටහා ගත්තේ නම් මා පුදුම නොවනු ඇත: රේඛාව සමඟ ටර්මිනේටර්, ඔබට හැකි සියලුම රේඛා ගොනු කේතනය කළ හැකිය. රේඛා බෙදුම්කරුවන් සමඟ, ශුන්ය රේඛා ගොනුවක් සහ තනි හිස් රේඛාවක් අඩංගු ගොනුවක් අතර වෙනසක් නැත; මේ දෙකම ශුන්ය අක්ෂර අඩංගු ගොනුවක් ලෙස කේතනය කර ඇත.
ඉතින්, හේතු:
wc -l
රේඛාවකින් අවසන් නොවන්නේ නම් අවසාන "රේඛාවක්" ගණන් නොගනී.cat
ක්රියා කරන අතර එය සංකූලතාවයකින් තොරව ක්රියා කරයි. එය අර්ථ නිරූපණයකින් තොරව එක් එක් ගොනුවේ බයිට් පිටපත් කරයි. මම හිතන්නේ නැහැ ඩොස් එකකට සමානයි කියලා cat
. භාවිතා copy a+b c
කිරීමෙන් අවසන් ගොනුවේ a
පළමු පේළිය සමඟ ඒකාබද්ධ b
වේ.මම මෙය වසර ගණනාවක් තිස්සේ කල්පනා කර ඇත්තෙමි. නමුත් මට අද හොඳ හේතුවක් හමු විය.
සෑම පේළියකම වාර්තාවක් ඇති ගොනුවක් ගැන සිතන්න (උදා: CSV ගොනුවක්). පරිගණකය ගොනුවේ අවසානයේ වාර්තා ලියන බවත්. නමුත් එය හදිසියේම කඩා වැටුණි. ගී අවසන් පේළිය සම්පූර්ණද? (හොඳ තත්වයක් නොවේ)
නමුත් අපි සෑම විටම අවසාන පේළිය අවසන් කරන්නේ නම්, එවිට අපි දැන ගන්නෙමු (අවසාන පේළිය අවසන් වී ඇත්දැයි පරීක්ෂා කරන්න). එසේ නොවුවහොත් අපට ආරක්ෂිතව සිටීම සඳහා සෑම විටම අවසාන පේළිය බැහැර කිරීමට සිදුවනු ඇත.
සමහර විග්රහ කිරීමේ කේතයන් එය පවතිනු ඇතැයි අපේක්ෂා කළ බවක් පෙනෙන්නට තිබේ.
මම එය "රීතියක්" ලෙස සලකනු ඇතැයි මට විශ්වාස නැත, එය නිසැකවම මම ආගමික වශයෙන් පිළිපැදිය යුතු දෙයක් නොවේ. අන්තිම පේළියේ නව රේඛාවක් සමඟ හෝ නැතිව පෙළ (පේළි-පේළිය) (පේළි අවසානයෙහි ඕනෑම තේරීමක්) පෙළ විග්රහ කරන්නේ කෙසේදැයි බොහෝ සංවේදී කේත දැන ගනු ඇත.
ඇත්ත වශයෙන්ම - ඔබ නව රේඛාවකින් අවසන් කරන්නේ නම්: (න්යායිකව) EOL සහ EOF අතර හිස් අවසාන රේඛාවක් තිබේද? මෙනෙහි කිරීමට එකක් ...
අවසානයේ නව රේඛා නොමැති ලිපිගොනු සමඟ ප්රායෝගික ක්රමලේඛන ගැටළුවක් ද ඇත: read
බාෂ් බිල්ට් (වෙනත් read
ක්රියාත්මක කිරීම් ගැන මම නොදනිමි ) අපේක්ෂා කළ පරිදි ක්රියා නොකරයි:
printf $'foo\nbar' | while read line
do
echo $line
done
මෙය මුද්රණය කිරීම පමණිfoo
! හේතුව read
, අවසාන පේළිය හමු වූ විට , එය අන්තර්ගතය ලියන $line
නමුත් පිටවීමේ කේතය 1 වෙත ආපසු එන්නේ එය EOF වෙත ළඟා වූ බැවිනි. මෙය while
ලූපය බිඳ දමයි , එබැවින් අපි කිසි විටෙකත් echo $line
කොටස වෙත ළඟා නොවෙමු . ඔබට මෙම තත්වය පාලනය කිරීමට අවශ්ය නම්, ඔබ පහත සඳහන් දෑ කළ යුතුය.
while read line || [ -n "${line-}" ]
do
echo $line
done < <(printf $'foo\nbar')
එනම්, ගොනුව අවසානයේ හිස් නොවන රේඛාවක් නිසා අසමත් echo
වුවහොත් read
කරන්න. ස්වාභාවිකවම, මෙම අවස්ථාවේ දී ආදානයේ නොතිබූ නිමැවුමේ එක් අතිරේක නව රේඛාවක් ඇත.
(පෙළ) ලිපිගොනු නව රේඛාවකින් අවසන් විය යුත්තේ ඇයි?
බොහෝ අය විසින් ප්රකාශිත පරිදි, මන්ද:
බොහෝ වැඩසටහන් හොඳින් හැසිරෙන්නේ නැත, නැතහොත් එය නොමැතිව අසමත් වේ.
ගොනුවක් හොඳින් හසුරුවන වැඩසටහන් පවා අවසානයක් නොමැති වුවද '\n'
, මෙවලමෙහි ක්රියාකාරීත්වය පරිශීලකයාගේ අපේක්ෂාවන් සපුරාලන්නේ නැත - මෙම කෙළවරේ දී අපැහැදිලි විය හැකිය.
වැඩසටහන් කලාතුරකින් අවසාන දේට ඉඩ'\n'
නොදේ (මම කිසිවක් නොදනිමි).
එහෙත් මෙය ඊළඟ ප්රශ්නය අසයි:
නව රේඛාවක් නොමැතිව පෙළ ලිපිගොනු සම්බන්ධයෙන් කේත කළ යුත්තේ කුමක්ද?
වැදගත්ම දේ - පෙළ ගොනුවක් නව රේඛාවකින් අවසන් වන බව උපකල්පනය කරන කේතයක් ලියන්න එපා . ගොනුවක් ආකෘතියකට අනුකූල යැයි උපකල්පනය කිරීම දත්ත දූෂණය, හැකර් ප්රහාර සහ බිඳ වැටීම් වලට තුඩු දෙයි. උදාහරණයක්:
// 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
...
}
අවසාන ලුහුබැඳීම '\n'
අවශ්ය නම්, එය නොමැතිවීම සහ ගනු ලබන ක්රියාමාර්ගය පිළිබඳව පරිශීලකයා දැනුවත් කරන්න. IOWs, ගොනුවේ ආකෘතිය වලංගු කරන්න. සටහන: මෙයට උපරිම පේළි දිග, අක්ෂර කේතන ක්රම ආදිය සඳහා සීමාවක් ඇතුළත් විය හැකිය.
අතුරුදහන් වූ අවසාන කොටස කේතය හැසිරවීම පැහැදිලිව නිර්වචනය කරන්න '\n'
.
හැකි තරම්, ගොනුවක් උත්පාදනය නොකරන්න '\n'
.
මෙහි ඉතා ප්රමාද නමුත් ලිපිගොනු සැකසීමේ එක් දෝෂයකට මා මුහුණ දුන් අතර එය පැමිණියේ ලිපිගොනු හිස් නව රේඛාවකින් අවසන් නොවන බැවිනි. අපි sed
සහ සමඟ පෙළ ලිපිගොනු සකස් කරමින් සිටියෙමුsed
අවලංගු json ව්යුහය සිදු කරමින් හා රාජ්ය අසාර්ථක වීමට ක්රියාවලිය සෙසු යැවීම කළ ප්රතිදානය සිට පසුගිය මාර්ගය සැර බාල කරන ලදී.
අපි කරමින් සිටියේ:
එක් සාම්පල ගොනුවක් ඇත: foo.txt
එහි යම් json
අන්තර්ගතයක් ඇත.
[{
someProp: value
},
{
someProp: value
}] <-- No newline here
ගොනුව වැන්දඹුවන්ගේ යන්ත්රයෙන් නිර්මාණය කර ඇති අතර කවුළු ස්ක්රිප්ට් එම ගොනුව පවර්ෂෙල් විධාන භාවිතයෙන් සැකසෙමින් පවතී. සියල්ල හොඳයි.
අපි sed
විධාන භාවිතා කරමින් එකම ගොනුවක් සැකසූ විටsed 's|value|newValue|g' foo.txt > foo.txt.tmp
අලුතින් ජනනය කරන ලද ගොනුව විය
[{
someProp: value
},
{
someProp: value
සහ උත්පාතය, අවලංගු JSON නිසා එය අනෙක් ක්රියාවලි අසාර්ථක විය.
එබැවින් ඔබගේ ගොනුව හිස් නව පේළියකින් අවසන් කිරීම සැමවිටම හොඳ පුරුද්දකි.
නව රේඛාවක් නොමැතිව ගොනුවක් විග්රහ කිරීම දුෂ්කර වූ දිනවල සිට රීතිය පැමිණි බව මම නිතරම සිතුවෙමි. එනම්, ඔබ ලිවීමේ කේතය අවසන් කරනුයේ රේඛාවේ අවසානය EOL අක්ෂරයෙන් හෝ EOF මගින් අර්ථ දක්වා ඇති බැවිනි. රේඛාවක් EOL සමඟ අවසන් යැයි උපකල්පනය කිරීම සරල ය.
කෙසේ වෙතත්, නව රේඛාව අවශ්ය වන සී සම්පාදකයින්ගෙන් රීතිය ව්යුත්පන්න වී ඇතැයි මම විශ්වාස කරමි. පෙන්වා දුන් පරිදි සම්පාදක අනතුරු ඇඟවීමක් "ගොනුව අවසානයේ දී නොමැත නව පේළියකට යොමු කිරීමේ අක්ෂරය" , #include වූ නව පේළියකට යොමු කිරීමේ අක්ෂරය එකතු කිරීමට නොහැකි වනු ඇත.
වෙනත් ක්රියාවලියක් මඟින් ගොනුව ජනනය කරන අතරතුර ගොනුව සැකසෙමින් පවතින බව සිතන්න.
එයට ඒ හා සම්බන්ධ විය හැකිද? ගොනුව සැකසීමට සූදානම් බව දැක්වෙන ධජයක්.
ප්රභව කේත ලිපිගොනු අවසානයේ මම පෞද්ගලිකව නව රේඛාවලට කැමතියි.
එහි මූලාරම්භය ලිනක්ස් හෝ ඒ සඳහා සියලු යුනික්ස් පද්ධති සමඟ තිබිය හැකිය. මූලාශ්ර කේත ලිපිගොනු හිස් නව පේළියකින් අවසන් නොවූ නිසා සම්පාදක දෝෂ (gcc මා වරදවා වටහා නොගත්තොත්) මට මතකයි. ඇයි මේ විදියට හැදුවේ කියලා පුදුම වෙන්න පුළුවන්.
IMHO, එය පෞද්ගලික ශෛලිය හා මතය පිළිබඳ කාරණයකි.
පැරණි දිනවලදී, මම එම නව රේඛාව තැබුවේ නැත. සුරකින ලද අක්ෂරයක් යනු එම 14.4K මොඩමය හරහා වැඩි වේගයක් ලබා ගැනීමයි.
පසුව, මම එම නව රේඛාව තැබුවෙමි.