Git history में बड़े कमिट्स को कैसे पहचाना / पहचाना जाए?


365

मेरे पास 300 एमबी गिट रेपो है। मेरी वर्तमान में जांच की गई फ़ाइलों का कुल आकार 2 एमबी है, और बाकी के रेपो रेपो का कुल आकार 298 एमबी है। यह मूल रूप से एक कोड-केवल रेपो है जो कुछ एमबी से अधिक नहीं होना चाहिए।

मुझे संदेह है कि किसी ने गलती से कुछ बड़ी फाइलें (वीडियो, चित्र इत्यादि) बनाई हैं, और फिर उन्हें हटा दिया ... लेकिन गिट से नहीं, इसलिए इतिहास में अभी भी बेकार बड़ी फाइलें हैं। गिट इतिहास में बड़ी फाइलें कैसे पा सकते हैं? 400+ कमिट हैं, इसलिए एक-एक करके जाना व्यावहारिक नहीं है।

नोट : मेरा प्रश्न फ़ाइल को निकालने के तरीके के बारे में नहीं है , लेकिन इसे पहली जगह में कैसे खोजें



जवाबों:


143

मैंने इस स्क्रिप्ट को एक पुराने भंडार में बड़ी (और गैर-स्पष्ट) वस्तुओं को खोजने के लिए अतीत में बहुत उपयोगी पाया है:


#!/bin/bash
#set -x 

# Shows you the largest objects in your repo's pack file.
# Written for osx.
#
# @see https://stubbisms.wordpress.com/2009/07/10/git-script-to-show-largest-pack-objects-and-trim-your-waist-line/
# @author Antony Stubbs

# set the internal field separator to line break, so that we can iterate easily over the verify-pack output
IFS=$'\n';

# list all objects including their size, sort by size, take top 10
objects=`git verify-pack -v .git/objects/pack/pack-*.idx | grep -v chain | sort -k3nr | head`

echo "All sizes are in kB's. The pack column is the size of the object, compressed, inside the pack file."

output="size,pack,SHA,location"
allObjects=`git rev-list --all --objects`
for y in $objects
do
    # extract the size in bytes
    size=$((`echo $y | cut -f 5 -d ' '`/1024))
    # extract the compressed size in bytes
    compressedSize=$((`echo $y | cut -f 6 -d ' '`/1024))
    # extract the SHA
    sha=`echo $y | cut -f 1 -d ' '`
    # find the objects location in the repository tree
    other=`echo "${allObjects}" | grep $sha`
    #lineBreak=`echo -e "\n"`
    output="${output}\n${size},${compressedSize},${other}"
done

echo -e $output | column -t -s ', '

यह आपको बूँद का ऑब्जेक्ट नाम (SHA1sum) देगा, और फिर आप इस तरह से एक स्क्रिप्ट का उपयोग कर सकते हैं:

... उन सभी में से प्रत्येक को इंगित करने वाले वचन को खोजने के लिए।


31
यह उत्तर वास्तव में मददगार था, क्योंकि इसने मुझे ऊपर की पोस्ट पर भेज दिया। जबकि पोस्ट की स्क्रिप्ट ने काम किया, मैंने पाया कि यह काफी धीमी है। इसलिए मैंने इसे फिर से लिखा है, और यह अब बड़े रिपॉजिटरी पर काफी तेज हो गया है। एक नज़र है: gist.github.com/nk9/b150542ef72abc7974cb
Nick K9

7
कृपया अपने उत्तरों में पूर्ण निर्देश शामिल करें, न कि केवल ऑफसाइट लिंक; हम क्या करते हैं जब stubbisms.wordpress.com अनिवार्य रूप से एह नीचे चला जाता है?
ThorSummoner

@ NickK9 दिलचस्प रूप से मुझे आपकी स्क्रिप्ट और दूसरे से अलग आउटपुट मिलता है। बड़ी वस्तुओं का एक समूह है जो आपकी याद आती है। क्या मुझे कुछ याद आ रहा है?
उपआदाम

ओह बढ़िया! मेरी स्क्रिप्ट को तेजी से बनाने के लिए धन्यवाद @nick \ k9: D @UpAndAdam, क्या आप कह रहे हैं कि मेरी स्क्रिप्ट ने गलत आउटपुट तैयार किया है?
एंटनी स्टब्ब्स

1
इन टिप्पणियों से ऐसा लगता है जैसे हम बाइट्स में आकार की रिपोर्ट कर रहे हैं, लेकिन मुझे किलोबाइट मिलते हैं।
कैट

680

🚀 एक धधकते हुए तेज खोल एक लाइनर ly

यह शेल लिपि रिपॉजिटरी में सभी ब्लॉब ऑब्जेक्ट्स को प्रदर्शित करती है, जो सबसे छोटे से लेकर सबसे बड़े तक छांटे जाते हैं।

मेरे सैंपल रेपो के लिए, यह यहां पाए गए अन्य लोगों की तुलना में लगभग 100 गुना अधिक तेजी से चला।
मेरे भरोसेमंद एथलॉन II X4 सिस्टम पर, यह केवल एक मिनट में 5.6 मिलियन ऑब्जेक्ट के साथ लिनक्स कर्नेल रिपॉजिटरी को संभालता है

द बेस स्क्रिप्ट

git rev-list --objects --all \
| git cat-file --batch-check='%(objecttype) %(objectname) %(objectsize) %(rest)' \
| sed -n 's/^blob //p' \
| sort --numeric-sort --key=2 \
| cut -c 1-12,41- \
| $(command -v gnumfmt || echo numfmt) --field=2 --to=iec-i --suffix=B --padding=7 --round=nearest

जब आप उपरोक्त कोड चलाते हैं, तो आपको अच्छा मानव-पठनीय आउटपुट मिलेगा :

...
0d99bb931299  530KiB path/to/some-image.jpg
2ba44098e28f   12MiB path/to/hires-image.png
bd1741ddce0d   63MiB path/to/some-video-1080p.mp4

macOS उपयोगकर्ता : चूंकि numfmtmacOS पर उपलब्ध नहीं है, आप या तो अंतिम पंक्ति को छोड़ सकते हैं और कच्चे बाइट आकार के साथ सौदा कर सकते हैं याbrew install coreutils

छनन

प्राप्त करने के लिए आगे छानने , निम्नलिखित लाइनों के किसी भी सम्मिलित करने से पहले sortलाइन

मौजूद फ़ाइलोंHEAD को बाहर करने के लिए, निम्नलिखित पंक्ति डालें:

| grep -vF --file=<(git ls-tree -r HEAD | awk '{print $3}') \

केवल दी गई आकार से अधिक फ़ाइलों को दिखाने के लिए (जैसे 1 MiB = 2 20  B), निम्नलिखित पंक्ति डालें:

| awk '$2 >= 2^20' \

कंप्यूटर के लिए आउटपुट

कंप्यूटर द्वारा आगे की प्रक्रिया के लिए अधिक उपयुक्त उत्पादन को उत्पन्न करने के लिए , आधार स्क्रिप्ट की अंतिम दो पंक्तियों को छोड़ दें। वे सभी प्रारूपण करते हैं। यह आपको कुछ इस तरह से छोड़ देगा:

...
0d99bb93129939b72069df14af0d0dbda7eb6dba 542455 path/to/some-image.jpg
2ba44098e28f8f66bac5e21210c2774085d2319b 12446815 path/to/hires-image.png
bd1741ddce0d07b72ccf69ed281e09bf8a2d0b2f 65183843 path/to/some-video-1080p.mp4

फ़ाइल निकालना

वास्तविक फ़ाइल हटाने के लिए, विषय पर इस SO प्रश्न को देखें


14
यह सिर्फ मेरे उत्थान से अधिक योग्य है! कंप्यूटर और मानव पठनीय आउटपुट दोनों प्रदान करने के लिए विशेष धन्यवाद।
मिशेल जंग

2
यह बेहद तेज और उपयोग में आसान है!
चिन

31
मैक पर इस का उपयोग करने के लिए आप की जरूरत है brew install coreutilsऔर उसके बाद की जगह cutके साथ gcutऔर numfmtसाथ gnumfmt
निक स्वीटिंग

2
मुझे फिर से जोर देना चाहिए - यह मैंने देखा है अन्य सभी लिस्टिंग की तुलना में बहुत तेज है।
श्रीधर सरनोबत

4
यह एक बहुत बढ़िया उर्फ ​​बनाता है :) git largeकिसी को भी?
अनारकट

160

मुझे ETH ज्यूरिख डिपार्टमेंट ऑफ फिजिक्स विकी पेज (उस पेज के अंत के करीब) पर एक-लाइनर समाधान मिला है । बस git gcबासी कबाड़ को हटाने के लिए एक करें, और फिर

git rev-list --objects --all \
  | grep "$(git verify-pack -v .git/objects/pack/*.idx \
           | sort -k 3 -n \
           | tail -10 \
           | awk '{print$1}')"

आपको रिपॉजिटरी में 10 सबसे बड़ी फाइलें देगा।

अब उपलब्ध एक लेज़ियर समाधान भी है, GitExtensions में अब एक प्लगइन है जो UI में ऐसा करता है (और इतिहास को फिर से लिखता है)।

GitExtensions 'बड़ी फ़ाइलों का पता लगाएं संवाद


8
यह एक-लाइनर केवल तभी काम करता है जब आप एकल सबसे बड़ी फ़ाइल प्राप्त करना चाहते हैं (यानी, टेल -1 का उपयोग करें)। किसी भी बड़ी चीज के लिए नए रास्ते मिलते हैं। आप git rev-list --objects --all | grep -E `git verify-pack -v .git/objects/pack/*.idx | sort -k 3 -n | tail -10 | awk '{print$1}' | sed ':a;N;$!ba;s/\n/|/g'`
sedlines का

10
grep: a70783fca9bfbec1ade1519a41b6cc4ee36faea0: ऐसी कोई फ़ाइल या निर्देशिका नहीं
जोनाथन एलार्ड

1
विकी लिंक को यहां ले जाया गया: readme.phys.ethz.ch/documentation/git_advanced_hints
outsmartin

11
GitExtensions को खोजना सोने के बर्तन और इंद्रधनुष के अंत की तरह है - धन्यवाद!
कोकपिला

3
क्या कोई एक्सटेंशन भी है जो फ़ाइलों के आकार को प्रिंट करता है?
माइकल

27

चरण 1 सभी फ़ाइल SHA1s को एक पाठ फ़ाइल में लिखें:

git rev-list --objects --all | sort -k 2 > allfileshas.txt

चरण 2 सबसे बड़ी से छोटी से बड़ी चीज़ों को क्रमबद्ध करें और पाठ फ़ाइल में परिणाम लिखें:

git gc && git verify-pack -v .git/objects/pack/pack-*.idx | egrep "^\w+ blob\W+[0-9]+ [0-9]+ [0-9]+$" | sort -k 3 -n -r > bigobjects.txt

चरण 3a फ़ाइल नाम / sha1 / आकार की जानकारी प्राप्त करने के लिए दोनों पाठ फ़ाइलों को मिलाएं:

for SHA in `cut -f 1 -d\  < bigobjects.txt`; do
echo $(grep $SHA bigobjects.txt) $(grep $SHA allfileshas.txt) | awk '{print $1,$3,$7}' >> bigtosmall.txt
done;

चरण 3 बी यदि आपके पास रिक्त स्थान वाले फ़ाइल नाम या पथ नाम हैं , तो चरण 3a के इस भिन्नता का प्रयास करें। इसके cutबजाय awkवांछित कॉलम झुकाव प्राप्त करने के लिए उपयोग करता है । कॉलम 7 से पंक्ति के अंत तक रिक्त स्थान:

for SHA in `cut -f 1 -d\  < bigobjects.txt`; do
echo $(grep $SHA bigobjects.txt) $(grep $SHA allfileshas.txt) | cut -d ' ' -f'1,3,7-' >> bigtosmall.txt
done;

अब आप फ़ाइल bigtosmall.txt पर देख सकते हैं ताकि यह तय किया जा सके कि आप अपने गिट इतिहास से कौन सी फाइलें निकालना चाहते हैं।

चरण 4 निष्कासन करने के लिए (नोट करें कि यह हिस्सा धीमा है क्योंकि यह आपके इतिहास की हर उस जाँच के लिए जा रहा है जो आपके द्वारा पहचानी गई फ़ाइल के डेटा के लिए है):

git filter-branch --tree-filter 'rm -f myLargeFile.log' HEAD

स्रोत

1-3a कदमों की खोज और खोज इतिहास से बड़ी फ़ाइलों को हटाने से कॉपी किया गया था

संपादित करें

2017 की दूसरी छमाही में लेख को कुछ समय के लिए हटा दिया गया था, लेकिन इसकी एक संग्रहीत प्रति अभी भी वेबैक मशीन का उपयोग करके एक्सेस की जा सकती है ।


6
एक ही काम करने के लिए एक लाइनर:git gc && join -e ERROR -a 2 -j 1 -o 2.1,2.3,1.2 --check-order <( git rev-list --objects --all | sort -k 1 ) <( git verify-pack -v .git/objects/pack/pack-*.idx | gawk '( NF == 5 && $2 == "blob" ){print}' | sort -k1 ) | sort -k2gr
इवान Aucamp

1
@ इवान, वन-लाइनर के लिए धन्यवाद! यह उन में रिक्त स्थान के साथ फ़ाइल नाम नहीं संभालता है, ऐसा लगता है join -t' ' -e ERROR -a 2 -j 1 -o 2.1,2.3,1.2 --check-order <( git rev-list --objects --all | sed 's/[[:space:]]/\t/' | sort -k 1 ) <( git verify-pack -v .git/objects/pack/pack-*.idx | gawk '( NF == 5 && $2 == "blob" ){print}' | sort -k1 | sed 's/[[:space:]]\+/\t/g' ) | sort -k2gr | less:। ध्यान दें कि आपको join -t'CTRL + V <TAB> प्रति geekbraindump.blogspot.ru/2009/04/unix-join-with-tabs.html
Nickolay

2
@ बैश के साथ निकोल $'\t'आपको एक टैब देना चाहिए। echo -n $'\t' | xxd -ps->09
इवान Aucamp

1
@IwanAucamp: और भी बेहतर, टिप के लिए धन्यवाद! (बहुत बुरा मैं पिछली टिप्पणी को संपादित नहीं कर सकता .. ओह ठीक है।)
निकोले

1
@ श्रीधर-सरनोबत लेख को वेकबैक मशीन द्वारा सहेजा गया था! :) web.archive.org/web/20170621125743/http://www.naleid.com/blog/…
friederbluemle

18

आपको BFG रेपो-क्लीनर का उपयोग करना चाहिए ।

वेबसाइट के अनुसार:

बीएफजी एक आसान, तेजी से अपने गिट रिपॉजिटरी बुक से खराब डेटा को साफ करने के लिए गिट-फिल्टर-शाखा का तेज विकल्प है।

  • क्रेजी बिग फाइल्स को हटाना
  • पासवर्ड, क्रेडेंशियल्स और अन्य निजी डेटा हटाना

एक रिपॉजिटरी के आकार को कम करने की क्लासिक प्रक्रिया होगी:

git clone --mirror git://example.com/some-big-repo.git
java -jar bfg.jar --strip-biggest-blobs 500 some-big-repo.git
cd some-big-repo.git
git reflog expire --expire=now --all
git gc --prune=now --aggressive
git push

4
बीएफजी रेपो-क्लीनर बहुत अच्छा है। यह तेजी से हल्का हो रहा है और बहुत मज़बूती से काम करता है।
fschmitt

30
यह आपको नहीं बताता कि सभी बड़ी फ़ाइलों को कैसे सूचीबद्ध किया जाए।
एंडी जे

5
इसके साथ समस्या यह है कि आप केवल यह नहीं देख सकते हैं कि वास्तव में उन्हें हटाने के बिना बड़ी फाइलें क्या हैं। मैं एक सूखा रन के बिना यह करना सहज महसूस नहीं करता कि पहले बड़ी फ़ाइलों को सूचीबद्ध करता है।
श्रीधर सरनोबत

क्या करता --strip-biggest-blobs 500है?
2540625

git इस टूल द्वारा किए गए परिवर्तनों को अस्वीकार कर देगा।
क्रिस्टोफर

9

यदि आप केवल बड़ी फ़ाइलों की एक सूची रखना चाहते हैं, तो मैं आपको निम्नलिखित एक-लाइनर प्रदान करना चाहता हूं:

join -o "1.1 1.2 2.3" <(git rev-list --objects --all | sort) <(git verify-pack -v objects/pack/*.idx | sort -k3 -n | tail -5 | sort) | sort -k3 -n

जिसका उत्पादन होगा:

commit       file name                                  size in bytes

72e1e6d20... db/players.sql 818314
ea20b964a... app/assets/images/background_final2.png 6739212
f8344b9b5... data_test/pg_xlog/000000010000000000000001 1625545
1ecc2395c... data_development/pg_xlog/000000010000000000000001 16777216
bc83d216d... app/assets/images/background_1forfinal.psd 95533848

सूची में अंतिम प्रविष्टि आपके गिट इतिहास की सबसे बड़ी फ़ाइल की ओर इशारा करती है।

आप इस आउटपुट का उपयोग यह आश्वस्त करने के लिए कर सकते हैं कि आप सामान नहीं हटा रहे हैं BFG के अपने इतिहास में आवश्यकता होगी।


2
बहुत बढ़िया!! हालाँकि, आपको ध्यान देना चाहिए कि इस कमांड को चलाने से पहले आपको रेपो - themirror विकल्पों के साथ क्लोन करना होगा।
एंडी जे

मैं उत्सुक हूं, इसके लिए 1.1, 1.2, 2.3संख्याएं क्या हैं ?
यमपोस्टर

संख्याएँ <filenumber>.<field>संयोजन के क्रम को निर्दिष्ट करने की एक सूची है । अधिक जानकारी के लिए man.cx/join देखें ।
स्किमिजोस

6

यदि आप विंडोज पर हैं, तो यहां एक पॉवरशेल स्क्रिप्ट है जो आपकी रिपॉजिटरी में 10 सबसे बड़ी फाइलों को प्रिंट करेगी:

$revision_objects = git rev-list --objects --all;
$files = $revision_objects.Split() | Where-Object {$_.Length -gt 0 -and $(Test-Path -Path $_ -PathType Leaf) };
$files | Get-Item -Force | select fullname, length | sort -Descending -Property Length | select -First 10

1
यह @ रिप्लाई करने के लिए अलग-अलग उत्तर का उत्पादन करता है, मेरी रिपॉजिटरी पर सबसे बड़ी फाइलों का एक गुच्छा गायब है। जब एक बड़ी फ़ाइल में बहुत सारे संशोधन होते हैं, तो केवल सबसे बड़े आकार की सूचना दी जाती है।
क्रिश्चियनप

यह स्क्रिप्ट मेरे लिए विफल रही, त्रुटि के साथ You cannot call a method on a null-valued expression. At line: 2 char: 1:। हालाँकि, इस उत्तर ने काम किया: stackoverflow.com/a/57793716/2441655 (यह भी छोटा है)
Venryx

4

प्रयत्न git ls-files | xargs du -hs --threshold=1M

हम अपने CI पाइपलाइन में नीचे दिए गए कमांड का उपयोग करते हैं, यह रुक जाता है अगर यह गिट रेपो में कोई बड़ी फाइल ढूंढता है:

test $(git ls-files | xargs du -hs --threshold=1M 2>/dev/null | tee /dev/stderr | wc -l) -gt 0 && { echo; echo "Aborting due to big files in the git repository."; exit 1; } || true

2

मैं सबसे लोकप्रिय उत्तर का उपयोग करने में असमर्थ था क्योंकि --batch-check कमांड लाइन स्विच Git 1.8.3 (जिसका मुझे उपयोग करना है) किसी भी तर्क को स्वीकार नहीं करता है। बास 4.1.2 के साथ सेंटोस 6.5 पर आगामी कदमों की कोशिश की गई है

प्रमुख धारणाएँ

गिट में, शब्द बूँद एक फ़ाइल की सामग्री का अर्थ है। ध्यान दें कि एक कमेटी फाइल या पाथनाम की सामग्री को बदल सकती है। इस प्रकार, एक ही फाइल कमिट के आधार पर एक अलग ब्लॉब को संदर्भित कर सकती है। एक निश्चित फ़ाइल एक आदेश में निर्देशिका पदानुक्रम में सबसे बड़ी हो सकती है, जबकि दूसरे में नहीं। इसलिए, बड़ी फ़ाइलों के बजाय बड़े कमिट खोजने का प्रश्न, मामलों को सही परिप्रेक्ष्य में रखता है।

अधीर के लिए

आकार के अवरोही क्रम में बूँद की सूची को मुद्रित करने के लिए आदेश है:

git cat-file --batch-check < <(git rev-list --all --objects  | \
awk '{print $1}')  | grep blob  | sort -n -r -k 3

नमूना उत्पादन:

3a51a45e12d4aedcad53d3a0d4cf42079c62958e blob 305971200
7c357f2c2a7b33f939f9b7125b155adbd7890be2 blob 289163620

इस तरह के ब्लब्स को हटाने के लिए, BFG रेपो क्लीनर का उपयोग करें , जैसा कि अन्य उत्तरों में बताया गया है। blobs.txtउदाहरण के लिए, एक फ़ाइल जिसमें केवल बूँद हैश है, दिया गया है:

3a51a45e12d4aedcad53d3a0d4cf42079c62958e
7c357f2c2a7b33f939f9b7125b155adbd7890be2

करना:

java -jar bfg.jar -bi blobs.txt <repo_dir>

सवाल कमिट्स खोजने के बारे में है, जो कि ब्लब्स खोजने से ज्यादा काम है। जानने के लिए, कृपया पर पढ़ें।

आगे का कार्य

एक प्रतिबद्ध हैश को देखते हुए, एक कमांड जो कि इसके साथ जुड़े सभी वस्तुओं के हैश को प्रिंट करता है, जिसमें ब्लब्स भी शामिल है:

git ls-tree -r --full-tree <commit_hash>

इसलिए, अगर हमारे पास रेपो में सभी कमिट्स के लिए ऐसे आउटपुट उपलब्ध हैं, तो एक बूँद हैश दिया जाता है, कमिट्स का गुच्छा वे होते हैं जो किसी भी आउटपुट से मेल खाते हैं। यह विचार निम्नलिखित स्क्रिप्ट में एन्कोडेड है:

#!/bin/bash
DB_DIR='trees-db'

find_commit() {
    cd ${DB_DIR}
    for f in *; do
        if grep -q $1 ${f}; then
            echo ${f}
        fi
    done
    cd - > /dev/null
}

create_db() {
    local tfile='/tmp/commits.txt'
    mkdir -p ${DB_DIR} && cd ${DB_DIR}
    git rev-list --all > ${tfile}

    while read commit_hash; do
        if [[ ! -e ${commit_hash} ]]; then
            git ls-tree -r --full-tree ${commit_hash} > ${commit_hash}
        fi
    done < ${tfile}
    cd - > /dev/null
    rm -f ${tfile}
}

create_db

while read id; do
    find_commit ${id};
done

यदि सामग्री नाम की फ़ाइल में सहेजी जाती है, find-commits.shतो एक विशिष्ट आह्वान निम्नानुसार होगा:

cat blobs.txt | find-commits.sh

पहले की तरह, फ़ाइल blobs.txtएक पंक्ति में बूँद हैश को सूचीबद्ध करती है। create_db()समारोह सभी की एक कैश वर्तमान निर्देशिका में एक उप निर्देशिका में लिस्टिंग के लिए प्रतिबद्ध बचाता है।

दो Intel (R) Xeon (R) CPU E5-2620 2.00GHz प्रोसेसर के साथ सिस्टम पर मेरे प्रयोग के कुछ आँकड़े OS द्वारा 24 वर्चुअल कोर के रूप में प्रस्तुत किए गए हैं:

  • रेपो में कुल संख्या लगभग 11,000 है
  • फ़ाइल निर्माण की गति = 126 फाइलें / एस। स्क्रिप्ट प्रति एक एकल फ़ाइल बनाता है। यह केवल तब होता है जब कैश पहली बार बनाया जा रहा हो।
  • कैश निर्माण ओवरहेड = 87 एस।
  • औसत खोज गति = 522 कमिट / एस। कैश ऑप्टिमाइज़ेशन से रनिंग टाइम में 80% की कमी आई।

ध्यान दें कि स्क्रिप्ट सिंगल थ्रेडेड है। इसलिए, किसी भी एक समय में केवल एक कोर का उपयोग किया जाएगा।


2

विंडोज़ गेट के लिए पॉवर्सशेल समाधान, सबसे बड़ी फ़ाइलों को खोजें:

git ls-tree -r -t -l --full-name HEAD | Where-Object {
 $_ -match '(.+)\s+(.+)\s+(.+)\s+(\d+)\s+(.*)'
 } | ForEach-Object {
 New-Object -Type PSObject -Property @{
     'col1'        = $matches[1]
     'col2'      = $matches[2]
     'col3' = $matches[3]
     'Size'      = [int]$matches[4]
     'path'     = $matches[5]
 }
 } | sort -Property Size -Top 10 -Descending

0

मैं गिट इतिहास में बड़ी फ़ाइलों को कैसे ट्रैक कर सकता हूं?

मूल कारण का विश्लेषण, सत्यापन और चयन करके प्रारंभ करें। git-repo-analysisमदद करने के लिए उपयोग करें ।

आप BFG रेपो-क्लीनर द्वारा उत्पन्न विस्तृत रिपोर्ट में कुछ मूल्य भी पा सकते हैं , जो कि उनके 10MBB / s नेटवर्क थ्रूपुट का उपयोग करके डिजिटल महासागर की छोटी बूंद से क्लोन करके बहुत तेज़ी से चलाया जा सकता है।


मुझे लगता है कि आपके पास BFG सुझाव में एक अच्छा सामान्य उत्तर है, लेकिन आप इसे कोई विवरण नहीं देकर और फिर एक अलग तृतीय-पक्ष सेवा (बिना किसी स्पष्टीकरण के भी) का उपयोग करके सुझाव देते हैं। क्या आप इस BFG उपयोग का कमांड-लाइन उदाहरण प्रदान करने के लिए कुछ को साफ कर सकते हैं?
फॉर्ड

0

मैं किसी और के लिए भी इसी कारण से ठोकर खाई। लेकिन उद्धृत स्क्रिप्ट मेरे लिए काफी काम की नहीं थी। मैंने एक ऐसा बना दिया है जो मैंने देखा है और यह अब यहाँ रहता है - https://gitlab.com/inorton/git-sc-calc

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.