¿Resolver "mv: Lista de argumentos demasiado larga"?

Tengo una carpeta con más de un millón de archivos que necesita ser ordenada, pero realmente no puedo hacer nada porque mvgenera este mensaje todo el tiempo

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

Estoy usando este comando para mover archivos sin extensión:

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

xargsEs la herramienta para el trabajo. Eso o findcon -exec … {} +. Estas herramientas ejecutan un comando varias veces, con tantos argumentos como se pueden pasar de una vez.

Ambos métodos son más fáciles de llevar a cabo cuando la lista de argumentos variables está al final, lo cual no es el caso aquí: el argumento final mves el destino. Con las utilidades GNU (es decir, en Linux no integrado o Cygwin), la -topción mves útil, para pasar el destino primero.

Si los nombres de archivo no tienen espacios en blanco ni ninguno \"', simplemente puede proporcionar los nombres de archivo como entrada xargs(el echocomando es un bash incorporado, por lo que no está sujeto al límite de longitud de la línea de comando):

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

Puede usar la -0opción para xargsusar una entrada delimitada por nulos en lugar del formato predeterminado entre comillas.

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

Alternativamente, puede generar la lista de nombres de archivo con find. Para evitar recurrir a subdirectorios, use -type d -prune. Como no se especifica ninguna acción para los archivos de imagen enumerados, solo se mueven los otros archivos.

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

(Esto incluye archivos de puntos, a diferencia de los métodos comodín de shell).

Si no tiene utilidades GNU, puede usar un shell intermedio para obtener los argumentos en el orden correcto. Este método funciona en todos los sistemas POSIX.

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

En zsh, puede cargar el mvarchivo incorporado :

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

o si prefiere dejar que mvotros nombres sigan refiriéndose a los comandos externos:

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

o con globos de estilo ksh:

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

Alternativamente, usando GNU mvy zargs:

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

Si trabajar con el kernel de Linux es suficiente, simplemente puede hacer

ulimit -s 100000

eso funcionará porque el kernel de Linux incluyó un parche hace unos 10 años que cambió el límite de argumento para basarse en el tamaño de la pila: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/ commit /? id = b6a2fea39318e43fee84fa7b0b90d68bed92d2ba

Actualización: si te sientes valiente, puedes decir

ulimit -s unlimited

y estará bien con cualquier expansión de shell siempre que tenga suficiente RAM.

El límite de aprobación de argumentos del sistema operativo no se aplica a las expansiones que ocurren dentro del intérprete de shell. Entonces, además de usar xargso find, simplemente podemos usar un bucle de shell para dividir el procesamiento en mvcomandos individuales :

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

Esto usa solo las características y utilidades del lenguaje de comandos de shell POSIX. Esta línea es más clara con sangría, con puntos y comas innecesarios eliminados:

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

Para obtener una solución más agresiva que las ofrecidas anteriormente, abra la fuente de su núcleo y edite include/linux/binfmts.h

Aumente el tamaño MAX_ARG_PAGESa algo más grande que 32. Esto aumenta la cantidad de memoria que el núcleo permitirá para argumentos de programa, lo que le permite especificar su mvo rmcomando para un millón de archivos o lo que sea que esté haciendo. Recompilar, instalar, reiniciar.

¡TENER CUIDADO! Si configura esto demasiado grande para la memoria de su sistema, y ​​luego ejecuta un comando con muchos argumentos ¡MALAS COSAS OCURRIRÁN! Sea extremadamente cauteloso al hacer esto con los sistemas multiusuario, ¡facilita a los usuarios maliciosos el uso de toda su memoria!

Si no sabe cómo volver a compilar y reinstalar su núcleo manualmente, probablemente sea mejor que simplemente finja que esta respuesta no existe por ahora.

Una solución más simple usando en "$origin"/!(*.jpg|*.png|*.bmp)lugar de un bloque catch:

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

Gracias a @Score_Under

Para una secuencia de comandos de varias líneas, puede hacer lo siguiente (observe ;antes de que donese elimine):

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

Para hacer una solución más generalizada que mueva todos los archivos, puede hacer una línea:

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

Que se ve así si haces sangría:

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

Esto toma cada archivo en el origen y los mueve uno por uno al destino. Las comillas $fileson necesarias en caso de que haya espacios u otros caracteres especiales en los nombres de archivo.

Aquí hay un ejemplo de este método que funcionó perfectamente

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

A veces es más fácil escribir un pequeño script, por ejemplo, en Python:

import glob, shutil

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

Puede sortear esa restricción mientras la sigue usando mvsi no le importa ejecutarla un par de veces.

Puede mover porciones a la vez. Digamos, por ejemplo, que tenía una larga lista de nombres de archivos alfanuméricos.

mv ./subdir/a* ./

Eso funciona. Luego elimine otro gran pedazo. Después de un par de movimientos, puede volver a usarmv ./subdir/* ./

Aquí están mis dos centavos, agregue esto a .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/