blocks|key|1710839|text|以下两个脚本都将blob的SHA1作为第一个参数，然后可选地将blob可以理解的任何参数作为第一个参数。例如，使用--all在所有分支中搜索，而不仅仅是在当前分支中搜索，或者使用-g在reflog中搜索，或者其他任何你喜欢的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1710840|这是一个shell脚本-简短而甜蜜，但速度很慢：|1710841|#!/bin/sh
obj_name="$1"
shift
git+log+"$@"+--pretty=tformat:'%25T+%25h+%25s'+\
%7C+while+read+tree+commit+subject+;+do
++++if+git+ls-tree+-r+$tree+%7C+grep+-q+"$obj_name"+;+then
++++++++echo+$commit+"$subject"
++++fi
done|code-block|syntax|javascript|1710842|Perl的一个优化版本，仍然很短，但速度快得多：|1710843|#!/usr/bin/perl
use+5.008;
use+strict;
use+Memoize;

my+$obj_name;

sub+check_tree+{
++++my+(+$tree+)+=+@_;
++++my+@subtree;

++++{
++++++++open+my+$ls_tree,+'-%7C',+git+=>+'ls-tree'+=>+$tree
++++++++++++or+die+"Couldn't+open+pipe+to+git-ls-tree:+$!\n";

++++++++while+(+<$ls_tree>+)+{
++++++++++++/\A[0-7]{6}+(\S%2B)+(\S%2B)/
++++++++++++++++or+die+"unexpected+git-ls-tree+output";
++++++++++++return+1+if+$2+eq+$obj_name;
++++++++++++push+@subtree,+$2+if+$1+eq+'tree';
++++++++}
++++}

++++check_tree(+$_+)+&&+return+1+for+@subtree;

++++return;
}

memoize+'check_tree';

die+"usage:+git-find-blob+<blob>+[<git-log+arguments+...>]\n"
++++if+not+@ARGV;

my+$obj_short+=+shift+@ARGV;
$obj_name+=+do+{
++++local+$ENV{'OBJ_NAME'}+=+$obj_short;
+++++`git+rev-parse+--verify+\$OBJ_NAME`;
}+or+die+"Couldn't+parse+$obj_short:+$!\n";
chomp+$obj_name;

open+my+$log,+'-%7C',+git+=>+log+=>+@ARGV,+'--pretty=format:%25T+%25h+%25s'
++++or+die+"Couldn't+open+pipe+to+git-log:+$!\n";

while+(+<$log>+)+{
++++chomp;
++++my+(+$tree,+$commit,+$subject+)+=+split+"+",+$_,+3;
++++print+"$commit+$subject\n"+if+check_tree(+$tree+);
}|1710844|entityMap^0|1L|5|2H|2|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

Both of the following scripts take the blob’s SHA1 as the first argument, and after it, optionally, any arguments that <a href="http://git-scm.com/docs/git-log" rel="nofollow noreferrer"><code>git log</code></a> will understand. E.g. <code>--all</code> to search in all branches instead of just the current one, or <code>-g</code> to search in the reflog, or whatever else you fancy.
Here it is as a shell script – short and sweet, but slow:
<pre class="lang-bash prettyprint-override"><code>#!/bin/sh
obj_name=&quot;$1&quot;
shift
git log &quot;$@&quot; --pretty=tformat:'%T %h %s' \
| while read tree commit subject ; do
 if git ls-tree -r $tree | grep -q &quot;$obj_name&quot; ; then
 echo $commit &quot;$subject&quot;
 fi
done
</code></pre>
And an optimised version in Perl, still quite short but much faster:
<pre class="lang-perl prettyprint-override"><code>#!/usr/bin/perl
use 5.008;
use strict;
use Memoize;

my $obj_name;

sub check_tree {
 my ( $tree ) = @_;
 my @subtree;

 {
 open my $ls_tree, '-|', git =&gt; 'ls-tree' =&gt; $tree
 or die &quot;Couldn't open pipe to git-ls-tree: $!\n&quot;;

 while ( &lt;$ls_tree&gt; ) {
 /\A[0-7]{6} (\S+) (\S+)/
 or die &quot;unexpected git-ls-tree output&quot;;
 return 1 if $2 eq $obj_name;
 push @subtree, $2 if $1 eq 'tree';
 }
 }

 check_tree( $_ ) &amp;&amp; return 1 for @subtree;

 return;
}

memoize 'check_tree';

die &quot;usage: git-find-blob &lt;blob&gt; [&lt;git-log arguments ...&gt;]\n&quot;
 if not @ARGV;

my $obj_short = shift @ARGV;
$obj_name = do {
 local $ENV{'OBJ_NAME'} = $obj_short;
 `git rev-parse --verify \$OBJ_NAME`;
} or die &quot;Couldn't parse $obj_short: $!\n&quot;;
chomp $obj_name;

open my $log, '-|', git =&gt; log =&gt; @ARGV, '--pretty=format:%T %h %s'
 or die &quot;Couldn't open pipe to git-log: $!\n&quot;;

while ( &lt;$log&gt; ) {
 chomp;
 my ( $tree, $commit, $subject ) = split &quot; &quot;, $_, 3;
 print &quot;$commit $subject\n&quot; if check_tree( $tree );
}
</code></pre>

blocks|key|1710900|text|虽然原始问题没有要求它，但我认为还可以检查登台区域，以查看是否引用了blob。我修改了原始的bash脚本来执行此操作，并发现在我的存储库中引用了一个损坏的blob：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1710901|#!/bin/sh
obj_name="$1"
shift
git+ls-files+--stage+\
%7C+if+grep+-q+"$obj_name";+then
++++echo+Found+in+staging+area.+Run+git+ls-files+--stage+to+see.
fi

git+log+"$@"+--pretty=format:'%25T+%25h+%25s'+\
%7C+while+read+tree+commit+subject+;+do
++++if+git+ls-tree+-r+$tree+%7C+grep+-q+"$obj_name"+;+then
++++++++echo+$commit+"$subject"
++++fi
done|code-block|syntax|javascript|1710902|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

While the original question does not ask for it, I think it is useful to also check the staging area to see if a blob is referenced. I modified the original bash script to do this and found what was referencing a corrupt blob in my repository:

<pre class="lang-bash prettyprint-override"><code>#!/bin/sh
obj_name="$1"
shift
git ls-files --stage \
| if grep -q "$obj_name"; then
 echo Found in staging area. Run git ls-files --stage to see.
fi

git log "$@" --pretty=format:'%T %h %s' \
| while read tree commit subject ; do
 if git ls-tree -r $tree | grep -q "$obj_name" ; then
 echo $commit "$subject"
 fi
done
</code></pre>

blocks|key|1495883|text|所以..。我需要在超过8+8GB、超过108,000个修订版的存储库中找到超过给定限制的所有文件。我改编了亚里士多德的perl脚本和我写的ruby脚本来实现这个完整的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1495884|首先，git+gc+-这样做是为了确保所有对象都在包文件中-我们不扫描不在包文件中的对象。|offset|length|style|CODE|1495885|接下来，运行此脚本以定位CUTOFF_SIZE字节上的所有blobs。将输出捕获到类似"large-blobs.log“的文件中|1495886|#!/usr/bin/env+ruby

require+'log4r'

#+The+output+of+git+verify-pack+-v+is:
#+SHA1+type+size+size-in-packfile+offset-in-packfile+depth+base-SHA1
#
#
GIT_PACKS_RELATIVE_PATH=File.join('.git',+'objects',+'pack',+'*.pack')

#+10MB+cutoff
CUTOFF_SIZE=1024*1024*10
#CUTOFF_SIZE=1024

begin

++include+Log4r
++log+=+Logger.new+'git-find-large-objects'
++log.level+=+INFO
++log.outputters+=+Outputter.stdout

++git_dir+=+%25x[+git+rev-parse+--show-toplevel+].chomp

++if+git_dir.empty?
++++log.fatal+"ERROR:+must+be+run+in+a+git+repository"
++++exit+1
++end

++log.debug+"Git+Dir:+'#{git_dir}'"

++pack_files+=+Dir[File.join(git_dir,+GIT_PACKS_RELATIVE_PATH)]
++log.debug+"Git+Packs:+#{pack_files.to_s}"

++#+For+details+on+this+IO,+see+http://stackoverflow.com/questions/1154846/continuously-read-from-stdout-of-external-process-in-ruby
++#
++#+Short+version+is,+git+verify-pack+flushes+buffers+only+on+line+endings,+so
++#+this+works,+if+it+didn't,+then+we+could+get+partial+lines+and+be+sad.

++types+=+{
++++:blob+=>+1,
++++:tree+=>+1,
++++:commit+=>+1,
++}


++total_count+=+0
++counted_objects+=+0
++large_objects+=+[]

++IO.popen("git+verify-pack+-v+--+#{pack_files.join("+")}")+do+%7Cpipe%7C
++++pipe.each+do+%7Cline%7C
++++++#+The+output+of+git+verify-pack+-v+is:
++++++#+SHA1+type+size+size-in-packfile+offset-in-packfile+depth+base-SHA1
++++++data+=+line.chomp.split('+')
++++++#+types+are+blob,+tree,+or+commit
++++++#+we+ignore+other+lines+by+looking+for+that
++++++next+unless+types[data[1].to_sym]+==+1
++++++log.info+"INPUT_THREAD:+Processing+object+#{data[0]}+type+#{data[1]}+size+#{data[2]}"
++++++hash+=+{
++++++++:sha1+=>+data[0],
++++++++:type+=>+data[1],
++++++++:size+=>+data[2].to_i,
++++++}
++++++total_count+%2B=+hash[:size]
++++++counted_objects+%2B=+1
++++++if+hash[:size]+>+CUTOFF_SIZE
++++++++large_objects.push+hash
++++++end
++++end
++end

++log.info+"Input+complete"

++log.info+"Counted+#{counted_objects}+totalling+#{total_count}+bytes."

++log.info+"Sorting"

++large_objects.sort!+{+%7Ca,b%7C+b[:size]+<=>+a[:size]+}

++log.info+"Sorting+complete"

++large_objects.each+do+%7Cobj%7C
++++log.info+"#{obj[:sha1]}+#{obj[:type]}+#{obj[:size]}"
++end

++exit+0
end|code-block|syntax|javascript|1495887|接下来，编辑该文件以删除任何不需要等待的blob和顶部的INPUT_THREAD位。一旦您只有了要查找的sha1s的行，就像这样运行以下脚本：|1495888|cat+edited-large-files.log+%7C+cut+-d'+'+-f4+%7C+xargs+git-find-blob+%7C+tee+large-file-paths.log|1495889|下面是git-find-blob脚本的位置。|1495890|#!/usr/bin/perl

#+taken+from:+http://stackoverflow.com/questions/223678/which-commit-has-this-blob
#+and+modified+by+Carl+Myers+<cmyers@cmyers.org>+to+scan+multiple+blobs+at+once
#+Also,+modified+to+keep+the+discovered+filenames
#+vi:+ft=perl

use+5.008;
use+strict;
use+Memoize;
use+Data::Dumper;


my+$BLOBS+=+{};

MAIN:+{

++++memoize+'check_tree';

++++die+"usage:+git-find-blob+<blob1>+<blob2>+...+--+[<git-log+arguments+...>]\n"
++++++++if+not+@ARGV;


++++while+(+@ARGV+&&+$ARGV[0]+ne+'--'+)+{
++++++++my+$arg+=+$ARGV[0];
++++++++#print+"Processing+argument+$arg\n";
++++++++open+my+$rev_parse,+'-%7C',+git+=>+'rev-parse'+=>+'--verify',+$arg+or+die+"Couldn't+open+pipe+to+git-rev-parse:+$!\n";
++++++++my+$obj_name+=+<$rev_parse>;
++++++++close+$rev_parse+or+die+"Couldn't+expand+passed+blob.\n";
++++++++chomp+$obj_name;
++++++++#$obj_name+eq+$ARGV[0]+or+print+"($ARGV[0]+expands+to+$obj_name)\n";
++++++++print+"($arg+expands+to+$obj_name)\n";
++++++++$BLOBS->{$obj_name}+=+$arg;
++++++++shift+@ARGV;
++++}
++++shift+@ARGV;+#+drop+the+--+if+present

++++#print+"BLOBS:+"+.+Dumper($BLOBS)+.+"\n";

++++foreach+my+$blob+(+keys+%25{$BLOBS}+)+{
++++++++#print+"Printing+results+for+blob+$blob:\n";

++++++++open+my+$log,+'-%7C',+git+=>+log+=>+@ARGV,+'--pretty=format:%25T+%25h+%25s'
++++++++++++or+die+"Couldn't+open+pipe+to+git-log:+$!\n";

++++++++while+(+<$log>+)+{
++++++++++++chomp;
++++++++++++my+(+$tree,+$commit,+$subject+)+=+split+"+",+$_,+3;
++++++++++++#print+"Checking+tree+$tree\n";
++++++++++++my+$results+=+check_tree(+$tree+);

++++++++++++#print+"RESULTS:+"+.+Dumper($results);
++++++++++++if+(%25{$results})+{
++++++++++++++++print+"$commit+$subject\n";
++++++++++++++++foreach+my+$blob+(+keys+%25{$results}+)+{
++++++++++++++++++++print+"\t"+.+(join+",+",+@{$results->{$blob}})+.+"\n";
++++++++++++++++}
++++++++++++}
++++++++}
++++}

}


sub+check_tree+{
++++my+(+$tree+)+=+@_;
++++#print+"Calculating+hits+for+tree+$tree\n";

++++my+@subtree;

++++#+results+=+{+BLOB+=>+[+FILENAME1+]+}
++++my+$results+=+{};
++++{
++++++++open+my+$ls_tree,+'-%7C',+git+=>+'ls-tree'+=>+$tree
++++++++++++or+die+"Couldn't+open+pipe+to+git-ls-tree:+$!\n";

++++++++#+example+git+ls-tree+output:
++++++++#+100644+blob+15d408e386400ee58e8695417fbe0f858f3ed424++++filaname.txt
++++++++while+(+<$ls_tree>+)+{
++++++++++++/\A[0-7]{6}+(\S%2B)+(\S%2B)\s%2B(.*)/
++++++++++++++++or+die+"unexpected+git-ls-tree+output";
++++++++++++#print+"Scanning+line+'$_'+tree+$2+file+$3\n";
++++++++++++foreach+my+$blob+(+keys+%25{$BLOBS}+)+{
++++++++++++++++if+(+$2+eq+$blob+)+{
++++++++++++++++++++print+"Found+$blob+in+$tree:$3\n";
++++++++++++++++++++push+@{$results->{$blob}},+$3;
++++++++++++++++}
++++++++++++}
++++++++++++push+@subtree,+[$2,+$3]+if+$1+eq+'tree';
++++++++}
++++}

++++foreach+my+$st+(+@subtree+)+{
++++++++#+$st->[0]+is+tree,+$st->[1]+is+dirname
++++++++my+$st_result+=+check_tree(+$st->[0]+);
++++++++foreach+my+$blob+(+keys+%25{$st_result}+)+{
++++++++++++foreach+my+$filename+(+@{$st_result->{$blob}}+)+{
++++++++++++++++my+$path+=+$st->[1]+.+'/'+.+$filename;
++++++++++++++++#print+"Generating+subdir+path+$path\n";
++++++++++++++++push+@{$results->{$blob}},+$path;
++++++++++++}
++++++++}
++++}

++++#print+"Returning+results+for+tree+$tree:+"+.+Dumper($results)+.+"\n\n";
++++return+$results;
}|1495891|输出将如下所示：|1495892|<hash+prefix>+<oneline+log+message>
++++path/to/file.txt
++++path/to/file2.txt
++++...
<hash+prefix2>+<oneline+log+msg...>|1495893|诸若此类。每一次在树中包含大文件的提交都会被列出。如果您对以制表符开头的行执行grep操作，并对其执行分支操作，那么您将获得一个列表，其中包含您可以通过筛选分支来删除的所有路径，或者您也可以执行一些更复杂的操作。|1495894|让我重申一下:这个进程成功运行，在一个10+me的存储库上，提交了108,000次。当运行大量的blob时，花费的时间比我预计的要长得多，但是，超过10个小时，我将不得不查看记忆位是否工作……|1495895|entityMap^0|0|3|6|0|0|0|0|0|3|D|0|0|0|0|13|4|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@$D|18|E|19|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1A|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1B|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1D|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1E|8|@$D|1F|E|1G|F|G]]|9|@]|A|$]]|$1|U|3|V|5|L|7|1H|8|@]|9|@]|A|$M|N]]|$1|W|3|X|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|L|7|1J|8|@]|9|@]|A|$M|N]]|$1|10|3|11|5|6|7|1K|8|@$D|1L|E|1M|F|G]]|9|@]|A|$]]|$1|12|3|13|5|6|7|1N|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|15|$]]

So... I needed to find all files over a given limit in a repo over 8GB in size, with over 108,000 revisions. I adapted Aristotle's perl script along with a ruby script I wrote to reach this complete solution.

First, <code>git gc</code> - do this to ensure all objects are in packfiles - we don't scan objects not in pack files.

Next Run this script to locate all blobs over CUTOFF_SIZE bytes. Capture output to a file like "large-blobs.log"

<pre class="lang-ruby prettyprint-override"><code>#!/usr/bin/env ruby

require 'log4r'

# The output of git verify-pack -v is:
# SHA1 type size size-in-packfile offset-in-packfile depth base-SHA1
#
#
GIT_PACKS_RELATIVE_PATH=File.join('.git', 'objects', 'pack', '*.pack')

# 10MB cutoff
CUTOFF_SIZE=1024*1024*10
#CUTOFF_SIZE=1024

begin

 include Log4r
 log = Logger.new 'git-find-large-objects'
 log.level = INFO
 log.outputters = Outputter.stdout

 git_dir = %x[ git rev-parse --show-toplevel ].chomp

 if git_dir.empty?
 log.fatal "ERROR: must be run in a git repository"
 exit 1
 end

 log.debug "Git Dir: '#{git_dir}'"

 pack_files = Dir[File.join(git_dir, GIT_PACKS_RELATIVE_PATH)]
 log.debug "Git Packs: #{pack_files.to_s}"

 # For details on this IO, see http://stackoverflow.com/questions/1154846/continuously-read-from-stdout-of-external-process-in-ruby
 #
 # Short version is, git verify-pack flushes buffers only on line endings, so
 # this works, if it didn't, then we could get partial lines and be sad.

 types = {
 :blob =&gt; 1,
 :tree =&gt; 1,
 :commit =&gt; 1,
 }


 total_count = 0
 counted_objects = 0
 large_objects = []

 IO.popen("git verify-pack -v -- #{pack_files.join(" ")}") do |pipe|
 pipe.each do |line|
 # The output of git verify-pack -v is:
 # SHA1 type size size-in-packfile offset-in-packfile depth base-SHA1
 data = line.chomp.split(' ')
 # types are blob, tree, or commit
 # we ignore other lines by looking for that
 next unless types[data[1].to_sym] == 1
 log.info "INPUT_THREAD: Processing object #{data[0]} type #{data[1]} size #{data[2]}"
 hash = {
 :sha1 =&gt; data[0],
 :type =&gt; data[1],
 :size =&gt; data[2].to_i,
 }
 total_count += hash[:size]
 counted_objects += 1
 if hash[:size] &gt; CUTOFF_SIZE
 large_objects.push hash
 end
 end
 end

 log.info "Input complete"

 log.info "Counted #{counted_objects} totalling #{total_count} bytes."

 log.info "Sorting"

 large_objects.sort! { |a,b| b[:size] &lt;=&gt; a[:size] }

 log.info "Sorting complete"

 large_objects.each do |obj|
 log.info "#{obj[:sha1]} #{obj[:type]} #{obj[:size]}"
 end

 exit 0
end
</code></pre>

Next, edit the file to remove any blobs you don't wait and the INPUT_THREAD bits at the top. once you have only lines for the sha1s you want to find, run the following script like this:

<pre><code>cat edited-large-files.log | cut -d' ' -f4 | xargs git-find-blob | tee large-file-paths.log
</code></pre>

Where the <code>git-find-blob</code> script is below.

<pre class="lang-perl prettyprint-override"><code>#!/usr/bin/perl

# taken from: http://stackoverflow.com/questions/223678/which-commit-has-this-blob
# and modified by Carl Myers &lt;cmyers@cmyers.org&gt; to scan multiple blobs at once
# Also, modified to keep the discovered filenames
# vi: ft=perl

use 5.008;
use strict;
use Memoize;
use Data::Dumper;


my $BLOBS = {};

MAIN: {

 memoize 'check_tree';

 die "usage: git-find-blob &lt;blob1&gt; &lt;blob2&gt; ... -- [&lt;git-log arguments ...&gt;]\n"
 if not @ARGV;


 while ( @ARGV &amp;&amp; $ARGV[0] ne '--' ) {
 my $arg = $ARGV[0];
 #print "Processing argument $arg\n";
 open my $rev_parse, '-|', git =&gt; 'rev-parse' =&gt; '--verify', $arg or die "Couldn't open pipe to git-rev-parse: $!\n";
 my $obj_name = &lt;$rev_parse&gt;;
 close $rev_parse or die "Couldn't expand passed blob.\n";
 chomp $obj_name;
 #$obj_name eq $ARGV[0] or print "($ARGV[0] expands to $obj_name)\n";
 print "($arg expands to $obj_name)\n";
 $BLOBS-&gt;{$obj_name} = $arg;
 shift @ARGV;
 }
 shift @ARGV; # drop the -- if present

 #print "BLOBS: " . Dumper($BLOBS) . "\n";

 foreach my $blob ( keys %{$BLOBS} ) {
 #print "Printing results for blob $blob:\n";

 open my $log, '-|', git =&gt; log =&gt; @ARGV, '--pretty=format:%T %h %s'
 or die "Couldn't open pipe to git-log: $!\n";

 while ( &lt;$log&gt; ) {
 chomp;
 my ( $tree, $commit, $subject ) = split " ", $_, 3;
 #print "Checking tree $tree\n";
 my $results = check_tree( $tree );

 #print "RESULTS: " . Dumper($results);
 if (%{$results}) {
 print "$commit $subject\n";
 foreach my $blob ( keys %{$results} ) {
 print "\t" . (join ", ", @{$results-&gt;{$blob}}) . "\n";
 }
 }
 }
 }

}


sub check_tree {
 my ( $tree ) = @_;
 #print "Calculating hits for tree $tree\n";

 my @subtree;

 # results = { BLOB =&gt; [ FILENAME1 ] }
 my $results = {};
 {
 open my $ls_tree, '-|', git =&gt; 'ls-tree' =&gt; $tree
 or die "Couldn't open pipe to git-ls-tree: $!\n";

 # example git ls-tree output:
 # 100644 blob 15d408e386400ee58e8695417fbe0f858f3ed424 filaname.txt
 while ( &lt;$ls_tree&gt; ) {
 /\A[0-7]{6} (\S+) (\S+)\s+(.*)/
 or die "unexpected git-ls-tree output";
 #print "Scanning line '$_' tree $2 file $3\n";
 foreach my $blob ( keys %{$BLOBS} ) {
 if ( $2 eq $blob ) {
 print "Found $blob in $tree:$3\n";
 push @{$results-&gt;{$blob}}, $3;
 }
 }
 push @subtree, [$2, $3] if $1 eq 'tree';
 }
 }

 foreach my $st ( @subtree ) {
 # $st-&gt;[0] is tree, $st-&gt;[1] is dirname
 my $st_result = check_tree( $st-&gt;[0] );
 foreach my $blob ( keys %{$st_result} ) {
 foreach my $filename ( @{$st_result-&gt;{$blob}} ) {
 my $path = $st-&gt;[1] . '/' . $filename;
 #print "Generating subdir path $path\n";
 push @{$results-&gt;{$blob}}, $path;
 }
 }
 }

 #print "Returning results for tree $tree: " . Dumper($results) . "\n\n";
 return $results;
}
</code></pre>

The output will look like this:

<pre><code>&lt;hash prefix&gt; &lt;oneline log message&gt;
 path/to/file.txt
 path/to/file2.txt
 ...
&lt;hash prefix2&gt; &lt;oneline log msg...&gt;
</code></pre>

And so on. Every commit which contains a large file in its tree will be listed. if you <code>grep</code> out the lines that start with a tab, and <code>uniq</code> that, you will have a list of all paths you can filter-branch to remove, or you can do something more complicated.

Let me reiterate: this process ran successfully, on a 10GB repo with 108,000 commits. It took much longer than I predicted when running on a large number of blobs though, over 10 hours, I will have to see if the memorize bit is working...

blocks|key|1495993|text|不幸的是，脚本对我来说有点慢，所以我不得不优化一下。幸运的是，我不仅有散列，还有文件的路径。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1495994|git+log+--all+--pretty=format:%25H+--+<path>+%7C+xargs+-I%25+sh+-c+"git+ls-tree+%25+--+<path>+%7C+grep+-q+<hash>+&&+echo+%25"|code-block|syntax|javascript|1495995|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Unfortunately scripts were a bit slow for me, so I had to optimize a bit. Luckily I had not only the hash but also the path of a file.
<pre><code>git log --all --pretty=format:%H -- &lt;path&gt; | xargs -I% sh -c &quot;git ls-tree % -- &lt;path&gt; | grep -q &lt;hash&gt; &amp;&amp; echo %&quot;
</code></pre>

blocks|key|1496050|text|对于人类来说，最有用的命令可能是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1496051|git+whatchanged+--all+--find-object=<blob+hash>|code-block|syntax|javascript|1496052|这将跨--all分支显示任何使用该散列添加或删除文件的提交，以及路径是什么。|offset|length|style|CODE|1496053|git$+git+whatchanged+--all+--find-object=b3bb59f06644
commit+8ef93124645f89c45c9ec3edd3b268b38154061a+
⋮
diff:+do+not+show+submodule+with+untracked+files+as+"-dirty"
⋮
:100644+100644+b3bb59f06644+8f6227c993a5+M++++++submodule.c

commit+7091499bc0a9bccd81a1c864de7b5f87a366480e+
⋮
Revert+"submodules:+fix+of+regression+on+fetching+of+non-init+subsub-repo"
⋮
:100644+100644+eef5204e641e+b3bb59f06644+M++submodule.c|1496054|请注意，git+whatchanged已经在其输出行中包含了前后的blob散列。|1496055|entityMap^0|0|0|3|5|0|0|4|F|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

For humans, the most useful command is probably
<pre><code>git whatchanged --all --find-object=&lt;blob hash&gt;
</code></pre>
This shows, across <code>--all</code> branches, any commits that added or removed a file with that hash, along with what the path was.
<pre><code>git$ git whatchanged --all --find-object=b3bb59f06644
commit 8ef93124645f89c45c9ec3edd3b268b38154061a 
⋮
diff: do not show submodule with untracked files as &quot;-dirty&quot;
⋮
:100644 100644 b3bb59f06644 8f6227c993a5 M submodule.c

commit 7091499bc0a9bccd81a1c864de7b5f87a366480e 
⋮
Revert &quot;submodules: fix of regression on fetching of non-init subsub-repo&quot;
⋮
:100644 100644 eef5204e641e b3bb59f06644 M submodule.c
</code></pre>
Note that <code>git whatchanged</code> already includes the before-and-after blob hashes in its output lines.

Given the hash of a blob, is there a way to get a list of commits that have this blob in their tree?

Which commit has this blob?

Perl

给定blob的散列，有没有办法获得树中包含此blob的提交列表？

问哪个提交有这个blob？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问哪个提交有这个blob？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问哪个提交有这个blob？
EN