Mv සමඟ ෆෝල්ඩර ඒකාබද්ධ කිරීම?

මම mv"ෆෝල්ඩරය" නම් ෆෝල්ඩරයක් දැනටමත් "ෆෝල්ඩරය" අඩංගු නාමාවලියකට ගෙන යාමට භාවිතා කරන්නේ නම් ඒවා ඒකාබද්ධ වේද? නැතහොත් එය ප්‍රතිස්ථාපනය වේද?

mvඩිරෙක්ටරි ඒකාබද්ධ කිරීමට හෝ නැවත ලිවීමට නොහැකිය , ඔබ --forceවිකල්පය භාවිතා කරන විට පවා "mv: 'a' 'b' වෙත ගෙන යා නොහැක: නාමාවලිය හිස් නොවේ" .

ඔබ මෙම භාවිතා වෙනත් මෙවලම් (වගේ පමණ වැඩ කළ හැකි rsync, find, හෝ cp), නමුත් ඔබ ප්රවේශමෙන් ඇඟවුම් සලකා බැලිය යුත්තේ:

• rsyncඑක් ඩිරෙක්ටරියක අන්තර්ගතය තවත් ඩිරෙක්ටරයකට ඒකාබද්ධ කළ හැකිය ( සාර්ථකව මාරු කරන ලද ප්‍රභව ලිපිගොනු පමණක් ආරක්ෂිතව මකා දැමීමේ --remove-source-files¹ විකල්පය සමඟ, සහ -aඔබට අවශ්‍ය නම් සුපුරුදු අවසරය / හිමිකාරිත්වය / කාල සංරක්ෂණ විකල්පය සමඟ )
  … නමුත් මෙය සම්පූර්ණ පිටපත් මෙහෙයුමකි , එබැවින් ඉතා තැටි-තීව්‍ර විය හැකිය.
• දැනට කැමති විකල්පය: ඔබට විකල්පය ඒකාබද්ධ rsyncකළ --link-dest=DIRහැකිය (ගොනු අන්තර්ගතයන් පිටපත් කිරීම වෙනුවට දෘඩ සබැඳි නිර්මාණය කිරීම, හැකි සෑම තැනකම) සහ --remove-source-filesසාමාන්‍යයට සමාන අර්ථකථනයක් ලබා ගැනීම mv.
  මේ සඳහා, ප්‍රභව නාමාවලියට --link-destනිරපේක්ෂ මාර්ගයක් ලබා දිය යුතුය (හෝ ගමනාන්තයේ සිට ප්‍රභවයට සාපේක්ෂ මාර්ගයක් ). … නමුත් මෙය අනපේක්ෂිත ආකාරයකින් භාවිතා කරයි (එය සංකූලතා ඇති කළ හැකි හෝ නොවිය හැකි), ප්‍රභවයට නිරපේක්ෂ මාර්ගය දැන ගැනීම (හෝ තීරණය කිරීම) (තර්කයක් ලෙස ) අවශ්‍ය වන අතර නැවත හිස් නාමාවලි ව්‍යුහයක් පිරිසිදු කිරීමට ඉතිරි වේ. එක් ¹ .
  --link-dest--link-dest
• findඉලක්කගත මූලාශ්‍ර නාමාවලි ව්‍යුහය අනුපිළිවෙලින් ප්‍රතිනිර්මාණය කිරීමට, පසුව සත්‍ය ලිපිගොනු තනි තනිව ගෙනයාමට ඔබට භාවිතා කළ හැකිය
  … නමුත් මෙය ප්‍රභවය හරහා කිහිප වතාවක් පුනරාවර්තනය විය යුතු අතර තරඟ කොන්දේසි වලට මුහුණ දිය හැකිය (බහු-පියවර ක්‍රියාවලියේදී ප්‍රභවයේ නව නාමාවලි නිර්මාණය වෙමින් පවතී )
• cpදෘ link සබැඳි නිර්මාණය කළ හැකිය (සරලවම කිවහොත්, පවතින එකම ගොනුවට අතිරේක දර්ශක), එය ඒකාබද්ධ කිරීමකට බොහෝ සමානකම් දක්වයි mv(සහ දර්ශකයන් පමණක් නිර්මාණය වී ඇති හෙයින් සත්‍ය දත්ත පිටපත් කළ යුතු නොවන බැවින් එය ඉතා IO- කාර්යක්ෂම වේ)
  … නමුත් මෙය නැවතත් සිදුවිය හැකි ධාවන තත්වයකින් පීඩා විඳිති (මූලාශ්‍රයේ ඇති නව ලිපිගොනු පෙර පියවරේදී පිටපත් නොකළද මකා දමනු ලැබේ)

මෙම කුමන ක්‍රියාමාර්ග (සුදුසු නම්) ඔබගේ විශේෂිත භාවිත අවස්ථාව මත රඳා පවතී.
සෑම විටම මෙන්, ඔබ මෙම විධානයන් කිසිවක් ක්‍රියාත්මක කිරීමට පෙර සිතා බලා උපස්ථ ලබා ගන්න.

_{1: rsync --remove-source-filesකිසිදු නාමාවලියක් මකා නොදමන බව සලකන්න , එබැවින් find -depth -type d -empty -deleteහිස් මූලාශ්‍ර නාමාවලි ගස ඉවත් කිරීම සඳහා ඔබට පසුව යමක් කිරීමට සිදුවේ.}

rsync -av /source/ /destination/
(after checking)
rm -rf /source/

ඔබට cp විධානයේ -lවිකල්පය භාවිතා කළ හැකිය , එය සම්පූර්ණ දත්ත පිටපත් වෙනුවට එකම ගොනු පද්ධතියේ දෘඩ සම්බන්ධතා නිර්මාණය කරයි . පහත දැක්වෙන විධානය මඟින් ෆෝල්ඩරය මව් ෆෝල්ඩරයකට පිටපත් කරයි ( ) එය දැනටමත් නම සහිත නාමාවලියක් අඩංගු වේ .source/folderdestinationfolder

cp -rl source/folder destination
rm -r source/folder

ඔබ ද භාවිතා කිරීමට ඔබට අවශ්ය විය හැක -P( --no-dereference- නැහැ de-යොමු සංකේතාත්මක සබැඳි කරන්න) හෝ -a( --archive- සියලු පාර-දත්ත ආරක්ෂා ද ඇතුළත් වේ -Pඔබගේ අවශ්යතා මත පදනම්ව, විකල්පය විය).

මම මෙම පියවර හතර නිර්දේශ කරමි:

cd ${SOURCE}; 
find . -type d -exec mkdir -p ${DEST}/\{} \; 
find . -type f -exec mv \{} ${DEST}/\{} \; 
find . -type d -empty -delete

හෝ වඩා හොඳ තවමත්, සමාන අර්ථකථන ක්‍රියාත්මක කරන පිටපතක් මෙන්න mv:

#!/bin/bash

DEST="${@:${#@}}"
ABS_DEST="$(cd "$(dirname "$DEST")"; pwd)/$(basename "$DEST")"

for SRC in ${@:1:$((${#@} -1))}; do   (
    cd "$SRC";
    find . -type d -exec mkdir -p "${ABS_DEST}"/\{} \;
    find . -type f -exec mv \{} "${ABS_DEST}"/\{} \;
    find . -type d -empty -delete
) done

නාමාවලි ඒකාබද්ධ කරන ක්‍රමයක් මෙන්න. එය rsync ට වඩා වේගවත් බැවින් එය පිටපත් කර ඒවා මකා දැමීම වෙනුවට නැවත නම් කරයි.

cd source; find -type f -print0 | xargs -0 -n 1 -I {} mv '{}' 'dest/{}'

මෙය ඉටු කර ගත හැකි එක් ක්‍රමයක් නම්:

mv folder/* directory/folder/
rmdir folder

ලෙස කිසිදු ගොනු දෙකක් එකම නම තිබේ තාක් කල් folderසහ directory/folder, ඔබ සමඟ ඒකබද්ධ එනම් එම ප්රතිඵලයම ලබා ඇත.

පිරිසිදු පිටපත් සඳහා, මම තාර (-) බී අවහිර කිරීමේ පිටපත් ක්‍රමය භාවිතා කරමි.

උදාහරණයක් ලෙස, ප්‍රභව මාර්ගයෙන් (අවශ්‍ය නම් 'සීඩී'):

tar cBf - <sourcefolder> | (cd /your/target/folder ; tar xBf -)

මෙය ප්‍රභව ගසෙහි නිශ්චිත පිටපතක් නිර්මාණය කරයි, හිමිකරු සමඟ සහ අවසරයන් නොවෙනස්ව. ඉලක්ක ෆෝල්ඩරය තිබේ නම්, දත්ත ඒකාබද්ධ කෙරේ. දැනටමත් පවතින ගොනු පමණක් නැවත ලියනු ලැබේ.

උදාහරණයක්:

 $ cd /data1/home
 $ tar cBf - jdoe | (cd /data2/home ; tar xBf -)

පිටපත් කිරීමේ ක්‍රියාව සාර්ථක වූ විට, ඔබට ප්‍රභවය ඉවත් කළ හැකිය ( rm -rf <source>). ඇත්ත වශයෙන්ම මෙය නිශ්චිත පියවරක් නොවේ: ඔබ ප්‍රභවය ඉවත් කරන තුරු දත්ත පිටපත් කරනු ලැබේ.

විකල්පයක් ලෙස ඔබට වාචික විය හැකිය (ගොනුව පිටපත් කර ඇති තිරය මත පෙන්වන්න), -v: tar cBvf -

• c: සාදන්න
• B: සම්පූර්ණ කොටස කියවන්න (පයිප්ප කියවීම සඳහා)
• v: වාචික
• f: ලිවීමට ගොනුව
• x: උපුටා ගැනීම
• -: stdout / stdin

sourcefolderද කළ හැකි *(වත්මන් ෆෝල්ඩරය තුළ ඕනෑම දෙයක් සඳහා)

Cp හෝ rsync වැනි විධානයන් භාවිතා කිරීම හොඳ අදහසක් නොවේ. විශාල ගොනු සඳහා, එය බොහෝ කාලයක් ගතවනු ඇත. mv වඩා වේගවත් වන්නේ එය භෞතිකව ගොනු පිටපත් නොකර ඉනෝඩ් යාවත්කාලීන කරන බැවිනි. වඩා හොඳ විකල්පයක් වන්නේ ඔබේ මෙහෙයුම් පද්ධතියේ ගොනු කළමනාකරු භාවිතා කිරීමයි. Opensuse සඳහා, Konquerer නමින් ගොනු කළමනාකරුවෙකු සිටී. එය ඇත්ත වශයෙන්ම පිටපත් නොකර ගොනු ගෙන යා හැකිය. එය වින්ඩෝස් හි මෙන් "කැපීම හා ඇලවීම" ශ්‍රිතය ඇත. ඩිරෙක්ටරියේ ඇති සියලුම උප ඩිරෙක්ටරි තෝරන්න. රයිට් ක්ලික් කර එකම නාමයන් සහිත උප ඩිරෙක්ටරි අඩංගු විය හැකි බී ඩිරෙක්ටරියට යන්න. එය ඔවුන් ඒකාබද්ධ කරනු ඇත. එකම නමකින් ලිපිගොනු නැවත ලිවීමට හෝ නැවත නම් කිරීමට ඔබට අවශ්‍යද යන්න විකල්ප ඇත.

පයිතන් විසඳුම

පූර්වයෙන් පවතින සතුටුදායක විසඳුමක් මට සොයාගත නොහැකි වූ නිසා, එය සාක්ෂාත් කර ගැනීම සඳහා ඉක්මන් පයිතන් පිටපතක් සෑදීමට මම තීරණය කළෙමි.

විශේෂයෙන්, මෙම ක්‍රමය කාර්යක්ෂම වන්නේ එය ප්‍රභව ගොනු ගස පහළට පහළට ගමන් කරන බැවිනි.

ඔබගේ අභිමතය පරිදි ලිපිගොනු නැවත ලිවීම වැනි දෑ ඉක්මනින් වෙනස් කිරීමටද එය ඔබට ඉඩ සලසයි.

භාවිතය:

move-merge-dirs src/ dest/

සියලු අන්තර්ගතයන් src/*තුළට ගෙන යන dest/අතර src/අතුරුදහන් වනු ඇත.

move-merge-dirs

#!/usr/bin/env python3

import argparse
import os

def move_merge_dirs(source_root, dest_root):
    for path, dirs, files in os.walk(source_root, topdown=False):
        dest_dir = os.path.join(
            dest_root,
            os.path.relpath(path, source_root)
        )
        if not os.path.exists(dest_dir):
            os.makedirs(dest_dir)
        for filename in files:
            os.rename(
                os.path.join(path, filename),
                os.path.join(dest_dir, filename)
            )
        for dirname in dirs:
            os.rmdir(os.path.join(path, dirname))
    os.rmdir(source_root)

if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description='Move merge src/* into dest. Overwrite existing files.'
    )
    parser.add_argument('src_dir')
    parser.add_argument('dest_dir')
    args = parser.parse_args()
    move_merge_dirs(args.src_dir, args.dest_dir)

GitHub ඉහළට .

මෙයද බලන්න: /programming/22588225/how-do-you-merge-two-directories-or-move-with-replace-from-the-windows-command

මෙන්න මට වැඩ කළ පිටපතක්. මම rsync වලට වඩා mv වලට කැමතියි, එබැවින් මම ජුවල් සහ ජොනතන් මේයර්ගේ විසඳුම් භාවිතා කරමි.

#!/bin/bash

# usage source1 .. sourceN dest

length=$(($#-1))
sources=${@:1:$length}
DEST=$(readlink -f ${!#})
for SRC in "$sources"; do
    pushd "$SRC";
    find . -type d -exec mkdir -p "${DEST}/{}" \;
    find . -type f -exec mv {} "${DEST}/{}" \;
    find . -type d -empty -delete
    popd
done

ලිපිගොනු සහ ෆෝල්ඩර වෙනත් ගමනාන්තයකට ගෙන යාමේ විධානය මෙයයි:

$ mv /source/path/folder /target/destination/

මතක තබා ගන්න : mvෆෝල්ඩරය b̲e̲i̲n̲g m̲e̲r̲ge̲d̲ (එනම් එකම නමක් ඇති තවත් ෆෝල්ඩරයක් දැනටමත් ගමනාන්තය තුළ පවතී) සහ d̲e̲s̲t̲i̲n̲a̲t̲i̲o̲n̲ o̲n̲e̲ i̲s̲ n̲o̲t̲ e̲m̲pt̲y නම් විධානය ක්‍රියා නොකරනු ඇත .

mv: '/ source / path / folder' වෙත '/ target / destination / folder' වෙත ගෙන යා නොහැක: නාමාවලිය හිස් නොවේ

ගමනාන්ත ෆෝල්ඩරය හිස් නම්, ඉහත විධානය හොඳින් ක්‍රියාත්මක වේ.

එබැවින්, ඕනෑම අවස්ථාවක ෆෝල්ඩර දෙකම ඒකාබද්ධ කිරීම සඳහා,
එක්කෝ එය විධාන 2 කින් කරන්න:

$ cp -rf /source/path/folder /target/destination/
$ rm -rf /source/path/folder

නැතහොත් දෙකම එක් වරක් විධානයක් ලෙස ඒකාබද්ධ කරන්න:

$ cp -rf /source/path/folder /target/destination/ && rm -rf /source/path/folder

mv = චලනය
cp = පිටපත
rm = ඉවත් කරන්න

-r නාමාවලිය සඳහා (ෆෝල්ඩරය)
-f බල ක්‍රියාත්මක කිරීම

හිස් ෆෝල්ඩර පිටපත් කිරීමේ තේරුමක් නැත - YMMV

#!/bin/bash

# usage source1 .. sourceN dest

length=$(($#-1))
sources=${@:1:$length}
DEST=$(readlink -f ${!#})
for SRC in $sources; do
    pushd "$SRC";
    # Only one scan - we only need folders with files
    find . -type f | while read FILE ; do
        DIRNAME=`dirname "$FILE"`
        # Create the lowest level directory at once
        if [ ! -d "$DEST/$DIRNAME" ] ; then
            mkdir -v "$DEST/$DIRNAME"
        fi
        mv -v "$FILE" "$DEST/$FILE"
    done
    # Remove the directories no longer needed
    find . -type -d | sort -r | xargs -i rmdir "{}"
    popd
done

• කිහිප වතාවක් ක්‍රියාත්මක කර නැති බව සොයා ගන්න
• අනුක්‍රමිකව නාමාවලි සොයා ගැනීමෙන් පසුව පවා mkdir -p ක්‍රියාත්මක වේ

ඔබට a සහ b සමඟ ඒකාබද්ධ කළ හැකිය :

shopt -s dotglob
mv a/* b

Mv ට පෙර:

.
├── a
│   ├── c
│   │   └── x
│   └── .x
└── b
    ├── y
    └── .y

Mv පසු:

.
├── a
└── b
    ├── c
    │   └── x
    ├── .x
    ├── y
    └── .y

dotglob ඔබ වැනි සඟවා තිතක් ගොනු කිරීමට ඉඩ .x

හිස් නාමාවලිය ඉවත් කිරීමට rmdir භාවිතා කරන්න .