පයිප්පයේ බෆරින් කිරීම අක්‍රිය කරන්න

416

මට විධාන දෙකක් ඇතුළත් පිටපතක් ඇත:

long_running_command | print_progress

මෙම long_running_commandමුද්රණ ප්රගතියක් නමුත් මම එය රෑගෙන ඉන්නේ. මම print_progressඑය වඩාත් හොඳ කිරීමට භාවිතා කරමි (එනම්, මම ප්‍රගතිය තනි පේළියකින් මුද්‍රණය කරමි).

ගැටලුව: stdout වෙත පයිප්පයක් සම්බන්ධ කිරීම ද 4K බෆරයක් සක්‍රිය කරයි, එබැවින් ලස්සන මුද්‍රණ වැඩසටහනට කිසිවක් නොලැබේ ... කිසිවක් නැත ... කිසිවක් නැත ... සම්පූර්ණ ගොඩක් ... :)

(නැත, මට ප්‍රභවයක් නොමැත) 4Kසඳහා බෆරය අක්‍රිය කරන්නේ කෙසේද long_running_command?

shell pipe buffer

— ආරොන් ඩිගුල්ලා
source

1

ඉතින් ඔබ නල මාර්ගයෙන් තොරව දිගු_රන_කමාන්ඩ් ධාවනය කරන විට ප්‍රගති යාවත්කාලීනයන් නිසියාකාරව දැකිය හැකිය, නමුත් නල මාර්ගයේ ඒවා ආරක්ෂිත වේ?

1

ඔව්, එය හරියටම සිදු වේ.

— ආරොන් ඩිගුල්ලා

24

බෆරින් පාලනය කිරීමේ සරල ක්‍රමයක් සඳහා ඇති නොහැකියාව දශක ගණනාවක් තිස්සේ ගැටලුවක් වී තිබේ. උදාහරණයක් ලෙස, බලන්න: marc.info/?l=glibc-bug&m=98313957306297&w=4 මූලික වශයෙන් පවසන්නේ "මට මෙය කළ නොහැකි අතර මගේ ස්ථාවරය සාධාරණීකරණය කිරීම සඳහා අත්පුඩි උගුලක් මෙහි ඇත"

2

serverfault.com/a/589614/67097

— නකිලෝන්

1

ඇත්ත වශයෙන්ම එය ප්‍රමාණවත් දත්ත බලාපොරොත්තුවෙන් ප්‍රමාද වීමට හේතු වන නළය නොවේ. පයිප්පවල ධාරිතාවක් ඇත, නමුත් නලයට කිසියම් දත්තයක් ලියා ඇති විගසම එය අනෙක් කෙළවරේ කියවීමට සූදානම්ය.

— සෑම් වොට්කින්ස්

266

ඔබට unbufferවිධානය භාවිතා කළ හැකිය (එය expectපැකේජයේ කොටසක් ලෙස පැමිණේ ), උදා

unbuffer long_running_command | print_progress

unbufferlong_running_commandව්‍යාජ ටර්මිනල් (pty) හරහා සම්බන්ධ වන අතර එමඟින් පද්ධතිය අන්තර්ක්‍රියාකාරී ක්‍රියාවලියක් ලෙස සලකයි, එබැවින් ප්‍රමාදයට හේතුවන නල මාර්ගයේ 4-kiB බෆරින් භාවිතා නොකිරීම.

දිගු නල මාර්ග සඳහා, ඔබට එක් එක් විධානය ඉවත් කිරීමට සිදු විය හැකිය (අවසාන එක හැර), උදා

unbuffer x | unbuffer -p y | z

— ස්ටීවන් කිට්
source

3

ඇත්ත වශයෙන්ම, අන්තර්ක්‍රියාකාරී ක්‍රියාවලීන් හා සම්බන්ධ වීමට pty එකක් භාවිතා කිරීම පොදුවේ අපේක්ෂාවෙන් සත්‍ය වේ.

17

නල මාර්ගගත කිරීම සඳහා ඇමතුම් ලබා ගැනීමේදී, ඔබ -p තර්කය භාවිතා කළ යුතුය.

26

සටහන: Debian පද්ධති මත, මෙම ලෙස හැඳින්වේ expect_unbufferසහ ය expect-devපැකේජය නොව, expectපැකේජය

— bdonlan

4

dbdonlan: අවම වශයෙන් උබුන්ටු (ඩෙබියන් මත පදනම් වූ), expect-devදෙකම සපයන unbufferඅතර expect_unbuffer(කලින් සඳහන් කළ දෙය දෙකට සමාන වේ). expect 5.44.1.14-1(2009) සිට සබැඳි ලබා ගත හැකිය .

— jfs

1

unbufferexpectදැන් ඩෙබියන් හි ප්‍රධාන පැකේජයේ ඇත (එය තවමත් සමමුහුර්තයක් expect_unbufferවන අතර එය ප්‍රධාන expectපැකේජයේ ද ඇත)

— cas

480

මෙම බළලා සමට stdbufදැමිය හැකි තවත් ක්‍රමයක් නම් GNU Coreutils හි කොටසක් වන වැඩසටහන භාවිතා කිරීමයි (FreeBSD ද එහි ම එකක් ඇත).

stdbuf -i0 -o0 -e0 command

ආදානය, ප්‍රතිදානය සහ දෝෂ සඳහා මෙය සම්පූර්ණයෙන්ම බෆරය අක්‍රිය කරයි. සමහර යෙදුම් සඳහා, කාර්ය සාධන හේතූන් මත රේඛීය බෆරින් වඩාත් සුදුසු විය හැකිය:

stdbuf -oL -eL command

_{එය ක්‍රියාත්මක වන්නේ ගතිකව සම්බන්ධිත යෙදුම් සඳහා stdioබෆරින් ( printf(), fputs()...) සඳහා පමණක් වන අතර, එම යෙදුම වෙනත් යෙදුම් ආවරණය කළ යුතු වුවද, එහි සම්මත ධාරාවන්හි බෆරින් තනිවම වෙනස් නොකරන්නේ නම් පමණි.}

— a3nm
source

6

පැකේජය තුළ ඇති උබුන්ටු හි "unbuffer" ස්ථාපනය කළ යුතුය: expect-dev 2MB වේ ...

— lepe

2

ලොග් වීම ඉවත් කිරීම සඳහා සුපුරුදු රාස්බියන් ස්ථාපනය මත මෙය විශිෂ්ට ලෙස ක්‍රියා කරයි. sudo stdbuff … commandඑසේ නොවූවත් මම කෘති සොයා ගතිමි stdbuff … sudo command.

— natevw

22

dqdii සමඟ stdbufක්‍රියා නොකරයි tee, මන්ද teeපෙරනිමි පෙරනිමිති නැවත ලියයි stdbuf. හි අත්පොත බලන්න stdbuf.

— ceving

5

@lepe Bizarrely, unbuffer හි x11 සහ tcl / tk මත පරායත්තතා ඇත, එයින් අදහස් කරන්නේ ඔබ ඒවා නොමැතිව සේවාදායකයක ස්ථාපනය කරන්නේ නම් එය සැබවින්ම> 80 MB අවශ්‍ය බවයි.

— lambshaanxy

11

dqdii තමන්ගේම ගතිකව පටවන ලද පුස්තකාලය ඇතුළු කිරීමට යාන්ත්‍රණයක් stdbufභාවිතා කරයි . මෙයින් අදහස් කරන්නේ එය මේ ආකාරයේ ක්‍රියාත්මක කළ හැකි දේ සමඟ ක්‍රියා නොකරන බවයි: සෙටූයිඩ් හෝ ගොනු හැකියාවන් සහිතව, සංඛ්‍යාත්මකව සම්බන්ධ කර ඇති අතර සම්මත ලිබ්සී භාවිතා නොකරයි. මෙම අවස්ථා වලදී / / සමඟ විසඳුම් භාවිතා කිරීම වඩා හොඳය . සෙටූයිඩ් / හැකියාවන් සහිත stdbuf ද බලන්න . LD_PRELOADlibstdbuf.sounbufferscriptsocat

— pabouk

82

රේඛීය-බෆරින් ප්‍රතිදාන මාදිලිය සක්‍රිය කිරීමට තවත් ක්‍රමයක් නම්, ව්‍යාජ පර්යන්තයක (pty) ධාවනය වන විධානය long_running_commandභාවිතා කිරීමයි .scriptlong_running_command

script -q /dev/null long_running_command | print_progress      # FreeBSD, Mac OS X
script -c "long_running_command" /dev/null | print_progress    # Linux

— චැඩ්
source

15

+1 කදිම උපක්‍රමයක්, scriptඑතරම් පැරණි විධානයක් බැවින් එය යුනික්ස් වැනි සියලුම වේදිකාවල තිබිය යුතුය.

— ආරොන් ඩිගුල්ලා

5

ඔබට -qලිනක්ස් ද අවශ්‍ය වේ:script -q -c 'long_running_command' /dev/null | print_progress

— jfs

1

ස්ක්‍රිප්ට් කියවන බවක් පෙනේ stdin, එමඟින් long_running_commandපසුබිම තුළ එවැනි දෙයක් ක්‍රියාත්මක කිරීමට නොහැකි වන අතර අවම වශයෙන් අන්තර්ක්‍රියාකාරී පර්යන්තයෙන් ආරම්භ වේ. වැඩ කිරීමට, /dev/nullමගේ long_running_commandභාවිතය භාවිතා නොකරන බැවින් මට stdin හරවා යැවීමට හැකි විය stdin.

— haridsv

1

ඇන්ඩ්‍රොයිඩ් වල පවා ක්‍රියා කරයි.

— not2qubit

3

සැලකිය යුතු අවාසියක් නම්: ctrl-z තවදුරටත් ක්‍රියාත්මක නොවේ (එනම් මට පිටපත අත්හිටුවිය නොහැක). මෙය නිවැරදි කළ හැකිය, උදාහරණයක් ලෙස: echo | sudo script -c / usr / local / bin / ec2-snapshot-all / dev / null | ts, ඔබට වැඩසටහන සමඟ අන්තර් ක්‍රියා කිරීමට නොහැකි නම්.

— rlpowell

71

සඳහා grep, sedසහ awkඔබට ප්‍රතිදානය රේඛීය බෆර් කිරීමට බල කළ හැකිය. ඔයාට පාවිච්චි කරන්න පුළුවන්:

grep --line-buffered

ප්‍රතිදානය රේඛීය බෆර් කිරීමට බල කරන්න. පෙරනිමියෙන්, ප්‍රතිදානය රේඛීය බෆරයක් වන අතර සම්මත ප්‍රතිදානය පර්යන්තයක් වන අතර බ්ලොක් බෆර් කරන ලද වෙනත් නැණවත් වේ.

sed -u

ප්‍රතිදාන රේඛාව බෆර් කරන්න.

වැඩි විස්තර සඳහා මෙම පිටුව බලන්න: http://www.perkin.org.uk/posts/how-to-fix-stdio-buffering.html

— yaneku
source

බෆරින් අක්‍රීය කිරීම pythonසඳහා -uපරාමිතියට සහය දක්වයි .

— ඩේවිඩ් පාක්ස්

මේ වගේ grep (ආදිය) භාවිතා කිරීම සාර්ථක නොවේ. ඔබ ක්‍රියාත්මක කරන long_running_commandවිට එය ප්‍රමාද වැඩියි. එය ග්‍රහණය වීමට පෙර එය ආරක්ෂිත වේ.

— tgm1024 -

මෙය තවමත් ආරක්ෂිතයි. යමෙකුට රේඛාවේ ප්‍රගතිය දැකීමට අවශ්‍ය නම් ...

— මයිකල්

මෙය සමඟ වැඩ කළ යුතුද grep --line-buffered pattern *many*many*files* | head? එය වගේ grepප්රතිදාන රේඛා පෝෂණය කිරීමට පෙර සියලු ගොනු ක්රියාවලියhead

— golimar

54

ප්‍රතිදානය පර්යන්තයකට නොයන විට එහි බෆරින් / ෆ්ලෂ් කිරීම වෙනස් කිරීම ලිබ්සී හි ගැටළුවක් නම්, ඔබ සොකාට් උත්සාහ කළ යුතුය . ඔබට ඕනෑම ආකාරයක I / O යාන්ත්‍රණයක් අතර ද්විපාර්ශ්වික ප්‍රවාහයක් නිර්මාණය කළ හැකිය. ඒවායින් එකක් නම් ව්‍යාජ ටයිටියක් සමඟ කතා කරන ව්‍යාජ වැඩසටහනකි.

 socat EXEC:long_running_command,pty,ctty STDIO

එය කරන්නේ එයයි

ව්‍යාජ ටීටී එකක් සාදන්න
දෙබලක දිගු_රොනිං_කමාන්ඩ් එක pty හි වහල් පැත්ත සමඟ stdin / stdout ලෙස
pty හි ප්‍රධාන පැත්ත සහ දෙවන ලිපිනය අතර ද්විපාර්ශ්වික ප්‍රවාහයක් ස්ථාපිත කරන්න (මෙන්න එය STDIO වේ)

මෙය ඔබට සමාන ප්‍රතිදානයක් ලබා දෙන්නේ නම් long_running_command, ඔබට පයිප්පයක් සමඟ ඉදිරියට යා හැකිය.

සංස්කරණය කරන්න: වාව් නොවරදින පිළිතුර දුටුවේ නැත! හොඳයි, කෙසේ හෝ සොකාට් හොඳ මෙවලමක්, එබැවින් මම මෙම පිළිතුර තබමි

— shodanex
source

1

... මම සොකාට් ගැන දැන සිටියේ නැත - නෙට්කැට් මෙන් පෙනේ. ;) ස්තූතියි සහ +1.

3

මම socat -u exec:long_running_command,pty,end-close -මෙහි භාවිතා කරමි

— ස්ටෙෆාන් චසෙලාස්

20

ඔයාට පාවිච්චි කරන්න පුළුවන්

long_running_command 1>&2 |& print_progress

ගැටළුව වන්නේ libc තිරයට stdout වන විට රේඛීය-බෆරය සහ ගොනුවකට stdout වන විට පූර්ණ බෆරය ලබා දීමයි. නමුත් stderr සඳහා කිසිදු බෆරයක් නොමැත.

මම හිතන්නේ නැහැ එය පයිප්ප බෆරයේ ගැටලුව, ඒ සියල්ල libc හි ස්වාරක්ෂක ප්‍රතිපත්තිය ගැන.

— වැන්ග් හොංකින්
source

ඔයා හරි; මගේ ප්‍රශ්නය තවමත් පවතී: නැවත සම්පාදනය නොකර libc හි ස්වාරක්ෂක ප්‍රතිපත්තියට මා බලපෑම් කරන්නේ කෙසේද?

— ආරොන් ඩිගුල්ලා

@ ස්ටෙෆාන් චැසෙලාස් fd1 stderr වෙත හරවා යවනු ලැබේ

— වැන්ග් හොංක්වින්

@ ස්ටෙෆාන් චැසෙලාස් මට ඔබේ තර්ක විතර්ක නොලැබේ. plz පරීක්ෂණයක් කරන්න, එය ක්‍රියාත්මක වේ

— වැන්ග් හොංකින්

3

හරි, සිදුවෙමින් පවතින්නේ දෙකම සමඟ zsh( |&csh වෙතින් අනුවර්තනය වූ තැන සිට) සහ bashඔබ එසේ කරන cmd1 >&2 |& cmd2විට fd 1 සහ 2 යන දෙකම පිටත ස්ථරයට සම්බන්ධ වීමයි. එම නිසා එය ක්‍රියාත්මක වන්නේ එම පිටත ස්ථරය පර්යන්තයක් වන විට බෆරින් වැළැක්වීම සඳහා ය, නමුත් ප්‍රතිදානය නළය හරහා නොයන නිසා පමණි (එබැවින් print_progressකිසිවක් මුද්‍රණය නොකෙරේ). එබැවින් එය සමාන වේ long_running_command & print_progress(print_progress stdin යනු ලේඛකයෙකු නොමැති පයිප්පයක් හැර). ls -l /proc/self/fd >&2 |& catසාපේක්ෂව ඔබට සත්‍යාපනය කළ හැකිය ls -l /proc/self/fd |& cat.

— ස්ටෙෆාන් චසෙලාස්

3

එයට හේතුව වචනාර්ථයෙන් |&කෙටි 2>&1 |වීමයි. එසේ cmd1 |& cmd2ය cmd1 1>&2 2>&1 | cmd2. එබැවින්, fd 1 සහ 2 යන දෙකම මුල් ස්ටෙඩරයට සම්බන්ධ වන අතර නලයට කිසිවක් ලිවීමට ඉතිරි නොවේ. ( s/outer stdout/outer stderr/gමගේ පෙර අදහස් දැක්වීමේදී).

— ස්ටෙෆාන් චසෙලාස්

11

සම්මත ප්‍රතිදානය පර්යන්තයකට ලියා ඇති විට, එය පෙරනිමියෙන් රේඛා බෆර් කර ඇත - නව රේඛාවක් ලියා ඇති විට, රේඛාව පර්යන්තයට ලියා ඇති බව එය එසේ විය. සම්මත ප්‍රතිදානය පයිප්පයකට යවන විට, එය සම්පුර්ණයෙන්ම ආරක්ෂිත වේ - එබැවින් දත්ත යවනු ලබන්නේ සම්මත I / O බෆරය පුරවන විට නල මාර්ගයේ ඊළඟ ක්‍රියාවලියට පමණි.

කරදරයේ උල්පත එයයි. වැඩසටහන ලිවීමට නළය වෙනස් නොකර ඔබට එය නිවැරදි කිරීමට බොහෝ දේ කළ හැකිදැයි මට විශ්වාස නැත. ඔබට ධජය setvbuf()සමඟ ශ්‍රිතය _IOLBFකොන්දේසි විරහිතව stdoutරේඛීය බෆර් ප්‍රකාරයට ඇතුළත් කළ හැකිය. නමුත් වැඩසටහනක් මත එය බලාත්මක කිරීමට පහසු ක්‍රමයක් මා දකින්නේ නැත. නැතහොත් වැඩසටහනට fflush()සුදුසු ස්ථානවලදී කළ හැකිය (එක් එක් නිමැවුම් රේඛාවෙන් පසුව), නමුත් එකම අදහස් දැක්වීම අදාළ වේ.

මම හිතන්නේ ඔබ නළය ව්‍යාජ පර්යන්තයක් මගින් ප්‍රතිස්ථාපනය කළහොත්, සම්මත I / O පුස්තකාලය සිතන්නේ ප්‍රතිදානය පර්යන්තයක් (එය ටර්මිනල් වර්ගයක් බැවින්) සහ ස්වයංක්‍රීයව බෆරය රේඛා කරනු ඇති බවයි. එය කාරණා සමඟ ගනුදෙනු කිරීමේ සංකීර්ණ ක්‍රමයකි.

— ජොනතන් ලෙෆ්ලර්
source

ඇත්ත වශයෙන්ම, ප්‍රශ්නය පවසන පරිදි, වැඩසටහන් කේතය වෙනස් කිරීම විකල්පයක් නොවන විට, එය දේවල් සමඟ කටයුතු කිරීමේ පහසු ක්‍රමයකි. unix.stackexchange.com/a/215071/5132

— JdeBP

7

මෙය පැරණි ප්‍රශ්නයක් බවත් දැනටමත් පිළිතුරු රාශියක් ඇති බවත් මම දනිමි, නමුත් ඔබට ස්වාරක්ෂක ගැටළුව මඟහරවා ගැනීමට අවශ්‍ය නම්, මෙවැනි දෙයක් උත්සාහ කරන්න:

stdbuf -oL tail -f /var/log/messages | tee -a /home/your_user_here/logs.txt

මෙය තථ්‍ය කාලීනව ලොග් ප්‍රතිදානය කරන අතර ඒවා logs.txtගොනුවට සුරකිනු ඇති අතර බෆරය තවදුරටත් tail -fවිධානයට බලපාන්නේ නැත .

— මැරින් නෙඩියා
source

6

මෙය දෙවන පිළිතුර ලෙස පෙනේ: - /

— ආරොන් ඩිගුල්ලා

2

stdbuf gnu coreutils හි ඇතුළත් කර ඇත (මම නවතම අනුවාදය 8.25 මත සත්‍යාපනය කළෙමි). සත්‍යාපනය කළ මෙය කාවැද්දූ ලිනක්ස් මත ක්‍රියා කරයි.

— zhaorufei

Stdbuf ගේ ලියකියවිලි වලින්,

NOTE: If COMMAND adjusts the buffering of its standard  streams  ('tee'        does  for  example)  then  that  will override corresponding changes by        'stdbuf'.

— shrewmouse

5

මම හිතන්නේ නැහැ ගැටලුව නළය සමඟ ඇති බව. ඔබේ දිගුකාලීන ක්‍රියාවලිය තමන්ගේම බෆරය නිතර නිතර ගලා නොයන බවක් පෙනේ. පයිප්පයේ බෆරයේ ප්‍රමාණය වෙනස් කිරීම එය වට කර ගැනීම සඳහා කඩුල්ලක් වනු ඇත, නමුත් කර්නලය නැවත ගොඩනඟා නොගෙන එය කළ හැකි යැයි මම නොසිතමි - ඔබට එය අනවසරයෙන් කිරීමට අවශ්‍ය නොවනු ඇත, එය බොහෝ විට ඇවර්ස්ලි වෙනත් ක්‍රියාදාමයන්ට බලපායි.

18

මූලික හේතුව වන්නේ stdout tty එකක් නොවේ නම් libc 4k බෆරින් වෙත මාරු වීමයි.

— ආරොන් ඩිගුල්ලා

5

එය ඉතා රසවත් ය! පයිප්ප කිසිදු බෆරයක් ඇති නොකරන නිසා. ඒවා බෆරින් සපයයි, නමුත් ඔබ පයිප්පයකින් කියවන්නේ නම්, ඔබට ලබා ගත හැකි ඕනෑම දත්තයක් ලැබෙනු ඇත, ඔබට පයිප්පයේ බෆරයක් එනතෙක් බලා සිටිය යුතු නැත. එබැවින් වැරදිකරු වන්නේ යෙදුමේ ස්ථායී බෆරයයි.

3

චැඩ්ගේ පිළිතුරට සමාන ආකාරයකින් , ඔබට මේ වගේ කුඩා පිටපතක් ලිවිය හැකිය:

# save as ~/bin/scriptee, or so
script -q /dev/null sh -c 'exec cat > /dev/null'

ඉන්පසු මෙම scripteeවිධානය ආදේශකයක් ලෙස භාවිතා කරන්න tee.

my-long-running-command | scriptee

අහෝ, මට ලිනක්ස් හි පරිපූර්ණ ලෙස ක්‍රියා කිරීමට එවැනි සංස්කරණයක් ලබා ගත නොහැකි බව පෙනේ, එබැවින් BSD විලාසිතාවේ යුනික්ස් වලට පමණක් සීමා වී ඇත.

ලිනක්ස් හි, මෙය ආසන්නයි, නමුත් එය අවසන් වූ විට ඔබේ විමසුම නැවත නොලැබේ (ඔබ එන්ටර් එබෙන තුරු) ...

script -q -c 'cat > /proc/self/fd/1' /dev/null

— jwd
source

එය ක්‍රියාත්මක වන්නේ ඇයි? "ස්ක්‍රිප්ට්" බෆරය අක්‍රිය කරයිද?

— ආරොන් ඩිගුල්ලා

A ආරොන් ඩිගුල්ලා: scriptපර්යන්තයක් අනුකරණය කරයි, එබැවින් ඔව්, එය බෆරින් ක්‍රියා විරහිත කරයි. එය යවන සෑම අක්‍ෂරයක්ම දෝංකාර දෙයි - මේ නිසා උදාහරණයට catයවනු ලැබේ /dev/null. ඇතුළත ක්‍රියාත්මක වන වැඩසටහන scriptසම්බන්ධයෙන් ගත් කල, එය කතා කරන්නේ අන්තර්ක්‍රියාකාරී සැසියකට ය. expectමේ සම්බන්ධයෙන් එය සමාන යැයි මම විශ්වාස කරමි , නමුත් scriptබොහෝ විට එය ඔබේ මූලික පද්ධතියේ කොටසක් විය හැකිය.

— jwd

මා භාවිතා කිරීමට හේතුව teeධාරාවේ පිටපතක් ගොනුවකට යැවීමයි. ගොනුව නිශ්චිතව දක්වා ඇත්තේ කොතැනටද scriptee?

— බ un නෝ බ්‍රොනොස්කි

RBrunoBronosky: ඔබ හරි, එය මෙම වැඩසටහනට නරක නමකි. එය ඇත්ත වශයෙන්ම 'ටී' මෙහෙයුමක් නොවේ. එය මුල් ප්‍රශ්නයට අනුව ප්‍රතිදානය බෆර් කිරීම අක්‍රීය කිරීමකි. සමහර විට එය "ස්ක්‍රිප්ට් කැට්" ලෙස හැඳින්විය යුතුය (එය සංක්ෂිප්ත කිරීමක් සිදු නොකලද ...). කෙසේ වෙතත්, ඔබට catවිධානය ආදේශ tee myfile.txtකළ හැකි අතර ඔබට අවශ්‍ය බලපෑම ලබා ගත යුතුය.

— jwd

2

මෙහි ඇති මෙම පෝස්ටයට අනුව , ඔබට නල උලිමිට් එක බයිට් 512 බ්ලොක් එකකට අඩු කිරීමට උත්සාහ කළ හැකිය. එය නිසැකවම බෆරින් ක්‍රියා විරහිත නොකරනු ඇත, නමුත් හොඳයි, බයිට් 512 4K: 3 ට වඩා අඩුය

— රාක්
source

1

මම මෙම දක්ෂ විසඳුම සොයාගත්තා: (echo -e "cmd 1\ncmd 2" && cat) | ./shell_executable

මෙය උපක්‍රමය කරයි. catඅතිරේක ආදානය කියවනු ඇත (EOF තෙක්) සහ echoඑහි ආදාන ප්‍රවාහයට තර්ක ඉදිරිපත් කිරීමෙන් පසුව එය පයිප්පයට යවනු ඇත shell_executable.

— jaggedsoft
source

3

ඇත්ත වශයෙන්ම, catප්‍රතිදානය නොපෙනේ echo; ඔබ විධාන දෙකක් උප කුලකයකින් ධාවනය කරන අතර දෙකේම ප්‍රතිදානය පයිප්පයට යවනු ලැබේ. උප කුලකයේ දෙවන විධානය ('cat') මව් / පිටත stdin වෙතින් කියවනු ලැබේ, ඒ නිසා එය ක්‍රියාත්මක වේ.

— ආරොන් ඩිගුල්ලා

-1

අනුව මෙම නල බෆරය ප්රමාණය කර්නලය පිහිටුවා ඇති බව පෙනේ සහ වෙනස් කිරීම සඳහා ඔබේ කර්නල් recompile ඔබ අවශ්ය වනු ඇත.

— දෙවැනි
source

7

මම විශ්වාස කරන්නේ එය වෙනස් බෆරයක් බවයි.

— සැමුවෙල් එඩ්වින් වෝඩ්