Na przykład, teraz używam poniższego, aby zmienić kilka plików, których ścieżki uniksowe napisałem do pliku:

cat file.txt | while read in; do chmod 755 "$in"; done

Czy jest bardziej elegancki i bezpieczniejszy sposób?

Przeczytaj plik wiersz po wierszu i wykonaj polecenia: 4 odpowiedzi

Dzieje się tak, ponieważ nie ma tylko jednej odpowiedzi ...

1. shell rozwinięcie wiersza poleceń
2. xargs dedykowane narzędzie
3. while read z kilkoma uwagami
4. while read -uużycie dedykowanego fd, interaktywnego przetwarzania (przykład)

Odnośnie żądania OP: działającym chmodna wszystkich celach wymienionych w pliku , xargsjest wskazanym narzędziem. Ale w przypadku niektórych innych aplikacji, niewielkiej liczby plików itp.

1. Czytaj cały plik jako argument wiersza poleceń.

   Jeśli twój plik nie jest zbyt duży i wszystkie pliki są dobrze nazwane (bez spacji lub innych znaków specjalnych, takich jak cudzysłowy), możesz użyć shellrozwinięcia wiersza poleceń . Po prostu:

   chmod 755 $(<file.txt)

   W przypadku małej liczby plików (linii) to polecenie jest lżejsze.

2. xargs to właściwe narzędzie

   W przypadku większej liczby plików lub prawie dowolnej liczby wierszy w pliku wejściowym ...

   Dla wielu Binutilsw narzędzi, takich jak chown, chmod, rm, cp -t...

   xargs chmod 755 <file.txt

   Jeśli masz specjalne znaki i / lub dużo linii w file.txt.

   xargs -0 chmod 755 < <(tr \\n \\0 <file.txt)

   jeśli twoje polecenie musi zostać uruchomione dokładnie 1 raz przez wpis:

   xargs -0 -n 1 chmod 755 < <(tr \\n \\0 <file.txt)

   Nie jest to potrzebne w tym przykładzie, ponieważ chmodakceptujemy wiele plików jako argument, ale pasuje to do tytułu pytania.

   W niektórych przypadkach możesz nawet zdefiniować lokalizację argumentu plikowego w poleceniach generowanych przez xargs:

   xargs -0 -I '{}' -n 1 myWrapper -arg1 -file='{}' wrapCmd < <(tr \\n \\0 <file.txt)

   Testuj seq 1 5jako dane wejściowe

   Spróbuj tego:

   xargs -n 1 -I{} echo Blah {} blabla {}.. < <(seq 1 5)
   Blah 1 blabla 1..
   Blah 2 blabla 2..
   Blah 3 blabla 3..
   Blah 4 blabla 4..
   Blah 5 blabla 5..
   

   Gdzie polecenie jest wykonywane raz w wierszu .

3. while read i warianty.

   Zgodnie z sugestią OP cat file.txt | while read in; do chmod 755 "$in"; donezadziała, ale są 2 problemy:

   • cat |jest bezużytecznym widelcem i

   • | while ... ;donestanie się podpowłoką, po której środowisko zniknie ;done.

   Więc można to lepiej napisać:

   while read in; do chmod 755 "$in"; done < file.txt

   Ale,

   • Możesz zostać ostrzeżony $IFSi readflagi:

     help read

     read: read [-r] ... [-d delim] ... [name ...]
         ...
         Reads a single line from the standard input... The line is split
         into fields as with word splitting, and the first word is assigned
         to the first NAME, the second word to the second NAME, and so on...
         Only the characters found in $IFS are recognized as word delimiters.
         ...
         Options:
           ...
           -d delim   continue until the first character of DELIM is read, 
                      rather than newline
           ...
           -r do not allow backslashes to escape any characters
         ...
         Exit Status:
         The return code is zero, unless end-of-file is encountered...
     

     W niektórych przypadkach może być konieczne użycie

     while IFS= read -r in;do chmod 755 "$in";done <file.txt

     Aby uniknąć problemów z obcymi nazwami plików. A może jeśli napotkasz problemy z UTF-8:

     while LANG=C IFS= read -r in ; do chmod 755 "$in";done <file.txt

   • Kiedy używasz STDINdo czytania file.txt, twój skrypt nie może być interaktywny (nie możesz STDINjuż go używać ).

4. while read -u, używając dedykowanego fd.

   Składnia: while read ...;done <file.txtprzekieruje STDINdo file.txt. Oznacza to, że nie będziesz w stanie poradzić sobie z procesem, dopóki nie zakończą.

   Jeśli planujesz stworzyć narzędzie interaktywne , musisz unikać używania STDINalternatywnego deskryptora pliku i używać go .

   Deskryptory plików stałych to: 0dla STDIN , 1dla STDOUT i 2dla STDERR . Możesz je zobaczyć poprzez:

   ls -l /dev/fd/

   lub

   ls -l /proc/self/fd/

   Stamtąd musisz wybrać nieużywany numer, od 0do 63(więcej, w rzeczywistości, w zależności od sysctlnarzędzia superużytkownika) jako deskryptor pliku :

   W tym demo użyję fd 7 :

   exec 7<file.txt      # Without spaces between `7` and `<`!
   ls -l /dev/fd/
   

   Wtedy możesz użyć w read -u 7ten sposób:

   while read -u 7 filename;do
       ans=;while [ -z "$ans" ];do
           read -p "Process file '$filename' (y/n)? " -sn1 foo
           [ "$foo" ]&& [ -z "${foo/[yn]}" ]&& ans=$foo || echo '??'
       done
       if [ "$ans" = "y" ] ;then
           echo Yes
           echo "Processing '$filename'."
       else
           echo No
       fi
   done 7<file.txt
   

   done

   Aby zamknąć fd/7:

   exec 7<&-            # This will close file descriptor 7.
   ls -l /dev/fd/
   

   Uwaga: zezwalam na przekreśloną wersję, ponieważ ta składnia może być przydatna podczas wykonywania wielu operacji we / wy z procesem równoległym:

   mkfifo sshfifo
   exec 7> >(ssh -t user@host sh >sshfifo)
   exec 6<sshfifo
   

Tak.

while read in; do chmod 755 "$in"; done < file.txt

W ten sposób możesz uniknąć catprocesu.

catjest prawie zawsze złe w takim celu jak ten. Możesz przeczytać więcej o bezużytecznym użyciu Cat.

jeśli masz fajny selektor (na przykład wszystkie pliki .txt w katalogu), możesz zrobić:

for i in *.txt; do chmod 755 "$i"; done

bash for loop

lub Twój wariant:

while read line; do chmod 755 "$line"; done <file.txt

Jeśli wiesz, że nie masz żadnych białych znaków na wejściu:

xargs chmod 755 < file.txt

Jeśli w ścieżkach mogą znajdować się spacje i jeśli masz GNU xargs:

tr '\n' '\0' < file.txt | xargs -0 chmod 755

Jeśli chcesz uruchomić swoje polecenie równolegle dla każdej linii, możesz użyć GNU Parallel

parallel -a <your file> <program>

Każda linia twojego pliku zostanie przekazana do programu jako argument. Domyślnie paralleluruchamia tyle wątków, ile liczy Twoje procesory. Ale możesz to określić za pomocą-j

Widzę, że oznaczyłeś bash, ale Perl byłby również dobrym sposobem, aby to zrobić:

perl -p -e '`chmod 755 $_`' file.txt

Możesz również zastosować wyrażenie regularne, aby upewnić się, że otrzymujesz właściwe pliki, np. Aby przetwarzać tylko pliki .txt:

perl -p -e 'if(/\.txt$/) `chmod 755 $_`' file.txt

Aby „wyświetlić podgląd” tego, co się dzieje, wystarczy zamienić lewe apostrofy na podwójne cudzysłowy i dodać przed print:

perl -p -e 'if(/\.txt$/) print "chmod 755 $_"' file.txt

Możesz także użyć AWK, który daje większą elastyczność w obsłudze pliku

awk '{ print "chmod 755 "$0"" | "/bin/sh"}' file.txt

jeśli twój plik ma separator pól, taki jak:

pole1, pole2, pole3

Aby uzyskać tylko pierwsze pole, które robisz

awk -F, '{ print "chmod 755 "$1"" | "/bin/sh"}' file.txt

Więcej szczegółów można znaleźć w dokumentacji GNU https://www.gnu.org/software/gawk/manual/html_node/Very-Simple.html#Very-Simple

Logika odnosi się do wielu innych celów. A jak czytać .sh_history każdego użytkownika z / home / filesystem? A jeśli jest ich tysiąc?

#!/bin/ksh
last |head -10|awk '{print $1}'|
 while IFS= read -r line
 do
su - "$line" -c 'tail .sh_history'
 done

Oto skrypt https://github.com/imvieira/SysAdmin_DevOps_Scripts/blob/master/get_and_run.sh

Wiem, że jest późno, ale nadal

Jeśli przez przypadek napotkasz plik tekstowy zapisany w systemie Windows z \r\nzamiast \n, możesz się zdezorientować, jeśli twoja komenda ma sth po przeczytanej linii jako argument. Usuń więc \rna przykład:

cat file | tr -d '\r' | xargs -L 1 -i echo do_sth_with_{}_as_line