Loop attraverso il contenuto di un file in Bash

Come faccio a scorrere ogni riga di un file di testo con Bash?

Con questo script:

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

Ottengo questo output sullo schermo:

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

(Poi voglio fare qualcosa di più complicato, con $p di solo output sullo schermo.)


La variabile di ambiente SHELL è (env):

SHELL=/bin/bash

/bin/bash --version di uscita:

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

cat /proc/version di uscita:

Linux version 2.6.18.2-34-default ([email protected]) (gcc version 4.1.2 20061115 (prerelease) (SUSE Linux)) #1 SMP Mon Nov 27 11:46:27 UTC 2006

Il file peptides.txt contiene:

RKEKNVQ
IPKKLLQK
QYFHQLEKMNVK
IPKKLLQK
GDLSTALEVAIDCYEK
QYFHQLEKMNVKIPENIYR
RKEKNVQ
VLAKHGKLQDAIN
ILGFMK
LEDVALQILL

 

12 Replies
  1. 1898

    Un modo per farlo è:

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

    Come sottolineato nei commenti, questo ha effetti collaterali di ritaglio di spazio all’inizio, interpretting barra rovesciata sequenze, e saltare la finale di riga se manca una di terminazione di avanzamento riga. Se queste sono le preoccupazioni, si può fare:

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

    Eccezionalmente, se il corpo del loop può leggere dallo standard input, è possibile aprire il file utilizzando un altro file descrittore:

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

    Qui, 10 è solo un numero arbitrario (diverso da 0, 1, 2).

    • Come devo interpretare l’ultima riga? File peptides.txt viene reindirizzato a standard input e in qualche modo per tutto il tempo di blocco?
    • “Slurp peptides.txt in questo ciclo, in modo che la ‘lettura’ di comando ha qualcosa da consumare.” Il mio “gatto” metodo è simile, inviare l’output di un comando in mentre il blocco per il consumo di ‘leggere’, troppo, solo che lancia un altro programma per ottenere il lavoro fatto.
    • Questo non ha funzionato per me. Il secondo classificato risposta, che ha utilizzato gatto e un tubo, ha funzionato per me.
    • Questo metodo sembra saltare l’ultima riga di un file.
    • Questo può essere fatto in senso inverso partendo dal fondo del file?
    • Quindi vorrei utilizzare una soluzione a base di cat ma sostituire cat da tac.
    • Ho provato ma tac sembra rendere ogni spazio una nuova linea. Ho bisogno di una linea completa delimitato da un ritorno a capo char. forse mi sono sbagliato.
    • Ok ho trovato questo: unix.stackexchange.com/a/7012 ..cambiare gatto a tac e funziona. Grazie!
    • Volevo dire che la soluzione da Warren Giovani stackoverflow.com/a/1521470/6918 ; basta sostituire gatto dalla tac e si dovrebbe leggere le righe in senso inverso.
    • Virgolette doppie linee !! echo “$p” e il file.. fidati di me è in grado di mordere, se non ne ha!!! IO LO SO! lol
    • Che opzione-u reso la mia giornata 😉 Grazie!
    • Entrambe le versioni non riescono a leggere una riga finale, se non è terminato con un “a capo”. Sempre l’utilizzo while read p || [[ -n $p ]]; do ...
    • Questo non funziona per le righe che terminano con una barra rovesciata “\”. Le righe che terminano con una barra rovesciata sarà aggiunto alla riga successiva (e \ potranno essere rimossi).
    • Ora che strano. Quello che mi aspetta è, si ottiene un extra di n dopo la barra, e le linee diventano concatenate. Perché vorrebbe dire, la barra rovesciata sfugge la barra rovesciata di \n, causando ad essere interpretata letteralmente, piuttosto che come un “a capo”. Ma il fatto che la barra rovesciata scompare, così come il carattere di nuova riga, significa che è consumato per un qualche tipo di fuga, come previsto, ma si è fusa con l’originale carattere di nuova riga in qualcosa che non è stampato… hai uno strumento che visualizza non stampati caratteri in qualche modo? Mi interessa quello che comporta.
    • l’ \ sfugge il carattere “\n” che è un singolo carattere. Google per una “tabella ascii”. Carattere 10 \n e il carattere 13 \r. Linux “xxd” strumento mostrerà i personaggi. Un file con a\na\n\\n sarà simile a: 610a 610a 5c0a (0a hex è per le 10, in modo da \n). Così quest’ultimo caso la “5c” carattere o “\” scappa un singolo carattere.
    • Ah OK, ora ho capito meglio. Non si è accorto il contenuto del file viene scaricato nel flusso di esecuzione il modo in cui è all’interno del file, dove, naturalmente, \n è un singolo carattere. Per qualche ragione ho pensato che ottiene backresolved per la sequenza di controllo, mentre elaborati. Ancora, è un po ‘ strano che un escape \n è qualcosa senza un prodotto stampato. Ci si aspetta di risolvere il char sequenza “\n” quando è scappato.
    • La tua anima sia benedetto per diversi descrittore di file di comando, mi ha reso felice, sprecato 8 giorni su un errore generato da standard input sostituzione. +1
    • Il primo esempio manca un “;” dopo il fatto.
    • potete per favore parlare di cosa -r la bandierina?
    • disabilita l’interpretazione del backslash come le sequenze di escape. Il vuoto IFS disabilita che read spezza la linea nei campi. E perché read non riesce quando incontra la fine del file prima che la linea termina, ci prova anche per una riga non vuota.
    • read è ignorando il \r carattere quando si utilizza windows terminatori di linea (cioè \r\n). Come posso fare read trattare \r come parte del newline sequenza?
    • Se siete come me e si fanno queste cose in shell in una sola riga, è necessario aggiungere un altro punto e virgola, così: durante la lettura p; do echo “$p”; fatto <peptides.txt

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

    e il one-liner variante:

    cat peptides.txt | while read line; do something_with_$line_here; done
    • In generale, se stai usando il “gatto” con un solo argomento, stai facendo qualcosa di sbagliato (o non ottimale).
    • Ho provato e funziona (così come Bruno De Fraine s).
    • Sì, è solo non è efficace come Bruno, perché lancia un altro programma, inutilmente. Se l’efficienza di questioni di farlo Bruno modo. Mi ricordo la mia strada, perché si può usare con altri comandi, dove il “redirect da” sintassi non funziona.
    • C’è un altro, più grave problema con questo: perché il ciclo while è parte di una pipeline, corre in una subshell, e, di conseguenza, qualsiasi set di variabili all’interno del ciclo sono perso quando esce (vedi bash-hackers.org/wiki/doku.php/mirroring/bashfaq/024). Questo può essere molto fastidioso (a seconda di che cosa stai cercando di fare in loop).
    • puoi dirci con un esempio alternativo?
    • Egli significa che si dovrebbe fare come Bruno ha fatto nel suo accettato di rispondere. Sia il lavoro. Bruno è solo un po ‘ più efficiente, dal momento che esso non viene eseguito un comando esterno per fare la lettura di file bit. Se l’efficienza di questioni di farlo Bruno modo. Se non, quindi fare qualunque modo rende più senso per voi.
    • Warren è giusto. Il “gatto” di comando è utilizzato per concatenare i file. Se non la concatenazione di file, le probabilità sono che non avete bisogno di utilizzare “gatto”.
    • Ok, ha un senso. Ho voluto fare un punto di esso, perché vedo un sacco di abusata esempi di script, dove “gatto” serve semplicemente come un ulteriore passo per ottenere il contenuto di un singolo file.
    • Io uso “cat file |” come l’inizio di un sacco di miei comandi, solo perché io spesso prototipo con “file |”
    • Inoltre, in quale altro modo si potrebbe costruire un intero file con una pipeline? Bash offre qui delle stringhe, che sono impressionanti (soprattutto per cose come if grep -q 'findme' <<< "$var") ma non portatile, e non vorrei iniziare una grande pipeline con uno. Qualcosa di simile cat ifconfig.output | grep inet[^6] | grep -v '127.0.0.1' | awk '{print $2}' | cut -d':' -f2 è più facile da leggere, dal momento che tutto segue da sinistra a destra. È come strtoking con awk invece di cut perché c’è il vuoto (a gettoni), è una specie di abuso di comando, ma questo è solo come è fatto.
    • Questo potrebbe non essere così efficiente, ma è molto più leggibile rispetto ad altre risposte.
    • +1 per la leggibilità, e anche modularità – questo codice può essere facilmente mettere in una più complessa pipeline sostituendo ” il gatto …’ con l’uscita di qualcosa d’altro.
    • È molto meglio risolvere che Bruno ha scritto. E ‘ particolarmente utile quando i dati vengono creati dinamicamente dal comando. Utilizzando Bruno soluzione, loop, potranno ricevere i dati dopo il comando sarà completamente fatto. La soluzione dà il risultato di un comando on line in loop, senza prendere in buffer di sistema. per esempio sostituire il “gatto peptides.txt’ da ‘find /’, o nella soluzione precedente ‘fatto <peptides.txt’ dal ‘fatto < $(find /)’ . si può fallire esecuzione, in quanto c’è una possibilità di overflow del buffer o consumare tutta la memoria.
    • Con il tempo si cura circa la differenza di prestazioni non sarà COSÌ chiedere questo tipo di domande.
    • < peptides.txt | while read line...
    • Tuttavia, questo è grande per grep, sed, o qualsiasi altra manipolazione del testo anteponendo la lettura.
    • questo non funziona se uno qualsiasi dei comandi all’interno del ciclo di eseguire comandi tramite ssh; stdin stream si consuma (anche se ssh non la utilizza), e il ciclo termina dopo la prima iterazione.
    • questo è un zsh-ism; non funziona in bash.
    • Come accettate risposta, questo permetterà di avere spiacevoli sorprese senza read -r in alcuni casi particolari. Fondamentalmente utilizzare sempre read -r a meno che non si richiede espressamente il bizzarro comportamento di pianura legacy read.
    • E ‘ saltato l’ultima riga. Così come soluzione alternativa, è necessario aggiungere una riga vuota all’ultimo.
    • Non solo che, se l’ultima riga del file non ha LF terminator, che causerà un sacco di altre cose per fallire, troppo.

  3. 138

    Opzione 1a: ciclo While: Singola riga alla volta: il reindirizzamento dell’Input

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

    Opzione 1b: ciclo While: Singola riga alla volta:

    Aprire il file, leggere da un descrittore di file (in questo caso il descrittore di file n. 4).

    #!/bin/bash
    filename='peptides.txt'
    exec 4<$filename
    echo Start
    while read -u4 p ; do
        echo $p
    done
    • Per l’opzione 1b: il descrittore di file deve essere chiuso di nuovo? E. g. il ciclo potrebbe essere un ciclo interno.
    • Il descrittore di file verrà pulito con il processo di chiusura. Un esplicito vicino si può fare per riutilizzare il fd numero. Per chiudere un fd, utilizzare un altro exec con il &- sintassi, come questo: exec 4<&-
    • Grazie per l’Opzione 2. Mi sono imbattuto in problemi enormi con l’Opzione 1 perché avevo bisogno di leggere da stdin all’interno del ciclo; in tal caso l’Opzione 1 non funziona.
    • Si dovrebbe notare più chiaramente che l’Opzione 2 è fortemente sconsigliato. @masgo Opzione 1b dovrebbe funzionare in questo caso, e può essere combinato con il reindirizzamento dell’input sintassi, l’Opzione 1a sostituendo done < $filename con done 4<$filename (il che è utile se si desidera leggere il nome del file da un parametro di comando, nel qual caso si può semplicemente sostituire $filename da $1).
    • Ho bisogno di eseguire un ciclo di file contenuti come tail -n +2 myfile.txt | grep 'somepattern' | cut -f3, durante l’esecuzione di comandi ssh all’interno del ciclo (consuma stdin); opzione 2 qui sembra essere l’unico modo?
    • Opzione 2 sembra essere il migliore quando alcune azioni devono essere eseguite su un host remoto via SSH.

  4. 77

    Questo non è migliore di altre risposte, ma è più di un modo per ottenere il lavoro fatto in un file senza spazi (vedi commenti). Trovo che spesso necessitano di una fodere per scavare attraverso elenchi di file di testo senza la necessità di usare un file di script.

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

    Questo formato mi permette di mettere tutto in una riga di comando. Modificare il “echo $parola” parte di quello che si vuole e si può eseguire più comandi separati da punto e virgola. L’esempio seguente utilizza il contenuto del file come argomento in due altri script lei ha scritto.

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

    O se si intende utilizzare questo come un editor di flusso (per saperne di sed) è possibile scaricare l’output di un altro file come indicato di seguito.

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

    Ho usato questi come scritto sopra, perché ho usato il file di testo dove ho creato con una parola per riga. (Vedi commenti) Se si dispone di spazi che non vuoi spaccare le tue parole/righe, diventa un po ‘ più brutti, ma lo stesso comando funziona ancora come segue:

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

    Questo dice solo la shell a spalato a capo solo, e non gli spazi, quindi restituisce l’ambiente indietro a quello che era in precedenza. A questo punto, si potrebbe considerare di mettere tutto in uno script di shell, piuttosto che spremere tutto in una sola riga, però.

    In bocca al lupo!

    • Questo non soddisfa il requisito (scorrere ogni riga) se il file contiene spazi o tabulazioni, ma può essere utile se si desidera scorrere ogni campo in una scheda/spazio file separato.
    • Bash $(<peptides.txt è forse più elegante, ma è comunque sbagliato, quello che ha detto Joao corretto, è possibile eseguire la sostituzione di comando logica in cui lo spazio o newline è la stessa cosa. Se una riga è uno spazio, il ciclo viene eseguito due VOLTE o più per quella riga. Quindi il codice dovrebbe leggere correttamente: per parola in $(<peptides.txt); fare …. Se si sa per certo non ci sono spazi, quindi, una linea uguale a una parola e si sta bene.
    • Buoni punti che non avevo considerato. Ho modificato il post originale di riflettere. Grazie!
    • Utilizzando for rende l’ingresso gettoni/linee soggette a shell espansioni, che di solito è indesiderabile; provare questo: for l in $(echo '* b c'); do echo "[$l]"; done – come si vedrà, la * – anche se, originariamente, un citato letterale – restituisce il file nella directory corrente.
    • Non dimenticare di citare i tuoi usi di "$word" e "$line"
    • Joao e maxpolk, si sta affrontando il problema che sto avendo, ma sto ancora ricevendo un separato iterazione per ogni semestre di ogni riga con uno spazio: > gatto linkedin_OSInt.txt linkedin.com/vsearch/f?type=all&keywords=”pippo bar” linkedin.com/vsearch/f?type=all&parole chiave=”paperino bux” > per un url in $(<linkedin_OSInt.txt); do echo “$url”; fatto linkedin.com/vsearch/f?type=all&keywords=”pippo bar” linkedin.com/vsearch/f?type=all&parole chiave=”paperino bux” proverò gli altri approcci, ma vorrei capire perché questo non funziona.
    • L’ultimo esempio, l’utilizzo di $IFS, dovrebbe ignorare gli spazi. Hai provato quella versione?
    • si prega di notare per la modifica di gatto peptides.txt da trovare / . per il ciclo non si avvia prima di interni gatto finiture. tra questi passaggi è possibile overflow del buffer.
    • Il modo in cui questo comando si ottiene molto di più complesso come cruciale problemi sono risolti, si presenta molto bene perché utilizza for per scorrere righe del file è una cattiva idea. Inoltre, l’espansione aspetto citato da @mklement0 (anche se, probabilmente, può essere aggirata da portare in sfuggito citazioni, che a sua volta rende le cose più complesse e meno leggibile).
    • Questo è, in modo leggibile, l’unica risposta che legge anche l’ultima riga di un file, che è un pro.

  5. 64

    Un paio di cose in più non coperti da altre risposte:

    La lettura da un file delimitato

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

    Lettura dall’uscita di un altro comando, utilizzando il processo di sostituzione

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

    Questo approccio è migliore di command ... | while read -r line; do ... perché il ciclo while qui corre nella shell corrente, piuttosto che una subshell, come nel caso di questi ultimi. Vedi il post correlati Una variabile modificata all’interno di un ciclo while non viene ricordata.

    La lettura da un null delimitato da ingresso, per esempio 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)

    Relative leggere: BashFAQ/020 – Come posso trovare e gestire in modo sicuro i nomi di file contenenti caratteri, spazi o entrambi?

    Lettura da più di un file alla volta

    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

    Base @chepner s risposta qui:

    -u è un bash estensione. Per la compatibilità POSIX, ogni chiamata sarebbe simile read -r X <&3.

    La lettura di un intero file in un array (Bash versioni precedenti alla 4)

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

    Se il file termina con una linea incompleta (a capo mancante alla fine), quindi:

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

    La lettura di un intero file in un array (Bash versioni 4x e versioni successive)

    readarray -t my_array < my_file

    o

    mapfile -t my_array < my_file

    E poi

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

    Post correlati:

    • nota che invece di command < input_filename.txt si può sempre fare input_generating_command | command o command < <(input_generating_command)
  6. 45

    Utilizzare un ciclo while, come questo:

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

    Note:

    1. Se non si imposta il IFS correttamente, si perde l’indentazione.

    2. Si dovrebbe sempre usare l’opzione-r con la lettura.

    3. Non leggere le linee con per

    • Perché il -r opzione?
    • L’opzione-r impedisce la barra rovesciata interpretazione. Note #2 è un link dove è descritto in dettaglio…
    • Combinate questo con il “read-u” opzione in un’altra risposta e poi è perfetto.
    • L’esempio di cui sopra non necessita di -u opzione, stai parlando di un altro esempio con -u?
    • Guardò attraverso il tuo link, e fu sorpreso di sapere che c’e ‘ nessuna risposta che rimanda semplicemente il tuo link in Nota 2. La pagina fornisce tutto ciò che occorre sapere su questo argomento. O sono link-solo risposte scoraggiato o qualcosa del genere?
    • link solo risposte sono generalmente eliminati.
    • Ah. Va bene, mai suggerire un collegamento, solo rispondere di nuovo. Forse c’erano anche alcuni, non lo sapremo mai.

  7. 13

    Se non vuoi che la tua lettura sia rotto dal carattere di nuova riga, utilizzare –

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

    Quindi eseguire lo script con il nome del file come parametro.

  8. 13

    Si supponga di avere questo file:

    $ 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

    Ci sono quattro elementi che alterano il senso del file di output letto da molti Bash soluzioni:

    1. La riga vuota 4;
    2. Spazi iniziali o finali su due linee;
    3. Mantenendo il significato delle singole linee (cioè, ogni riga è un record);
    4. La linea 6 non è terminato con un CR.

    Se si desidera che il file di testo riga per riga tra le righe vuote e la terminazione delle linee senza CR, è necessario utilizzare un ciclo while e si deve avere una prova alternativa per il finale di riga.

    Qui sono i metodi che possono modificare il file (in confronto a quello che cat restituisce):

    1) Perdere l’ultima riga e gli spazi iniziali e finali:

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

    (Se si while IFS= read -r p; do printf "%s\n" "'$p'"; done </tmp/test.txt invece, si conservano gli spazi iniziali e finali, ma ancora perdere l’ultima riga se non è terminato con CR)

    2) Utilizzando il processo di sostituzione con cat si legge l’intero file in un sorso e si perde il significato delle singole linee:

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

    (Se si rimuove il " da $(cat /tmp/test.txt) il file viene letto parola per parola, piuttosto che un sol boccone. Anche probabilmente non è ciò che si intende…)


    Più robusto e più semplice modo per leggere un file riga per riga e preservare la spaziatura è:

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

    Se si desidera striscia di leader e spazi commerciali, rimuovere il 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 file di testo senza una terminazione \n, anche se è piuttosto comune, è considerata interrotta in POSIX. Se si può contare sul finale \n non è necessario || [[ -n $line ]] in while ciclo).

    Più al BASH FAQ

    • Mio chiedo perché i downvote?
  9. 4
    #!/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
    • Questa risposta deve le avvertenze indicate in mightypile la risposta, e può fallire male se ogni riga contiene i metacaratteri della shell (a causa della non quotate “$x”).
    • Sono davvero sorpreso la gente non ha ancora venire con il solito non leggere le linee con
  10. 3

    Qui è il mio esempio di vita reale come loop linee di un altro programma di uscita, controllare per le sottostringhe, eliminare le doppie virgolette da variabile, utilizzare tale variabile al di fuori del ciclo. Credo che molti si chiedono queste domande, prima o poi.

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

    Dichiarare la variabile al di fuori del ciclo, impostare il valore da utilizzare al di fuori del ciclo richiede fatto <<< “$(…)” sintassi. Applicazione devono essere eseguite all’interno di un contesto attuale di console. Virgolette il comando mantiene a capo del flusso in uscita.

    Loop partita per le sottostringhe legge nome=valore coppia, si divide a destra parte dell’ultimo = carattere, gocce prima citazione, gocce ultima citazione, si dispone di una copia di valore per essere utilizzato altrove.

    • Se la risposta è corretta, mi pare di capire come è andata a finire qui. Il metodo essenziale è la stessa proposta da molte altre risposte. Inoltre, è completamente annega nel vostro FPS esempio.
  11. 0

    Questo è piuttosto tardi, ma con il pensiero che potrebbe essere di aiuto a qualcuno, sto aggiungendo la risposta. Anche questo potrebbe non essere il modo migliore. head comando può essere utilizzato con -n argomento di leggere n linee dall’inizio del file e allo stesso modo tail comando può essere utilizzato per leggere dal basso. Ora, per recuperare ennesimo riga dal file, ci dirigiamo n linee, tubo di dati di coda solo 1 linea dai dati in pipe.

       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
  12. -1

    @Pietro: Questo potrebbe funzionare per voi-

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

    Restituirà l’uscita-

    Start!
    RKEKNVQ
    IPKKLLQK
    QYFHQLEKMNVK
    IPKKLLQK
    GDLSTALEVAIDCYEK
    QYFHQLEKMNVKIPENIYR
    RKEKNVQ
    VLAKHGKLQDAIN
    ILGFMK
    LEDVALQILL
    • Questo è molto male! Perché non leggere le righe con “per”.
    • Questa risposta è sconfiggere tutti i principi del buon risposte di cui sopra!
    • Si prega di cancellare questa risposta.
    • Ora ragazzi, non esageriamo. La risposta è male, ma sembra funzionare, almeno per semplici casi di utilizzo. Fintanto che la condizione, di essere una cattiva risposta non toglie la risposta del diritto di esistere.
    • Io non sono d’accordo: Il punto di risposte è quello di insegnare alla gente come scrivere software. Insegnare alle persone a fare le cose in un modo che è sa è dannoso per loro e le persone che utilizzano il loro software (introduzione di bug / comportamenti imprevisti / ecc) è consapevolmente del male agli altri. Una risposta nocivi per la salute non ha il “diritto di esistere” in un ben curato insegnamento di risorse (e la curatela è esattamente quello che abbiamo, le persone che sono per il voto e la segnalazione, dovrebbe fare qui).
    • la peggiore perdita di dati incidente sono stato personalmente testimone è stato causato da ops personale di fare qualcosa che “sembrava di lavoro” in uno script (utilizzando uno non quotate di espansione per un nome di file per essere eliminato — quando il nome è stato supposto per essere in grado di contenere solo cifre esadecimali). Ad eccezione di un bug in un altro pezzo di software scritto un nome casuale e contenuti, che aveva uno spazio circondato *, e di un enorme tesoro di fatturazione-backup dei dati è stato perso.
    • Questo sarà il lavoro, in alcuni casi, ma la soluzione proposta è tutt’altro che buono.

Lascia un commento