it-swarm.com.de

Wie zähle ich die Anzahl der Zeilen, die von einem bestimmten Autor in einem Git-Repository geändert wurden?

Gibt es einen Befehl, den ich aufrufen kann, um die Zeilen zu zählen, die von einem bestimmten Autor in einem Git-Repository geändert wurden? Ich weiß, dass es Möglichkeiten geben muss, die Anzahl der Festschreibungen zu zählen, da Github dies für das Auswirkungsdiagramm tut.

408
Gav

Die Ausgabe des folgenden Befehls sollte relativ einfach an ein Skript zu senden sein, um die Summen zu addieren:

git log --author="<authorname>" --oneline --shortstat

Dies gibt Statistiken für alle Commits auf dem aktuellen HEAD. Wenn Sie Statistiken in anderen Zweigen addieren möchten, müssen Sie diese als Argumente an git log Übergeben.

Für die Übergabe an ein Skript kann sogar das "oneline" -Format mit einem leeren Protokollformat entfernt werden. Wie Jakub Narębski kommentierte, ist --numstat Eine weitere Alternative. Es generiert Statistiken pro Datei und nicht pro Zeile, ist jedoch noch einfacher zu analysieren.

git log --author="<authorname>" --pretty=tformat: --numstat
283
CB Bailey

Dies gibt einige Statistiken über den Autor, ändern Sie nach Bedarf.

Verwendung von Gawk:

git log --author="_Your_Name_Here_" --pretty=tformat: --numstat \
| gawk '{ add += $1; subs += $2; loc += $1 - $2 } END { printf "added lines: %s removed lines: %s total lines: %s\n", add, subs, loc }' -

Verwenden von Awk unter Mac OS X:

git log --author="_Your_Name_Here_" --pretty=tformat: --numstat | awk '{ add += $1; subs += $2; loc += $1 - $2 } END { printf "added lines: %s, removed lines: %s, total lines: %s\n", add, subs, loc }' -

BEARBEITEN (2017)

Es gibt ein neues Paket auf Github, das schick aussieht und Bash als Abhängigkeiten verwendet (getestet unter Linux). Es ist eher für die direkte Verwendung als für Skripte geeignet.

Es ist git-quick-stats (Github-Link) .

Kopieren git-quick-stats zu einem Ordner und fügen Sie den Ordner dem Pfad hinzu.

mkdir ~/source
cd ~/source
git clone [email protected]:arzzen/git-quick-stats.git
mkdir ~/bin
ln -s ~/source/git-quick-stats/git-quick-stats ~/bin/git-quick-stats
chmod +x ~/bin/git-quick-stats
export PATH=${PATH}:~/bin

Verwendungszweck:

git-quick-stats

enter image description here

553
Alex

Für den Fall, dass jemand die Statistiken für jeden Benutzer in seiner Codebasis sehen möchte, haben sich kürzlich einige meiner Kollegen diesen schrecklichen Einzeiler ausgedacht:

git log --shortstat --pretty="%cE" | sed 's/\(.*\)@.*/\1/' | grep -v "^$" | awk 'BEGIN { line=""; } !/^ / { if (line=="" || !match(line, $0)) {line = $0 "," line }} /^ / { print line " # " $0; line=""}' | sort | sed -E 's/# //;s/ files? changed,//;s/([0-9]+) ([0-9]+ deletion)/\1 0 insertions\(+\), \2/;s/\(\+\)$/\(\+\), 0 deletions\(-\)/;s/insertions?\(\+\), //;s/ deletions?\(-\)//' | awk 'BEGIN {name=""; files=0; insertions=0; deletions=0;} {if ($1 != name && name != "") { print name ": " files " files changed, " insertions " insertions(+), " deletions " deletions(-), " insertions-deletions " net"; files=0; insertions=0; deletions=0; name=$1; } name=$1; files+=$2; insertions+=$3; deletions+=$4} END {print name ": " files " files changed, " insertions " insertions(+), " deletions " deletions(-), " insertions-deletions " net";}'

(Es dauert ein paar Minuten, bis unser Repo mit etwa 10-15.000 Commits durchgearbeitet ist.)

184
Dan

Git-Ruhm https://github.com/oleander/git-fame-rb

ist ein nützliches Tool, um die Anzahl aller Autoren auf einmal zu ermitteln, einschließlich der Anzahl von Commits und geänderten Dateien:

Sudo apt-get install Ruby-dev
Sudo gem install git_fame
cd /path/to/gitdir && git fame

Es gibt auch Python Version unter https://github.com/casperdcl/git-fame (von @fracz erwähnt):

Sudo apt-get install python-pip python-dev build-essential 
pip install --user git-fame
cd /path/to/gitdir && git fame

Beispielausgabe:

Total number of files: 2,053
Total number of lines: 63,132
Total number of commits: 4,330

+------------------------+--------+---------+-------+--------------------+
| name                   | loc    | commits | files | percent            |
+------------------------+--------+---------+-------+--------------------+
| Johan Sørensen         | 22,272 | 1,814   | 414   | 35.3 / 41.9 / 20.2 |
| Marius Mathiesen       | 10,387 | 502     | 229   | 16.5 / 11.6 / 11.2 |
| Jesper Josefsson       | 9,689  | 519     | 191   | 15.3 / 12.0 / 9.3  |
| Ole Martin Kristiansen | 6,632  | 24      | 60    | 10.5 / 0.6 / 2.9   |
| Linus Oleander         | 5,769  | 705     | 277   | 9.1 / 16.3 / 13.5  |
| Fabio Akita            | 2,122  | 24      | 60    | 3.4 / 0.6 / 2.9    |
| August Lilleaas        | 1,572  | 123     | 63    | 2.5 / 2.8 / 3.1    |
| David A. Cuadrado      | 731    | 111     | 35    | 1.2 / 2.6 / 1.7    |
| Jonas Ängeslevä        | 705    | 148     | 51    | 1.1 / 3.4 / 2.5    |
| Diego Algorta          | 650    | 6       | 5     | 1.0 / 0.1 / 0.2    |
| Arash Rouhani          | 629    | 95      | 31    | 1.0 / 2.2 / 1.5    |
| Sofia Larsson          | 595    | 70      | 77    | 0.9 / 1.6 / 3.8    |
| Tor Arne Vestbø        | 527    | 51      | 97    | 0.8 / 1.2 / 4.7    |
| spontus                | 339    | 18      | 42    | 0.5 / 0.4 / 2.0    |
| Pontus                 | 225    | 49      | 34    | 0.4 / 1.1 / 1.7    |
+------------------------+--------+---------+-------+--------------------+

Aber sei gewarnt: Wie von Jared in dem Kommentar erwähnt, wird es Stunden dauern, es in einem sehr großen Repository zu tun. Ich bin mir nicht sicher, ob dies verbessert werden könnte, wenn man bedenkt, dass so viele Git-Daten verarbeitet werden müssen.

Ich fand Folgendes nützlich, um herauszufinden, wer die meisten Zeilen in der Codebasis hatte:

git ls-files -z | xargs -0n1 git blame -w | Ruby -n -e '$_ =~ /^.*\((.*?)\s[\d]{4}/; puts $1.strip' | sort -f | uniq -c | sort -n

Die anderen Antworten konzentrierten sich hauptsächlich auf Zeilen, die in Commits geändert wurden. Wenn Commits jedoch nicht überleben und überschrieben werden, waren sie möglicherweise nur abgehackt. Die obige Beschwörung bringt Sie auch dazu, alle Committer nach Zeilen zu sortieren, anstatt nur einen nach dem anderen. Sie können einige Optionen zu git blame (-C -M) hinzufügen, um bessere Zahlen zu erhalten, die das Verschieben von Dateien und das Verschieben von Zeilen zwischen Dateien berücksichtigen. Andernfalls wird der Befehl möglicherweise viel länger ausgeführt.

Wenn Sie nach Zeilen suchen, die in allen Commits für alle Committer geändert wurden, ist das folgende kleine Skript hilfreich:

http://git-wt-commit.rubyforge.org/#git-rank-contributors

102
mmrobins

Um die Anzahl der Commits eines bestimmten Autors (oder aller Autoren) in einem bestimmten Zweig zu zählen, können Sie git-shortlog ; siehe vor allem seine --numbered und --summary Optionen, z.B. Wenn auf dem Git-Repository ausgeführt:

$ git shortlog v1.6.4 --numbered --summary
  6904  Junio C Hamano
  1320  Shawn O. Pearce
  1065  Linus Torvalds
    692  Johannes Schindelin
    443  Eric Wong
88
Jakub Narębski

Nachdem ich mir die Antworten von Alex und Gerty30 angesehen habe, habe ich versucht, den Einzeiler zu verkürzen:

Grundsätzlich wird mit git log numstat und nicht die Anzahl der Dateien geändert.

Git Version 2.1.0 unter Mac OSX:

git log --format='%aN' | sort -u | while read name; do echo -en "$name\t"; git log --author="$name" --pretty=tformat: --numstat | awk '{ add += $1; subs += $2; loc += $1 - $2 } END { printf "added lines: %s, removed lines: %s, total lines: %s\n", add, subs, loc }' -; done

Beispiel:

Jared Burrows   added lines: 6826, removed lines: 2825, total lines: 4001
69
Jared Burrows

Das Answer von AaronM mit dem Shell-Einzeiler ist gut, aber tatsächlich gibt es noch einen weiteren Fehler, bei dem Leerzeichen die Benutzernamen verfälschen, wenn es unterschiedliche Mengen an Weiß gibt Leerzeichen zwischen dem Benutzernamen und dem Datum. Die beschädigten Benutzernamen geben mehrere Zeilen für die Benutzeranzahl an, und Sie müssen sie selbst zusammenfassen.

Diese kleine Änderung hat das Problem für mich behoben:

git ls-files -z | xargs -0n1 git blame -w --show-email | Perl -n -e '/^.*?\((.*?)\s+[\d]{4}/; print $1,"\n"' | sort -f | uniq -c | sort -n

Beachten Sie das + nach dem, das alle Leerzeichen vom Namen bis zum Datum verbraucht.

Tatsächlich füge ich diese Antwort zu meiner eigenen Erinnerung und zur Unterstützung anderer hinzu, da dies zumindest das zweite Mal ist, dass ich das Thema google :)

  • Bearbeiten 23.01.2019 Hinzugefügt --show-email bis git blame -w, um stattdessen E-Mails zusammenzufassen, da einige Benutzer auf verschiedenen Computern unterschiedliche Name -Formate verwenden und manchmal zwei Personen mit demselben Namen im selben Git arbeiten.
27
Erik Zivkovic

Hier ist ein kurzer Einzeiler, der Statistiken für alle Autoren erstellt. Es ist viel schneller als Dans obige Lösung unter https://stackoverflow.com/a/20414465/1102119 (meine hat Zeitkomplexität O(N) anstelle von O(NM) wobei N die Anzahl der Commits und M die Anzahl der Autoren ist).

git log --no-merges --pretty=format:%an --numstat | awk '/./ && !author { author = $0; next } author { ins[author] += $1; del[author] += $2 } /^$/ { author = ""; next } END { for (a in ins) { printf "%10d %10d %10d %s\n", ins[a] - del[a], ins[a], del[a], a } }' | sort -rn
23
kccqzy

@mmrobins @AaronM @ErikZ @JamesMishra stellte Varianten zur Verfügung, die alle ein gemeinsames Problem haben: Sie fordern git auf, eine Mischung von Informationen zu erstellen, die nicht für den Skriptverbrauch vorgesehen sind, einschließlich des Zeileninhalts aus dem Repository in derselben Zeile, und das Durcheinander mit einem regulären Ausdruck abzugleichen .

Dies ist ein Problem, wenn einige Zeilen keinen gültigen UTF-8-Text enthalten und einige Zeilen zufällig mit dem regulären Ausdruck übereinstimmen (dies ist hier geschehen).

Hier ist eine modifizierte Zeile, die diese Probleme nicht hat. Es fordert git auf, Daten sauber in getrennten Zeilen auszugeben, was es einfach macht, das, was wir wollen, robust zu filtern:

git ls-files -z | xargs -0n1 git blame -w --line-porcelain | grep -a "^author " | sort -f | uniq -c | sort -n

Sie können nach anderen Zeichenfolgen suchen, z. B. Autor-Mail, Committer usw.

Vielleicht mache ich zuerst export LC_ALL=C (unter der Annahme von bash), um die Verarbeitung auf Byte-Ebene zu erzwingen (dies beschleunigt auch grep von den UTF-8-basierten Gebietsschemas enorm).

21

Eine Lösung wurde mit Ruby in der Mitte angegeben, Perl ist hier standardmäßig ein wenig verfügbarer, eine Alternative zur Verwendung von Perl für aktuelle Zeilen nach Autor.

git ls-files -z | xargs -0n1 git blame -w | Perl -n -e '/^.*\((.*?)\s*[\d]{4}/; print $1,"\n"' | sort -f | uniq -c | sort -n
16
AaronM

Zusätzlich zu Charles Baileys Antwort möchten Sie möglicherweise das -C Parameter zu den Befehlen. Andernfalls zählen Umbenennungen von Dateien als viele Hinzufügungen und Entfernungen (so viele wie die Datei Zeilen enthält), auch wenn der Dateiinhalt nicht geändert wurde.

Zur Veranschaulichung ist hier ein Commit mit vielen Dateien, die aus einem meiner Projekte verschoben werden, wenn git log --oneline --shortstat Befehl:

9052459 Reorganized project structure
 43 files changed, 1049 insertions(+), 1000 deletions(-)

Und hier das gleiche Commit mit dem git log --oneline --shortstat -C Befehl, der Dateikopien erkennt und umbenennt:

9052459 Reorganized project structure
 27 files changed, 134 insertions(+), 85 deletions(-)

Meiner Meinung nach vermittelt letzteres eine realistischere Ansicht darüber, wie viel Einfluss eine Person auf das Projekt hatte, da das Umbenennen einer Datei ein viel kleinerer Vorgang ist, als das Schreiben der Datei von Grund auf.

13
Esko Luontola

Hier ist ein kurzes Ruby Skript, das die Auswirkung pro Benutzer auf eine bestimmte Protokollabfrage ermittelt.

Zum Beispiel für rubinius :

Brian Ford: 4410668
Evan Phoenix: 1906343
Ryan Davis: 855674
Shane Becker: 242904
Alexander Kellett: 167600
Eric Hodel: 132986
Dirkjan Bussink: 113756
...

das Drehbuch:

#!/usr/bin/env Ruby

impact = Hash.new(0)

IO.popen("git log --pretty=format:\"%an\" --shortstat #{ARGV.join(' ')}") do |f|
  prev_line = ''
  while line = f.gets
    changes = /(\d+) insertions.*(\d+) deletions/.match(line)

    if changes
      impact[prev_line] += changes[1].to_i + changes[2].to_i
    end

    prev_line = line # Names are on a line of their own, just before the stats
  end
end

impact.sort_by { |a,i| -i }.each do |author, impact|
  puts "#{author.strip}: #{impact}"
end
11
Nevir

sie können whodid verwenden ( https://www.npmjs.com/package/whodid )

$ npm install whodid -g
$ cd your-project-dir

und

$ whodid author --include-merge=false --path=./ --valid-threshold=1000 --since=1.week

oder einfach tippen

$ whodid

dann können Sie das Ergebnis so sehen

Contribution state
=====================================================
 score  | author
-----------------------------------------------------
 3059   | someguy <[email protected]>
 585    | somelady <[email protected]>
 212    | niceguy <[email protected]>
 173    | coolguy <[email protected]>
=====================================================
9
victor.cheval

dies ist der beste Weg und gibt Ihnen auch ein klares Bild der Gesamtzahl der Festschreibungen aller Benutzer

git shortlog -s -n
8
edrich13

Ich habe oben eine Änderung einer kurzen Antwort angegeben, die jedoch für meine Bedürfnisse nicht ausreichte. Ich musste in der Lage sein, sowohl festgeschriebene Zeilen als auch Zeilen im endgültigen Code zu kategorisieren. Ich wollte auch eine Aufschlüsselung nach Akten. Dieser Code ist nicht wiederverwendbar. Er gibt nur die Ergebnisse für ein einzelnes Verzeichnis zurück. Es ist jedoch ein guter Anfang, wenn jemand weiter gehen möchte. Kopieren Sie sie und fügen Sie sie in eine Datei ein und machen Sie sie ausführbar oder führen Sie sie mit Perl aus.

#!/usr/bin/Perl

use strict;
use warnings;
use Data::Dumper;

my $dir = shift;

die "Please provide a directory name to check\n"
    unless $dir;

chdir $dir
    or die "Failed to enter the specified directory '$dir': $!\n";

if ( ! open(GIT_LS,'-|','git ls-files') ) {
    die "Failed to process 'git ls-files': $!\n";
}
my %stats;
while (my $file = <GIT_LS>) {
    chomp $file;
    if ( ! open(GIT_LOG,'-|',"git log --numstat $file") ) {
        die "Failed to process 'git log --numstat $file': $!\n";
    }
    my $author;
    while (my $log_line = <GIT_LOG>) {
        if ( $log_line =~ m{^Author:\s*([^<]*?)\s*<([^>]*)>} ) {
            $author = lc($1);
        }
        elsif ( $log_line =~ m{^(\d+)\s+(\d+)\s+(.*)} ) {
            my $added = $1;
            my $removed = $2;
            my $file = $3;
            $stats{total}{by_author}{$author}{added}        += $added;
            $stats{total}{by_author}{$author}{removed}      += $removed;
            $stats{total}{by_author}{total}{added}          += $added;
            $stats{total}{by_author}{total}{removed}        += $removed;

            $stats{total}{by_file}{$file}{$author}{added}   += $added;
            $stats{total}{by_file}{$file}{$author}{removed} += $removed;
            $stats{total}{by_file}{$file}{total}{added}     += $added;
            $stats{total}{by_file}{$file}{total}{removed}   += $removed;
        }
    }
    close GIT_LOG;

    if ( ! open(GIT_BLAME,'-|',"git blame -w $file") ) {
        die "Failed to process 'git blame -w $file': $!\n";
    }
    while (my $log_line = <GIT_BLAME>) {
        if ( $log_line =~ m{\((.*?)\s+\d{4}} ) {
            my $author = $1;
            $stats{final}{by_author}{$author}     ++;
            $stats{final}{by_file}{$file}{$author}++;

            $stats{final}{by_author}{total}       ++;
            $stats{final}{by_file}{$file}{total}  ++;
            $stats{final}{by_file}{$file}{total}  ++;
        }
    }
    close GIT_BLAME;
}
close GIT_LS;

print "Total lines committed by author by file\n";
printf "%25s %25s %8s %8s %9s\n",'file','author','added','removed','pct add';
foreach my $file (sort keys %{$stats{total}{by_file}}) {
    printf "%25s %4.0f%%\n",$file
            ,100*$stats{total}{by_file}{$file}{total}{added}/$stats{total}{by_author}{total}{added};
    foreach my $author (sort keys %{$stats{total}{by_file}{$file}}) {
        next if $author eq 'total';
        if ( $stats{total}{by_file}{$file}{total}{added} ) {
            printf "%25s %25s %8d %8d %8.0f%%\n",'', $author,@{$stats{total}{by_file}{$file}{$author}}{qw{added removed}}
            ,100*$stats{total}{by_file}{$file}{$author}{added}/$stats{total}{by_file}{$file}{total}{added};
        } else {
            printf "%25s %25s %8d %8d\n",'', $author,@{$stats{total}{by_file}{$file}{$author}}{qw{added removed}} ;
        }
    }
}
print "\n";

print "Total lines in the final project by author by file\n";
printf "%25s %25s %8s %9s %9s\n",'file','author','final','percent', '% of all';
foreach my $file (sort keys %{$stats{final}{by_file}}) {
    printf "%25s %4.0f%%\n",$file
            ,100*$stats{final}{by_file}{$file}{total}/$stats{final}{by_author}{total};
    foreach my $author (sort keys %{$stats{final}{by_file}{$file}}) {
        next if $author eq 'total';
        printf "%25s %25s %8d %8.0f%% %8.0f%%\n",'', $author,$stats{final}{by_file}{$file}{$author}
            ,100*$stats{final}{by_file}{$file}{$author}/$stats{final}{by_file}{$file}{total}
            ,100*$stats{final}{by_file}{$file}{$author}/$stats{final}{by_author}{total}
        ;
    }
}
print "\n";


print "Total lines committed by author\n";
printf "%25s %8s %8s %9s\n",'author','added','removed','pct add';
foreach my $author (sort keys %{$stats{total}{by_author}}) {
    next if $author eq 'total';
    printf "%25s %8d %8d %8.0f%%\n",$author,@{$stats{total}{by_author}{$author}}{qw{added removed}}
        ,100*$stats{total}{by_author}{$author}{added}/$stats{total}{by_author}{total}{added};
};
print "\n";


print "Total lines in the final project by author\n";
printf "%25s %8s %9s\n",'author','final','percent';
foreach my $author (sort keys %{$stats{final}{by_author}}) {
    printf "%25s %8d %8.0f%%\n",$author,$stats{final}{by_author}{$author}
        ,100*$stats{final}{by_author}{$author}/$stats{final}{by_author}{total};
}
5
AaronM

Speichern Sie Ihre Protokolle in einer Datei mit:

git log --author="<authorname>" --oneline --shortstat > logs.txt

Für Python Liebhaber:

with open(r".\logs.txt", "r", encoding="utf8") as f:
    files = insertions = deletions = 0
    for line in f:
        if ' changed' in line:
            line = line.strip()
            spl = line.split(', ')
            if len(spl) > 0:
                files += int(spl[0].split(' ')[0])
            if len(spl) > 1:
                insertions += int(spl[1].split(' ')[0])
            if len(spl) > 2:
                deletions += int(spl[2].split(' ')[0])

    print(str(files).ljust(10) + ' files changed')
    print(str(insertions).ljust(10) + ' insertions')
    print(str(deletions).ljust(10) + ' deletions')

Ihre Ausgaben wären wie folgt:

225        files changed
6751       insertions
1379       deletions
1
Amen Ayach

Dieses Skript hier wird es tun. Stellen Sie es in authorship.sh, chmod + x it und Sie sind fertig.

#!/bin/sh
declare -A map
while read line; do
    if grep "^[a-zA-Z]" <<< "$line" > /dev/null; then
        current="$line"
        if [ -z "${map[$current]}" ]; then 
            map[$current]=0
        fi
    Elif grep "^[0-9]" <<<"$line" >/dev/null; then
        for i in $(cut -f 1,2 <<< "$line"); do
            map[$current]=$((map[$current] + $i))
        done
    fi
done <<< "$(git log --numstat --pretty="%aN")"

for i in "${!map[@]}"; do
    echo -e "$i:${map[$i]}"
done | sort -nr -t ":" -k 2 | column -t -s ":"
1
user1074897

Bei der Frage wurden Informationen zu einem bestimmten Autor abgefragt, aber viele der Antworten waren Lösungen, die geänderte Ranglisten von Autoren basierend auf ihren Codezeilen zurückgaben.

Das war es, wonach ich gesucht habe, aber die vorhandenen Lösungen waren nicht ganz perfekt. Im Interesse der Leute, die diese Frage über Google finden, habe ich einige Verbesserungen an ihnen vorgenommen und sie in ein Shell-Skript umgewandelt, das ich unten zeige. Eine kommentierte (die ich weiterhin pflegen werde) kann auf meinem Github zu finden sein.

Es gibt keine Abhängigkeiten von Perl oder Ruby. Außerdem werden Leerzeichen, Umbenennungen und Zeilenbewegungen bei der Zeilenänderungsanzahl berücksichtigt. Fügen Sie dies einfach in eine Datei ein und übergeben Sie Ihr Git-Repository als ersten Parameter.

#!/bin/bash
git --git-dir="$1/.git" log > /dev/null 2> /dev/null
if [ $? -eq 128 ]
then
    echo "Not a git repository!"
    exit 128
else
    echo -e "Lines  | Name\nChanged|"
    git --work-tree="$1" --git-dir="$1/.git" ls-files -z |\
    xargs -0n1 git --work-tree="$1" --git-dir="$1/.git" blame -C -M  -w |\
    cut -d'(' -f2 |\
    cut -d2 -f1 |\
    sed -e "s/ \{1,\}$//" |\
    sort |\
    uniq -c |\
    sort -nr
fi
0
James Mishra

Das beste Tool, das ich bisher identifiziert habe, ist Gitinspector. Es gibt den eingestellten Bericht pro Benutzer, pro Woche usw. Sie können wie unten mit npm installieren

npm install -g gitinspector

Die Links um die Details zu erfahren

https://www.npmjs.com/package/gitinspector

https://github.com/ejwa/gitinspector/wiki/Documentation

https://github.com/ejwa/gitinspector

beispielbefehle sind

gitinspector -lmrTw 
gitinspector --since=1-1-2017 etc

Sie wollen Git Schuld .

Es gibt die Option --show-stats, um einige Statistiken auszudrucken.

0
gbjbaanb