ලුහුබඳිමින් සිටි ගොනුවක් ඇත git, නමුත් දැන් ගොනුව .gitignoreලැයිස්තුවේ ඇත.

කෙසේ වෙතත්, එම ගොනුව git statusසංස්කරණය කිරීමෙන් පසුව එය දිගටම පෙන්වයි . gitඑය සම්පූර්ණයෙන්ම අමතක කිරීමට ඔබ බල කරන්නේ කෙසේද ?

.gitignoreadd -fgit විසින් ලුහුබැඳ ඇති ලිපිගොනු සමූහයට (අ නොමැතිව ) එකතු නොකිරීම වළක්වනු ඇත , කෙසේ වෙතත් git විසින් දැනටමත් ලුහුබැඳ ඇති ඕනෑම ලිපිගොනු ලුහුබැඳීම දිගටම කරගෙන යනු ඇත.

ගොනුවක් ලුහුබැඳීම නැවැත්වීමට ඔබ එය දර්ශකයෙන් ඉවත් කළ යුතුය. මෙම විධානය මඟින් මෙය සාක්ෂාත් කරගත හැකිය.

git rm --cached <file>

ඔබට සම්පූර්ණ ෆෝල්ඩරයක් ඉවත් කිරීමට අවශ්‍ය නම්, එහි ඇති සියලුම ලිපිගොනු නැවත නැවත ඉවත් කළ යුතුය.

git rm -r --cached <folder>

ප්‍රධාන සංශෝධනයෙන් ගොනුව ඉවත් කිරීම ඊළඟ බැඳීම මත සිදුවනු ඇත.

අවවාදයයි: මෙය ඔබේ දේශීය වෙතින් භෞතික ගොනුව ඉවත් නොකරන අතර, එය ඊළඟට වෙනත් සංවර්ධක යන්ත්‍ර වලින් ගොනු ඉවත් කරනු ඇත git pull.

පහත දැක්වෙන විධාන මාලාව මඟින් Git දර්ශකයෙන් (වැඩකරන නාමාවලියෙන් හෝ දේශීය repo වෙතින් නොවේ) සියලුම අයිතම ඉවත් කරනු ඇත, පසුව Git නොසලකා හැරීමට ගරු කරන අතරම Git දර්ශකය යාවත්කාලීන කරයි. පීඑස්. දර්ශකය = හැඹිලිය

පලමු:

git rm -r --cached . 
git add .

ඉන්පසු:

git commit -am "Remove ignored files"

හෝ එක් ලයිනර්:

git rm -r --cached . && git add . && git commit -am "Remove ignored files"

git update-index මට වැඩ කරයි:

git update-index --assume-unchanged <file>

සටහන: මෙම විසඳුම ඇත්ත වශයෙන්ම ස්වාධීන වන්නේ .gitignoregitignore සොයා නොගත් ලිපිගොනු සඳහා පමණි.

සංස්කරණය කරන්න: මෙම පිළිතුර පළ කරන ලද බැවින්, නව විකල්පයක් නිර්මාණය කර ඇති අතර එය වඩාත් සුදුසු විය යුතුය. --skip-worktreeපරිශීලකයා තවදුරටත් කැප කිරීමට අකමැති නවීකරණය කරන ලද ලුහුබැඳ ඇති ලිපිගොනු සඳහා ඔබ භාවිතා කළ යුතු අතර --assume-unchangedවිශාල ලුහුබැඳ ඇති ලිපිගොනු වල තත්වය පරීක්ෂා කිරීම සඳහා git වැළැක්වීම සඳහා කාර්ය සාධනය සඳහා තබා ගන්න . වැඩි විස්තර සඳහා https://stackoverflow.com/a/13631525/717372 බලන්න ...

git update-index --skip-worktree <file>

git ls-files --ignored --exclude-standard -z | xargs -0 git rm --cached
git commit -am "Remove ignored files"

මෙය නොසලකා හරින ලද ගොනු ලැයිස්තුවක් ගෙන ඒවා දර්ශකයෙන් ඉවත් කර වෙනස්කම් සිදු කරයි.

හඳුනා නොගත් ලිපිගොනු ඉවත් කිරීමට මම සෑම විටම මෙම විධානය භාවිතා කරමි. එක් පේළියක්, යුනික්ස් විලාසිතාව, පිරිසිදු ප්‍රතිදානය:

git ls-files --ignored --exclude-standard | sed 's/.*/"&"/' | xargs git rm -r --cached

එය ඔබගේ නොසලකා හරින ලද සියලුම ලිපිගොනු ලැයිස්තුගත කරයි, සෑම නිමැවුම් රේඛාවක්ම උපුටා ගත් රේඛාවක් වෙනුවට ආදේශ git rm -r --cachedකරන්න.

එය පිටතට ගෙනයන්න, කැපවන්න, පසුව එය නැවත ඇතුළට ගෙන යන්න. මෙය අතීතයේ මට වැඩ කර ඇත. මෙය ඉටු කිරීම සඳහා බොහෝ විට 'ගිටාර්' ක්‍රමයක් තිබේ.

ඔබට git rmලුහුබැඳ ගිය ගොනුවක් වෙනත් පුද්ගලයින්ට අවශ්‍ය විය හැකි නම් (අනතුරු ඇඟවීම, ඔබ git rm --cached වෙනත් කෙනෙකුට මෙම වෙනස ලැබුනත්, ඔවුන්ගේ ගොනු ඔවුන්ගේ ගොනු පද්ධතියේ මැකෙනු ඇත). මේවා බොහෝ විට සිදු කරනුයේ වින්‍යාස ගොනු අභිබවා යාම, සත්‍යාපන අක්තපත්‍ර යනාදිය හේතුවෙනි. කරුණාකර https://gist.github.com/1423106 බලන්න .

සාරාංශ ගත කිරීමට:

• ඔබගේ යෙදුම නොසලකා හරින ලද config-overide.ini ගොනුවක් සොයන්න සහ කැපවූ ගොනුව config.ini හරහා භාවිතා කරන්න (හෝ විකල්පයක් ලෙස ~ / .config / myapp.ini හෝ $ MYCONFIGFILE සඳහා බලන්න)
• Config-sample.ini ගොනුව කැප කර config.ini ගොනුව නොසලකා හරින්න, ස්ක්‍රිප්ට් එකක් හෝ අවශ්‍ය නම් ගොනුව අවශ්‍ය පරිදි පිටපත් කරන්න.
• ඔබ සඳහා වන වෙනස්කම් යෙදීමට සහ ඉවත් කිරීමට gitattributes clean / smudge magic භාවිතා කිරීමට උත්සාහ කරන්න, නිදසුනක් ලෙස වින්‍යාස ගොනුව විකල්ප ශාඛාවකින් පිටවීමක් ලෙස විග්‍රහ කර HEAD වෙතින් පිටවීමක් ලෙස වින්‍යාස ගොනුව පිරිසිදු කරන්න. මෙය උපක්‍රමශීලී දෙයක්, නවක පරිශීලකයා සඳහා මම එය නිර්දේශ නොකරමි.
• වින්‍යාස ගොනුව කිසි විටෙකත් මාස්ටර් සමඟ ඒකාබද්ධ නොවන විහිදුණු ශාඛාවක තබා ගන්න. ඔබට යෙදවීමට / සම්පාදනය කිරීමට / පරීක්ෂා කිරීමට අවශ්‍ය වූ විට ඔබ එම ශාඛාවට ඒකාබද්ධ වී එම ගොනුව ලබා ගන්න. මානව ඒකාබද්ධ කිරීමේ ප්‍රතිපත්ති සහ අතිරේක-මොඩියුල මොඩියුල භාවිතා කිරීම හැර මෙය අත්‍යවශ්‍යයෙන්ම දුම් / පිරිසිදු ප්‍රවේශය වේ.
• ප්‍රති-නිර්දේශ කිරීම: උපකල්පනය නොවෙනස්ව භාවිතා නොකරන්න, එය අවසන් වන්නේ කඳුළු වලින් පමණි (මක්නිසාද යත්, තමාටම බොරු කීම නරක දේ සිදුවීමට හේතු වනු ඇත, ඔබේ වෙනස සදහටම නැති වී යන ආකාරයට).

මෙය භාවිතා කරන්න:

1. ඔබට ලිපිගොනු ගොඩක් ඉවත් කිරීමට අවශ්‍යයි, හෝ

2. ඔබ ඔබේ gitignore ගොනුව යාවත්කාලීන කළේය

මූලාශ්‍ර සබැඳිය: http://www.codeblocq.com/2016/01/Untrack-files-already-added-to-git-repository-based-on-gitignore/

ඔබගේ git ගබඩාවට ඔබ දැනටමත් ලිපිගොනු කිහිපයක් එකතු කර ඇති බව කියමු. ඉන්පසු ඒවා ඔබේ .gitignore වෙත එක් කරන්න; මෙම ලිපිගොනු ඔබගේ ගබඩාවේ දර්ශකයේ තවමත් පවතී. ඒවායින් මිදෙන්නේ කෙසේදැයි මෙම ලිපියෙන් අපි බලමු.

පියවර 1: ඔබගේ සියලු වෙනස්කම් කරන්න

ඉදිරියට යාමට පෙර, ඔබගේ .gitignore ගොනුව ඇතුළුව ඔබගේ සියලු වෙනස්කම් සිදු කර ඇති බවට වග බලා ගන්න.

පියවර 2: නිධියෙන් සියල්ල ඉවත් කරන්න

ඔබේ repo ඉවත් කිරීමට, භාවිතා කරන්න:

git rm -r --cached .

• rm යනු ඉවත් කිරීමේ විධානයයි
• -r මඟින් පුනරාවර්තන ඉවත් කිරීමට ඉඩ දෙනු ඇත
• -කැච් මඟින් දර්ශකයෙන් ගොනු ඉවත් කරනු ඇත. ඔබගේ ලිපිගොනු තවමත් පවතී.

මෙම rmවිධානය සමාව විය හැක. එය කලින් කරන දේ උත්සාහ කිරීමට ඔබට අවශ්‍ය නම්, දේවල් පරීක්ෂා කිරීමට -nහෝ --dry-runධජය එක් කරන්න .

පියවර 3: සියල්ල නැවත එකතු කරන්න

git add .

පියවර 4: කැප වන්න

git commit -m ".gitignore fix"

ඔබේ ගබඩාව පිරිසිදුයි :)

එහි effective ලදායී වෙනස්කම් දැකීමට ඔබගේ දුරස්ථයට වෙනස්කම් තල්ලු කරන්න.

මම මෙය ඉටු කළේ git filter-branch භාවිතා කරමිනි . මා භාවිතා කළ නිශ්චිත විධානය man පිටුවෙන් ලබාගෙන ඇත:

අවවාදයයි : මෙය ඔබගේ සමස්ත ඉතිහාසයෙන් ගොනුව මකා දමනු ඇත

git filter-branch --index-filter 'git rm --cached --ignore-unmatch filename' HEAD

මෙම විධානය මඟින් සමස්ත කැපවීමේ ඉතිහාසයම ප්‍රතිනිර්මාණය කරනු ඇති අතර, git rmඑක් එක් බැඳීමට පෙර ක්‍රියාත්මක වන අතර එමඟින් නිශ්චිත ගොනුව ඉවත් කරනු ඇත. එය විධානය ධාවනය පෙර එය තහවුරු කිරීම අමතක කරන්න එපා ඇත අහිමි කළ යුතුය.

මට වැඩ නොකළ දේ

(ලිනක්ස් යටතේ), ls-files --ignored --exclude-standard | xargs git rm -r --cachedප්‍රවේශය යෝජනා කරමින් මෙහි ලිපි භාවිතා කිරීමට මට අවශ්‍ය විය . කෙසේ වෙතත්, (සමහරක්) ඉවත් කළ යුතු ලිපිගොනු වල නව රේඛාවක් / එල්එෆ් / \nඒවායේ නම් ඇතුළත් කර ඇත. විසඳුම් දෙකම:

git ls-files --ignored --exclude-standard | xargs -d"\n" git rm --cached
git ls-files --ignored --exclude-standard | sed 's/.*/"&"/' | xargs git rm -r --cached

මෙම තත්වයට මුහුණ දෙන්න (සොයාගත නොහැකි ලිපිගොනු පිළිබඳ දෝෂ ලබා ගන්න).

ඒ නිසා මම ඉදිරිපත් කරනවා

git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached
git commit -am "Remove ignored files"

මෙය භාවිතා කරයි -zකිරීමට තර්කය LS-ගොනු , සහ -0කිරීමට තර්කය xargs ගොනු නාමය දී "මොහොත," අක්ෂර සඳහා ආරක්ෂිතව / නිවැරදිව උචිත.

අත්පොත පිටුවේ git-ls-files (1) හි මෙසේ සඳහන් වේ:

-Z විකල්පය භාවිතා නොකරන විට, මාර්ග නාමවල TAB, LF සහ බැක්ස්ලෑෂ් අක්ෂර පිළිවෙලින් \ t, \ n සහ as ලෙස නිරූපණය කෙරේ.

එබැවින් ගොනු නාමවල මෙම අක්ෂර කිසිවක් තිබේ නම් මගේ විසඳුම අවශ්‍ය යැයි මම සිතමි.

1. ඔබගේ .gitignoreගොනුව යාවත්කාලීන කරන්න - නිදසුනක් ලෙස, ඔබට ලුහුබැඳීමට අවශ්‍ය නැති ෆෝල්ඩරයක් එක් කරන්න .gitignore.

2. git rm -r --cached .- අවශ්‍ය සහ අනවශ්‍ය ඇතුළුව සියලුම ලුහුබැඳ ඇති ලිපිගොනු ඉවත් කරන්න. ඔබ දේශීයව සුරකින තාක් කල් ඔබේ කේතය ආරක්ෂිත වේ.

3. git add .- ඇති ලිපිගොනු හැර අනෙක් සියලුම ගොනු නැවත ඇතුලත් වේ .gitignore.

අපව නිවැරදි දිශාවට යොමු කිරීම සඳහා k අකිරයමමොටෝ වෙත තොප්පියක්.

මම හිතන්නේ, සමහර විට එය ගොනුව සංකල්පනය කිරීම නිසා සම්පූර්ණයෙන්ම අමතක කළ නොහැක ( "ස්නැප්ෂොට්, වෙනස්කම් නොවේ" යන කොටස ).

උදාහරණයක් ලෙස, සීවීඑස් භාවිතා කරන විට මෙම ගැටළුව නොමැත. CVS තොරතුරු ගොනු පදනම් කරගත් වෙනස්කම් ලැයිස්තුවක් ලෙස ගබඩා කරයි. සීවීඑස් සඳහා තොරතුරු යනු ලිපිගොනු සමූහයක් වන අතර කාලයත් සමඟ එක් එක් ගොනුවට කරන ලද වෙනස්කම් වේ.

නමුත් Git හි ඔබ කැපවන සෑම අවස්ථාවකම හෝ ඔබේ ව්‍යාපෘතියේ තත්වය සුරකින විට, එය මූලික වශයෙන් ඔබගේ සියලු ලිපිගොනු ඒ මොහොතේ පෙනෙන්නේ කෙසේද යන්න පිළිබඳ පින්තූරයක් ගන්නා අතර එම ඡායාරූපයට යොමු කිරීමක් ගබඩා කරයි. එබැවින්, ඔබ එක් වරක් ගොනුව එක් කළහොත්, එය සෑම විටම එම ඡායාරූපයේ අඩංගු වේ.

මෙම ලිපි දෙක මට ප්‍රයෝජනවත් විය:

git උපකල්පනය-නොවෙනස්ව එදිරිව skip-worktree සහ Git සමඟ ලුහුබැඳ ඇති ලිපිගොනු වල වෙනස්කම් නොසලකා හරින ආකාරය

ගොනුව දැනටමත් ලුහුබැඳ තිබේ නම්, එය පදනම් කරගෙන මම පහත සඳහන් දේ කරමි:

git update-index --skip-worktree <file>

මේ මොහොතේ සිට මෙම ගොනුවේ සියලුම දේශීය වෙනස්කම් නොසලකා හරිනු ඇති අතර දුරස්ථයට නොයනු ඇත. දුරස්ථව ගොනුව වෙනස් කළ හොත්, ගැටුම් ඇති git pullවේ. ස්ටෑෂ් ක්‍රියා නොකරයි. එය විසඳීම සඳහා, ගොනු අන්තර්ගතය ආරක්ෂිත ස්ථානයට පිටපත් කර මෙම පියවර අනුගමනය කරන්න:

git update-index --no-skip-worktree <file>
git stash
git pull 

ගොනු අන්තර්ගතය දුරස්ථ අන්තර්ගතයෙන් ප්‍රතිස්ථාපනය වේ. ඔබගේ වෙනස්කම් ආරක්ෂිත ස්ථානයේ සිට ගොනුවට අලවා නැවත ක්‍රියාත්මක කරන්න:

git update-index --skip-worktree <file>

ව්යාපෘතිය සමඟ වැඩ කරන සෑම කෙනෙකුම ඉටු කරන්නේ නම් git update-index --skip-worktree <file>, ගැටළු pullනොමැති විය යුතුය. සෑම සංවර්ධකයෙකුටම තමන්ගේම ව්‍යාපෘති වින්‍යාසයක් ඇති විට, වින්‍යාස ගොනු සඳහා මෙම විසඳුම හරි ය.

දුරස්ථව ගොනුව වෙනස් කර ඇති සෑම අවස්ථාවකම මෙය කිරීම එතරම් පහසු නැත, නමුත් දුරස්ථ අන්තර්ගතයන් නැවත ලිවීමෙන් එය ආරක්ෂා කළ හැකිය.

පහත දැක්වෙන පියවර අනුක්‍රමිකව කරන්න, ඔබ හොඳින් වනු ඇත.

1. ඩිරෙක්ටරියෙන් / ගබඩාවෙන් වැරදියට එකතු කළ ගොනු ඉවත් කරන්න . ඔබට "rm -r" (linux සඳහා) විධානය භාවිතා කළ හැකිය, නැතහොත් නාමාවලි පිරික්සීමෙන් ඒවා මකා දැමිය හැකිය. නැතහොත් ඒවා ඔබේ පරිගණකයේ වෙනත් ස්ථානයකට ගෙන යන්න. [ චලනය / ඉවත් කිරීම සඳහා ධාවනය වන්නේ නම් ඔබට IDE වසා දැමිය යුතුය ]

2. දැන් ගොනු කිරීමට ගොනු / නාමාවලි එකතු gitignoreකර එය සුරකින්න.

3. දැන් මෙම විධානයන් භාවිතා කිරීමෙන් ඒවා git හැඹිලියෙන් ඉවත් කරන්න (බහලුම් එකකට වඩා තිබේ නම්, මෙම විධානය නැවත නැවත නිකුත් කිරීමෙන් ඒවා එකින් එක ඉවත් කරන්න)

git rm -r --cached path-to-those-files

4.now කරන්න ඇති කොමිට් තල්ලුව , මෙම විධානය භාවිතා කරන්න. මෙමඟින් එම ගොනු git දුරස්ථයෙන් ඉවත් කර git එම ගොනු ලුහුබැඳීම නවත්වනු ඇත.

git add .
git commit -m "removed unnecessary files from git"
git push origin

පිටපත / පේස්ට් පිළිතුර git rm --cached -r .; git add .; git status

මෙම විධානය මඟින් දැනටමත් Git නිධියකට බැඳී ඇති ගොනු නොසලකා හරිනු ඇත, නමුත් දැන් අපි ඒවා එකතු කර ඇත්තෙමු .gitignore.

මැට් ෆියර්ගේ පිළිතුර වඩාත් effective ලදායී IMHO විය. පහත දැක්වෙන්නේ වින්ඩෝස් වල සිටින අයට ඔවුන්ගේ බැහැර කිරීමේ ලැයිස්තුවට ගැලපෙන ඔවුන්ගේ git repo වෙතින් ගොනු ඉවත් කිරීමට පමණි.

# Get files matching exclusionsfrom .gitignore
# Excluding comments and empty lines
$ignoreFiles =  gc .gitignore | ?{$_ -notmatch  "#"} |  ?{$_ -match  "\S"} | % {
                    $ignore = "*" + $_ + "*"
                    (gci -r -i $ignore).FullName
                }
$ignoreFiles = $ignoreFiles| ?{$_ -match  "\S"}

# Remove each of these file from Git 
$ignoreFiles | % { git rm $_}

git add .

ගොනුව ආරක්ෂිත ස්ථානයකට ගෙනයන්න හෝ පිටපත් කරන්න, එවිට ඔබට එය නැති නොවේ. ඉන්පසු ගොනුව rm කර බැඳ තබන්න. ඔබ කලින් කළ එක් කටයුත්තකට හෝ එය ඉවත් නොකළ වෙනත් ශාඛාවකට ආපසු ගියහොත් ගොනුව තවමත් පෙන්වනු ඇත. කෙසේ වෙතත්, සියලු අනාගත කොමිස් වලදී, ඔබට නැවත ගොනුව නොපෙනේ. ගොනුව නොසලකා හරින්නේ නම්, ඔබට එය නැවත ෆෝල්ඩරයට ගෙන යා හැකි අතර git එය නොපෙනේ.

git rm --cachedවිධානය භාවිතා කිරීමෙන් මුල් ප්‍රශ්නයට පිළිතුරු නොලැබේ:

git[ගොනුවක්] සම්පූර්ණයෙන්ම අමතක කිරීමට ඔබ බල කරන්නේ කෙසේද ?

ඇත්ත වශයෙන්ම, මෙම විසඳුම මඟින් ගොනුව ගබඩාවේ අනෙක් සෑම අවස්ථාවකම මකා දැමීමට හේතු වනු ඇත git pull.

ගොනුවක් අමතක කිරීමට git බල කිරීමට නිවැරදි ක්‍රමය මෙහි ලේඛනගත කර ඇත්තේ GitHub විසිනි.

ප්‍රලේඛනය කියවීමට මම නිර්දේශ කරමි, නමුත් මූලික වශයෙන්:

git fetch --all
git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch full/path/to/file' --prune-empty --tag-name-filter cat -- --all
git push origin --force --all
git push origin --force --tags
git for-each-ref --format='delete %(refname)' refs/original | git update-ref --stdin
git reflog expire --expire=now --all
git gc --prune=now

full/path/to/fileගොනුවේ සම්පූර්ණ මාර්ගය සමඟ ප්‍රතිස්ථාපනය කරන්න. ඔබ ගොනුව ඔබගේ එකතු කර ඇති බවට වග බලා ගන්න .gitignore.

ඔබ ඔබේ තාවකාලික ඉතිහාසය වෙනස් කරන බැවින් (තාවකාලිකව) ඔබේ ගබඩාවට වේගයෙන් ඉදිරියට නොයෑමට ඉඩ දිය යුතුය.

මෙම BFG '--strip-blobs-: එය ඕනෑම විශාල ඓතිහාසික (නෑ-in-ඔබේ-වත්මන්-නසා) ගොනු ඉවත් කරන බවට සරල ධජය ඇත එසේ, විශේෂයෙන් Git ප්රතිමිලදී සිට විශාල ගොනු හෝ මුරපද වගේ අනවශ්ය දත්ත ඉවත් කිරීම සඳහා සැලසුම් කර ඇත වඩා විශාල '

$ java -jar bfg.jar --strip-blobs-bigger-than 100M

ඔබ නමින් ලිපිගොනු නියම කිරීමට කැමති නම්, ඔබට එය ද කළ හැකිය:

$ java -jar bfg.jar --delete-files *.mp4

BFG git filter-branch වලට වඩා 10-1000x වේගවත් වන අතර සාමාන්‍යයෙන් භාවිතා කිරීමට වඩා පහසුය - වැඩි විස්තර සඳහා සම්පූර්ණ භාවිත උපදෙස් සහ උදාහරණ පරීක්ෂා කරන්න .

මුලාශ්‍රය: https://confluence.atlassian.com/bitbucket/reduce-repository-size-321848262.html

ඔබට සීඑල්අයි භාවිතා කිරීමට අවශ්‍ය නැතිනම් වින්ඩෝස් හි වැඩ කරන්නේ නම්, ඉතා සරල විසඳුමක් වන්නේ ඉබ්බන්ගිට් භාවිතා කිරීමයි , එයට මෙනුවේ “මකන්න (දේශීයව තබා ගන්න)” ක්‍රියාව ඇත.

මම ජෝන්බ්‍රේව්ගේ පිළිතුරට කැමතියි, නමුත් මට වැඩ කරන ඩිරෙක්ටරි ප්‍රමාණවත් තරම් අවුල් සහගතය - එය මට ටිකක් බයයි, එබැවින් මෙන්න මම කළ දේ:

git config --global alias.exclude-ignored '! git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached && git ls-files -z --ignored --exclude-standard | xargs -0 git stage && git stage .gitignore && git commit -m "නව gitignore සහ නොසලකා හරින ලද ගොනු දර්ශකයෙන් ඉවත් කරන්න"

එය බිඳ දැමීම:

git ls-files -z --ignored --exclude-standard | xargs -0 git rm -r --cached 
git ls-files -z --ignored --exclude-standard | xargs -0 git stage 
git stage .gitignore 
git commit -m "new gitignore and remove ignored files from index"

• නොසලකා හරින ලද ගොනු දර්ශකයෙන් ඉවත් කරන්න
• අදියර .gitignore සහ ඔබ දැන් ඉවත් කළ ගොනු
• කැපවන්න

මෙය නවතම git හි තවදුරටත් ගැටළුවක් නොවේ (ලියන අවස්ථාවේ v2.17.1).

මෙම .gitignoreඅවසානයේ දම්වැල් මත ධාවනය වන-නමුත්-මකා නොසලකා හරියි ගොනු. පහත දැක්වෙන ස්ක්‍රිප්ට් ධාවනය කිරීමෙන් ඔබට මෙය පරීක්ෂා කර බැලිය හැකිය. අවසාන git statusප්‍රකාශය "කැපවීමට කිසිවක් නැත" යනුවෙන් වාර්තා කළ යුතුය.

# Create empty repo
mkdir gitignore-test
cd gitignore-test
git init

# Create a file and commit it
echo "hello" > file
git add file
git commit -m initial

# Add the file to gitignore and commit
echo "file" > .gitignore
git add .gitignore
git commit -m gitignore

# Remove the file and commit
git rm file
git commit -m "removed file"

# Reintroduce the file and check status.
# .gitignore is now respected - status reports "nothing to commit".
echo "hello" > file
git status

දැනටමත් කැපවී ඇත්නම් DS_Store:

find . -name .DS_Store -print0 | xargs -0 git rm --ignore-unmatch

ඒවා නොසලකා හරින්න:

echo ".DS_Store" >> ~/.gitignore_global
echo "._.DS_Store" >> ~/.gitignore_global
echo "**/.DS_Store" >> ~/.gitignore_global
echo "**/._.DS_Store" >> ~/.gitignore_global
git config --global core.excludesfile ~/.gitignore_global

අවසාන වශයෙන්, කැපවීමක් කරන්න!

විශේෂයෙන් IDE මත පදනම් වූ ලිපිගොනු සඳහා, මම මෙය භාවිතා කරමි:

නිදසුනක් ලෙස slnx.sqlite, මම පහත දැක්වෙන ආකාරයට මුළුමනින්ම ඉවත් කර ගතිමි:

git rm {PATH_OF_THE_FILE}/slnx.sqlite -f
git commit -m "remove slnx.sqlite"

එම ලිපිගොනු සමහරක් දේශීය පරිශීලක සැකසුම් සහ ව්‍යාපෘති සඳහා මනාපයන් ගබඩා කරන බව මතක තබා ගන්න (ඔබ විවෘත කළ ගොනු වැනි). එබැවින් ඔබ සැරිසැරීමේදී හෝ ඔබගේ IDE හි යම් යම් වෙනස්කම් සිදු කරන සෑම අවස්ථාවකම එම ගොනුව වෙනස් වන අතර එම නිසා එය පරීක්ෂා කර බලා නොගැලපෙන වෙනස්කම් ඇති බව පෙන්වයි.

පිළිගත් පිළිතුර ගොනුවක් ගැන " Git " අමතක නොකරයි ... "( ically තිහාසිකව ). එය වර්තමාන / අනාගතයේදී ගොනුව නොසලකා හැරීමට පමණක් හේතු වේ.

මෙම ක්රමය වර්ගයන් Git සම්පූර්ණයෙන්ම අමතක නොසලකා ගොනු ( පසුගිය / වර්තමාන / අනාගත), නමුත් කරන්නේ නැහැ වැඩකරන බහලුම (දුරස්ථ සිට නැවත ඇද විට පවා) සිට delete දෙයක්.

මෙම ක්රමය භාවිතා කිරීම අවශ්ය වේ /.git/info/exclude(කැමති) හෝ එය පෙර දැනට පවතින .gitignore දී සියලු අමතක / නොසලකා නොහැරිය හැකි ගොනු ඇති බව අනාචාරයේ. ¹

GIT ක්රියාත්මක සියලු ක්රම ඵලදායී නැවත ලිවීම් ඉතිහාසය පසු-the-ඇත්ත හැසිරීම නොසලකා හා ඒ නිසා ඇති සැලකිය යුතු ප්රතිවිපාක කෙටි කලකින් මෙම ක්රියාවලිය පසු කොපමන විය හැකි ඕනෑම මහජන / පොදු / සහයෝගී ප්රතිමිලදී සඳහා. ²

සාමාන්‍ය උපදෙස්: පිරිසිදු රෙපෝ එකකින් ආරම්භ කරන්න - සෑම දෙයක්ම කැපවී ඇත, වැඩ කරන නාමාවලියෙහි හෝ දර්ශකයේ කිසිවක් ඉතිරිව නැත, උපස්ථයක් සාදන්න !

එසේම, අදහස් / සංශෝධන ඉතිහාසය පිළිබඳ මෙම පිළිතුර ( හා සංශෝධන ඉතිහාසය පිළිබඳ මෙම ප්රශ්නය ) ප්රයෝජනවත් / දැනුවත් විය හැක.

#commit up-to-date .gitignore (if not already existing)
#this command must be run on each branch

git add .gitignore
git commit -m "Create .gitignore"

#apply standard git ignore behavior only to current index, not working directory (--cached)
#if this command returns nothing, ensure /.git/info/exclude AND/OR .gitignore exist
#this command must be run on each branch

git ls-files -z --ignored --exclude-standard | xargs -0 git rm --cached

#Commit to prevent working directory data loss!
#this commit will be automatically deleted by the --prune-empty flag in the following command
#this command must be run on each branch

git commit -m "ignored index"

#Apply standard git ignore behavior RETROACTIVELY to all commits from all branches (--all)
#This step WILL delete ignored files from working directory UNLESS they have been dereferenced from the index by the commit above
#This step will also delete any "empty" commits.  If deliberate "empty" commits should be kept, remove --prune-empty and instead run git reset HEAD^ immediately after this command

git filter-branch --tree-filter 'git ls-files -z --ignored --exclude-standard | xargs -0 git rm -f --ignore-unmatch' --prune-empty --tag-name-filter cat -- --all

#List all still-existing files that are now ignored properly
#if this command returns nothing, it's time to restore from backup and start over
#this command must be run on each branch

git ls-files --other --ignored --exclude-standard

අවසාන වශයෙන්, පහත දැක්වෙන විධානයන් පිළිබඳ වැදගත් අනතුරු ඇඟවීම් / තොරතුරු ඇතුළත් මෙම GitHub මාර්ගෝපදේශයේ (6 වන පියවරෙන් ආරම්භ කරන්න) අනුගමනය කරන්න .

git push origin --force --all
git push origin --force --tags
git for-each-ref --format="delete %(refname)" refs/original | git update-ref --stdin
git reflog expire --expire=now --all
git gc --prune=now

දැන් වෙනස් කරන ලද දුරස්ථ repo වෙතින් අදින වෙනත් devs උපස්ථයක් සාදා පසුව:

#fetch modified remote

git fetch --all

#"Pull" changes WITHOUT deleting newly-ignored files from working directory
#This will overwrite local tracked files with remote - ensure any local modifications are backed-up/stashed

git reset FETCH_HEAD

පාද සටහන්

¹/.git/info/exclude ඉහත උපදෙස් භාවිතා කරමින් සියලුම historical තිහාසික කොමිස් වලට අදාළ කළ හැකි නිසා , සමහර විට .gitignoreගොනුවක් අවශ්‍ය වන commit තිහාසික බැඳීම් (ය) වෙත ලබා ගැනීම පිළිබඳ විස්තර මෙම පිළිතුරේ සීමාවෙන් ඔබ්බට විය හැකිය. මට අවශ්‍ය වූයේ .gitignoreමූල කැපවීම තුළ නිසි ලෙස කටයුතු කිරීමයි, එය මා කළ පළමු දෙයයි. සිට දැනුනා විය හැක /.git/info/excludeනොතකා එහිදී එකම දෙයක් ඉටු කළ හැකි .gitignoreවන සිදු ඉතිහාසයේ පවතින අතර, එය පැහැදිලිව නැවත ලියා ඉතිහාසය යනු ඉතා පවා විට දැන, මතභේදයට තුඩු විෂය ප්රතිවිපාක කෙටි කලකින් .

FWIW, විභව ක්‍රම ඇතුළත් විය හැකිය git rebaseහෝ මෙම ප්‍රශ්නයට පිළිතුරු වැනි එක් එක් බැඳීමට බාහිරgit filter-branch පිටපත් කරයි .gitignore

² හුදකලා විධානයක ප්‍රති results ල ලබා දීමෙන් පසු සත්‍යය නොසලකා හැරීමේ හැසිරීම බලාත්මක කිරීම බලහත්කාරයෙන් තල්ලු කරන ලද දුරස්ථයෙන් අනාගතයේදී ඇද ගැනීමේදී git rm --cachedඅලුතින් නොසලකා හරින ලද ගොනු මකාදැමීමට හේතු විය හැක . --prune-emptyපහත දැක්වෙන git filter-branchවිධානයෙහි ඇති ධජය පෙර "නොසලකා හරින ලද සියලුම ගොනු මකන්න" දර්ශකය පමණක් කැපවීම ස්වයංක්‍රීයව ඉවත් කිරීමෙන් මෙම ගැටළුව මඟහරවා ගනී. Git ඉතිහාසය නැවත ලිවීමෙන් බැඳීම් හැෂ් ද වෙනස් වන අතර එමඟින් අනාගත / පොදු / හවුල් / සහයෝගිතා ගබඩාවලින් සිදුවන විනාශයන් විනාශ වනු ඇත . එවැනි රෙපෝ එකකට මෙය කිරීමට පෙර කරුණාකර එහි ඇති ප්‍රබලතා තේරුම් ගන්න . මෙම GitHub මාර්ගෝපදේශය පහත සඳහන් දේ නියම කරයි:

ඔබේ සගයින්ට එක්ව කියන්න rebase , නෑ ඒකාබද්ධ, ඔවුන් ඔබගේ (දූෂණය) පැරණි ගබඩාව ඉතිහාසයේ ලකුණු නිර්මාණය ශාඛාවන්. එක් ඒකාබද්ධ කිරීමේ කැපවීමකින් ඔබ පිරිසිදු කිරීමේ කරදරයට ගිය අපකීර්තිමත් ඉතිහාසය නැවත හඳුන්වා දිය හැකිය.

බව විකල්ප විසඳුම් නැහැ දුරස්ථ ණයකට බලපාන වේ git update-index --assume-unchanged </path/file>හෝ git update-index --skip-worktree <file>සොයා ගත හැක උදාහරණ වන මෙහි .

යමෙකුට වින්ඩෝස් හි අසීරු කාලයක් තිබේ නම් සහ ඔබට සම්පූර්ණ ෆෝල්ඩරය නොසලකා හැරීමට අවශ්‍ය නම්, 'සීඩී' 'ෆෝල්ඩරය' අපේක්‍ෂා කර 'මෙහි Git Bash' කරන්න.

git ls-files -z | xargs -0 git update-index --assume-unchanged

මගේ නඩුවේදී, මට ඉවත් කිරීමට අවශ්‍ය ඩිරෙක්ටරි කිහිපයක .lock ගොනු කිහිපයක් තිබුණි. මම පහත සඳහන් දෑ ධාවනය කළ අතර ඒවා ඉවත් කිරීම සඳහා එක් එක් නාමාවලියට නොයා එය ක්‍රියාත්මක විය:

git rm -r --cached **/*.lock

මෙය කිරීමෙන් මා සිටි ස්ථානයේ 'root' යටතේ ඇති සෑම ෆෝල්ඩරයකටම ගොස් රටාවට ගැලපෙන සියලුම ගොනු බැහැර කර ඇත.

මෙය අන් අයට උපකාරී වේ යැයි සිතමු!