项目总监必看：如何利用Git深度统计团队代码贡献？多语言实践教程揭秘！

git shortlog -s -n

git log --numstat --pretty="%aN" | awk 'NF==3 {plus+=$1; minus+=$2} END {printf("新增行数: %d, 删除行数: %d\n", plus, minus)}'

#!/bin/bash

echo "统计代码提交情况："

# 获取所有贡献者列表
authors=$(git log --format='%aN' | sort -u)

for author in $authors; do
    echo "----------------------------------------"
    echo "作者：$author"

    # 统计提交次数
    commit_count=$(git shortlog -s -n --author="$author" | awk '{print $1}')
    echo "提交次数：$commit_count"

    # 统计新增和删除行数
    line_stat=$(git log --numstat --pretty="%aN" --author="$author" | awk 'NF==3 {plus+=$1; minus+=$2} END {printf("%d %d", plus, minus)}')
    IFS=' ' read -ra stats <<< "$line_stat"
    echo "新增行数：${stats[0]}"
    echo "删除行数：${stats[1]}"
done

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;

public class GitStats {

    public static void main(String[] args) throws Exception {
        String repoPath = "/path/to/your/repo"; // 项目目录
        String since = "2023-01-01";  // 开始时间
        String until = "2023-12-31";  // 结束时间

        ProcessBuilder processBuilder = new ProcessBuilder(
            "git", "log", "--since=" + since, "--until=" + until, "--shortstat", "--pretty=format:%aN"
        );
        processBuilder.directory(new java.io.File(repoPath));
        Process process = processBuilder.start();
        BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));

        Map<String, Integer> commitsCount = new HashMap<>();
        Map<String, Integer> insertionsCount = new HashMap<>();
        Map<String, Integer> deletionsCount = new HashMap<>();

        String line;
        String currentAuthor = null;
        while ((line = reader.readLine()) != null) {
            if (!line.isEmpty()) {
                if (!line.startsWith(" ")) {
                    currentAuthor = line;
                    commitsCount.put(currentAuthor, commitsCount.getOrDefault(currentAuthor, 0) + 1);
                } else {
                    String[] stats = line.trim().split(",");
                    for (String stat : stats) {
                        stat = stat.trim();
                        if (stat.endsWith("insertions(+)")) {
                            int count = Integer.parseInt(stat.split(" ")[0]);
                            insertionsCount.put(currentAuthor, insertionsCount.getOrDefault(currentAuthor, 0) + count);
                        } else if (stat.endsWith("deletions(-)")) {
                            int count = Integer.parseInt(stat.split(" ")[0]);
                            deletionsCount.put(currentAuthor, deletionsCount.getOrDefault(currentAuthor, 0) + count);
                        }
                    }
                }
            }
        }

        for (String author : commitsCount.keySet()) {
            System.out.println("Author: " + author);
            System.out.println("Commits: " + commitsCount.get(author));
            System.out.println("Insertions: " + insertionsCount.getOrDefault(author, 0));
            System.out.println("Deletions: " + deletionsCount.getOrDefault(author, 0));
            System.out.println("-------------");
        }
    }
}

import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.storage.file.FileRepositoryBuilder;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.diff.DiffFormatter;
import org.eclipse.jgit.diff.DiffEntry;
import org.eclipse.jgit.util.io.DisabledOutputStream;

import java.io.File;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class GitStats {

    public static void main(String[] args) throws Exception {
        File repoDir = new File("/path/to/your/git/repo/.git"); // 替换为你的 Git 仓库路径
        Repository repo = new FileRepositoryBuilder().setGitDir(repoDir).build();

        Map<String, UserStats> statsMap = new HashMap<>();

        try (Git git = new Git(repo) ) {
            Iterable<RevCommit> commits = git.log().call();

            for (RevCommit commit : commits) {
                if (commit.getAuthorIdent().getWhen().after(/* your start date */) &&
                    commit.getAuthorIdent().getWhen().before(/* your end date */)) {

                    String author = commit.getAuthorIdent().getName();
                    UserStats userStats = statsMap.getOrDefault(author, new UserStats());

                    userStats.commitCount++;
                    
                    try (DiffFormatter diffFormatter = new DiffFormatter(DisabledOutputStream.INSTANCE)) {
                        diffFormatter.setRepository(repo);
                        List<DiffEntry> diffs = diffFormatter.scan(commit.getParent(0), commit);
                        for (DiffEntry diff : diffs) {
                            userStats.addedLines += diff.getInsertions();
                            userStats.deletedLines += diff.getDeletions();
                        }
                    }
                    statsMap.put(author, userStats);
                }
            }
        }

        for (Map.Entry<String, UserStats> entry : statsMap.entrySet()) {
            System.out.println("Author: " + entry.getKey());
            System.out.println("Commits: " + entry.getValue().commitCount);
            System.out.println("Added lines: " + entry.getValue().addedLines);
            System.out.println("Deleted lines: " + entry.getValue().deletedLines);
        }
    }

    static class UserStats {
        int commitCount;
        int addedLines;
        int deletedLines;
    }
}

import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.json.JSONArray;
import org.json.JSONObject;

import java.util.HashMap;
import java.util.Map;

public class GitLabDetailedStats {

    private static final String GITLAB_URL = "https://gitlab.example.com";
    private static final String PRIVATE_TOKEN = "YOUR_PRIVATE_TOKEN";

    public static void main(String[] args) throws Exception {
        String projectId = "your_project_id"; // 替换为你的项目 ID
        String sinceDate = "2023-01-01"; // 开始日期
        String untilDate = "2023-12-31"; // 结束日期

        Map<String, UserStats> statsMap = new HashMap<>();

        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            HttpGet commitsRequest = new HttpGet(GITLAB_URL + "/api/v4/projects/" + projectId + "/repository/commits?since=" + sinceDate + "&until=" + untilDate);
            commitsRequest.setHeader("PRIVATE-TOKEN", PRIVATE_TOKEN);

            try (CloseableHttpResponse response = httpClient.execute(commitsRequest)) {
                String responseBody = EntityUtils.toString(response.getEntity());
                JSONArray commitsArray = new JSONArray(responseBody);

                for (int i = 0; i < commitsArray.length(); i++) {
                    JSONObject commit = commitsArray.getJSONObject(i);
                    String commitId = commit.getString("id");
                    String authorName = commit.getJSONObject("author").getString("name");

                    UserStats userStats = statsMap.getOrDefault(authorName, new UserStats());

                    HttpGet diffRequest = new HttpGet(GITLAB_URL + "/api/v4/projects/" + projectId + "/repository/commits/" + commitId + "/diff");
                    diffRequest.setHeader("PRIVATE-TOKEN", PRIVATE_TOKEN);
                    try (CloseableHttpResponse diffResponse = httpClient.execute(diffRequest)) {
                        String diffResponseString = EntityUtils.toString(diffResponse.getEntity());
                        JSONArray diffArray = new JSONArray(diffResponseString);
                        for (int j = 0; j < diffArray.length(); j++) {
                            JSONObject diff = diffArray.getJSONObject(j);
                            userStats.addedLines += diff.getInt("additions");
                            userStats.deletedLines += diff.getInt("deletions");
                        }
                    }

                    userStats.commitCount++;
                    statsMap.put(authorName, userStats);
                }
            }
        }

        for (Map.Entry<String, UserStats> entry : statsMap.entrySet()) {
            System.out.println("Author: " + entry.getKey());
            System.out.println("Commits: " + entry.getValue().commitCount);
            System.out.println("Added lines: " + entry.getValue().addedLines);
            System.out.println("Deleted lines: " + entry.getValue().deletedLines);
        }
    }

    static class UserStats {
        int commitCount;
        int addedLines;
        int deletedLines;
    }
}

import subprocess

def git_stats(repo_path):
    # 获取所有贡献者
    cmd_authors = ["git", "log", "--format='%aN'", "--no-merges"]
    authors_output = subprocess.Popen(cmd_authors, cwd=repo_path, stdout=subprocess.PIPE).communicate()[0].decode()
    unique_authors = set(authors_output.splitlines())

    stats = {}

    for author in unique_authors:
        # 统计每个贡献者的提交次数
        cmd_commits = ["git", "shortlog", "-s", "-n", "--author=" + author]
        commits_output = subprocess.Popen(cmd_commits, cwd=repo_path, stdout=subprocess.PIPE).communicate()[0].decode()
        commit_count = int(commits_output.strip().split()[0])

        # 统计每个贡献者的新增和删除行数
        cmd_lines = ["git", "log", "--numstat", "--author=" + author, "--pretty=tformat:", "--no-merges"]
        lines_output = subprocess.Popen(cmd_lines, cwd=repo_path, stdout=subprocess.PIPE).communicate()[0].decode()

        added, deleted = 0, 0
        for line in lines_output.splitlines():
            if '\t' in line:
                a, d, _ = line.split('\t')
                added += int(a)
                deleted += int(d)

        stats[author] = {"commits": commit_count, "added": added, "deleted": deleted}

    return stats

if __name__ == "__main__":
    repo = "/path/to/repo"  # 修改为你的仓库路径
    statistics = git_stats(repo)

    for author, data in statistics.items():
        print(f"Author: {author}")
        print(f"Commits: {data['commits']}")
        print(f"Added lines: {data['added']}")
        print(f"Deleted lines: {data['deleted']}")
        print("-------------------------")

package main

import (
	"os/exec"
	"fmt"
)

func GitStats(repoPath string) {
	cmd := exec.Command("git", "shortlog", "-s", "-n")
	cmd.Dir = repoPath
	out, err := cmd.Output()
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(string(out))
}

func main() {
	GitStats("/path/to/repo")
}

package main

import (
	"os/exec"
	"fmt"
	"strings"
)

func GitStats(repoPath string) {
    // 获取所有贡献者
	cmdAuthors := exec.Command("git", "log", "--format=%aN", "--no-merges")
	cmdAuthors.Dir = repoPath
	authorsOutput, err := cmdAuthors.Output()
	if err != nil {
		fmt.Println(err)
		return
	}
	uniqueAuthors := removeDuplicates(strings.Split(string(authorsOutput), "\n"))

	stats := make(map[string]map[string]int)

	for _, author := range uniqueAuthors {
		// 统计每个贡献者的提交次数
		cmdCommits := exec.Command("git", "shortlog", "-s", "-n", "--author=" + author)
		cmdCommits.Dir = repoPath
		commitsOutput, err := cmdCommits.Output()
		if err != nil {
			fmt.Println(err)
			return
		}
		commitCount, _ := strconv.Atoi(strings.TrimSpace(strings.Split(string(commitsOutput), "\t")[0]))

		// 统计每个贡献者的新增和删除行数
		cmdLines := exec.Command("git", "log", "--numstat", "--author=" + author, "--pretty=tformat:", "--no-merges")
		cmdLines.Dir = repoPath
		linesOutput, err := cmdLines.Output()
		if err != nil {
			fmt.Println(err)
			return
		}

		added, deleted := 0, 0
		for _, line := range strings.Split(string(linesOutput), "\n") {
			if strings.Contains(line, "\t") {
				parts := strings.Split(line, "\t")
				add, _ := strconv.Atoi(parts[0])
				del, _ := strconv.Atoi(parts[1])
				added += add
				deleted += del
			}
		}

		stats[author] = map[string]int{"commits": commitCount, "added": added, "deleted": deleted}
	}

	for author, data := range stats {
		fmt.Println("Author:", author)
		fmt.Println("Commits:", data["commits"])
		fmt.Println("Added lines:", data["added"])
		fmt.Println("Deleted lines:", data["deleted"])
		fmt.Println("-------------------------")
	}
}

func removeDuplicates(elements []string) []string {
    encountered := map[string]bool{}
    result := []string{}

    for v := range elements {
        if encountered[elements[v]] == true {
        } else {
            encountered[elements[v]] = true
            result = append(result, elements[v])
        }
    }

    return result
}

func main() {
	GitStats("/path/to/repo")
}