¿Hay alguna manera de hacer que mv cree el directorio al que se moverá si no existe?

Entonces, si estoy en mi directorio de inicio y quiero mover foo.c a ~ / bar / baz / foo.c, pero esos directorios no existen, ¿hay alguna forma de crear esos directorios automáticamente, de modo que solo tendrías que escribir

mv foo.c ~/bar/baz/ 

y todo saldría bien? Parece que podría alias mv a un script bash simple que verificaría si esos directorios existían y si no llamaría a mkdir y luego a mv, pero pensé en verificar si alguien tenía una mejor idea.

¿Qué tal este one-liner (en bash):

mkdir --parents ./some/path/; mv yourfile.txt $_

Desglosando eso:

mkdir --parents ./some/path

crea el directorio (incluidos todos los directorios intermedios), después de lo cual:

mv yourfile.txt $_

mueve el archivo a ese directorio ($ _ se expande al último argumento pasado al comando de shell anterior, es decir: el directorio recién creado).

No estoy seguro de hasta qué punto esto funcionará en otros shells, pero podría darle algunas ideas sobre qué buscar.

Aquí hay un ejemplo usando esta técnica:

$ > ls
$ > touch yourfile.txt
$ > ls
yourfile.txt
$ > mkdir --parents ./some/path/; mv yourfile.txt $_
$ > ls -F
some/
$ > ls some/path/
yourfile.txt

mkdir -p `dirname /destination/moved_file_name.txt`  
mv /full/path/the/file.txt  /destination/moved_file_name.txt

Guardar como un script llamado mv o mv.sh

#!/bin/bash
# mv.sh
dir="$2"
tmp="$2"; tmp="${tmp: -1}"
[ "$tmp" != "/" ] && dir="$(dirname "$2")"
[ -a "$dir" ] ||
mkdir -p "$dir" &&
mv "$@"

O coloque al final de su archivo ~ / .bashrc como una función que reemplaza el mv predeterminado en cada terminal nueva. El uso de una función permite que bash lo mantenga en memoria, en lugar de tener que leer un archivo de script cada vez.

function mv ()
{
    dir="$2"
    tmp="$2"; tmp="${tmp: -1}"
    [ "$tmp" != "/" ] && dir="$(dirname "$2")"
    [ -a "$dir" ] ||
    mkdir -p "$dir" &&
    mv "$@"
}

Estos basados ​​en la presentación de Chris Lutz.

Puedes usar mkdir:

mkdir -p ~/bar/baz/ && \
mv foo.c ~/bar/baz/

Un script simple para hacerlo automáticamente (no probado):

#!/bin/sh

# Grab the last argument (argument number $#)    
eval LAST_ARG=\$$#

# Strip the filename (if it exists) from the destination, getting the directory
DIR_NAME=`echo $2 | sed -e 's_/[^/]*$__'`

# Move to the directory, making the directory if necessary
mkdir -p "$DIR_NAME" || exit
mv "$@"

Parece que la respuesta es no :). Realmente no quiero crear un alias o función solo para hacer esto, a menudo porque es único y ya estoy en el medio de escribir el mvcomando, pero encontré algo que funciona bien para eso:

mv *.sh  shell_files/also_with_subdir/ || mkdir -p $_

Si mvfalla (el directorio no existe), creará el directorio (que es el último argumento del comando anterior, también lo $_tiene). Simplemente ejecute este comando, luego upvuelva a ejecutarlo, y esta vez mvdebería tener éxito.

¿El siguiente script de shell, tal vez?

#!/bin/sh
if [[ -e $1 ]]
then
  if [[ ! -d $2 ]]
  then
    mkdir --parents $2
  fi
fi
mv $1 $2

Esa es la parte básica. Es posible que desee agregar un poco para verificar los argumentos, y puede que desee que el comportamiento cambie si el destino existe o si el directorio fuente existe o no existe (es decir, no sobrescriba algo que no existe) .

rsync comando puede hacer el truco solo si el último directorio en la ruta de destino no existe, por ejemplo, para la ruta de destino de ~/bar/baz/if barexiste pero bazno existe , entonces se puede usar el siguiente comando:

rsync -av --remove-source-files foo.c ~/bar/baz/

-a, --archive               archive mode; equals -rlptgoD (no -H,-A,-X)
-v, --verbose               increase verbosity
--remove-source-files   sender removes synchronized files (non-dir)

En este caso, el bazdirectorio se creará si no existe. Pero si ambos bary bazno existen, rsync fallará:

sending incremental file list
rsync: mkdir "/root/bar/baz" failed: No such file or directory (2)
rsync error: error in file IO (code 11) at main.c(657) [Receiver=3.1.2]

Entonces, básicamente, debería ser seguro de usar rsync -av --remove-source-files como un alias para mv.

La forma más sencilla de hacerlo es:

mkdir [directory name] && mv [filename] $_

Supongamos que descargué archivos pdf ubicados en mi directorio de descargas ( ~/download) y quiero moverlos a un directorio que no existe (digamosmy_PDF ).

Escribiré el siguiente comando (asegurándome de que mi directorio de trabajo actual sea ~/download):

mkdir my_PDF && mv *.pdf $_

Puede agregar una -popción a mkdirsi desea crear subdirectorios así: (se supone que quiero crear un subdirectorio llamado python):

mkdir -p my_PDF/python && mv *.pdf $_

Más tonto, pero trabajando de la manera:

mkdir -p $2
rmdir $2
mv $1 $2

Cree el directorio con mkdir -p, incluido un directorio temporal que comparta el nombre del archivo de destino, luego elimine ese directorio con un simple rmdir, luego mueva su archivo a su nuevo destino. Sin embargo, creo que la respuesta usando dirname es probablemente la mejor.

((cd src-path && tar --remove-files -cf - files-to-move) | ( cd dst-path && tar -xf -))

Código:

if [[ -e $1 && ! -e $2 ]]; then
   mkdir --parents --verbose -- "$(dirname -- "$2")"
fi
mv --verbose -- "$1" "$2"

Ejemplo:

argumentos: "d1" "d2 / sub"

mkdir: created directory 'd2'
renamed 'd1' -> 'd2/sub'

Esto se moverá foo.cal nuevo directorio bazcon el directorio padre bar.

mv foo.c `mkdir -p ~/bar/baz/ && echo $_`

La -popción mkdircreará directorios intermedios según sea necesario.
Sin-p todos los directorios en el prefijo de ruta ya debe existir.

Todo lo que está dentro de los backticks ``se ejecuta y la salida se devuelve en línea como parte de su comando.
Como mkdirno devuelve nada, solo la salida de echo $_se agregará al comando.

$_hace referencia al último argumento al comando ejecutado anteriormente.
En este caso, devolverá la ruta a su nuevo directorio ( ~/bar/baz/) pasado al mkdircomando.

mv `ls -A | grep -v demo-app.zip` `mkdir -p demo-app && echo $_`

ls -Adevuelve todos los nombres de archivo, incluidos los archivos ocultos ( excepto los implícitos .y.. ).

El símbolo de canalización |se utiliza para canalizar la salida del lscomando grep( una utilidad de búsqueda de texto sin formato en la línea de comandos ).
El -vindicador dirige grepa buscar y devolver todos los nombres de archivo, excepto demo-app.zip.
Esa lista de archivos se agrega a nuestra línea de comandos como argumentos de origen para el comando mover mv. El argumento objetivo es la ruta al nuevo directorio pasado a mkdirreferenciado usando $_y salida usando echo.

Incluso puedes usar extensiones de llaves:

mkdir -p directory{1..3}/subdirectory{1..3}/subsubdirectory{1..2}      

• que crea 3 directorios (directorio1, directorio2, directorio3),
  • y en cada uno de ellos dos subdirectorios (subdirectorio1, subdirectorio2),
    • y en cada uno de ellos dos subdirectorios (subsubdirectory1 y subsubdirectory2).

Tienes que usar bash 3.0 o más reciente.

$what=/path/to/file;
$dest=/dest/path;

mkdir -p "$(dirname "$dest")";
mv "$what" "$dest"

Mi solución de una cadena:

test -d "/home/newdir/" || mkdir -p "/home/newdir/" && mv /home/test.txt /home/newdir/

Puede encadenar comandos: mkdir ~/bar/baz | mv foo.c ~/bar/baz/
o el script de shell está aquí:

#!/bin/bash
mkdir $2 | mv $1 $2

1. Abra cualquier editor de texto
2. Copie y pegue el script de shell.
3. Guárdelo como mkdir_mv.sh
4. Ingrese el directorio de su script: cd your/script/directory
5. Cambie el modo de archivo : chmod +x mkdir_mv.sh
6. Establezca el alias : alias mv="./mkdir_mv.sh"
Ahora, cada vez que ejecute el comando mv, se creará un directorio móvil si no existe.

Basado en un comentario en otra respuesta, aquí está mi función de shell.

# mvp = move + create parents
function mvp () {
    source="$1"
    target="$2"
    target_dir="$(dirname "$target")"
    mkdir --parents $target_dir; mv $source $target
}

Incluya esto en .bashrc o similar para que pueda usarlo en todas partes.