Resolvendo “mv: lista de argumentos muito longa”?

Eu tenho uma pasta com mais de um milhão de arquivos que precisa ser classificada, mas não posso fazer nada porque mvgera essa mensagem o tempo todo

-bash: /bin/mv: Argument list too long

Estou usando este comando para mover arquivos sem extensão:

mv -- !(*.jpg|*.png|*.bmp) targetdir/

xargsé a ferramenta para o trabalho. Isso ou findcom -exec … {} +. Essas ferramentas executam um comando várias vezes, com tantos argumentos quanto podem ser passados ​​de uma só vez.

Ambos os métodos são mais fáceis de executar quando a lista de argumentos variáveis ​​está no final, o que não é o caso aqui: o argumento final para mvé o destino. Com os utilitários GNU (ou seja, no Linux ou Cygwin não incorporado), a -topção to mvé útil para passar o destino primeiro.

Se os nomes dos arquivos não tiverem espaço em branco nem nenhum \"', você poderá simplesmente fornecer os nomes dos arquivos como entrada xargs(o echocomando é um bash integrado, portanto, não está sujeito ao limite de comprimento da linha de comando):

echo !(*.jpg|*.png|*.bmp) | xargs mv -t targetdir

Você pode usar a -0opção para xargsusar entrada delimitada por nulo em vez do formato entre aspas padrão.

printf '%s\0' !(*.jpg|*.png|*.bmp) | xargs -0 mv -t targetdir

Como alternativa, você pode gerar a lista de nomes de arquivos com find. Para evitar a recursão em subdiretórios, use -type d -prune. Como nenhuma ação é especificada para os arquivos de imagem listados, apenas os outros arquivos são movidos.

find . -name . -o -type d -prune -o \
       -name '*.jpg' -o -name '*.png' -o -name '*.bmp' -o \
       -exec mv -t targetdir/ {} +

(Isso inclui arquivos de ponto, ao contrário dos métodos curinga do shell.)

Se você não possui utilitários GNU, pode usar um shell intermediário para obter os argumentos na ordem correta. Este método funciona em todos os sistemas POSIX.

find . -name . -o -type d -prune -o \
       -name '*.jpg' -o -name '*.png' -o -name '*.bmp' -o \
       -exec sh -c 'mv "$@" "$0"' targetdir/ {} +

No zsh, você pode carregar o mvbuiltin :

setopt extended_glob
zmodload zsh/files
mv -- ^*.(jpg|png|bmp) targetdir/

ou se você preferir permitir mve outros nomes continuem se referindo aos comandos externos:

setopt extended_glob
zmodload -Fm zsh/files b:zf_\*
zf_mv -- ^*.(jpg|png|bmp) targetdir/

ou com globs no estilo ksh:

setopt ksh_glob
zmodload -Fm zsh/files b:zf_\*
zf_mv -- !(*.jpg|*.png|*.bmp) targetdir/

Como alternativa, usando GNU mve zargs:

autoload -U zargs
setopt extended_glob
zargs -- ./^*.(jpg|png|bmp) -- mv -t targetdir/

Se trabalhar com o kernel Linux é suficiente, você pode simplesmente fazer

ulimit -s 100000

isso funcionará porque o kernel do Linux incluiu um patch há cerca de 10 anos que mudou o limite de argumentos para se basear no tamanho da pilha: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/ confirmar /? id = b6a2fea39318e43fee84fa7b0b90d68bed92d2ba

Atualização: Se você se sente corajoso, pode dizer

ulimit -s unlimited

e você ficará bem com todas as expansões de shell, desde que tenha RAM suficiente.

O limite de aprovação de argumentos do sistema operacional não se aplica a expansões que ocorrem dentro do interpretador de shell. Portanto, além de usar xargsor find, podemos simplesmente usar um loop de shell para dividir o processamento em mvcomandos individuais :

for x in *; do case "$x" in *.jpg|*.png|*.bmp) ;; *) mv -- "$x" target ;; esac ; done

Isso usa apenas recursos e utilitários da POSIX Shell Command Language. Essa linha única é mais clara com recuo, com ponto e vírgula desnecessário removido:

for x in *; do
  case "$x" in
    *.jpg|*.png|*.bmp) 
       ;; # nothing
    *) # catch-all case
       mv -- "$x" target
       ;;
  esac
done

Para uma solução mais agressiva do que as oferecidas anteriormente, acesse a fonte do kernel e edite include/linux/binfmts.h

Aumente o tamanho MAX_ARG_PAGESpara algo maior que 32. Isso aumenta a quantidade de memória que o kernel permitirá para argumentos do programa, permitindo que você especifique seu comando mvou rmpara um milhão de arquivos ou o que estiver fazendo. Recompile, instale, reinicie.

Cuidado! Se você definir isso muito grande para a memória do sistema e executar um comando com muitos argumentos, COISAS MAU ACONTECEREM! Seja extremamente cauteloso ao fazer isso em sistemas multiusuário, pois torna mais fácil para usuários mal-intencionados usar toda a sua memória!

Se você não sabe como recompilar e reinstalar seu kernel manualmente, provavelmente é melhor que você apenas finja que essa resposta não existe por enquanto.

Uma solução mais simples usando em "$origin"/!(*.jpg|*.png|*.bmp)vez de um bloco catch:

for file in "$origin"/!(*.jpg|*.png|*.bmp); do mv -- "$file" "$destination" ; done

Obrigado a @Score_Under

Para um script de várias linhas, você pode fazer o seguinte (observe o ;antes do donelançamento):

for file in "$origin"/!(*.jpg|*.png|*.bmp); do        # don't copy types *.jpg|*.png|*.bmp
    mv -- "$file" "$destination" 
done 

Para fazer uma solução mais generalizada que mova todos os arquivos, você pode fazer o seguinte procedimento:

for file in "$origin"/*; do mv -- "$file" "$destination" ; done

Que fica assim se você fizer o recuo:

for file in "$origin"/*; do
    mv -- "$file" "$destination"
done 

Isso pega todos os arquivos na origem e os move um a um para o destino. As aspas $filesão necessárias caso haja espaços ou outros caracteres especiais nos nomes dos arquivos.

Aqui está um exemplo desse método que funcionou perfeitamente

for file in "/Users/william/Pictures/export_folder_111210/"*.jpg; do
    mv -- "$file" "/Users/william/Desktop/southland/landingphotos/";
done

Às vezes é mais fácil escrever um pequeno script, por exemplo, em Python:

import glob, shutil

for i in glob.glob('*.jpg'):
  shutil.move(i, 'new_dir/' + i)

Você pode contornar essa restrição enquanto ainda estiver usando, mvse não se importar de executá-la algumas vezes.

Você pode mover partes de cada vez. Digamos, por exemplo, que você tenha uma longa lista de nomes de arquivos alfanuméricos.

mv ./subdir/a* ./

Isso funciona. Então nocauteie outro pedaço grande. Depois de alguns movimentos, você pode voltar a usarmv ./subdir/* ./

Aqui estão meus dois centavos, acrescente isso .bash_profile

mv() {
  if [[ -d $1 ]]; then #directory mv
    /bin/mv $1 $2
  elif [[ -f $1 ]]; then #file mv
    /bin/mv $1 $2
  else
    for f in $1
    do
      source_path=$f
      #echo $source_path
      source_file=${source_path##*/}
      #echo $source_file
      destination_path=${2%/} #get rid of trailing forward slash

      echo "Moving $f to $destination_path/$source_file"

      /bin/mv $f $destination_path/$source_file
    done
  fi
}
export -f mv

Uso

mv '*.jpg' ./destination/
mv '/path/*' ./destination/