Bash Xargs comanda da maneira mais difícil pelo exemplo

Quando você apenas começa a aprender programação bash da maneira mais difícil, ninguém lhe fala sobre o comando xargs. Desde então, você conseguiu pegar xargs suficientes para sobreviver sem quebrar muito. Agora, você se pergunta - e todas as outras opções? Posso fazer isso? E se eu quiser .. ?

Agora você provavelmente já tem um entendimento bom o suficiente de como executar o comando no bash. Mas e se você quiser executar fluxos de comandos em sequência ou às vezes em paralelo? É onde nos encontramos usando xargs.

Aqui esperamos responder a todas estas questões e mais sobre bash e o comando xargs por exemplo.

O que é xargs em bash?

xargs é um comando externo usado para converter entrada padrão em argumentos de linha de comando que significa "argumentos estendidos.”Ele foi criado principalmente para uso com comandos não construídos para lidar com entrada canalizada ou entrada padrão, como rm, cp, echo ¹ e outros comandos externos aceitando apenas argumentos como parâmetros.

¹ Embora a maioria dos sistemas venha com um comando echo, echo é um bash embutido; Isto é, a menos que chame o comando echo, o eco embutido é usado. Da mesma forma, os builtins do bash não estão cientes da entrada canalizada.

Opções de Xargs com exemplos de bash

Vamos examinar o xargs e suas opções com exemplos em bash. Junto com o tratamento convencional para as opções de linha de comando esperadas com xargs, as opções são agrupadas por objetos, como obter informações ou modificar o comportamento.

Informação Xargs

Aqui estão as opções que fornecem informações sobre xargs.

Ajuda do Xargs

xargs --help
Uso: xargs [OPTION]… COMMAND [INITIAL-ARGS]…
Execute COMMAND com argumentos INITIAL-ARGS e mais argumentos lidos da entrada.
Argumentos obrigatórios e opcionais para opções longas também são
obrigatório ou opcional para a opção curta correspondente.
-0, - os itens nulos são separados por um nulo, não um espaço em branco;
desativa o processamento de cotação e barra invertida e
processamento EOF lógico
-a, --arg-file = FILE lê os argumentos de FILE, não a entrada padrão
-d, --delimiter = CHARACTER itens no fluxo de entrada são separados por CHARACTER,
não por espaço em branco; desativa aspas e barra invertida
processamento e processamento lógico EOF
-E END definir string lógica EOF; se END ocorre como uma linha
de entrada, o resto da entrada é ignorado
(ignorado se -0 ou -d foi especificado)
-e, --eof [= END] equivalente a -E END se END for especificado;
caso contrário, não há string de fim de arquivo
-I R igual a --replace = R
-i, --replace [= R] substitui R em INITIAL-ARGS por nomes lidos
da entrada padrão; se R não for especificado,
presumir
-L, --max-lines = MAX-LINES usam no máximo MAX-LINES linhas de entrada não em branco por
linha de comando
-l [MAX-LINES] semelhante a -L, mas o padrão é no máximo um não-
linha de entrada em branco se MAX-LINES não for especificado
-n, --max-args = MAX-ARGS usa no máximo argumentos MAX-ARGS por linha de comando
-P, --max-procs = MAX-PROCS executado na maioria dos processos MAX-PROCS por vez
-p, - prompt interativo antes de executar comandos
--process-slot-var = VAR definir variável de ambiente VAR em processos filho
-r, --no-run-if-empty se não houver argumentos, então não execute COMMAND;
se esta opção não for fornecida, COMMAND será
correr pelo menos uma vez
-s, --max-chars = MAX-CHARS limita o comprimento da linha de comando a MAX-CHARS
--show-limits mostram limites no comprimento da linha de comando
-t, --verbose imprimir comandos antes de executá-los
-x, --exit sai se o tamanho (veja -s) for excedido
--ajude a exibir esta ajuda e saia
--versão saída informação da versão e saída

Consulte a ajuda do xargs como uma referência rápida para o uso e opções do xargs.

Versão Xargs

xargs --version
xargs (GNU findutils) 4.6.0

Limites Xargs

Mesmo xargs tem seus limites. A opção -show-limits para xargs mostra os limites usados ​​por xargs antes de executar os comandos. Os limites reais dependem do seu ambiente. No entanto, para a maioria dos usuários, isso é o suficiente. Os limites podem ser ajustados na linha de comando, veja os exemplos.

Exemplo) Limites de xargs do seu ambiente

xargs --show-limits
Suas variáveis ​​de ambiente ocupam 6234 bytes
Limite superior POSIX no comprimento do argumento (este sistema): 23718
POSIX menor limite superior permitido no comprimento do argumento (todos os sistemas): 4096
Comprimento máximo do comando que podemos realmente usar: 17484
Tamanho do buffer de comando que estamos usando: 23718
Paralelismo máximo (--max-procs não deve ser maior): 2147483647

A execução do xargs continuará agora, e ele tentará ler sua entrada e executar comandos; se não era isso que você queria que acontecesse, digite a tecla de fim de arquivo.

Aviso: o echo será executado pelo menos uma vez.  Se você não quiser que isso aconteça, pressione a tecla de interrupção.

Observe que o comando que seria executado como consequência de xargs é echo, o comando padrão de xargs.

Exemplo) Limites de Xargs com um limite de buffer de comando ajustado

xargs --show-limits -s 1
Suas variáveis ​​de ambiente ocupam 9479 bytes
Limite superior POSIX no comprimento do argumento (este sistema): 20473
POSIX menor limite superior permitido no comprimento do argumento (todos os sistemas): 4096
Comprimento máximo do comando que podemos realmente usar: 10994
Tamanho do buffer de comando que estamos usando: 1
Paralelismo máximo (--max-procs não deve ser maior): 2147483647
…
Aviso: o echo será executado pelo menos uma vez.  Se você não quer que isso aconteça,
em seguida, pressione a tecla de interrupção.
xargs: não cabe um único argumento dentro do limite de tamanho da lista de argumentos

Observe que os erros aparecerão na parte inferior após os Avisos se houver. Temos um erro ”xargs: não é possível caber um único argumento no limite de tamanho da lista de argumentos”, o que significa apenas que estamos tentando trabalhar fora do tamanho do buffer de comando permitido, que é definido como um caracter.

O buffer de comando contém o comando seguido por todos os argumentos incluindo espaços.
No caso do comando neste exemplo de opção xargs, o buffer de comando é

"eco"

que contém 4 caracteres.
Portanto, precisamos definir o tamanho do buffer de comando para um valor maior ou igual a 5 da seguinte forma. Observe que o consumo do buffer de comando será igual a length_of_command + length_args_including_spaces_plus_one + 1.

xargs --show-limits -s 5

# Não mais "xargs: não cabe um único argumento dentro do limite de tamanho da lista de argumentos" erro

Mas e se nosso comando tiver args?

sim | xargs -t --show-limits -t -s 6 # será executado com a seguinte saída
echo y
…

Xargs verbose

lhs | xargs -t other_xargs_options_if_any | rhs

A opção -t pode ser usada para mostrar comandos executados por xargs como saída para fd2, erro padrão. Ou seja, xargs -t pode ser anulado redirecionando o erro padrão para / dev / null como segue.

xargs -t 2> / dev / null

Exemplo) Sim uma vez

sim | cabeça -n 5 | xargs -t true
true y y y y y

Exemplo) Sim 5 vezes

sim | cabeça -n 5 | xargs -t -I true
verdade y
verdade y
verdade y
verdade y
verdade y

Comportamento Xargs

Nenhum comando está completo sem opções para modificar o comportamento do tempo de execução. Xargs não é diferente. Aqui estão as opções que permitem que você altere seu comportamento.

Xargs null

lhs | xargs -0 other_xargs_options_if_any | rhs

A opção -0 pode ser usada para dizer ao xargs para usar nulo em vez de espaço em branco. Também desativa aspas e sequências de escape.

sim | cabeça -n 5 | sed "s /.* / cul- "de" - 'sac' / "| xargs -I echo -en" \ n \ x00 "
beco sem saída
beco sem saída
beco sem saída
beco sem saída
beco sem saída
sim | cabeça -n 5 | sed "s /.* / cul- "de" - 'sac' / "| xargs -0 -I echo -en" \ n \ x00 "
cul- "de" - 'sac'
cul- "de" - 'sac'
cul- "de" - 'sac'
cul- "de" - 'sac'
cul- "de" - 'sac'

Caso de uso nulo de Xargs

O pretendido usado para xargs null é para lidar com casos como quando os itens contêm espaços, como arquivos contendo espaços ou caracteres de nova linha.

Suponha que você tenha um diretório “a b c” incluindo espaços em um nome de diretório.

ls "a b c"
de / fg / h / 'i j k l' /

Você deseja executar um comando em cada diretório em “a b c” usando o comando find.

Você pode tentar o seguinte:

encontre "a b c" -tipo d | xargs du -d 0 -h
du: não é possível acessar 'a': Não existe esse arquivo ou diretório
du: não é possível acessar 'b': Não existe esse arquivo ou diretório
du: não é possível acessar 'c': Não existe esse arquivo ou diretório
du: não é possível acessar 'a': Não existe esse arquivo ou diretório
du: não é possível acessar 'b': Não existe esse arquivo ou diretório
du: não é possível acessar 'c / de': Não existe esse arquivo ou diretório
du: não é possível acessar 'a': Não existe esse arquivo ou diretório
du: não é possível acessar 'b': Não existe esse arquivo ou diretório
du: não é possível acessar 'c / fg': Não existe esse arquivo ou diretório
du: não é possível acessar 'a': Não existe esse arquivo ou diretório
du: não é possível acessar 'b': Não existe esse arquivo ou diretório
du: não é possível acessar 'c / h': Não existe esse arquivo ou diretório
du: não é possível acessar 'a': Não existe esse arquivo ou diretório
du: não é possível acessar 'b': Não existe esse arquivo ou diretório
du: não é possível acessar 'c / i': Não existe esse arquivo ou diretório
du: não é possível acessar 'j': Não existe esse arquivo ou diretório
du: não é possível acessar 'k': Não existe esse arquivo ou diretório
du: não é possível acessar 'l': Não existe esse arquivo ou diretório

Funciona incorretamente porque os nomes de nossos diretórios estão repletos de espaços. Esta não era sua intenção.

Você pode corrigir isso adicionando substituição de xargs, i.e -I como segue.

encontre "a b c" -tipo d | xargs -i du -d 0 -h
0 a b c
0 a b c / de
0 a b c / fg
0 a b c / h
0 a b c / i j k l

Funciona corretamente ao usar a substituição do xargs. Observe que usamos -i, que é uma abreviação de -I .

Outra maneira de obter o mesmo resultado é usando xargs null, -null, em combinação com a opção find -print0 da seguinte forma.

encontre "a b c" -tipo d -print0 | xargs --null -i du -d 0 -h
0 a b c
0 a b c / de
0 a b c / fg
0 a b c / h
0 a b c / i j k l

Excelente! Agora temos mais de uma maneira de penetrar profundamente no universo do sistema de arquivos sem ter que nos preocupar em colidir com lixo espacial em nossa jornada. Pode apostar.

Xargs interativo

Talvez você não confie no xargs para executar todos os comandos sem confirmação. Nesse caso, xargs interativo ou -p é a opção que você precisa para controlar quais comandos são executados por xargs como segue.

encontre "a b c" -tipo d -print0 | xargs --null -i -p du -d 0 -h
du -d 0 -h a b c ?…
du -d 0 -h a b c / de ?…
du -d 0 -h a b c / fg ?… Y
0 a b c / fg
du -d 0 -h a b c / h ?… Sim
0 a b c / h
du -d 0 -h a b c / i j k l ?… não

Aqui, qualquer comando que comece com 'y' ou 'Y' é executado. Caso contrário, os comandos são ignorados.

Arquivo Xargs

Você já tem um arquivo, arg-file, pronto para ser lido no xargs. Seu programa pode estar esperando em um diretório em algum lugar por outra pessoa ou outra instância sua para colocar em um arquivo arg. Neste caso, você pode especificar o arquivo como uma opção para xargs usando -a arg-file em vez de ter que usar cat file | xargs… exemplos de arquivo Xargs a seguir.

Apenas por diversão, vamos transformar suas rotinas de limpeza da área de trabalho em um arquivo arg que podemos usar.

ls cleanup-desktop | tee arg-file
190605_cleanup_desktop_files_sh.TXT
190605_cleanup_desktop_lnk_files_sh.TXT
190605_cleanup_desktop_un_files_sh.TXT

Cada arquivo contém uma rotina que pode ser executada usando o bash. Isso significa que o comando que usaremos é bash.

Vamos executar as rotinas de limpeza usando xargs.

xargs -a arg-arquivo -i -P 99 bash -c 'echo ; . cleanup-desktop / ; '
190605_cleanup_desktop_files_sh.TXT
190605_cleanup_desktop_lnk_files_sh.TXT
190605_cleanup_desktop_un_files_sh.TXT

E funciona!
Apenas no caso de precisarmos especificar um arquivo arg em vez de usar a entrada canalizada, a opção de arquivo xargs é útil.

Xargs substituir

lhs_if_any | xargs -i other_args_etc | rhs_if_any

Por último, mas não menos importante, xargs replace -i permite que você tenha controle total sobre o formato do comando antes de executá-lo. Qualquer caractere pode ser usado. No entanto, seguindo a convenção a maioria dos programadores de bash usa este ou este%. Observe que o padrão é . -i diz ao xargs que você usará o padrão. E é considerado taquigrafia. -Segui por um caractere de substituição de sua escolha que diz ao xargs qual caractere você usará. Evite usar caracteres comuns como a letra a. Isso quebrará seu código mais do que qualquer espaço ou nova linha já fez.

Paralelo de Xargs

lhs_if_any | xargs -P n_ge_1 other_args_etc | rhs_if_any

Xargs parallel -P permite que os comandos sejam executados simultaneamente em vez de em sequência. Consulte os limites de xargs -show-limits para argumentos válidos para n_ge_1 ou simultaneidade. Por exemplo, se

Paralelismo máximo (--max-procs não deve ser maior): 2147483647

Você pode definir -P 2147483647 sem erros. Na prática, você pode encontrar uma configuração mais agradável como -P 99 que melhora o desempenho geral sem aumentar a sobrecarga para gerenciar processos simultâneos.

Exemplos mostrando como o uso de xargs parallel pode melhorar o desempenho a seguir.

Exemplo) Contagem em sequência versus paralelo usando xargs

Vamos ver o que acontece quando contamos o tempo em sequência usando xargs.

eco de tempo 1… 1000 | xargs '-d' -i bash -c 'echo '
…
998
999
1000
real 1m13.927s
usuário 0m6.994s
sys 0m15.184s

Agora veja o que acontece se contarmos o tempo em paralelo usando xargs.

eco de tempo 1… 1000 | xargs -P 200 '-d' -i bash -c 'echo '
…
998
999
1000
real 0m13.554s
usuário 0m6.446s
sys 0m14.293s

Melhoria significativa no desempenho é observada usando xargs parallel para executar comandos simples sem recursos compartilhados.

Exemplo) Comparando a ordem e o tempo de xargs parallel

Vamos ver o que acontece quando um comando consome tempo de CPU.

eco de tempo 1… 10 | xargs '-d' -i bash -c 'sleep $ (($ RANDOM% 2)); echo '
1
2
3
4
5
6
7
8
9
10
0m5 real.Anos 601
usuário 0m0.180s
sys 0m0.334s

Observe que todos os comandos estão completos em ordem.

Agora veja o que acontece quando o mesmo comando é executado em paralelo.

eco de tempo 1… 10 | xargs -P 10 '-d' -i bash -c 'sleep $ (($ RANDOM% 2)); echo '
3
4
6
7
8
1
2
5
9
10
0m1 real.257s
usuário 0m0.060s
sys 0m0.225s
Os comandos 1, 2, 5 e 9 foram dormir. No entanto, fomos capazes de reduzir o
tempo para concluir em até 78 por cento.

Conclusão Paralela Xargs

A adição simples de xargs parallel como uma opção de linha de comando pode melhorar o desempenho dez vezes. No entanto, você deve proceder com cuidado ao usar procedimentos dependentes do pedido ou quando os comandos estão compartilhando recursos.

Delimitador Xargs

lhs_if_any | xargs '-dc' other_args_etc | rhs_if_any

Delimitador Xargs -d permite que você defina o separador de itens para qualquer caractere c da mesma forma que os caracteres delimitadores são definidos no comando cortar.

Por padrão, -dc é definido como espaço em branco criado pelo caractere de nova linha -d \ x0a.
Ao usar xargs null -0, -dc é definido como o caractere nulo -d \ x00.

Por exemplo, você pode definir o delimitador para o caractere de espaço, i.e. -dc é '-d' em uma linha de comando ou seu script bash.

Você pode definir o delimitador para o caractere de vírgula, i.e. -dc é '-d,'.

A opção do delimitador em xargs -d permite- lhe definir o separador de itens para qualquer caractere que desejar.

Exemplos de Bash xargs

Aqui cobrimos exemplos de uso do comando xargs no bash, incluindo exemplos de uso na linha de comando, bem como scripts.

Exemplos de comandos Bash xargs

Aqui, cobrimos os exemplos de uso de linha de comando do comando xargs no bash, incluindo o uso de exemplo com e sem entrada canalizada.

Exemplo) Faça sua própria entrada: divirta-se com xargs sem entrada

O que xargs faz sozinho em casa?

xargs
Ola tem alguem em casa?
…
(Ctrl-D)
Ola tem alguem em casa?…

Parece que recebemos nossa pergunta como resposta, mas parece ser apenas um eco.

Por que?

Como você deve ter lido sobre o que xargs é, ele converte entrada padrão em argumentos de linha de comando. Se nenhuma opção e argumento forem fornecidos, ele se comporta como um comando de eco ciente de pipe. Isso é:

xargs
Ola tem alguem em casa?
…
(Controle-D) 2

Produz a expressão de linha de comando echo equivalente implicitamente

echo Olá, tem alguém em casa?…
2 Em um script, heredoc pode ser usado da seguinte forma.
xargs << EOF
Ola tem alguem em casa?
…
EOF
echo Olá, tem alguém em casa?…

Exemplo) Use xargs como um marcador de posição para canais interativos

Usar xargs no lado esquerdo de um tubo é paradoxal⁴ então vamos rodar o bash no modo super restrito⁵.

⁴ Comandos com reconhecimento de tubulação não precisam de xargs. Comandos Pipe Unware não sabem sobre xargs

⁵ Modo restrito que redefine todas as linhas. Outras restrições podem ser adicionadas posteriormente.

xargs -I bash -cr ""
i = 1
echo $ i
echo olá!
Olá!
!!
bash: !!: comando não encontrado
i = 1; echo $ i
1
CD…
bash: linha 0: cd: restrito

Exemplo) Use xargs como um marcador de posição para argumentos interativos

De acordo com o HackerRank Developer Skills Report 2019³,  “Calculadoras são os novos jogos.”Mais desenvolvedores com menos de 38 anos estão promovendo calculadoras como seu primeiro projeto de codificação. ³ Insights com base em 71.281 desenvolvedores

Então, vamos construir uma calculadora usando xargs!

_ () ​​echo $ (("$ @")); # calculadora
enquanto :
Faz
_ $ (xargs)
feito
1 + 2 + 3 + 4
(Ctrl-D)
10
1 - 2 + 3 - 4 + 5
(Ctrl-D)
3
1 ** 2 + 2 ** 2
(Ctrl-D)
3
1+
2+
3+
4+
5
(Ctrl-D)
15

Exemplo) gerador de site estático

Suponha que você tenha alguns milhares de arquivos de texto simples que deseja usar para gerar um site estático e nenhum dos arquivos é denominado índice. Os nomes dos arquivos incluem caracteres ascii minúsculos e um hífen, se houver.

Aqui está a aparência de uma linha ou duas no terminal de uma máquina teórica executando o bash. A máquina terá outros comandos externos, incluindo findutils e pandoc. Você pode usar qualquer comando equivalente de sua escolha.

# estamos no diretório
# ver muitos arquivos

test -d "html" || mkdir -v $ _
achar . -mindepth 1 -maxdepth 1 -tipo f \
| xargs -P 6000 -i bash -c "echo ; cat | sed -e 's / $ / /' |
pandoc -thtml -o .html "

# vê o dobro de arquivos agora, incluindo arquivos html
# feito

Exemplos de script Bash xargs

Exemplo) Use xargs para gerar matrizes quadradas

Aqui está um script que criei para gerar matrizes quadradas usando xargs. Especificamente, ele tira vantagem do comportamento usando a opção -n e usa o comando seq para sequências de números a serem usadas em matrizes.

#!/ bin / bash
## matriz quadrada
## - gera matrizes quadradas
## versão 0.0.1 - inicial
###############################################################
matriz quadrada ajuda ()

gato << EOF
matriz quadrada
1 - pedido
EXEMPLOS
> matriz quadrada 1
1
> matriz quadrada 2
1 2
3 4
> matriz quadrada 3
1 2 3
4 5 6
7 8 9
EOF


matriz quadrada () ordem -i local; pedido = $ 1;
teste "$ order" || $ FUNCNAME -ajuda; Retorna ;
teste $ pedido -gt 0 || $ FUNCNAME -ajuda; Retorna ;
_ () ​​
seq $ (($ 1 ** 2)) | xargs -n $ 1

_ $ pedido

###############################################################
E se [ ! ]
então
verdadeiro
senão
saída 1 # args errados
fi
###############################################################
matriz quadrada $ @
###############################################################
## gerado por create-stub2.sh v0.1.2
## na Quarta, 29 de maio de 2019 13:44:06 +0900
## Vejo
###############################################################

Fonte: matriz quadrada.sh

Também incluí um programa de teste para mostrar o script em ação, gerando todas as matrizes quadradas de até 10 x 10.

#!/ bin / bash
## test-square-matrix
## - gera matrizes quadradas de até 10 x 10
## versão 0.0.1 - inicial
###############################################################
matriz quadrada de teste ()
teste -f "matriz quadrada.sh "
. $ _ 1> / dev / null
local eu
para i em 1… 10
Faz
echo "matriz quadrada ($ i)"
matriz quadrada $ i
feito

###############################################################
se [$ # -eq 0]
então
verdadeiro
senão
saída 1 # args errados
fi
###############################################################
matriz quadrada de teste
###############################################################
## gerado por create-stub2.sh v0.1.2
## na Quarta, 29 de maio de 2019 13:40:08 +0900
## Vejo
###############################################################

Fonte: matriz quadrada-teste.sh

Aqui está o que esperar:

matriz quadrada de teste bash.sh | cabeça
matriz quadrada (1)
1
matriz quadrada (2)
1 2
3 4
matriz quadrada (3)
1 2 3
4 5 6
7 8 9
…

Exercício: melhore a exibição no terminal aplicando preenchimento aos números

Quando tentamos gerar a matriz quadrada de ordem 10 por 10, obtemos a seguinte saída:

matriz quadrada bash.sh 10
1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60
61 62 63 64 65 66 67 68 69 70
71 72 73 74 75 76 77 78 79 80
81 82 83 84 85 86 87 88 89 90
91 92 93 94 95 96 97 98 99 100

Como um exercício, estenda a matriz quadrada.sh para permitir a saída da seguinte forma.

matriz quadrada bash.sh 10
001 002 003 004 005 006 007 008 009 010
011 012 013 014 015 016 017 018 019 020
021 022 023 024 025 026 027 028 029 030
031 032 033 034 035 036 037 038 039 040
041 042 043 044 045 046 047 048 049 050
051 052 053 054 055 056 057 058 059 060
061 062 063 064 065 066 067 068 069 070
071 072 073 074 075 076 077 078 079 080
081 082 083 084 085 086 087 088 089 090
091 092 093 094 095 096 097 098 099 100

Exemplos de uso prático do Bash xargs

Exemplo) Pesquisar arquivos para um padrão usando xargs grep

lista-arquivos¹ | padrão xargs grep -e

¹ list-files é um comando que retorna caminhos candidatos para o arquivo a serem tomados como entrada para o grep através do comando xargs

Como um exemplo de uso prático de xargs em bash, desenterrei xargs de uma base de código secreta.

find -type f -name \ *.sh | wc -l
994

Existem 994 scripts bash. Vamos ver quantos comandos xargs.

find -type f -name \ *.sh | xargs grep -e xargs lista todas as ocorrências
de xargs na base de código.
…
find -type f -name \ *.sh | xargs grep -e xargs | wc -l
18

Existem 18 correspondências para xargs na base de código. Agora podemos querer descobrir quantos scripts usam xargs.

find -type f -name \ *.sh | xargs grep | corte '-d:' '-f1' | sort |
uniq lista os scripts usando xargs.
…
find -type f -name \ *.sh | xargs grep -e xargs | corte '-d:' '-f1' |
sort | uniq | wc -l
10

Excelente! Existem 10 scripts com xargs na base de código. Vamos ver o que são.

find -type f -name \ *.sh | xargs grep -e xargs | corte '-d:' '-f1' | sort | uniq
vim $ ( !! )

Resumo das Constatações

• • Pesquise e destrua arquivos que contenham um padrão no nome do arquivo

find $ path -tipo f -nome \ * $ pattern \ * | xargs rm -vf

• • Listar informações sobre arquivos em lhs de tubo

localizar arquivos | xargs ls -al

• • Tornar os arquivos executáveis

localizar arquivos | xargs chmod + x

• • Listar nomes de diretórios de arquivos

localizar arquivos | xargs -I dirname ""

• • Purgar tudo

caminhos para purgar | xargs rm -rvf

• • Arquivos zip

localizar arquivos para compactar | xargs -I arquivo - $ (data +% s)

• • Listar nomes de arquivo de base

localizar arquivos | xargs -I nome de base

Exemplo) Instale o software de uma lista usando apt-get no Ubuntu

Ao atualizar o Ubuntu, após fazer o backup do seu sistema, você pode ter que instalar um novo software. Suponha que você tenha uma lista de software para instalar usando apt-get no Ubuntu.

sudo dpkg --get-selections | grep '[[: space:]] install $' |
\ awk 'print $ 1'> install_software
#…
cat install_software | xargs sudo apt-get install

Exemplo) Curl seige usando xargs em bash

Suponha que você tenha um monte de urls levando a um único nó em algum lugar na internet e você gostaria de criar um cerco usando curl em bash. De preferência, este é um de seus nós e o cerco não está em seu ambiente de produção. Aqui está como colocamos cerco usando xargs em bash.

#declare -f filter
filtro ()

grep -o -e 'loc [^<]*' | cut '-d>'' -f2 '

get-arg-file ()

curl https: // linuxhint.com / sitemap.xml --silent \
| filtro \
| xargs -i curl --silent \
| filtro \
| xargs -i echo > arquivo arg

#declare -f curl
ondulação ()

echo (falso) $ FUNCNAME "$ @"

declarar -xf curl
carga útil ()

test -f "arg-file" || Retorna
xargs -P 1000 -a arg-file -i echo curl | bash 1> / dev / null

cerco ()

test -f "arg-file" || obter - $ _
carga útil

cerco

Depuração do Bash xargs

Quando você se senta na frente do terminal, você é o chefe. No entanto, quando algo dá errado, ajuda se você souber como depurar scripts bash como um chefe.

Jogando pelo seguro, ter um método para validar o sucesso ao usar xargs no bash em vez de esperar cegamente que tudo ficará bem é altamente recomendado. Ou seja, você deve se certificar de que todos os comandos completos com sucesso e falha não sejam deixados desmarcados.

Métodos

• Tamanho da saída de erro padrão
  Se o erro padrão contiver 1 ou mais caracteres, algo deu errado
• Soma dos códigos de saída de comando
  Se a soma dos códigos de saída for maior que 0, algo deu errado
• Validação de carga útil
  Se uma parte da carga útil estiver faltando, algo deu errado
• Fim da validação do script
• Executando comandos xargs como um script, se o fim do script não for alcançado, algo deu errado. Observe que errexit está definido e os comandos são executados de dentro de uma função.
• Outro método
  Se o resultado for diferente do esperado, algo pode ter dado errado

Exemplo) Depurando xargs usando o tamanho da saída de erro padrão

Aqui está uma função anônima que testamos na depuração de xargs usando o erro stardart.

# declara -f _, i.e. Eu não escrevi o código abaixo
# se você achar que está um pouco enferrujado, declare que escrevi outro tutorial sobre
#
como o comando declare funciona no bash
_ ()

rm -vf errout;
toque em $ _;
echo 1… 10 | xargs -x -P 10 '-d' -i bash -c "teste $ (($ RANDOM% $ 1)) -eq 0 ||
echo 1> & 2; saída ; ; echo "2> errout;
teste ! $ (wc < errout -c ) -gt 0 || echo something went wrong…

## teste
_ 1 # probabilidade de falha (= 1-1 / 1 = 0%)
_ 2 # probabilidade de falha (= 1-1 / 2 = 1/2 = 50%)
_ 3 # probabilidade de falha (= 1-1 / 3 = 2/3 = 60%)
…

Se você não usar o erro padrão para mais nada usar o tamanho do erro padrão para depurar xargs é um método que pode funcionar para você.

Funções Bash xargs

Às vezes, o que você deseja fazer é usar funções que você definiu em xargs. Para fazer isso, precisamos disponibilizar a função para xargs. Aqui está como.

#declare -f _
_ ()

echo $ @ ^^

echo a… z 1… 9 | xargs '-d' -i bash -c "_ "
bash: _: comando não encontrado
…
declare -xf _
echo a… z 1… 9 | xargs '-d' -i bash -c "_ "
A1
A2
A3
…
# ou
echo a… z 1… 9 | xargs '-d' -i echo "_ " | bash
…
Z7
Z8
Z9

Observe que o exemplo de sessão interativa acima pode ser acelerado usando bash xargs parallel.

Conclusão

Xargs é um dos muitos comandos externos que é melhor você saber no bash. Ao escrever este guia sobre o comando xargs, aprendi algumas opções extras sozinho. Recomenda-se revisar de vez em quando. Só então você será capaz de usar xargs em seu verdadeiro potencial. Até então, codifique.