Una forma de hacerlo es:

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

Como se señaló en los comentarios, esto tiene los efectos secundarios de recortar los espacios en blanco iniciales, interpretar las secuencias de barra invertida y omitir la última línea si falta un salto de línea de terminación. Si estas son inquietudes, puede hacer lo siguiente:

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

Excepcionalmente, si el el cuerpo del bucle puede leer desde la entrada estándar, puede abrir el archivo usando un descriptor de archivo diferente:

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

Aquí, 10 es solo un número arbitrario (diferente de 0, 1, 2).

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

y la variante de una sola línea:

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

Estas opciones omitirán la última línea del archivo si no hay un avance de línea final.

Puede evitar esto de la siguiente manera:

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

Opción 1a: Bucle while: línea única a la vez: redirección de entrada

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

Opción 1b: Bucle while: línea única a la vez:
Abra el archivo, lea desde un descriptor de archivo (en este caso, el descriptor de archivo # 4).

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

Esta no es mejor que otras respuestas, pero es una forma más de hacer el trabajo en un archivo sin espacios (ver comentarios). Encuentro que a menudo necesito frases breves para buscar en listas en archivos de texto sin el paso adicional de usar archivos de script separados.

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

Este formato me permite ponerlo todo en una línea de comandos. Cambie la parte "echo $ word" a lo que desee y podrá emitir varios comandos separados por punto y coma. El siguiente ejemplo utiliza el contenido del archivo como argumentos en otros dos scripts que puede haber escrito.

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

O si tiene la intención de usar esto como un editor de flujo (aprender sed), puede volcar la salida a otro archivo de la siguiente manera.

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

Los he usado como se escribió anteriormente porque he usado archivos de texto donde los he creado con una palabra por línea. (Ver comentarios) Si tiene espacios en los que no desea dividir sus palabras / líneas, se vuelve un poco más feo, pero el mismo comando aún funciona de la siguiente manera:

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

Esto solo le dice al shell que se divida solo en líneas nuevas, no en espacios, luego devuelve el entorno a lo que era anteriormente. Sin embargo, en este punto, es posible que desee considerar ponerlo todo en un script de shell en lugar de comprimirlo todo en una sola línea.

¡Mucha suerte!

Algunas cosas más no cubiertas por otras respuestas:

Leyendo de un archivo delimitado

# ':' 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

Leer de la salida de otro comando, usando sustitución de proceso

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

Este enfoque es mejor que command ... | while read -r line; do ... porque el ciclo while aquí se ejecuta en el shell actual en lugar de en un subshell como en el caso de este último. Ver la publicación relacionada Una variable modificada dentro de un bucle while no se recuerda.

Lectura de una entrada delimitada por nulos, por ejemplo 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)

Lectura relacionada: BashFAQ / 020 - ¿Cómo puedo encontrar y manejar de forma segura los nombres de archivo que contienen nuevas líneas, espacios o ambos?

Leer de más de un archivo a la vez

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

Basado en @ chepner's https://www.youtube.com/watch?v=xB-eutXNUMXJtA&feature=youtu.be aquí:

-u es una extensión de bash. Para la compatibilidad POSIX, cada llamada se vería como read -r X <&3.

Leer un archivo completo en una matriz (versiones de Bash anteriores a la 4)

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

Si el archivo termina con una línea incompleta (falta una nueva línea al final), entonces:

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

Leer un archivo completo en una matriz (versiones de Bash 4x y posteriores)

readarray -t my_array < my_file

or

mapfile -t my_array < my_file

Y entonces

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

• Más sobre las incorporaciones de shell read y readarray comandos - GNU

• Más información sobre IFS - Wikipedia

• BashFAQ / 001 - ¿Cómo puedo leer un archivo (flujo de datos, variable) línea por línea (y / o campo por campo)?

Artículos Relacionados:

• Creando una matriz a partir de un archivo de texto en Bash
• ¿Cuál es la diferencia entre tres enfoques para leer un archivo que tiene solo una línea?
• Bash mientras que el bucle de lectura es extremadamente lento en comparación con el gato, ¿por qué?

Use un ciclo while, como este:

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

Notas

1. Si no configura el IFS correctamente, perderá la sangría.

2. Casi siempre debería usar la opción -r con read.

3. No leas líneas con for

Suponga que tiene este archivo:

$ 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

Hay cuatro elementos que alterarán el significado de la salida del archivo leído por muchas soluciones Bash:

1. La línea en blanco 4;
2. Espacios iniciales o finales en dos líneas;
3. Mantener el significado de las líneas individuales (es decir, cada línea es un registro);
4. La línea 6 no terminó con un CR.

Si desea que el archivo de texto línea por línea incluya líneas en blanco y líneas de terminación sin CR, debe usar un bucle while y debe tener una prueba alternativa para la línea final.

Estos son los métodos que pueden cambiar el archivo (en comparación con lo que cat devoluciones):

1) Pierde la última línea y los espacios iniciales y finales:

$ 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'

(Si lo haces while IFS= read -r p; do printf "%s\n" "'$p'"; done </tmp/test.txt en su lugar, conserva los espacios iniciales y finales pero aún pierde la última línea si no termina con CR)

2) Uso de la sustitución de procesos con cat leerá todo el archivo de un solo trago y pierde el significado de las líneas individuales:

$ 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'

(Si quita el " desde $(cat /tmp/test.txt) lee el archivo palabra por palabra en lugar de un trago. También probablemente no sea lo que se pretende ...)

La forma más sólida y sencilla de leer un archivo línea por línea y conservar todo el espacio es:

$ 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'

Si desea eliminar los espacios iniciales y comerciales, elimine el IFS= parte:

$ 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'

(Un archivo de texto sin terminación \n, aunque es bastante común, se considera roto en POSIX. Si puedes contar con el final \n usted no necesita || [[ -n $line ]] en el capítulo respecto a la while círculo.)

Más en el Preguntas frecuentes de BASH

Si no desea que su lectura se interrumpa por un carácter de nueva línea, use -

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

Luego ejecute el script con el nombre del archivo como parámetro.

#!/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

Aquí está mi ejemplo de la vida real sobre cómo hacer un bucle de líneas de salida de otro programa, verificar subcadenas, eliminar comillas dobles de la variable, usar esa variable fuera del bucle. Supongo que muchos se hacen estas preguntas tarde o temprano.

##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

Declarar la variable fuera del bucle, establecer el valor y usarlo fuera del bucle requiere hecho <<< "$ (...)" sintaxis. La aplicación debe ejecutarse en el contexto de la consola actual. Las comillas alrededor del comando mantienen nuevas líneas de flujo de salida.

Coincidencia de bucle para subcadenas y luego lee Nombre = valor par, divide la parte derecha del último = carácter, elimina la primera cita, elimina la última cita, tenemos un valor limpio para usar en otros lugares.

Me gusta usar xargs en lugar de while. xargs es potente y compatible con la línea de comandos

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

Con xargs, también puede agregar verbosidad con -t y validación con -p

Esta podría ser la respuesta más simple y tal vez no funcione en todos los casos, pero funciona muy bien para mí:

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

si necesita encerrar entre paréntesis para espacios:

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

Ahhh, esta es más o menos la misma que la respuesta que recibió más votos, pero todo está en una sola línea.

Esto llega bastante tarde, pero con la idea de que puede ayudar a alguien, agrego la respuesta. Además, esta puede no ser la mejor manera. head El comando se puede usar con -n argumento para leer n líneas desde el inicio del archivo e igualmente tail El comando se puede utilizar para leer desde abajo. Ahora, para ir a buscar nth línea de archivo, nos dirigimos n líneas, canalice los datos para que sigan solo una línea de los datos canalizados.

   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

@ Peter: Esto podría funcionar para ti-

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

Esto devolvería la salida

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