Erro muito longo na lista de argumentos para comandos rm, cp, mv

629

Eu tenho várias centenas de PDFs em um diretório no UNIX. Os nomes dos PDFs são realmente longos (aprox. 60 caracteres).

Quando tento excluir todos os PDFs juntos, usando o seguinte comando:

rm -f *.pdf

Estou tendo o erro a seguir:

/bin/rm: cannot execute [Argument list too long]

Qual é a solução para esse erro? Este erro ocorre para mve cpcomandos também? Se sim, como resolver esses comandos?

Vicky
fonte
21
Você pode achar este link útil
another.anon.coward
1
Também isso pode ser relevante http://mywiki.wooledge.org/BashFAQ/095
Lorenzo Belli
4
@jww: E continuei pensando por tantos anos que o bash se enquadra nas "ferramentas de software comumente usadas pelos programadores" - uma categoria cujas perguntas podem ser feitas aqui!
Vicky
@ Nik - Adicionando "... em um script" não é atraente. Quando o problema é reduzido a um exemplo Mínimo, Completo e Verificável , é apenas uma questão de como executar um comando. Peço desculpas se estou perdendo algo óbvio.
JWW

Respostas:

876

Isso ocorre porque o bash realmente expande o asterisco para todos os arquivos correspondentes, produzindo uma linha de comando muito longa.

Tente o seguinte:

find . -name "*.pdf" -print0 | xargs -0 rm

Aviso: esta é uma pesquisa recursiva e também encontrará (e excluir) arquivos em subdiretórios. Prenda -fo comando rm apenas se tiver certeza de que não deseja confirmação.

Você pode fazer o seguinte para tornar o comando não recursivo:

find . -maxdepth 1 -name "*.pdf" -print0 | xargs -0 rm

Outra opção é usar o -deletesinalizador de localização:

find . -name "*.pdf" -delete
DPlusV
fonte
7
Não, xargsdivide especificamente a lista e emite vários comandos, se necessário.
Tripleee
7
@ Dennis: -maxdepth 1precisa ser o primeiro argumento após o caminho.
Barton Chittenden
54
O Find tem um -deletesinalizador para excluir os arquivos que encontra e, mesmo que não o fizesse, ainda seria considerado uma melhor prática usar -execpara executar rm, em vez de invocar o xargs (que agora é de 3 processos e um canal em vez de um único processo com -deleteou 2 processos com -exec).
scragar
3
@ ÉdouardLopez ... Mas isso é leitura de entrada delimitada por NULL. E o todo dangerous (broken, exploitable, etc.), é bastante ridículo. Sem dúvida, você deve ter cuidado ao usar xargs, mas não é bem assim eval/evil.
Reinstate Monica Please
4
@scragar Com a -execchamada rm, o número de processos será 1 + número de arquivos, embora o número de processos simultâneos disso possa ser 2 (talvez o achado execute os processos rm simultaneamente). O número de processos usando xargsseria reduzido drasticamente para 2 + n, onde n é um número que processa menos que o número de arquivos (por exemplo, número de arquivos / 10, embora provavelmente mais dependendo do tamanho dos caminhos). Supondo que find faça a exclusão diretamente, use -deletedeve ser o único processo que seria invocado.
Neuralmer
397

tl; dr

É uma limitação do kernel no tamanho do argumento da linha de comando. Use um forloop em seu lugar.

Origem do problema

Este é um problema do sistema, relacionado execvee ARG_MAXconstante. Há muita documentação sobre isso (veja man execve , wiki do debian ).

Basicamente, a expansão produz um comando (com seus parâmetros) que excede o ARG_MAXlimite. No kernel 2.6.23, o limite foi definido em 128 kB. Essa constante foi aumentada e você pode obter seu valor executando:

getconf ARG_MAX
# 2097152 # on 3.5.0-40-generic

Solução: Usando forLoop

Use um forloop conforme recomendado no BashFAQ / 095 e não há limite, exceto para RAM / espaço de memória:

Execução a seco para verificar se ele excluirá o que você espera:

for f in *.pdf; do echo rm "$f"; done

E execute:

for f in *.pdf; do rm "$f"; done

Além disso, esta é uma abordagem portátil, pois a glob possui um comportamento forte e consistente entre os shells ( parte das especificações do POSIX ).

Nota: Como observado por vários comentários, isso é realmente mais lento, mas mais sustentável, pois pode adaptar cenários mais complexos, por exemplo , onde se deseja fazer mais do que apenas uma ação.

Solução: Usando find

Se você insiste, pode usar, findmas realmente não usa xargs , pois "é perigoso (quebrado, explorável etc.) ao ler entradas não delimitadas por NUL" :

find . -maxdepth 1 -name '*.pdf' -delete 

Usar em -maxdepth 1 ... -deletevez de -exec rm {} +permite findsimplesmente executar as chamadas necessárias do sistema sem usar um processo externo, portanto, mais rápido (graças ao comentário do @chepner ).

Referências

Édouard Lopez
fonte
31
Ótima resposta, é assim que todas as perguntas do SO devem ser respondidas. Obrigado!
Tommed 9/04
1
+1 por mencionar o forloop. Eu já usei findantes, mas estou sempre procurando saber como fazê-lo, pois esqueço as opções etc. o tempo todo. forParece mais fácil IMHO recordação
Robert Dundon
3
for f in *; do rm "$f"; done
Usei
3
A find -execsolução parece ser MUITO mais rápida que o forloop.
Threeve 19/0318
2
Cinco anos mais tarde, em 4.15.0 ( 4.15.0-1019-gcppara ser exato) eo limite ainda está em 2097152. Curiosamente, procurando ARG_MAX no linux git repo dá um resultado mostrando ARG_MAX estar em 131702.
Matt M.
181

findtem uma -deleteação:

find . -maxdepth 1 -name '*.pdf' -delete
ThiefMaster
fonte
4
Isso ainda retornaria "Lista de argumentos muito longa". Pelo menos para mim, sim. O uso xargs, conforme a resposta de Dennis, funciona como pretendido.
Sergio
7
Isso soa como um bug na busca.
ThiefMaster
3
O @Sergio teve o mesmo problema, foi causado pelas aspas ausentes ao redor do padrão de nome.
Luxian
argh, por que uma ferramenta para encontrar coisas tem uma opção para excluir? sou realmente eu quem acha desnecessário dizer o mínimo e também perigoso.
mathreadler
2
@mathreadler Ele aborda o fato de que um caso de uso comum -execé remover um monte de arquivos. -exec rm {} +faria a mesma coisa, mas ainda requer iniciar pelo menos um processo externo. -deletepermite findsimplesmente executar as chamadas de sistema necessárias sem usar um invólucro externo.
Chepner
21

Outra resposta é forçar o xargsprocessamento dos comandos em lotes. Por exemplo, para deleteos arquivos de 100cada vez, cdno diretório e execute:

echo *.pdf | xargs -n 100 rm

portforwardpodcast
fonte
4
Para excluir comandos no linux, o que pode ser um desastre se você é um engenheiro e digitou um erro, acredito que seja o 'mais seguro e sei o que está acontecendo' é o melhor. Coisas estranhas que, se você digitar um ponto, deixarão sua empresa cair em um minuto.
ArtificiallyIntelligence
1
Como podemos fazer disso a expansão padrão para certos comandos? Há um bom número de comandos "padrão" do Linux, onde é conhecido se eles precisam de tudo de uma vez ou não (como "rm")
user1212212
1
Observe que isso só funciona onde echoestá um shell embutido. Se você acabar usando o comando echo, continuará executando o limite de argumentos do programa.
precisa
14

Ou você pode tentar:

find . -name '*.pdf' -exec rm -f {} \;
Jon Lin
fonte
Isso exclui arquivos de subdiretórios também. Como evitar isso?
Vicky
@NikunjChauhan Add -maxdepth option:find . -maxdepth 1 -name '*.pdf' -exec rm -f {} \;
Jon Lin
Não consigo inserir a opção maxdepth
Vicky
Essa opção pode ser uma opção apenas para Linux, conforme a resposta de @ Dennis, acima (a resposta selecionada).
jvriesem
12

Se você estiver tentando excluir um número muito grande de arquivos ao mesmo tempo (eu excluí um diretório com mais de 485.000 hoje), provavelmente você encontrará esse erro:

/bin/rm: Argument list too long.

O problema é que, quando você digita algo como rm -rf *, o *é substituído por uma lista de todos os arquivos correspondentes, como “rm -rf arquivo1 arquivo2 arquivo3 arquivo4” e assim por diante. Há um buffer de memória relativamente pequeno alocado para armazenar esta lista de argumentos e, se estiver cheia, o shell não executará o programa.

Para contornar esse problema, muitas pessoas usarão o comando find para encontrar todos os arquivos e passá-los um a um para o comando “rm” como este:

find . -type f -exec rm -v {} \;

Meu problema é que eu precisava excluir 500.000 arquivos e estava demorando muito.

Eu me deparei com uma maneira muito mais rápida de excluir arquivos - o comando “find” tem uma bandeira “-delete” embutida! Aqui está o que eu acabei usando:

find . -type f -delete

Usando esse método, eu estava excluindo arquivos a uma taxa de cerca de 2000 arquivos / segundo - muito mais rápido!

Você também pode mostrar os nomes dos arquivos ao excluí-los:

find . -type f -print -delete

… Ou até mostrar quantos arquivos serão excluídos e tempo quanto tempo leva para excluí-los:

root@devel# ls -1 | wc -l && time find . -type f -delete
100000
real    0m3.660s
user    0m0.036s
sys     0m0.552s
Bibin Joseph
fonte
Obrigado. Eu fiz sudo find . -type f -deletepara excluir cerca de 485 mil arquivos e funcionou para mim. Demorou cerca de 20 segundos.
Nigel Alderton
11

você pode tentar isso:

for f in *.pdf
do
  rm $f
done

EDIT: O comentário do ThiefMaster sugere que eu não divulgue essa prática perigosa aos jedis do jovem shell, então adicionarei uma versão mais "segura" (para preservar as coisas quando alguém tem um arquivo "-rf. ..Pdf")

echo "# Whooooo" > /tmp/dummy.sh
for f in '*.pdf'
do
   echo "rm -i $f" >> /tmp/dummy.sh
done

Após executar o procedimento acima, basta abrir o arquivo /tmp/dummy.sh no seu favorito. editor e verifique se há nomes de arquivos perigosos em todas as linhas, comentando-os, se encontrados.

Em seguida, copie o script dummy.sh no seu diretório de trabalho e execute-o.

Tudo isso por razões de segurança.

BigMike
fonte
5
Eu acho que isso faria as coisas realmente agradáveis com um arquivo chamado por exemplo-rf .. .pdf
ThiefMaster
sim, mas geralmente quando usado no shell, o emissor do comando "deve" dar uma olhada no que está fazendo :). Na verdade, prefiro redirecionar para um arquivo e inspecionar todas as linhas.
BigMike
2
Isso não cita "$ f". Era sobre isso que o ThiefMaster estava falando. -rftem precedência -i, portanto, sua segunda versão não é melhor (sem inspeção manual). E é basicamente inútil para exclusão em massa, devido à solicitação de cada arquivo.
Peter Cordes
7

Você pode usar uma matriz bash:

files=(*.pdf)
for((I=0;I<${#files[@]};I+=1000)); do
    rm -f "${files[@]:I:1000}"
done

Dessa forma, ele será apagado em lotes de 1000 arquivos por etapa.

danjperron
fonte
2
Para um grande número de arquivos isso parece significativamente mais rápido
James Tocknell
5

você pode usar esse elogio

find -name "*.pdf"  -delete
Sarath Ak
fonte
4

O comando rm possui uma limitação de arquivos que você pode remover simultaneamente.

Uma possibilidade é removê-los usando várias vezes o comando rm com base em seus padrões de arquivo, como:

rm -f A*.pdf
rm -f B*.pdf
rm -f C*.pdf
...
rm -f *.pdf

Você também pode removê-los através do comando find :

find . -name "*.pdf" -exec rm {} \;
Fabio Farath
fonte
3
Não, rmnão existe esse limite no número de arquivos que ele processará (exceto que argcnão pode ser maior que INT_MAX). É a limitação do kernel no tamanho máximo de toda a matriz de argumentos (é por isso que o tamanho dos nomes dos arquivos é significativo).
Toby Speight
3

Se forem nomes de arquivos com espaços ou caracteres especiais, use:

find -maxdepth 1 -name '*.pdf' -exec rm "{}" \;

Essa frase pesquisa todos os arquivos no diretório atual (-maxdepth 1) com a extensão pdf (-name '* .pdf') e, em seguida, exclua cada um (-exec rm "{}").

A expressão {} substitui o nome do arquivo e "{}" define o nome do arquivo como string, incluindo espaços ou caracteres especiais.

Alejandro Salamanca Mazuelo
fonte
Embora esse trecho de código possa resolver a questão, incluindo uma explicação de como e por que isso resolve o problema realmente ajudaria a melhorar a qualidade da sua postagem. Lembre-se de que você está respondendo à pergunta dos leitores no futuro, não apenas à pessoa que está perguntando agora! Por favor edite sua resposta para adicionar explicação, e dar uma indicação do que limitações e premissas se aplicam.
Toby Speight
O ponto principal -execé que você não invoca um shell. As citações aqui não fazem absolutamente nada útil. (Eles evitar qualquer expansão curinga e divisão simbólica na corda no shell onde você digita este comando, mas a corda {}não contém qualquer espaço em branco ou desembolsar caracteres curinga.)
tripleee
2

eu estava enfrentando o mesmo problema ao copiar o diretório de origem do formulário para o destino

diretório de origem tinha arquivos ~ 3 lakcs

usei cp com a opção -r e funcionou para mim

cp -r abc / def /

ele copiará todos os arquivos do abc para o def sem avisar por muito tempo a lista de argumentos

user3405020
fonte
Não sei por que alguém votou contra isso, sem sequer comentar sobre isso (isso é política, pessoal!). Eu precisava excluir todos os arquivos dentro de uma pasta (a questão não é específica sobre PDFs, lembre-se) e, para isso, esse truque está funcionando bem; tudo o que precisamos fazer no final é recriar a pasta que foi excluída quando Eu usei `rm -R / path / to / folder".
Thomas Tempelmann
1
Funciona porque, no caso do OP, ele estava usando *, que se expandiu para uma enorme lista de .pdf, fornecer um diretório fará com que isso seja tratado internamente, portanto, sem ter que lidar com o problema do OP. Eu acho que foi votado por esse motivo. Pode não ser utilizável para OP se ele tem diretório aninhado ou outros arquivos (não pdf) em seu diretório
Alvein
2

Tente isso também Se você quiser excluir arquivos / pastas acima de 30/90 dias (+) ou abaixo de 30/90 (-) dias, use os comandos ex abaixo

Ex: para 90 dias exclui acima após 90 dias, arquivos / pastas são excluídos, significa 91,92 .... 100 dias

find <path> -type f -mtime +90 -exec rm -rf {} \;

Ex: Apenas para os arquivos mais recentes de 30 dias que você deseja excluir, use o comando abaixo (-)

find <path> -type f -mtime -30 -exec rm -rf {} \;

Se você deseja alterar os arquivos por mais de 2 dias

find <path> -type f -mtime +2 -exec gzip {} \;

Se você quiser ver os arquivos / pastas apenas no último mês. Ex:

find <path> -type f -mtime -30 -exec ls -lrt {} \;

Acima de mais de 30 dias, apenas liste os arquivos / pastas Ex:

find <path> -type f -mtime +30 -exec ls -lrt {} \;

find /opt/app/logs -type f -mtime +30 -exec ls -lrt {} \;
rajá
fonte
2

Estou surpreso que não haja ulimitrespostas aqui. Toda vez que tenho esse problema, acabo aqui ou aqui . Entendo que esta solução tem limitações, mas ulimit -s 65536parece que costuma fazer o truque para mim.

dps
fonte
1

Eu tive o mesmo problema com uma pasta cheia de imagens temporárias que crescia dia a dia e esse comando me ajudou a limpar a pasta

find . -name "*.png" -mtime +50 -exec rm {} \;

A diferença com os outros comandos é o parâmetro mtime que levará apenas os arquivos com mais de X dias (no exemplo 50 dias)

Usando isso várias vezes, diminuindo a cada execução do período, pude remover todos os arquivos desnecessários

Brugolo
fonte
1

Eu só sei uma maneira de contornar isso. A idéia é exportar a lista de arquivos pdf que você possui para um arquivo. Em seguida, divida esse arquivo em várias partes. Em seguida, remova os arquivos pdf listados em cada parte.

ls | grep .pdf > list.txt
wc -l list.txt

wc -l é para contar quantas linhas o list.txt contém. Quando você tem a idéia de quanto tempo leva, pode decidir dividi-lo ao meio, para a frente ou algo assim. Usando o comando split -l Por exemplo, divida-o em 600 linhas cada.

split -l 600 list.txt

isso criará alguns arquivos chamados xaa, xab, xac e assim por diante, dependendo de como você o divide. Agora, para "importar" cada lista desses arquivos no comando rm, use este:

rm $(<xaa)
rm $(<xab)
rm $(<xac)

Desculpe pelo meu inglês ruim.

thai_phan
fonte
5
Se você tiver um arquivo nomeado, pdf_format_sucks.docxisso também será excluído ... ;-) Você deve usar expressões regulares apropriadas e precisas ao grepping para os arquivos pdf.
Foof
1
Melhor, mas still_pdf_format_sucks.docxserá excluído. O ponto .na ".pdf"expressão regular corresponde a qualquer caractere. Eu sugeriria em "[.]pdf$"vez de .pdf.
Foof
1

Eu me deparei com esse problema algumas vezes. Muitas das soluções executam o rmcomando para cada arquivo individual que precisa ser excluído. Isso é muito ineficiente:

find . -name "*.pdf" -print0 | xargs -0 rm -rf

Acabei escrevendo um script python para excluir os arquivos com base nos 4 primeiros caracteres no nome do arquivo:

import os
filedir = '/tmp/' #The directory you wish to run rm on 
filelist = (os.listdir(filedir)) #gets listing of all files in the specified dir
newlist = [] #Makes a blank list named newlist
for i in filelist: 
    if str((i)[:4]) not in newlist: #This makes sure that the elements are unique for newlist
        newlist.append((i)[:4]) #This takes only the first 4 charcters of the folder/filename and appends it to newlist
for i in newlist:
    if 'tmp' in i:  #If statment to look for tmp in the filename/dirname
        print ('Running command rm -rf '+str(filedir)+str(i)+'* : File Count: '+str(len(os.listdir(filedir)))) #Prints the command to be run and a total file count
        os.system('rm -rf '+str(filedir)+str(i)+'*') #Actual shell command
print ('DONE')

Isso funcionou muito bem para mim. Consegui limpar mais de 2 milhões de arquivos temporários em uma pasta em cerca de 15 minutos. Eu comentei o tar do pouco código, para que qualquer pessoa com um conhecimento mínimo ou nenhum de python possa manipular esse código.

Pedro Montero
fonte
1

E um outro:

cd  /path/to/pdf
printf "%s\0" *.[Pp][Dd][Ff] | xargs -0 rm

printfé um shell embutido e, tanto quanto eu sei, sempre foi assim. Agora, como esse printfnão é um comando do shell (mas um interno), ele não está sujeito a "argument list too long ... " erro fatal.

Assim, podemos usá-lo com segurança com padrões de globbing do shell, como *.[Pp][Dd][Ff], em seguida, canalizamos sua saída para remover ( rm) o comando xargs, o que garante que ele se ajuste a nomes de arquivos suficientes na linha de comando para não falhar norm comando, que é um shell comando.

O \0in printfserve como um separador nulo para os nomes de arquivo que são processados ​​por xargscomando, usando-o ( -0) como separador, para rmque não falhe quando houver espaços em branco ou outros caracteres especiais nos nomes de arquivo.

lind
fonte
1
Embora esse trecho de código possa resolver a questão, incluindo uma explicação de como e por que isso resolve o problema realmente ajudaria a melhorar a qualidade da sua postagem. Lembre-se de que você está respondendo à pergunta dos leitores no futuro, não apenas à pessoa que está perguntando agora! Por favor edite sua resposta para adicionar explicação, e dar uma indicação do que limitações e premissas se aplicam.
quer
Em particular, se printfnão houver um shell embutido, ele estará sujeito à mesma limitação.
Toby Speight
0

Você pode criar uma pasta temporária, mover todos os arquivos e subpastas que deseja manter para a pasta temporária, excluir a pasta antiga e renomear a pasta temporária para a pasta antiga. Tente este exemplo até ter certeza de fazê-lo ao vivo:

mkdir testit
cd testit
mkdir big_folder tmp_folder
touch big_folder/file1.pdf
touch big_folder/file2.pdf
mv big_folder/file1,pdf tmp_folder/
rm -r big_folder
mv tmp_folder big_folder

o rm -r big_folderremoverá todos os arquivos, big_foldernão importa quantos. Você só precisa ter muito cuidado, primeiro tem todos os arquivos / pastas que deseja manter, neste caso, foifile1.pdf

Keithhn
fonte
0

Para excluir tudo *.pdfem um diretório/path/to/dir_with_pdf_files/

mkdir empty_dir        # Create temp empty dir

rsync -avh --delete --include '*.pdf' empty_dir/ /path/to/dir_with_pdf_files/

Excluir arquivos específicos rsyncusando o curinga é provavelmente a solução mais rápida, caso você tenha milhões de arquivos. E isso resolverá o erro que você está recebendo.


(Etapa opcional): EXECUÇÃO SECA. Para verificar o que será excluído sem excluir. `

rsync -avhn --delete --include '*.pdf' empty_dir/ /path/to/dir_with_pdf_files/

. . .

Clique em dicas e truques do rsync para obter mais hacks do rsync

Raman Kathpalia
fonte
0

Eu descobri que, para listas extremamente grandes de arquivos (> 1e6), essas respostas eram muito lentas. Aqui está uma solução usando processamento paralelo em python. Eu sei, eu sei, isso não é linux ... mas nada aqui funcionou.

(Isso me salvou horas)

# delete files
import os as os
import glob
import multiprocessing as mp

directory = r'your/directory'
os.chdir(directory)


files_names = [i for i in glob.glob('*.{}'.format('pdf'))]

# report errors from pool

def callback_error(result):
    print('error', result)

# delete file using system command
def delete_files(file_name):
     os.system('rm -rf ' + file_name)

pool = mp.Pool(12)  
# or use pool = mp.Pool(mp.cpu_count())


if __name__ == '__main__':
    for file_name in files_names:
        print(file_name)
        pool.apply_async(delete_files,[file_name], error_callback=callback_error)
mmann1123
fonte
0

Eu enfrentei um problema semelhante quando havia milhões de arquivos de log inúteis criados por um aplicativo que preenchia todos os inodes. Eu recorri ao "localizar", coloquei todos os arquivos "localizados" d em um arquivo de texto e os removi um a um. Demorou um pouco, mas fez o trabalho!

asatsi
fonte
Isso é bastante vago e requer que você tenha instalado locatenovamente quando ainda havia espaço no disco.
Tripleee
-2

Uma versão um pouco mais segura do que usar xargs, também não recursiva: ls -p | grep -v '/$' | grep '\.pdf$' | while read file; do rm "$file"; done

Filtrar nossos diretórios aqui é um pouco desnecessário, pois 'rm' não o exclui de qualquer maneira, e pode ser removido por simplicidade, mas por que executar algo que definitivamente retornará erro?

Kaplan Ilya
fonte
3
Isso não é seguro e não funciona com nomes de arquivos com novas linhas, para apontar um caso de canto óbvio. A análisels é um antipadrão comum que definitivamente deve ser evitado e adiciona vários bugs adicionais aqui. O grep | grepnão é apenas muito elegante.
Tripleee
De qualquer forma, não é um problema novo e exótico que exija uma solução complexa. As respostas findsão boas e bem documentadas aqui e em outros lugares. Veja, por exemplo, o mywiki.wooledge.org, para muito mais sobre este e outros tópicos relacionados.
Tripleee
-2

Usar o GNU paralelo ( sudo apt install parallel) é super fácil

Ele executa os comandos multithread onde '{}' é o argumento passado

Por exemplo

ls /tmp/myfiles* | parallel 'rm {}'

Jonathan
fonte
Eu não sei, mas acho que é porque passar a saída lsdiretamente para outros comandos é um antipadrão perigoso - isso e o fato de a expansão do curinga causar a mesma falha ao executar lscomo experimentado no rmcomando original .
Toby Speight
Para um contexto sobre isso, consulte ParsingLs . E paralleldeixa algumas pessoas que preferem evitar a complexidade desconfortável - se você olhar por baixo do capô, é bem opaco. Veja o tópico da lista de discussão em lists.gnu.org/archive/html/bug-parallel/2015-05/msg00005.html entre Stephane (um dos homens cinzentos do Unix e Linux StackExchange ) e Ole Tange (autor do Parallel). xargs -Ptambém paraleliza, mas o faz de maneira mais simples e mais burra, com menos partes móveis, tornando seu comportamento muito mais fácil de prever e raciocinar.
Charles Duffy
-2

Para remover os 100 primeiros arquivos:

rm -rf 'ls | cabeça -100 '

Nikunj Ranpura
fonte
2
Perigoso (ou seria se você usasse aspas posteriores como evidentemente pretendido) - se algum nome de arquivo contiver metacaracteres de shell, incluindo espaços, os resultados não serão o que você pretendia.
Toby Speight
-5

A opção abaixo parece simples para esse problema. Eu recebi essas informações de algum outro tópico, mas isso me ajudou.

for file in /usr/op/data/Software/temp/application/openpages-storage/*; do
    cp "$file" /opt/sw/op-storage/
done

Basta executar o comando acima e ele fará a tarefa.

Amittal
fonte