Git සමඟ ගොනුවක පැරණි අනුවාදයක් මා දකින්නේ කෙසේද?

කිසියම් ගොනුවක විශේෂිත අනුවාදයක් බැලීමට (එක්කෝ stdout වෙතට හෝ, $PAGERහෝ $EDITOR) බැලීමට Git හි විධානයක් තිබේද?

ඔබට git showනිධියේ මුල සිට මාර්ගයක් භාවිතා කළ හැකිය ( ./හෝ ../සාපේක්ෂ ව්යායාම සඳහා):

$ git show REVISION:path/to/file

REVISIONඔබගේ සත්‍ය සංශෝධනය සමඟ ප්‍රතිස්ථාපනය කරන්න (Git commit SHA, ටැග් නාමයක්, ශාඛා නාමයක්, සාපේක්ෂ බැඳීම් නාමයක් හෝ Git හි බැඳීමක් හඳුනා ගැනීමේ වෙනත් ක්‍රමයක් විය හැකිය)

උදාහරණයක් ලෙස, <repository-root>/src/main.cකොමිස් 4 කට පෙර සිට ගොනුවේ අනුවාදය බැලීමට , භාවිතා කරන්න:

$ git show HEAD~4:src/main.c

වින්ඩෝස් සඳහා වන Git වත්මන් නාමාවලියට සාපේක්ෂව මාර්ගවල පවා ඉදිරි කප්පාදුවක් අවශ්‍ය වේ . වැඩි විස්තර සඳහා, man පිටුව බලන්න git-show.

දිනය අනුව මෙය කිරීම පෙනේ:

git show HEAD@{2013-02-25}:./fileInCurrentDirectory.txt

බව සටහන HEAD@{2013-02-25}මාර්ගයෙන් මෙම නිධිය තුල "හිස 2013-02-25 මත සිටි" (භාවිතා වන reflog ), "පසුගිය 2013-02-25 පෙර මෙම ශාඛාව ඉතිහාසයේ සිදු නොවේ".

ඔබ GUI වලට කැමති නම්, ඔබට gitk භාවිතා කළ හැකිය:

1. සමඟ gitk ආරම්භ කරන්න:

   gitk /path/to/file
   

2. තිරයේ ඉහළ කොටසේ සංශෝධනය තෝරන්න, උදා: විස්තරය හෝ දිනය අනුව. පෙරනිමියෙන්, තිරයේ පහළ කොටස එම සංශෝධනය සඳහා වෙනස පෙන්වයි, ("පැච්" රේඩියෝ බොත්තමට අනුරූප වේ).

3. තෝරාගත් සංශෝධනය සඳහා ගොනුව බැලීමට:

   • "ගස" රේඩියෝ බොත්තම ක්ලික් කරන්න. මෙම සංශෝධනයේදී ගොනු ගසෙහි මුල පෙන්වනු ඇත.
   • ඔබේ ගොනුවට සරඹ කරන්න.

ඔබට විධානය සමඟ a commit hash(බොහෝ විට ද හැඳින්වේ commit ID) නියම කළ හැකිය .git show

කෙටියෙන් කිවහොත්

git show <commitHash>:/path/to/file

පියවරෙන් පියවර

1. දී ඇති ගොනුවක් සඳහා වන සියළු වෙනස්කම් වල ලොගය පෙන්වන්න git log /path/to/file
2. පෙන්වා ඇත වෙනස්වීම් ලැයිස්තුව දී, එය පෙන්නුම් commit hashවැනි commit 06c98...(06c98 ... මේ සිදු හැෂ් වීම)
3. පිටපත් කරන්න commit hash
4. 3 වන පියවර සහ 1 වන පියවර git show <commitHash>:/path/to/fileභාවිතා කරමින් විධානය ක්‍රියාත්මක කරන්න .commit hashpath/to/file

සටහන:./ සාපේක්ෂ මාර්ගයක් නියම කිරීමේදී එකතු කිරීම වැදගත් යැයි පෙනේ, එනම් git show b2f8be577166577c59b55e11cfff1404baf63a84:./flight-simulation/src/main/components/nav-horiz.html.

අමතරව ජිම් Hunziker පිළිතුරේ

සංශෝධනයෙන් ඔබට ගොනුව අපනයනය කළ හැකිය,

git show HEAD@{2013-02-25}:./fileInCurrentDirectory.txt > old_fileInCurrentDirectory.txt

මෙය උපකාරී වේ යැයි සිතමි :)

ගොනුවක පැරණි සංශෝධන සමඟ ඇති වෙනස්කම් ඉක්මනින් දැකීමට:

git show -1 filename.txt > ගොනුවේ අවසාන සංශෝධනය සමඟ සැසඳීමට

git show -2 filename.txt > 2 වන අවසාන සංශෝධනයට සාපේක්ෂව

git show -3 fielname.txt > අවසාන 3 වන අවසාන සංශෝධනයට සාපේක්ෂව

git log -pබැඳීම් ල logs ු-සටහන් පමණක් නොව, එක් එක් බැඳීම්වල වෙනස ද ඔබට පෙන්වනු ඇත (ඒකාබද්ධ කිරීමේ කොමිස් හැර). එවිට ඔබට එබිය හැකිය /, ගොනු නාමය ඇතුළත් කර ඔබන්න enter. ඔබන්න nහෝ pඊළඟ / පෙර සිදුවීමට යන්න. මේ ආකාරයෙන් ඔබ ගොනුවේ වෙනස්කම් පමණක් නොව බැඳීම් තොරතුරු ද දකිනු ඇත.

ලිපිගොනු වෙන් කිරීම සඳහා ගොනුවක සියලුම අනුවාදයන් බැහැර කිරීමට ඔබට මේ වගේ ස්ක්‍රිප්ට් එකක් භාවිතා කළ හැකිය:

උදා

git_dump_all_versions_of_a_file.sh path/to/somefile.txt

තවත් සමාන ප්‍රශ්නයකට පිළිතුරක් ලෙස මෙහි පිටපත ලබා ගන්න

මාර්ගය 1: (මම මේ ආකාරයට කැමතියි)

1. මේ සමඟ බැඳීම් හැඳුනුම්පත සොයා ගන්න :git reflog
2. බැඳීම් වලින් ගොනු ලැයිස්තුගත කරන්න git diff-tree --no-commit-id --name-only -r <commitHash>

උදාහරණය: git diff-tree --no-commit-id --name-only -r d2f9ba4// "d2f9ba4" යනු "1" සිට කැපවීමේ හැඳුනුම්පතයි.

3. අවශ්‍ය ගොනුව විධානය සමඟ විවෘත කරන්න:

git show <commitHash>:/path/to/file

උදාහරණය: git show d2f9ba4:Src/Ext/MoreSwiftUI/ListCustom.swift// "Src / ..." යනු "2" සිට ගොනු මාර්ගයයි.

මාර්ගය 2:

1. මේ සමඟ බැඳීම් හැඳුනුම්පත සොයා ගන්න :git reflog
2. මෙම කැපවීම නැවත සකස් කරන්න: git reset --hard %commit ID%

git reset --hard c14809fa

3. ඕනෑම අනවශ්‍ය වෙනසක් සිදු කර අවශ්‍ය ශාඛාවලට නැවුම් කැපවීමක් කරන්න :)

   ---

දී ඇති සංශෝධනයකින් ගොනු කිහිපයක් ලබා ගැනීමට උදව් කරන්න

ඒකාබද්ධ කිරීමේ ගැටුම් නිරාකරණය කිරීමට උත්සාහ කරන විට, මෙම සහායකයා ඉතා ප්‍රයෝජනවත් වේ:

#!/usr/bin/env python3

import argparse
import os
import subprocess

parser = argparse.ArgumentParser()
parser.add_argument('revision')
parser.add_argument('files', nargs='+')
args = parser.parse_args()
toplevel = subprocess.check_output(['git', 'rev-parse', '--show-toplevel']).rstrip().decode()
for path in args.files:
    file_relative = os.path.relpath(os.path.abspath(path), toplevel)
    base, ext = os.path.splitext(path)
    new_path = base + '.old' + ext
    with open(new_path, 'w') as f:
        subprocess.call(['git', 'show', '{}:./{}'.format(args.revision, path)], stdout=f)

GitHub ඉහළට .

භාවිතය:

git-show-save other-branch file1.c path/to/file2.cpp

ප්‍රති come ලය: පහත දැක්වෙන්නේ ලිපිගොනු වල විකල්ප අනුවාදයන් ය:

file1.old.c
path/to/file2.old.cpp

මේ ආකාරයෙන්, ඔබ ගොනු දිගුව තබා ගන්නා බැවින් ඔබේ සංස්කාරකවරයා පැමිණිලි නොකරනු ඇති අතර පැරණි ගොනුව නවතම ගොනුවට යාබදව පහසුවෙන් සොයාගත හැකිය.