පෙළ ගොනුවක එක් එක් පේළිය බාෂ් සමඟ නැවත කියවන්නේ කෙසේද?

මෙම පිටපත සමඟ:

echo "Start!"
for p in (peptides.txt)
do
    echo "${p}"
done

මම මෙම ප්‍රතිදානය තිරය මත ලබා ගනිමි:

Start!
./runPep.sh: line 3: syntax error near unexpected token `('
./runPep.sh: line 3: `for p in (peptides.txt)'

(පසුව මට අවශ්‍ය වන්නේ $pතිරයට ප්‍රතිදානය කරනවාට වඩා සංකීර්ණ දෙයක් කිරීමටයි.)

පරිසර විචල්‍යය SHELL (env වෙතින්):

SHELL=/bin/bash

/bin/bash --version ප්‍රතිදානය:

GNU bash, version 3.1.17(1)-release (x86_64-suse-linux-gnu)
Copyright (C) 2005 Free Software Foundation, Inc.

cat /proc/version ප්‍රතිදානය:

Linux version 2.6.18.2-34-default (geeko@buildhost) (gcc version 4.1.2 20061115 (prerelease) (SUSE Linux)) #1 SMP Mon Nov 27 11:46:27 UTC 2006

Peptides.txt ගොනුවේ අඩංගු වන්නේ:

RKEKNVQ
IPKKLLQK
QYFHQLEKMNVK
IPKKLLQK
GDLSTALEVAIDCYEK
QYFHQLEKMNVKIPENIYR
RKEKNVQ
VLAKHGKLQDAIN
ILGFMK
LEDVALQILL

එය කළ හැකි එක් ක්‍රමයක් නම්:

while read p; do
  echo "$p"
done <peptides.txt

අදහස් දැක්වීමේදී පෙන්වා දී ඇති පරිදි, මෙය ප්‍රමුඛ සුදු අවකාශය කැපීම, බැක්ස්ලෑෂ් අනුක්‍රමයන් අර්ථ නිරූපණය කිරීම සහ අවසන් වන රේඛීය රේඛාවක් නොමැති නම් අවසාන පේළිය මඟ හැරීම වැනි අතුරු ආබාධ ඇත. මේවා සැලකිලිමත් නම්, ඔබට කළ හැක්කේ:

while IFS="" read -r p || [ -n "$p" ]
do
  printf '%s\n' "$p"
done < peptides.txt

සුවිශේෂී ලෙස, ලූප් බොඩි සම්මත ආදානයෙන් කියවිය හැකි නම් , ඔබට වෙනත් ගොනු විස්තරයක් භාවිතා කර ගොනුව විවෘත කළ හැකිය:

while read -u 10 p; do
  ...
done 10<peptides.txt

මෙන්න, 10 යනු අත්තනෝමතික අංකයකි (0, 1, 2 ට වඩා වෙනස්).

cat peptides.txt | while read line 
do
   # do something with $line here
done

සහ එක්-ලයිනර් ප්‍රභේදය:

cat peptides.txt | while read line; do something_with_$line_here; done

පසුපස රේඛා සංග්‍රහයක් නොමැති නම් මෙම විකල්පයන් ගොනුවේ අවසාන පේළිය මඟ හරිනු ඇත.

පහත සඳහන් දෑ වලින් ඔබට මෙය වළක්වා ගත හැකිය:

cat peptides.txt | while read line || [[ -n $line ]];
do
   # do something with $line here
done

විකල්පය 1a: ලූප අතර: වරකට තනි පේළිය: ආදාන යළි හරවා යැවීම

#!/bin/bash
filename='peptides.txt'
echo Start
while read p; do 
    echo $p
done < $filename

විකල්පය 1b: ලූප අතර: වරකට තනි පේළිය:
ගොනුව විවෘත කරන්න, ගොනු විස්තර කරන්නෙකුගෙන් කියවන්න (මෙම අවස්ථාවේදී ගොනු විස්තරය # 4).

#!/bin/bash
filename='peptides.txt'
exec 4<$filename
echo Start
while read -u4 p ; do
    echo $p
done

මෙය වෙනත් පිළිතුරු වලට වඩා හොඳ නැත, නමුත් අවකාශයක් නොමැතිව ගොනුවක කාර්යය ඉටු කිරීමට තවත් එක් ක්‍රමයකි (අදහස් බලන්න). වෙනම ස්ක්‍රිප්ට් ලිපිගොනු භාවිතා කිරීමේ අමතර පියවරක් නොමැතිව පෙළ ගොනුවල ලැයිස්තු හෑරීමට මට බොහෝ විට එක්-ලයිනර් අවශ්‍ය බව මට පෙනී ගියේය.

for word in $(cat peptides.txt); do echo $word; done

මෙම ආකෘතිය මට එක විධාන රේඛාවකට දැමීමට ඉඩ දෙයි. "Echo $ word" කොටස ඔබට අවශ්‍ය ඕනෑම දෙයකට වෙනස් කරන්න, ඔබට අර්ධ සළකුණු වලින් වෙන් කරන ලද විධාන කිහිපයක් නිකුත් කළ හැකිය. පහත උදාහරණයෙන් ඔබ ලියා ඇති වෙනත් ස්ක්‍රිප්ට් දෙකකට තර්ක ලෙස ගොනුවේ අන්තර්ගතය භාවිතා කරයි.

for word in $(cat peptides.txt); do cmd_a.sh $word; cmd_b.py $word; done

නැතහොත් ඔබ මෙය ධාරා සංස්කාරකයක් ලෙස භාවිතා කිරීමට අදහස් කරන්නේ නම් (ඉගෙන ගන්න sed) ඔබට පහත පරිදි ප්‍රතිදානය වෙනත් ගොනුවකට දැමිය හැකිය.

for word in $(cat peptides.txt); do cmd_a.sh $word; cmd_b.py $word; done > outfile.txt

මම ඉහත ලියා ඇති පරිදි මේවා භාවිතා කර ඇත්තේ මා විසින් පෙළ ගොනු එක් පේළියකට එක් වචනයකින් නිර්මාණය කර ඇති බැවිනි. (අදහස් බලන්න) ඔබේ වචන / රේඛා බෙදීමට ඔබට අවශ්‍ය නැති අවකාශ තිබේ නම්, එය ටිකක් අවලස්සන වේ, නමුත් එකම විධානය තවමත් පහත පරිදි ක්‍රියාත්මක වේ:

OLDIFS=$IFS; IFS=$'\n'; for line in $(cat peptides.txt); do cmd_a.sh $line; cmd_b.py $line; done > outfile.txt; IFS=$OLDIFS

මෙය හුදෙක් කවචයට පවසන්නේ නව රේඛා මත පමණක් බෙදීමට මිස අවකාශයන් නොව පරිසරය පෙර පැවති තත්වයට නැවත ලබා දෙන බවයි. මෙම අවස්ථාවෙහිදී, ඒ සියල්ල තනි පේළියකට මිරිකනවාට වඩා ෂෙල් පිටපතකට දැමීම ගැන සලකා බැලීමට ඔබට අවශ්‍ය විය හැකිය.

සුභ පැතුම්!

වෙනත් පිළිතුරු වලින් ආවරණය නොවන තවත් කරුණු කිහිපයක්:

වෙන් කරන ලද ගොනුවකින් කියවීම

# ':' is the delimiter here, and there are three fields on each line in the file
# IFS set below is restricted to the context of `read`, it doesn't affect any other code
while IFS=: read -r field1 field2 field3; do
  # process the fields
  # if the line has less than three fields, the missing fields will be set to an empty string
  # if the line has more than three fields, `field3` will get all the values, including the third field plus the delimiter(s)
done < input.txt

ක්‍රියාවලි ආදේශනය භාවිතා කරමින් වෙනත් විධානයක ප්‍රතිදානයෙන් කියවීම

while read -r line; do
  # process the line
done < <(command ...)

මෙම ප්‍රවේශය වඩා හොඳ command ... | while read -r line; do ...වන්නේ මෙහි ඇති කාල ලූපය වත්මන් කවචයේ ධාවනය වන හෙයින් එය උප කවචයකට වඩා වත්මන් කවචයේ ක්‍රියාත්මක වන බැවිනි. අදාළ පෝස්ටුව බලන්න කාල පරාසයක් තුළ වෙනස් කළ විචල්‍යයක් මතක නැත .

නිදසුනක් ලෙස, ශුන්‍ය වෙන් කළ ආදානයකින් කියවීම find ... -print0

while read -r -d '' line; do
  # logic
  # use a second 'read ... <<< "$line"' if we need to tokenize the line
done < <(find /path/to/dir -print0)

ආශ්‍රිත කියවීම: BashFAQ / 020 - නව රේඛා, අවකාශ හෝ දෙකම අඩංගු ගොනු නම් සොයාගෙන ආරක්ෂිතව හැසිරවිය හැක්කේ කෙසේද?

වරකට එක් ගොනුවකට වඩා කියවීම

while read -u 3 -r line1 && read -u 4 -r line2; do
  # process the lines
  # note that the loop will end when we reach EOF on either of the files, because of the `&&`
done 3< input1.txt 4< input2.txt

මත පදනම් @ chepner ගේ පිළිතුර මෙතන :

-uයනු දිගුවකි. POSIX අනුකූලතාව සඳහා, සෑම ඇමතුමක්ම සමාන read -r X <&3වේ.

සම්පූර්ණ ගොනුවක් අරාවකට කියවීම (බාෂ් අනුවාද 4 ට පෙර)

while read -r line; do
    my_array+=("$line")
done < my_file

ගොනුව අසම්පූර්ණ රේඛාවකින් අවසන් වුවහොත් (අවසානයේ නව රේඛාව අස්ථානගත වී ඇත), එවිට:

while read -r line || [[ $line ]]; do
    my_array+=("$line")
done < my_file

සම්පූර්ණ ගොනුවක් අරාවකට කියවීම (Bash අනුවාද 4x සහ පසුව)

readarray -t my_array < my_file

හෝ

mapfile -t my_array < my_file

ඊළගට

for line in "${my_array[@]}"; do
  # process the lines
done

• ෂෙල් බිල්ඩින් readසහ readarrayවිධාන ගැන වැඩි විස්තර - GNU

• වැඩි විස්තර IFS- විකිපීඩියා

• BashFAQ / 001 - ගොනුවක් (දත්ත ප්‍රවාහය, විචල්‍යය) රේඛීයව (සහ / හෝ ක්ෂේත්‍රයෙන් ක්ෂේත්‍රය) කියවන්නේ කෙසේද?

අදාළ ලිපි:

• Bash හි පෙළ ගොනුවකින් අරාවක් නිර්මාණය කිරීම
• එක් පේළියක් පමණක් ඇති ගොනුවක් කියවීමට ඔබ ප්‍රවේශ වීම අතර ඇති වෙනස කුමක්ද?
• බළලා සමඟ සසඳන විට කියවීමේ ලූප ඉතා මන්දගාමී වේ, ඇයි?

මේ ආකාරයට කෙටි ලූපයක් භාවිතා කරන්න:

while IFS= read -r line; do
   echo "$line"
done <file

සටහන්:

1. ඔබ IFSනිසියාකාරව සකසා නොමැති නම්, ඔබට ඉන්ඩෙන්ෂන් නැති වේ.

2. ඔබ සෑම විටම පාහේ කියවීම සමඟ -r විකල්පය භාවිතා කළ යුතුය.

3. සමඟ පේළි කියවන්න එපා for

ඔබට මෙම ගොනුව ඇතැයි සිතමු:

$ cat /tmp/test.txt
Line 1
    Line 2 has leading space
Line 3 followed by blank line

Line 5 (follows a blank line) and has trailing space    
Line 6 has no ending CR

බොහෝ බාෂ් විසඳුම් කියවන ගොනු ප්‍රතිදානයේ අර්ථය වෙනස් කරන අංග හතරක් ඇත:

1. හිස් පේළිය 4;
2. පේළි දෙකක ඊයම් හෝ පසුපස අවකාශ;
3. තනි රේඛාවල අර්ථය පවත්වා ගැනීම (එනම්, එක් එක් පේළිය වාර්තාවකි);
4. 6 වන පේළිය CR ​​සමඟ අවසන් නොවේ.

ඔබට සීආර් නොමැතිව හිස් රේඛා සහ අවසන් රේඛා ඇතුළුව පෙළ ගොනු රේඛාව අවශ්‍ය නම්, ඔබ ටික වේලාවක් භාවිතා කළ යුතු අතර අවසාන පේළිය සඳහා විකල්ප පරීක්ෂණයක් තිබිය යුතුය.

ගොනුව වෙනස් කළ හැකි ක්‍රම මෙන්න ( catප්‍රතිලාභයට සාපේක්ෂව ):

1) අවසාන පේළිය සහ ප්‍රමුඛ හා පසුපස අවකාශය නැති කර ගන්න:

$ while read -r p; do printf "%s\n" "'$p'"; done </tmp/test.txt
'Line 1'
'Line 2 has leading space'
'Line 3 followed by blank line'
''
'Line 5 (follows a blank line) and has trailing space'

(ඔබ ඒ while IFS= read -r p; do printf "%s\n" "'$p'"; done </tmp/test.txtවෙනුවට කරන්නේ නම් , ඔබ ප්‍රමුඛ හා පසුපස අවකාශයන් ආරක්ෂා කරයි, නමුත් CR සමඟ අවසන් නොවන්නේ නම් අවසාන පේළිය තවමත් අහිමි වේ)

2) catකැමැත්ත සමඟ ක්‍රියාවලි ආදේශනය භාවිතා කිරීමෙන් මුළු ගොනුවම එකවර කියවන අතර තනි රේඛාවල අර්ථය නැති වේ:

$ for p in "$(cat /tmp/test.txt)"; do printf "%s\n" "'$p'"; done
'Line 1
    Line 2 has leading space
Line 3 followed by blank line

Line 5 (follows a blank line) and has trailing space    
Line 6 has no ending CR'

(ඔබ විසින් ඉවත් නම් "සිට $(cat /tmp/test.txt)ඔබ ... ඒ වෙනුවට එක් ඔවුන්ගේ උගුරෙන් පහළට වඩා වචනය විසින් ගොනු වචනය කියවන්න. එසේම බොහෝ විට අදහස් දේ නොවේ)

ලිපිගොනු පේළියක් කියවා සියලු පරතරයන් ආරක්ෂා කර ගැනීම සඳහා වඩාත්ම ශක්තිමත් හා සරලම ක්‍රමය නම්:

$ while IFS= read -r line || [[ -n $line ]]; do printf "'%s'\n" "$line"; done </tmp/test.txt
'Line 1'
'    Line 2 has leading space'
'Line 3 followed by blank line'
''
'Line 5 (follows a blank line) and has trailing space    '
'Line 6 has no ending CR'

ඔබට ප්‍රමුඛ හා වෙළඳ අවකාශ ඉවත් කිරීමට අවශ්‍ය නම්, IFS=කොටස ඉවත් කරන්න :

$ while read -r line || [[ -n $line ]]; do printf "'%s'\n" "$line"; done </tmp/test.txt
'Line 1'
'Line 2 has leading space'
'Line 3 followed by blank line'
''
'Line 5 (follows a blank line) and has trailing space'
'Line 6 has no ending CR'

(අ නිමාවන තොර පෙළ ගොනු \n, තරමක පොදු වන අතර, POSIX යටතේ බිඳ සැලකේ. ඔබ අවර ගණන් කළ හැකි නම් \nඔබට අවශ්ය නොවේ || [[ -n $line ]]තුළ whileපුඩුවක්.)

BASH FAQ හි තවත්

ඔබගේ කියවීම නව රේඛා අක්ෂරයෙන් බිඳ දැමීමට ඔබට අවශ්‍ය නැතිනම්, භාවිතා කරන්න -

#!/bin/bash
while IFS='' read -r line || [[ -n "$line" ]]; do
    echo "$line"
done < "$1"

ඉන්පසු පරාමිතිය ලෙස ගොනු නාමයෙන් ස්ක්‍රිප්ට් ධාවනය කරන්න.

#!/bin/bash
#
# Change the file name from "test" to desired input file 
# (The comments in bash are prefixed with #'s)
for x in $(cat test.txt)
do
    echo $x
done

මෙන්න මගේ සැබෑ ජීවිත උදාහරණය වෙනත් වැඩසටහන් නිමැවුමක රේඛා ලූප් කරන්නේ කෙසේද, උපස්ථර සඳහා පරික්ෂා කරන්න, විචල්‍යයෙන් ද්විත්ව උපුටා දැක්වීම් අතහරින්න, එම විචල්‍යය ලූපයෙන් පිටත භාවිතා කරන්න. බොහෝ දෙනෙක් ඉක්මනින් හෝ පසුව මෙම ප්‍රශ්න අසනු ඇතැයි මම සිතමි.

##Parse FPS from first video stream, drop quotes from fps variable
## streams.stream.0.codec_type="video"
## streams.stream.0.r_frame_rate="24000/1001"
## streams.stream.0.avg_frame_rate="24000/1001"
FPS=unknown
while read -r line; do
  if [[ $FPS == "unknown" ]] && [[ $line == *".codec_type=\"video\""* ]]; then
    echo ParseFPS $line
    FPS=parse
  fi
  if [[ $FPS == "parse" ]] && [[ $line == *".r_frame_rate="* ]]; then
    echo ParseFPS $line
    FPS=${line##*=}
    FPS="${FPS%\"}"
    FPS="${FPS#\"}"
  fi
done <<< "$(ffprobe -v quiet -print_format flat -show_format -show_streams -i "$input")"
if [ "$FPS" == "unknown" ] || [ "$FPS" == "parse" ]; then 
  echo ParseFPS Unknown frame rate
fi
echo Found $FPS

ලූපයෙන් පිටත විචල්‍යය ප්‍රකාශ කරන්න, අගය සකසා එය ලූපයෙන් පිටත භාවිතා කිරීම අවශ්‍ය වේ <<< "$ (...)" සින්ටැක්ස්. වත්මන් කොන්සෝලයේ සන්දර්භය තුළ යෙදුම ධාවනය කළ යුතුය. විධානය වටා ඇති උපුටා දැක්වීම් මඟින් ප්‍රතිදාන ප්‍රවාහයේ නව රේඛා තබා ගනී.

උපස්ථර සඳහා ලූප් ගැලපීම පසුව නම = අගය යුගලය කියවයි , අන්තිම = අක්ෂරයේ දකුණු පස බෙදී යයි , පළමු උපුටා දැක්වීම පහත වැටේ, අන්තිම උපුටා දැක්වීම පහත වැටේ, අපට වෙනත් තැනක භාවිතා කිරීමට පිරිසිදු අගයක් ඇත.

මෙය පැමිණෙන්නේ තරමක් ප්‍රමාදයි, නමුත් එය යමෙකුට උපකාර කළ හැකිය යන සිතිවිල්ලෙන් මම පිළිතුර එක් කරමි. එසේම මෙය හොඳම ක්‍රමය නොවිය හැකිය. headවිධානය භාවිතා කල හැක -nකියවීමට තර්කය n පේළි ගොනු හා එසේ ම ක ආරම්භයේ සිට tailවිධානය පහල සිට කියවීමට භාවිතා කළ හැක. දැන්, ගොනුවෙන් n වන පේළිය ලබා ගැනීම සඳහා, අපි රේඛා n වෙතට යමු , දත්ත වලිගයට නල මාර්ගයෙන් නල දත්ත වලින් පේළි 1 ක් පමණි.

   TOTAL_LINES=`wc -l $USER_FILE | cut -d " " -f1 `
   echo $TOTAL_LINES       # To validate total lines in the file

   for (( i=1 ; i <= $TOTAL_LINES; i++ ))
   do
      LINE=`head -n$i $USER_FILE | tail -n1`
      echo $LINE
   done

මම xargsඒ වෙනුවට භාවිතා කිරීමට කැමතියි while. xargsබලවත් සහ විධාන රේඛා හිතකාමී වේ

cat peptides.txt | xargs -I % sh -c "echo %"

සමඟ xargs, ඔබට සමඟ වාචිකතාව -tසහ වලංගුභාවය එකතු කළ හැකිය-p

Et පීටර්: මෙය ඔබට ප්‍රයෝජනවත් විය හැකිය-

echo "Start!";for p in $(cat ./pep); do
echo $p
done

මෙය ප්‍රතිදානය නැවත ලබා දෙනු ඇත-

Start!
RKEKNVQ
IPKKLLQK
QYFHQLEKMNVK
IPKKLLQK
GDLSTALEVAIDCYEK
QYFHQLEKMNVKIPENIYR
RKEKNVQ
VLAKHGKLQDAIN
ILGFMK
LEDVALQILL