Linux: salin dan buat direktori tujuan jika tidak ada

Saya ingin perintah (atau mungkin opsi untuk cp) yang membuat direktori tujuan jika tidak ada.

Contoh:

cp -? file /path/to/copy/file/to/is/very/deep/there

mkdir -p "$d" && cp file "$d"

(tidak ada opsi untuk cp).

Jika kedua hal berikut ini benar:

1. Anda menggunakan versi GNU dari cp (dan bukan, misalnya, versi Mac), dan
2. Anda menyalin dari beberapa struktur direktori yang ada dan Anda hanya perlu membuatnya kembali

maka Anda dapat melakukan ini dengan --parentsbendera cp. Dari halaman info (dapat dilihat di http://www.gnu.org/software/coreutils/manual/html_node/cp-invocation.html#cp-invocation atau dengan info cpatau man cp):

--parents
     Form the name of each destination file by appending to the target
     directory a slash and the specified name of the source file.  The
     last argument given to `cp' must be the name of an existing
     directory.  For example, the command:

          cp --parents a/b/c existing_dir

     copies the file `a/b/c' to `existing_dir/a/b/c', creating any
     missing intermediate directories.

Contoh:

/tmp $ mkdir foo
/tmp $ mkdir foo/foo
/tmp $ touch foo/foo/foo.txt
/tmp $ mkdir bar
/tmp $ cp --parents foo/foo/foo.txt bar
/tmp $ ls bar/foo/foo
foo.txt

Jawaban singkat

Untuk menyalin myfile.txtke /foo/bar/myfile.txt, gunakan:

mkdir -p /foo/bar && cp myfile.txt $_

Bagaimana cara kerjanya?

Ada beberapa komponen untuk ini, jadi saya akan membahas semua langkah demi langkah sintaksis.

The mkdir utilitas, sebagaimana ditentukan dalam standar POSIX , membuat direktori. The -pargumen, per dokumen, akan menyebabkan mkdir untuk

Membuat komponen pathname perantara yang hilang

artinya ketika memanggil mkdir -p /foo/bar, mkdir akan membuat /foo dan /foo/bar jika /foobelum ada. (Tanpa -p, itu malah akan menimbulkan kesalahan.

The &&Operator daftar, seperti yang didokumentasikan dalam standar POSIX (atau pengguna Bash jika Anda suka), memiliki efek yang cp myfile.txt $_hanya dijalankan jika mkdir -p /foo/barmengeksekusi berhasil. Ini berarti cpperintah tidak akan mencoba untuk mengeksekusi jika mkdirgagal karena salah satu dari banyak alasan itu mungkin gagal .

Akhirnya, $_kita cpmenganggap argumen kedua adalah "parameter khusus" yang berguna untuk menghindari pengulangan argumen panjang (seperti path file) tanpa harus menyimpannya dalam variabel. Per manual Bash , itu:

memperluas argumen terakhir ke perintah sebelumnya

Dalam hal ini, itulah yang /foo/barkami berikan mkdir. Jadi cpperintah diperluas ke cp myfile.txt /foo/bar, yang menyalin myfile.txtke /foo/bardirektori yang baru dibuat .

Perhatikan bahwa $_ini bukan bagian dari standar POSIX , sehingga secara teoritis varian Unix mungkin memiliki shell yang tidak mendukung konstruk ini. Namun, saya tidak tahu adanya kerang modern yang tidak mendukung $_; tentu Bash, Dash, dan zsh semua lakukan.

Catatan terakhir: perintah yang saya berikan di awal jawaban ini mengasumsikan bahwa nama direktori Anda tidak memiliki spasi. Jika Anda berurusan dengan nama dengan spasi, Anda harus mengutipnya sehingga kata-kata yang berbeda tidak diperlakukan sebagai argumen berbeda dengan mkdiratau cp. Jadi perintah Anda sebenarnya akan terlihat seperti:

mkdir -p "/my directory/name with/spaces" && cp "my filename with spaces.txt" "$_"

Pertanyaan yang lama, tapi mungkin saya bisa mengusulkan solusi alternatif.

Anda dapat menggunakan installprogram ini untuk menyalin file Anda dan membuat jalur tujuan "on the fly".

install -D file /path/to/copy/file/to/is/very/deep/there/file

Namun ada beberapa aspek yang perlu dipertimbangkan:

1. Anda harus menentukan juga nama file tujuan , bukan hanya jalur tujuan
2. file tujuan akan dapat dieksekusi (setidaknya, sejauh yang saya lihat dari tes saya)

Anda dapat dengan mudah mengubah # 2 dengan menambahkan -mopsi untuk mengatur izin pada file tujuan (contoh: -m 664akan membuat file tujuan dengan izin rw-rw-r--, seperti halnya membuat file baru dengan touch).

Dan di sini adalah tautan tak tahu malu ke jawaban yang saya terinspirasi oleh =)

Fungsi Shell yang melakukan apa yang Anda inginkan, menyebutnya salinan "mengubur" karena menggali lubang untuk tempat tinggal file:

bury_copy() { mkdir -p `dirname $2` && cp "$1" "$2"; }

Inilah satu cara untuk melakukannya:

mkdir -p `dirname /path/to/copy/file/to/is/very/deep/there` \
   && cp -r file /path/to/copy/file/to/is/very/deep/there

dirnameakan memberi Anda induk dari direktori tujuan atau file. mkdir -p `dirname ...` kemudian akan membuat direktori itu memastikan bahwa ketika Anda memanggil cp -r direktori basis yang benar sudah ada.

Keuntungan over - orang tua ini adalah bahwa ia bekerja untuk kasus di mana elemen terakhir di jalur tujuan adalah nama file.

Dan itu akan bekerja pada OS X.

install -D file -m 644 -t /path/to/copy/file/to/is/very/deep/there

dengan segala hormat saya untuk jawaban di atas, saya lebih suka menggunakan rsync sebagai berikut:

$  rsync -a directory_name /path_where_to_inject_your_directory/

contoh:

$ rsync -a test /usr/local/lib/

Hanya untuk melanjutkan dan memberikan solusi kerja yang lengkap, dalam satu baris. Hati-hati jika Anda ingin mengganti nama file Anda, Anda harus memasukkan cara untuk memberikan path dir bersih ke mkdir. $ fdst dapat berupa file atau dir. Kode selanjutnya harus berfungsi dalam hal apa pun.

fsrc=/tmp/myfile.unk
fdst=/tmp/dir1/dir2/dir3/myfile.txt
mkdir -p $(dirname ${fdst}) && cp -p ${fsrc} ${fdst}

atau spesifik bash

fsrc=/tmp/myfile.unk
fdst=/tmp/dir1/dir2/dir3/myfile.txt
mkdir -p ${fdst%/*} && cp -p ${fsrc} ${fdst}

Cukup tambahkan berikut ini di .bashrc Anda, tweak jika Anda perlu. Bekerja di Ubuntu.

mkcp() {
    test -d "$2" || mkdir -p "$2"
    cp -r "$1" "$2"
}

Misalnya Jika Anda ingin menyalin file 'test' ke direktori tujuan 'd' Gunakan,

mkcp test a/b/c/d

mkcp pertama-tama akan memeriksa apakah direktori tujuan ada atau tidak, jika tidak maka buatlah dan salin file sumber / direktori.

Ini untukku

cp -vaR ./from ./to

Saya menulis skrip dukungan untuk cp, yang disebut CP (huruf besar) yang dimaksudkan untuk melakukan hal ini. Script akan memeriksa kesalahan di jalur yang Anda masukkan (kecuali yang terakhir yang menjadi tujuan) dan jika semuanya baik-baik saja, ia akan melakukan langkah mkdir -p untuk membuat jalur tujuan sebelum memulai penyalinan. Pada titik ini utilitas cp reguler mengambil alih dan setiap sakelar yang Anda gunakan dengan CP (seperti -r, -p, -rpL akan disalurkan langsung ke cp). Sebelum Anda menggunakan skrip saya, ada beberapa hal yang perlu Anda pahami.

• semua info di sini dapat diakses dengan melakukan CP --help. CP --membantu semua sakelar cp yang disertakan.
• cp biasa tidak akan melakukan salinan jika tidak menemukan jalur tujuan. Anda tidak memiliki jaring pengaman untuk kesalahan ketik dengan CP. Tujuan Anda akan dibuat, jadi jika Anda salah mengeja tujuan Anda sebagai / usrr / share / ikon atau / usr / share / ikon dengan baik itulah yang akan dibuat.
• regular cp cenderung memodelkan perilaku di jalur yang ada: cp / a / b / c / d akan bervariasi pada apakah d ada atau tidak. jika d adalah folder yang ada, cp akan menyalin b ke dalamnya, membuat / c / d / b. Jika d tidak ada, b akan disalin ke c dan diganti namanya menjadi d. Jika d ada tetapi merupakan file dan b adalah file, itu akan ditimpa oleh salinan b. Jika c tidak ada, cp tidak melakukan penyalinan dan keluar.

CP tidak memiliki kemewahan untuk mengambil isyarat dari jalur yang ada, sehingga harus memiliki beberapa pola perilaku yang sangat tegas. CP mengasumsikan bahwa item yang Anda salin dijatuhkan di jalur tujuan dan bukan tujuan itu sendiri (alias, salinan yang diubah namanya dari file sumber / folder). Berarti:

• "CP / a / b / c / d" akan menghasilkan / c / d / b jika d adalah folder
• "CP / a / b / c / b" akan menghasilkan / c / b / b jika b in / c / b adalah folder.
• Jika b dan d adalah file: CP / a / b / c / d akan menghasilkan / c / d (di mana d adalah salinan b). Sama untuk CP / a / b / c / b dalam kondisi yang sama.

Perilaku CP default ini dapat diubah dengan sakelar "--rename". Dalam hal ini, diasumsikan demikian

• "CP --rename / a / b / c / d" menyalin b ke / c dan mengganti nama salinan menjadi d.

Beberapa catatan penutup: Seperti dengan cp, CP dapat menyalin beberapa item sekaligus dengan jalur terakhir yang didaftarkan dianggap sebagai tujuan. Itu juga bisa menangani jalur dengan spasi selama Anda menggunakan tanda kutip.

CP akan memeriksa jalur yang Anda letakkan dan memastikan keberadaannya sebelum melakukan penyalinan. Dalam mode ketat (tersedia melalui saklar --strict), semua file / folder yang disalin harus ada atau tidak ada salinan yang terjadi. Dalam mode santai (--relaxed), penyalinan akan dilanjutkan jika setidaknya ada satu item yang Anda daftarkan. Mode santai adalah default, Anda dapat mengubah mode sementara melalui sakelar atau secara permanen dengan mengatur variabel easy_going di awal skrip.

Berikut cara menginstalnya:

Di terminal non-root, lakukan:

sudo echo > /usr/bin/CP; sudo chmod +x /usr/bin/CP; sudo touch /usr/bin/CP
gedit admin:///usr/bin/CP 

Di gedit, rekatkan utilitas CP dan simpan:

#!/bin/bash
#Regular cp works with the assumption that the destination path exists and if it doesn't, it will verify that it's parent directory does.

#eg: cp /a/b /c/d will give /c/d/b if folder path /c/d already exists but will give /c/d (where d is renamed copy of b) if /c/d doesn't exists but /c does.

#CP works differently, provided that d in /c/d isn't an existing file, it assumes that you're copying item into a folder path called /c/d and will create it if it doesn't exist. so CP /a/b /c/d will always give /c/d/b unless d is an existing file. If you put the --rename switch, it will assume that you're copying into /c and renaming the singl item you're copying from b to d at the destination. Again, if /c doesn't exist, it will be created. So CP --rename /a/b /c/d will give a /c/d and if there already a folder called /c/d, contents of b will be merged into d. 

#cp+ $source $destination
#mkdir -p /foo/bar && cp myfile "$_"

err=0 # error count
i=0 #item counter, doesn't include destination (starts at 1, ex. item1, item2 etc)
m=0 #cp switch counter (starts at 1, switch 1, switch2, etc)
n=1 # argument counter (aka the arguments inputed into script, those include both switches and items, aka: $1 $2 $3 $4 $5)
count_s=0
count_i=0
easy_going=true #determines how you deal with bad pathes in your copy, true will allow copy to continue provided one of the items being copied exists, false will exit script for one bad path. this setting can also be changed via the custom switches: --strict and --not-strict
verbal="-v"


  help="===============================================================================\
    \n         CREATIVE COPY SCRIPT (CP) -- written by thebunnyrules\
    \n===============================================================================\n
    \n This script (CP, note capital letters) is intended to supplement \
    \n your system's regular cp command (note uncapped letters). \n
    \n Script's function is to check if the destination path exists \
    \n before starting the copy. If it doesn't it will be created.\n    
    \n To make this happen, CP assumes that the item you're copying is \
    \n being dropped in the destination path and is not the destination\
    \n itself (aka, a renamed copy of the source file/folder). Meaning:\n 
    \n * \"CP /a/b /c/d\" will result in /c/d/b \
    \n * even if you write \"CP /a/b /c/b\", CP will create the path /a/b, \
    \n   resulting in /c/b/b. \n
    \n Of course, if /c/b or /c/d are existing files and /a/b is also a\
    \n file, the existing destination file will simply be overwritten. \
    \n This behavior can be changed with the \"--rename\" switch. In this\
    \n case, it's assumed that \"CP --rename /a/b /c/d\" is copying b into /c  \
    \n and renaming the copy to d.\n
    \n===============================================================================\
    \n        CP specific help: Switches and their Usages \
    \n===============================================================================\n
    \
    \n  --rename\tSee above. Ignored if copying more than one item. \n
    \n  --quiet\tCP is verbose by default. This quiets it.\n
    \n  --strict\tIf one+ of your files was not found, CP exits if\
    \n\t\tyou use --rename switch with multiple items, CP \
    \n\t\texits.\n
    \n  --relaxed\tIgnores bad paths unless they're all bad but warns\
    \n\t\tyou about them. Ignores in-appropriate rename switch\
    \n\t\twithout exiting. This is default behavior. You can \
    \n\t\tmake strict the default behavior by editing the \
    \n\t\tCP script and setting: \n
    \n\t\teasy_going=false.\n
    \n  --help-all\tShows help specific to cp (in addition to CP)."

cp_hlp="\n\nRegular cp command's switches will still work when using CP.\
    \nHere is the help out of the original cp command... \
    \n\n===============================================================================\
    \n          cp specific help: \
    \n===============================================================================\n"

outro1="\n******************************************************************************\
    \n******************************************************************************\
    \n******************************************************************************\
    \n        USE THIS SCRIPT WITH CARE, TYPOS WILL GIVE YOU PROBLEMS...\
    \n******************************************************************************\
    \n******************************* HIT q TO EXIT ********************************\
    \n******************************************************************************"


#count and classify arguments that were inputed into script, output help message if needed
while true; do
    eval input="\$$n"
    in_=${input::1}

    if [ -z "$input" -a $n = 1 ]; then input="--help"; fi 

    if [ "$input" = "-h" -o "$input" = "--help" -o "$input" = "-?" -o "$input" = "--help-all" ]; then
        if [ "$input" = "--help-all" ]; then 
            echo -e "$help"$cp_hlp > /tmp/cp.hlp 
            cp --help >> /tmp/cp.hlp
            echo -e "$outro1" >> /tmp/cp.hlp
            cat /tmp/cp.hlp|less
            cat /tmp/cp.hlp
            rm /tmp/cp.hlp
        else
            echo -e "$help" "$outro1"|less
            echo -e "$help" "$outro1"
        fi
        exit
    fi

    if [ -z "$input" ]; then
        count_i=$(expr $count_i - 1 ) # remember, last item is destination and it's not included in cound
        break 
    elif [ "$in_" = "-" ]; then
        count_s=$(expr $count_s + 1 )
    else
        count_i=$(expr $count_i + 1 )
    fi
    n=$(expr $n + 1)
done

#error condition: no items to copy or no destination
    if [ $count_i -lt 0 ]; then 
            echo "Error: You haven't listed any items for copying. Exiting." # you didn't put any items for copying
    elif [ $count_i -lt 1 ]; then
            echo "Error: Copying usually involves a destination. Exiting." # you put one item and no destination
    fi

#reset the counter and grab content of arguments, aka: switches and item paths
n=1
while true; do
        eval input="\$$n" #input=$1,$2,$3,etc...
        in_=${input::1} #first letter of $input

        if [ "$in_" = "-" ]; then
            if [ "$input" = "--rename" ]; then 
                rename=true #my custom switches
            elif [ "$input" = "--strict" ]; then 
                easy_going=false #exit script if even one of the non-destinations item is not found
            elif [ "$input" = "--relaxed" ]; then 
                easy_going=true #continue script if at least one of the non-destination items is found
            elif [ "$input" = "--quiet" ]; then 
                verbal=""
            else
                #m=$(expr $m + 1);eval switch$m="$input" #input is a switch, if it's not one of the above, assume it belongs to cp.
                switch_list="$switch_list \"$input\""
            fi                                  
        elif ! [ -z "$input" ]; then #if it's not a switch and input is not empty, it's a path
                i=$(expr $i + 1)
                if [ ! -f "$input" -a ! -d "$input" -a "$i" -le "$count_i" ]; then 
                    err=$(expr $err + 1 ); error_list="$error_list\npath does not exit: \"b\""
                else
                    if [ "$i" -le "$count_i" ]; then 
                        eval item$i="$input" 
                        item_list="$item_list \"$input\""
                    else
                        destination="$input" #destination is last items entered
                    fi
                fi
        else
            i=0
            m=0
            n=1                     
            break
        fi      
        n=$(expr $n + 1)
done

#error condition: some or all item(s) being copied don't exist. easy_going: continue if at least one item exists, warn about rest, not easy_going: exit.
#echo "err=$err count_i=$count_i"
if [ "$easy_going" != true -a $err -gt 0 -a $err != $count_i ]; then 
    echo "Some of the paths you entered are incorrect. Script is running in strict mode and will therefore exit."
    echo -e "Bad Paths: $err $error_list"
    exit
fi

if [ $err = $count_i ]; then
    echo "ALL THE PATHS you have entered are incorrect! Exiting."
    echo -e "Bad Paths: $err $error_list"
fi

#one item to one destination:
#------------------------------
#assumes that destination is folder, it does't exist, it will create it. (so copying /a/b/c/d/firefox to /e/f/firefox will result in /e/f/firefox/firefox
#if -rename switch is given, will assume that the top element of destination path is the new name for the the item being given.

#multi-item to single destination:
#------------------------------
#assumes destination is a folder, gives error if it exists and it's a file. -rename switch will be ignored.

#ERROR CONDITIONS: 
# - multiple items being sent to a destination and it's a file.
# - if -rename switch was given and multiple items are being copied, rename switch will be ignored (easy_going). if not easy_going, exit.
# - rename option but source is folder, destination is file, exit.
# - rename option but source is file and destination is folder. easy_going: option ignored.

if [ -f "$destination" ]; then
    if [ $count_i -gt 1 ]; then 
        echo "Error: You've selected a single file as a destination and are copying multiple items to it. Exiting."; exit
    elif [ -d "$item1" ]; then
        echo "Error: Your destination is a file but your source is a folder. Exiting."; exit
    fi
fi
if [ "$rename" = true ]; then
    if [ $count_i -gt 1 ]; then
        if [ $easy_going = true ]; then
            echo "Warning: you choose the rename option but are copying multiple items. Ignoring Rename option. Continuing."
        else
            echo "Error: you choose the rename option but are copying multiple items. Script running in strict mode. Exiting."; exit
        fi
    elif [ -d "$destination" -a -f "$item1" ]; then
        echo -n "Warning: you choose the rename option but source is a file and destination is a folder with the same name. "
        if [ $easy_going = true ]; then
            echo "Ignoring Rename option. Continuing."
        else
            echo "Script running in strict mode. Exiting."; exit
        fi
    else
        dest_jr=$(dirname "$destination")
        if [ -d "$destination" ]; then item_list="$item1/*";fi
        mkdir -p "$dest_jr"
    fi
else
    mkdir -p "$destination"
fi

eval cp $switch_list $verbal $item_list "$destination"

cp_err="$?"
if [ "$cp_err" != 0 ]; then 
    echo -e "Something went wrong with the copy operation. \nExit Status: $cp_err"
else 
    echo "Copy operation exited with no errors."
fi

exit

cp memiliki beberapa penggunaan:

$ cp --help
Usage: cp [OPTION]... [-T] SOURCE DEST
  or:  cp [OPTION]... SOURCE... DIRECTORY
  or:  cp [OPTION]... -t DIRECTORY SOURCE...
Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.

@ AndyRoss menjawab bekerja untuk

cp SOURCE DEST

gaya cp, tetapi melakukan hal yang salah jika Anda menggunakan

cp SOURCE... DIRECTORY/

gaya cp.

Saya pikir "DEST" tidak jelas tanpa garis miring dalam penggunaan ini (yaitu di mana direktori target belum ada), yang mungkin mengapa cptidak pernah menambahkan opsi untuk ini.

Jadi, inilah versi saya dari fungsi ini yang memberlakukan garis miring pada direktori tujuan:

cp-p() {
  last=${@: -1}

  if [[ $# -ge 2 && "$last" == */ ]] ; then
    # cp SOURCE... DEST/
    mkdir -p "$last" && cp "$@"
  else
    echo "cp-p: (copy, creating parent dirs)"
    echo "cp-p: Usage: cp-p SOURCE... DEST/"
  fi
}

Baru saja mengalami masalah yang sama. Pendekatan saya adalah hanya memasukkan file ke arsip seperti:

tar cf your_archive.tar file1 /path/to/file2 path/to/even/deeper/file3

tar secara otomatis menyimpan file dalam struktur yang sesuai dalam arsip. Jika Anda berlari

tar xf your_archive.tar

file diekstraksi ke dalam struktur direktori yang diinginkan.

Seperti yang disarankan di atas oleh help_asap dan spongeman, Anda dapat menggunakan perintah 'install' untuk menyalin file ke direktori yang ada atau membuat membuat direktori tujuan baru jika belum ada.

Opsi 1 install -D filename some/deep/directory/filename
menyalin file ke direktori baru atau yang sudah ada dan memberikan izin nama file standar 755

Opsi 2 install -D filename -m640 some/deep/directory/filename
sesuai Opsi 1 tetapi memberikan nama file 640 izin.

Opsi 3 install -D filename -m640 -t some/deep/directory/
sesuai Opsi 2 tetapi menargetkan nama file ke direktori target sehingga nama file tidak perlu ditulis dalam sumber dan target.

Opsi 4 install -D filena* -m640 -t some/deep/directory/
sesuai Opsi 3 tetapi menggunakan wildcard untuk banyak file.

Ini berfungsi dengan baik di Ubuntu dan menggabungkan dua langkah (pembuatan direktori kemudian menyalin file) menjadi satu langkah tunggal.

Ini sangat terlambat tetapi mungkin membantu pemula di suatu tempat. Jika Anda perlu 'otomatis' membuat folder rsync harus menjadi teman terbaik Anda. rsync / path / ke / sourcefile / path / ke / tragetdir / thatdoestexist /

rsync file /path/to/copy/file/to/is/very/deep/there

Ini mungkin berhasil, jika Anda memiliki jenis yang tepat rsync.

Salin dari sumber ke jalur yang tidak ada

mkdir –p /destination && cp –r /source/ $_

CATATAN: perintah ini menyalin semua file

cp –r untuk menyalin semua folder dan kontennya

$_ berfungsi sebagai tujuan yang dibuat dalam perintah terakhir

Sederhana

cp -a * /path/to/dst/

harus melakukan trik.

Katakanlah Anda sedang melakukan sesuatu seperti

cp file1.txt A / B / C / D / file.txt

di mana A / B / C / D adalah direktori yang belum ada

Solusi yang mungkin adalah sebagai berikut

DIR=$(dirname A/B/C/D/file.txt)
# DIR= "A/B/C/D"
mkdir -p $DIR
cp file1.txt A/B/C/D/file.txt

berharap itu bisa membantu!