C'è un modo per fare in modo che mv crei la directory da spostare se non esiste?

Quindi, se sono nella mia home directory e voglio spostare foo.c in ~ / bar / baz / foo.c, ma quelle directory non esistono, c'è un modo per creare automaticamente quelle directory, in modo che dovresti solo digitare

mv foo.c ~/bar/baz/ 

e tutto funzionerebbe? Sembra che tu possa alias mv a un semplice script bash che verificherebbe se quelle directory esistessero e se no chiamasse mkdir e poi mv, ma ho pensato di controllare se qualcuno avesse avuto un'idea migliore.

Che ne dici di questo one-liner (in bash):

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

Abbattendo quello:

mkdir --parents ./some/path

crea la directory (comprese tutte le directory intermedie), dopo di che:

mv yourfile.txt $_

sposta il file in quella directory ($ _ si espande all'ultimo argomento passato al comando shell precedente, ovvero: la directory appena creata).

Non sono sicuro di quanto funzionerà in altre shell, ma potrebbe darti alcune idee su cosa cercare.

Ecco un esempio usando questa tecnica:

$ > 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

Salva come uno script chiamato 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 "$@"

Oppure inserisci alla fine del tuo file ~ / .bashrc come una funzione che sostituisce il mv predefinito su ogni nuovo terminale. L'uso di una funzione consente a bash di mantenerlo memoria, invece di dover leggere un file di script ogni volta.

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

Questi si basano sulla presentazione di Chris Lutz.

Puoi usare mkdir:

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

Un semplice script per farlo automaticamente (non testato):

#!/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 "$@"

Sembra che la risposta sia no :). Non voglio davvero creare un alias o una funzione solo per farlo, spesso perché è una tantum e sono già nel mezzo della digitazione del mvcomando, ma ho trovato qualcosa che funziona bene per quello:

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

Se mvfallisce (dir non esiste), creerà la directory (che è l'ultimo argomento del comando precedente, così $_ha). Quindi basta eseguire questo comando, quindi upeseguirlo nuovamente, e questa volta mvdovrebbe avere esito positivo.

Il seguente script di shell, forse?

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

Questa è la parte base. Potresti voler aggiungere un po 'per verificare la presenza di argomenti e potresti voler cambiare il comportamento se la destinazione esiste o la directory di origine esiste o non esiste (ovvero non sovrascrivere qualcosa che non esiste) .

Il comando rsync può fare il trucco solo se l'ultima directory nel percorso di destinazione non esiste, ad esempio per il percorso di destinazione di ~/bar/baz/se baresiste ma baznon esiste , è possibile utilizzare il seguente 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)

In questo caso la bazdirectory verrà creata se non esiste. Ma se entrambi bare baznon esistono, rsync fallirà:

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]

Quindi in pratica dovrebbe essere sicuro usare rsync -av --remove-source-filescome alias per mv.

Il modo più semplice per farlo è:

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

Supponiamo di aver scaricato i file pdf situati nella mia directory di download ( ~/download) e di volerli spostare in una directory che non esiste (diciamo my_PDF).

Digiterò il seguente comando (assicurandomi che la mia directory di lavoro corrente sia ~/download):

mkdir my_PDF && mv *.pdf $_

È possibile aggiungere -pun'opzione a mkdirse si desidera creare sottodirectory proprio in questo modo: (suppongo di voler creare una sottodirectory denominata python):

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

Modo più sciocco, ma funzionante:

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

Crea la directory con mkdir -p includendo una directory temporanea che condivida il nome del file di destinazione, quindi rimuovi quella directory del nome file con un semplice rmdir, quindi sposta il file nella sua nuova destinazione. Penso che rispondere usando dirname sia probabilmente il migliore però.

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

Codice:

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

Esempio:

argomenti: "d1" "d2 / sub"

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

Questo si sposterà foo.cnella nuova directory bazcon la directory padre bar.

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

L' -popzione per mkdircreare directory intermedie come richiesto.
Senza -ptutte le directory nel prefisso del percorso devono già esistere.

Tutto all'interno dei backtick ``viene eseguito e l'output viene restituito in linea come parte del comando.
Poiché mkdirnon restituisce nulla, solo l'output di echo $_verrà aggiunto al comando.

$_fa riferimento all'ultimo argomento al comando precedentemente eseguito.
In questo caso, restituirà il percorso alla nuova directory ( ~/bar/baz/) passata al mkdircomando.

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

ls -Arestituisce tutti i nomi di file inclusi i file nascosti ( tranne quelli impliciti .e.. ).

Il simbolo pipe |viene utilizzato per reindirizzare l'output del lscomando a grep( un'utilità di ricerca di testo semplice da riga di comando ).
Il -vflag indica grepdi trovare e restituire tutti i nomi dei file esclusi demo-app.zip.
Tale elenco di file viene aggiunto alla nostra riga di comando come argomenti di origine al comando move mv. L'argomento target è il percorso della nuova directory passata mkdirall'utilizzo referenziato $_e all'output echo.

Puoi anche usare le estensioni di parentesi graffe:

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

• che crea 3 directory (directory1, directory2, directory3),
  • e in ognuna di esse due sottodirectory (sottodirectory1, sottodirectory2),
    • e in ognuna di esse due sottosubdirectory (subsubdirectory1 e subsubdirectory2).

Devi usare bash 3.0 o versioni successive.

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

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

La mia soluzione a una stringa:

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

Puoi concatenare i comandi: mkdir ~/bar/baz | mv foo.c ~/bar/baz/
oppure lo script della shell è qui:

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

1. Apri qualsiasi editor di testo
2. Copia-incolla lo script della shell.
3. Salvalo come mkdir_mv.sh
4. Inserisci la directory del tuo script: cd your/script/directory
5. Cambia modalità file : chmod +x mkdir_mv.sh
6. Imposta alias : alias mv="./mkdir_mv.sh"
Ora, ogni volta che esegui il comando, la mvdirectory di spostamento verrà creata se non esiste.

Basato su un commento in un'altra risposta, ecco la mia funzione di shell.

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

Includilo in .bashrc o simili in modo da poterlo usare ovunque.