如果您想找出哪些文件占用了 git 存储库中的空间，请运行

git verify-pack -v .git/objects/pack/*.idx | sort -k 3 -n | tail -5

然后，提取占用最多空间的 blob 引用(最后一行) ，并检查占用如此多空间的文件名

git rev-list --objects --all | grep <reference>

这甚至可能是一个您用 git rm删除的文件，但是 git 会记住它，因为仍然有对它的引用，比如标记、远程和 reflog。

一旦您知道要删除哪个文件，我建议您使用 git forget-blob

Https://ownyourbits.com/2017/01/18/completely-remove-a-file-from-a-git-repository-with-git-forget-blob/

它很容易使用，只是做

git forget-blob file-to-forget

这将从 git 中删除所有引用，从历史记录中的每次提交中删除 blob，并运行垃圾回收以释放空间。

如果您希望查看所有 blob 的大小，那么 Vi 提供的 git-fatfiles 脚本非常可爱，但是它太慢以至于无法使用。我取消了40行的输出限制，它试图使用我的电脑的所有内存，而不是完成。另外，当对输出求和以查看文件使用的所有空间时，它会给出不准确的结果。

我用锈重写了它，我发现它比其他语言更不容易出错。我还添加了这样一个特性: 如果传递了 --directories标志，那么总结各个目录中的所有提交所使用的空间。可以给出路径来限制对某些文件或目录的搜索。

Src/main.rs:

use std::{
collections::HashMap,
io::{self, BufRead, BufReader, Write},
path::{Path, PathBuf},
process::{Command, Stdio},
thread,
};


use bytesize::ByteSize;
use structopt::StructOpt;


#[derive(Debug, StructOpt)]
#[structopt()]
pub struct Opt {
#[structopt(
short,
long,
help("Show the size of directories based on files committed in them.")
)]
pub directories: bool,


#[structopt(help("Optional: only show the size info about certain paths."))]
pub paths: Vec<String>,
}


/// The paths list is a filter. If empty, there is no filtering.
/// Returns a map of object ID -> filename.
fn get_revs_for_paths(paths: Vec<String>) -> HashMap<String, PathBuf> {
let mut process = Command::new("git");
let mut process = process.arg("rev-list").arg("--all").arg("--objects");


if !paths.is_empty() {
process = process.arg("--").args(paths);
};


let output = process
.output()
.expect("Failed to execute command git rev-list.");


let mut id_map = HashMap::new();
for line in io::Cursor::new(output.stdout).lines() {
if let Some((k, v)) = line
.expect("Failed to get line from git command output.")
.split_once(' ')
{
id_map.insert(k.to_owned(), PathBuf::from(v));
}
}
id_map
}


/// Returns a map of object ID to size.
fn get_sizes_of_objects(ids: Vec<&String>) -> HashMap<String, u64> {
let mut process = Command::new("git")
.arg("cat-file")
.arg("--batch-check=%(objectname) %(objecttype) %(objectsize:disk)")
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.spawn()
.expect("Failed to execute command git cat-file.");
let mut stdin = process.stdin.expect("Could not open child stdin.");


let ids: Vec<String> = ids.into_iter().cloned().collect(); // copy data for thread


// Stdin will block when the output buffer gets full, so it needs to be written
// in a thread:
let write_thread = thread::spawn(|| {
for obj_id in ids {
writeln!(stdin, "{}", obj_id).expect("Could not write to child stdin");
}
drop(stdin);
});


let output = process
.stdout
.take()
.expect("Could not get output of command git cat-file.");


let mut id_map = HashMap::new();
for line in BufReader::new(output).lines() {
let line = line.expect("Failed to get line from git command output.");


let line_split: Vec<&str> = line.split(' ').collect();


// skip non-blob objects
if let [id, "blob", size] = &line_split[..] {
id_map.insert(
id.to_string(),
size.parse::<u64>().expect("Could not convert size to int."),
);
};
}
write_thread.join().unwrap();
id_map
}


fn main() {
let opt = Opt::from_args();


let revs = get_revs_for_paths(opt.paths);
let sizes = get_sizes_of_objects(revs.keys().collect());


// This skips directories (they have no size mapping).
// Filename -> size mapping tuples. Files are present in the list more than once.
let file_sizes: Vec<(&Path, u64)> = sizes
.iter()
.map(|(id, size)| (revs[id].as_path(), *size))
.collect();


// (Filename, size) tuples.
let mut file_size_sums: HashMap<&Path, u64> = HashMap::new();
for (mut path, size) in file_sizes.into_iter() {
if opt.directories {
// For file path "foo/bar", add these bytes to path "foo/"
let parent = path.parent();
path = match parent {
Some(parent) => parent,
_ => {
eprint!("File has no parent directory: {}", path.display());
continue;
}
};
}


*(file_size_sums.entry(path).or_default()) += size;
}
let sizes: Vec<(&Path, u64)> = file_size_sums.into_iter().collect();


print_sizes(sizes);
}


fn print_sizes(mut sizes: Vec<(&Path, u64)>) {
sizes.sort_by_key(|(_path, size)| *size);
for file_size in sizes.iter() {
// The size needs some padding--a long size is as long as a tabstop
println!("{:10}{}", ByteSize(file_size.1), file_size.0.display())
}
}

返回文章页面货物:

[package]
name = "git-fatfiles"
version = "0.1.0"
edition = "2018"
[dependencies]
structopt = { version = "0.3"}
bytesize = {version = "1"}

选择:

USAGE:
git-fatfiles [FLAGS] [paths]...


FLAGS:
-d, --directories    Show the size of directories based on files committed in them.
-h, --help           Prints help information


ARGS:
<paths>...    Optional: only show the size info about certain paths.

值得检查 stacktrace.log。它基本上是一个跟踪失败提交的错误日志。我最近发现我的 stacktrace.log 是65.5 GB，我的应用程序是66.7 GB。

创建新的分支，其中当前提交是所有历史记录都消失的初始提交，以减少 git 对象和历史记录大小。

注意: 请在运行代码之前阅读注释。

1. Git checkout ——孤儿最新 _ 分支
2. Git add-A
3. Git commit-a-m“ Initialcommit message”# 提交更改
4. Git 分支-D master # 删除 master 分支
5. Git Branch-m master # 将 Branch 重命名为 master
6. Git push-f 原点 master # push to master Branch
7. Git gc ——咄咄逼人—— prune = all # 删除旧文件

我已经创建了原来在 这个答案中提供的 perl 脚本的一个新实现(后来在生锈时重写了它)。在对 perl 脚本进行了大量研究之后，我意识到它有多个 bug:

• 带空格路径的错误
• --sum不能正常工作(它实际上没有把所有的 delta 加起来)
• --directory不能正常工作(它依赖于 --sum)
• 如果没有 --sum，它将报告给定路径的有效随机对象的大小，这可能不是最大的路径

所以我最后完全改写了剧本。它使用相同的 git 命令序列(git rev-list和 git cat-file) ，但是它会正确地处理数据以得到准确的结果。我保留了 --sum和 --directories的特性。

我还更改了它，以报告文件的“磁盘”大小(即 git repo 中的压缩大小) ，而不是原始文件大小。这似乎与眼前的问题更为相关。(如果有人出于某种原因想要未压缩的尺寸，这可以是可选的。)

我还添加了一个选项，只报告已删除的文件，假设仍在使用的文件可能不那么有趣。(我的做法有点拙劣; 欢迎提出建议。)

我也可以在这里复制它，如果这是一个很好的 StackOverflow 礼仪? (它大约有180行长。)