Git ඉතිහාසයේ කැපවූ කේතය ග්‍රහණය කරගන්නේ කෙසේද?

මම අතීතයේ යම් කාලයකදී ගොනුවක ගොනුවක් හෝ කේතයක් මකා දැමුවෙමි. මට අන්තර්ගතය (බැඳීම් පණිවිඩවල නොවේ) ග්‍රහණය කර ගත හැකිද?

ඉතා දුර්වල විසඳුමක් වන්නේ ලොගය අතුගා දැමීමයි:

git log -p | grep <pattern>

කෙසේ වෙතත්, මෙය බැඳීම් හැෂ් එකවරම ආපසු නොඑයි. මම git grepකිසිම ප්‍රයෝජනයක් නැතිව සෙල්ලම් කළා .

බැඳීම් අන්තර්ගතය සෙවීම සඳහා (එනම්, සත්‍ය පණිවිඩ ප්‍රභවයන්, පණිවිඩ යැවීමට හා ඒ හා සමානව), ඔබ කළ යුත්තේ:

git grep <regexp> $(git rev-list --all)

git rev-list --all | xargs git grep <expression> ඔබ "තර්ක ලැයිස්තුව දිගු" දෝෂයකට හසු වුවහොත් එය ක්‍රියා කරයි.

ඔබ සමහර subtree (උදාහරණයක් ලෙස, "lib / util") වෙත සෙවුම සීමා කිරීමට අවශ්ය නම්, ඔබ වෙත ගමන් කිරීමට අවශ්ය වනු ඇත rev-listsubcommand හා grepමෙන්ම:

git grep <regexp> $(git rev-list --all -- lib/util) -- lib/util

මෙය ඔබගේ සියලු කැපවීමේ පා through හරහා ග්‍රහණය වනු ඇත regexp.

විධාන දෙකෙහිම මාර්ගය පසු කිරීමට හේතුව වන්නේ rev-listසියලු වෙනස්වීම් lib/utilසිදු වූ සංශෝධන ලැයිස්තුව නැවත ලබා දෙන grepනිසා පමණක් නොව, ඔබ සෙවිය යුතු වන පරිදි ඔබ සමත් විය යුතුය lib/util.

පහත දැක්වෙන තත්වය මවා ගන්න: ආපසු ලබා දුන් එකම සංශෝධනයේ අඩංගු වෙනත් ලිපිගොනු වලද එය grepසොයාගත හැකිය ( <regexp>එම සංශෝධනයේ rev-listඑම ගොනුවේ කිසිදු වෙනසක් සිදු නොවුනත්).

ඔබේ මූලාශ්‍රය සෙවීමේ තවත් ප්‍රයෝජනවත් ක්‍රම කිහිපයක් මෙන්න:

පෙළ ගැලපීම සඳහා වැඩ කරන ගස සොයන්න නිත්‍ය ප්‍රකාශනය regexp:

git grep <regexp>

සාමාන්‍ය ප්‍රකාශන regexp1 හෝ regexp2 ගැලපෙන පෙළ පේළි සඳහා වැඩ කරන ගස සොයන්න:

git grep -e <regexp1> [--or] -e <regexp2>

සාමාන්‍ය ප්‍රකාශන regexp1 සහ regexp2 ගැලපෙන පෙළ රේඛා සඳහා වැඩ කරන ගස සොයන්න, ගොනු මාර්ග පමණක් වාර්තා කරන්න:

git grep -l -e <regexp1> --and -e <regexp2>

සාමාන්‍ය ප්‍රකාශන regexp1 හා සාමාන්‍ය පෙළට ගැලපෙන පෙළ රේඛා ඇති ගොනු සඳහා වැඩ කරන ගස සොයන්න regexp2:

git grep -l --all-match -e <regexp1> -e <regexp2>

පෙළ ගැලපෙන රටාවේ වෙනස් වූ රේඛා සඳහා වැඩ කරන ගස සොයන්න:

git diff --unified=0 | grep <pattern>

පෙළ ගැලපීම සඳහා සියලු සංශෝධන සොයන්න නිත්‍ය ප්‍රකාශන regexp:

git grep <regexp> $(git rev-list --all)

පෙළ ගැළපෙන සාමාන්‍ය ප්‍රකාශනය සඳහා rev1 සහ rev2 අතර ඇති සියලුම සංශෝධන සොයන්න regexp:

git grep <regexp> $(git rev-list <rev1>..<rev2>)

ඔබ පිකැක්ස් ( -S) විකල්පය භාවිතා කළ යුතුය git log.

සෙවීම සඳහා Foo:

git log -SFoo -- path_containing_change
git log -SFoo --since=2009.1.1 --until=2010.1.1 -- path_containing_change

Git ඉතිහාසය බලන්න - වැඩි විස්තර සඳහා යතුරු පදයෙන් නැතිවූ රේඛාව සොයා ගන්න .

ලෙස Jakub Narębski අදහස් දැක්වූයේ මෙසේ ය:

• මෙය නිදසුනක් හඳුන්වා දෙන හෝ ඉවත් කරන වෙනස්කම් සොයයි<string> . එහි සාමාන්‍යයෙන් අදහස් වන්නේ "ඔබ 'ෆූ' සමඟ පේළිය එකතු කළ හෝ ඉවත් කළ සංශෝධන" යන්නයි.

• මෙම --pickaxe-regexවිකල්පය මඟින් නූලක් සෙවීම වෙනුවට දීර් P POSIX regex භාවිතා කිරීමට ඉඩ ලබා දේ. උදාහරණය (වෙතින් git log):git log -S"frotz\(nitfol" --pickaxe-regex

ලෙස රොබ් අදහස් දක්වමින්, මෙම සෝදිසි තටු සංවේදී වේ - ඔහු විවෘත පසු විපරම් ප්රශ්නය නඩුව-අසංවේදී පිරික්සා බලන ආකාරය පිළිබඳව.

එය කිරීමට මගේ ප්රියතම ආකාරය වේ git logගේ -Gවිකල්පය (1.7.4 අනුවාදය එකතු).

-G<regex>
       Look for differences whose added or removed line matches the given <regex>.

බැඳීමක් ගැලපෙන්නේද යන්න -Gසහ -Sවිකල්පයන් තීරණය කරන ආකාරය අතර සියුම් වෙනසක් ඇත :

• මෙම -Sවිකල්පය අවශ්යයෙන්ම පෙර සහ සිදු පසුව තිබෙන ගොනුව විටින් ඔබගේ සෙවුම් තරඟ සංඛ්යාව සතුය. පෙර සහ පසු ගණන් වෙනස් නම් බැඳීම ලොගයෙහි දැක්වේ. නිදසුනක් ලෙස, මෙය ඔබගේ සෙවුමට ගැලපෙන රේඛාවක් ගෙන ගිය ස්ථානයක් පෙන්වන්නේ නැත.
• -Gවිකල්පය සමඟ , ඔබගේ සෙවුම එකතු කරන ලද, ඉවත් කරන ලද හෝ වෙනස් කළ ඕනෑම රේඛාවකට ගැලපේ නම් බැඳීම ලොගයෙහි පෙන්වනු ලැබේ.

මෙම කැපවීම උදාහරණයක් ලෙස ගන්න:

diff --git a/test b/test
index dddc242..60a8ba6 100644
--- a/test
+++ b/test
@@ -1 +1 @@
-hello hello
+hello goodbye hello

මෙම කැපවීමට පෙර සහ පසු ගොනුවේ "හෙලෝ" දර්ශනය වන වාර ගණන එක හා සමාන බැවින් එය භාවිතයට නොගැලපේ -Shello. කෙසේ වෙතත්, රේඛා ගැලපුමක වෙනසක් සිදු වී ඇති බැවින් hello, කැපවීම භාවිතයෙන් පෙන්වනු ඇත -Ghello.

ඔබට කේත වෙනස්වීම් පිරික්සීමට අවශ්‍ය නම් (මුළු ඉතිහාසයේම දී ඇති වචනය සමඟ සැබවින්ම වෙනස් කර ඇති දේ බලන්න) patchමාදිලිය සඳහා යන්න - මට ඉතා ප්‍රයෝජනවත් සංයෝජනයක් හමු විය:

git log -p
# Hit '/' for search mode.
# Type in the word you are searching.
# If the first search is not relevant, hit 'n' for next (like in Vim ;) )

git log සියළුම ශාඛා හරහා පෙළ සෙවීමේ වඩාත් way ලදායී ක්‍රමයක් විය හැකිය, විශේෂයෙන් බොහෝ ගැලපීම් තිබේ නම්, ඔබට වඩාත් මෑත (අදාළ) වෙනස්කම් පළමුව දැකීමට අවශ්‍යය.

git log -p --all -S 'search string'
git log -p --all -G 'match regular expression'

මෙම ලොග් විධාන ලැයිස්තුව මඟින් ලබා දී ඇති සෙවුම් දාමය / රීජෙක්ස් එකතු කිරීම හෝ ඉවත් කිරීම සිදු කරයි. මෙම -pවිකල්පය ඔබට සන්දර්භය තුළ එය දැකීමට හැකි වන පරිදි අදාළ වෙනස, රටාව හෝ ඉවත් කරමින් සිටි පෙන්වා ඇත කළ යුතු හේතු වේ.

ඔබ සොයන පෙළ එකතු කරන අදාළ බැඳීමක් සොයාගත් පසු (නිදසුනක් ලෙස, 8beeff00d), බැඳීම අඩංගු ශාඛා සොයා ගන්න:

git branch -a --contains 8beeff00d

මම ජීට්ගේ පිළිතුර ගෙන එය වින්ඩෝස් වලට අනුවර්තනය කළෙමි ( මෙම පිළිතුරට ස්තූතියි ):

FOR /F %x IN ('"git rev-list --all"') DO @git grep <regex> %x > out.txt

යම් හේතුවක් නිසා, මෙම රීජෙක්ස් මකා දැමූ සත්‍ය කැපවීම විධානයේ ප්‍රතිදානයේ නොපෙන්වා ඇති බව සලකන්න.

සොයන්න , ඕනෑම සංශෝධනය කිසිදු ගොනු :

git rev-list --all | xargs git grep <regexp>

දී ඇති සමහර ලිපිගොනු වල පමණක් සොයන්න, උදාහරණයක් ලෙස XML ගොනු:

git rev-list --all | xargs -I{} git grep <regexp> {} -- "*.xml"

ප්‍රති lines ල රේඛා මේ ආකාරයට විය යුතුය: 6988bec26b1503d45eb0b2e8a4364afb87dde7af: bla.xml: එය සොයාගත් රේඛාවේ පෙළ ...

එවිට ඔබට කර්තෘ, දිනය, සහ වෙනස වැනි තවත් තොරතුරු ලබා ගත හැකිය git show:

git show 6988bec26b1503d45eb0b2e8a4364afb87dde7af

සරල බව සඳහා, මම යෝජනා කරන්නේ GUI: gitk - Git නිධිය බ්‍රව්සරය . එය නම්යශීලී ය

1. සෙවුම් කේතය සඳහා:
   
   
2. ගොනු සෙවීමට:
   
   
3. ඇත්ත වශයෙන්ම, එය නිත්‍ය ප්‍රකාශන සඳහා ද සහාය වේ:
   
   

ඉහළ / පහළ ඊතල භාවිතයෙන් ඔබට ප්‍රති results ල හරහා සැරිසැරීමට හැකිය.

Sourcetree හි වෙනත් අයෙකු මෙය කිරීමට උත්සාහ කරන විට, ඒ සඳහා UI හි සෘජු විධානයක් නොමැත (1.6.21.0 අනුවාදය අනුව). කෙසේ වෙතත්, ටර්මිනලය විවෘත කිරීමෙන් ඔබට පිළිගත් පිළිතුරෙහි දක්වා ඇති විධාන භාවිතා කළ හැකිය කවුළුව (ප්‍රධාන මෙවලම් තීරුවේ ඇති බොත්තම) ඒවා පිටපත් කිරීම / ඇලවීම කළ හැකිය.

සටහන: Sourcetree හි සෙවුම් දර්ශනයට අර්ධ වශයෙන් ඔබ සඳහා පෙළ සෙවීම කළ හැකිය. සෙවුම් දර්ශනයට යාමට Ctrl+ ඔබන්න 3(නැතහොත් පතුලේ ඇති සෙවුම් පටිත්ත ක්ලික් කරන්න). දකුණේ සිට, සෙවුම් වර්ගය ගොනු වෙනස්කම් ලෙස සකසා ඔබට සෙවීමට අවශ්‍ය නූල ටයිප් කරන්න. ඉහත විධානයට සාපේක්ෂව මෙම ක්‍රමයට පහත සීමාවන් ඇත:

1. Sourcetree පමණක් පෙන්වයි අනාචාරයේ වෙනස්වී ගොනු එක් සෙවුම් වචනය අඩංගු. සෙවුම් පා contain ය අඩංගු නිශ්චිත ගොනුව සොයා ගැනීම නැවතත් අතින් කළ යුතු කාර්යයකි.
2. RegEx සඳහා සහය නොදක්වයි.

මම ඔබේ ස්ථානයේ සිටින විට, මම පහත දැක්වෙන විධාන රේඛාව භාවිතා කරමි:

git log -S "<words/phrases i am trying to find>" --all --oneline  --graph

පැහැදිලි කිරීම:

1. git log- මට මෙහි තවත් ලිවීමට අවශ්‍යයි; එය කාලානුක්‍රමික පිළිවෙලින් ල logs ු-සටහන් පෙන්වයි.
2. -S "<words/phrases i am trying to find>" - ඕනෑම ගොනුවකට (එකතු කළ / වෙනස් කළ / මකා දැමූ) '<>' සංකේත නොමැතිව මම සොයා ගැනීමට උත්සාහ කරන වචන / වාක්‍ය ඛණ්ඩ ඇති සියලුම Git කොමිස් එය පෙන්වයි.
3. --all - සියලුම ශාඛා හරහා බලාත්මක කිරීම සහ සෙවීම.
4. --oneline - එය එක් පේළියක Git ලොගය සම්පීඩනය කරයි.
5. --graph - එය කාලානුක්‍රමිකව ඇණවුම් කළ කොමිට් වල ප්‍රස්ථාරය නිර්මාණය කරයි.

ජීට්ගේ පිළිතුර පවර්ෂෙල් හි ක්‍රියාත්මක වේ.

git grep -n <regex> $(git rev-list --all)

පහත දැක්වෙන්නේ a අඩංගු ඕනෑම ලිපිගොනුවකි password.

# Store intermediate result
$result = git grep -n "password" $(git rev-list --all)

# Display unique file names
$result | select -unique { $_ -replace "(^.*?:)|(:.*)", "" }

ඉතින් ඔබ උත්සාහ කරන්නේ කේතයේ පැරණි අනුවාදයන් අවසන් වරට යමක් තිබේදැයි බැලීමටද?

මම මෙය කරන්නේ නම්, මම බොහෝ විට git bisect භාවිතා කරමි . Bisect භාවිතා කරමින්, ඔබට දන්නා හොඳ අනුවාදයක්, දන්නා නරක අනුවාදයක් සහ සරල පිටපතක් නියම කළ හැකිය, එම අනුවාදය හොඳද නරකද යන්න පරීක්ෂා කර බලයි (මේ අවස්ථාවේ දී ඔබ සොයන කේතය තිබේද යන්න බැලීමට grep ). මෙය ක්‍රියාත්මක කිරීමෙන් කේතය ඉවත් කළ විට සොයාගත හැක.

සිදුවීම: ඔබගේ IDE භාවිතා කරමින් ඔබේ කේතය විශාල වශයෙන් පිරිසිදු කර ඇත. ගැටලුව: IDE අවශ්‍ය ප්‍රමාණයට වඩා පිරිසිදු කර ඇති අතර දැන් ඔබ කේත සම්පාදනය නොකරයි (සම්පත් නැතිවීම ආදිය)

විසඳුමක්:

git grep --cached "text_to_find"

එය "text_to_find" වෙනස් කළ ගොනුව සොයා ගනු ඇත.

ඔබට දැන් මෙම වෙනස අහෝසි කර ඔබේ කේතය සම්පාදනය කළ හැකිය.

git rev-list --all | xargs -n 5 git grep EXPRESSION

එය ජීට්ගේ විසඳුමේ වෙනස් කිරීමකි , එබැවින් එය සෙවීමේදී ප්‍රති results ල පෙන්වන අතර අවසානයේ පමණක් නොවේ (විශාල ගබඩාවක දීර් time කාලයක් ගතවනු ඇත).

මගේ නඩුවේදී මට කෙටි කැපවීමක් සෙවීමට අවශ්‍ය වූ අතර ලැයිස්තුගත විසඳුම් අවාසනාවන්ත ලෙස ක්‍රියාත්මක නොවීය.

මම එය කිරීමට සමත් විය ( REGEX ටෝකනය ආදේශ කරන්න ):

for commit in $(git rev-list --all --abbrev-commit)
do
    if [[ $commit =~ __REGEX__ ]]; then 
        git --no-pager show -s --format='%h %an - %s' $commit
    fi
done