Git-Konfigurationsbenutzername: Der komplette Leitfaden für ein sauberes Commit

Schnelle Antwort: So legst du deinen Git-Benutzernamen fest

Hier sind die beiden Befehle, die du brauchst:

# Set Git username globally (all repos)
git config --global user.name "Your Name"

# Set Git username for the current repo only
git config user.name "Your Name"

Die globale Konfiguration gilt für jedes Repository auf deinem Rechner, es sei denn, ein bestimmtes Repository überschreibt sie.

Der einfache Befehl „ git config “ (ohne „ --global “) wirkt sich nur auf das Repository aus, in dem du gerade bist.

Führ diesen Befehl aus, um zu checken, was Git für deinen nächsten Commit verwenden wird:

git config user.name

Hier siehst du den aktiven Benutzernamen für deinen aktuellen Standort – entweder die lokale Repo-Einstellung oder die globale Standby-Einstellung, wenn keine lokale Einstellung vorhanden ist.

git config user.name

Hier siehst du den aktiven Benutzernamen für deinen aktuellen Standort – entweder die lokale Repo-Einstellung oder die globale Standby-Einstellung, wenn keine lokale Einstellung vorhanden ist.

Über Git-Benutzernamen und Identität

Git fügt jedem Commit zwei Infos hinzu: einen Autorennamen und eine E-Mail-Adresse des Autors.

Die kommen direkt von user.name und user.email in deiner Git-Konfiguration. Wenn du „ git commit “ ausführst, schnappt sich Git alle eingestellten Werte und speichert sie dauerhaft in den Metadaten dieses Commits. Deine Teamkollegen sehen diese Infos in „ git log “, „blame views“ und „pull requests“.

Git überprüft nichts davon.

Du kannst deinen Namen auf „Batman“, „Linus Torvalds“ oder einfach nur deinen Vornamen mit dem Anfangsbuchstaben deines Nachnamens setzen. Entwickler, denen Datenschutz wichtig ist, benutzen oft Pseudonyme oder Spitznamen anstelle ihrer richtigen Namen, vor allem bei öffentlichen Open-Source-Projekten. Git ist das einfach egal. Es nimmt nur auf, was du ihm sagst.

Das Einzige, was du dir merken musst, ist, dass dein Git-Benutzername nicht mit deinem GitHub-Benutzernamen übereinstimmt.

Dein Git-Benutzername (user.name) ist der, den du lokal einrichtest. Dein GitHub-Benutzername ist dein Account-Name oder das, was in URLs wie github.com/your-handle angezeigt wird. Das sind komplett verschiedene Systeme und müssen nicht zusammenpassen.

Hosting-Plattformen wie GitHub und GitLab benutzen deine E-Mail-Adresse, um Commits mit deinem Konto zu verknüpfen. Der Name ist nur zur Anzeige. Wenn deine Commit-E-Mail mit einer E-Mail in deinem GitHub-Konto übereinstimmt, zeigt GitHub dein Profilbild und einen Link zu deinem Konto an. Der Name, den du unter „ user.name “ eingegeben hast, wird als Text angezeigt, aber die E-Mail-Adresse ist die, die deine Commits wirklich mit dir verknüpft.

Das Ändern von „ user.name “ wirkt sich nur auf zukünftige Commits aus. Alte Commits, die du schon gepusht hast, behalten ihren ursprünglichen Autorennamen.

Wie git config für user.name funktioniert

Git speichert Konfigurationseinstellungen an drei verschiedenen Orten. Ich zeige dir jetzt, was das ist, damit du nicht mit unerwarteten Namen konfrontiert wirst.

• Die Konfig en auf Systemebene (--system) gelten für alle Benutzer auf dem Rechner. Das kommt in der Praxis selten vor und die meisten Entwickler machen das nie.

• Globale Konfiguration (--global) gilt für dein Betriebssystem-Benutzerkonto und gilt für alle deine Repositorys.

• Lokale Konfiguration (--local) ist in der Datei „ .git/config ” eines einzelnen Repositorys und wirkt sich nur auf dieses Repo aus.

Git entscheidet anhand von Prioritätsregeln, welcher Wert gewinnt.

Lokale Einstellungen setzen globale Einstellungen außer Kraft, die wiederum Systemeinstellungen außer Kraft setzen. Wenn du „ user.name “ auf allen drei Ebenen einstellst, nimmt Git den lokalen Wert, wenn du in diesem Repo bist, und ignoriert die anderen.

Nehmen wir mal an, du hast:

• System: user.name = "System User"

• Global: user.name = "Global User"

• Lokal (innerhalb eines bestimmten Repos): user.name = "Local User"

Wenn du in diesem Repo ein Commit machst, nimmt Git „Local User“, weil „local“ hier am spezifischsten ist. Außerhalb dieses Repos greift Git auf den „globalen Benutzer” aus deiner globalen Konfiguration zurück.

Du kannst alle deine Konfigurationswerte sehen und woher sie kommen:

git config --list
git config --list --show-origin

Das Flag „ --show-origin “ zeigt den Dateipfad neben jeder Einstellung an. So findest du raus, warum Git diesen Namen benutzt – du siehst genau, welche Konfigurationsdatei den Wert festlegt.

Diese Konfigurationsdateien sind an vorhersehbaren Orten zu finden: ~/.gitconfig für globale Einstellungen und .git/config in jedem Repository für lokale Einstellungen. Die Systemkonfiguration ist normalerweise unter Linux und macOS im Verzeichnis „ /etc/gitconfig “ zu finden.

Wenn du „ git config --global user.name "Your Name" “ ausführst, schreibt Git in „ ~/.gitconfig “ und dieser Wert wird zu deinem Standardwert für jedes Repository, es sei denn, du überschreibst ihn lokal.

So checkst du deinen aktuellen Git-Benutzernamen

Du musst wissen, welchen Namen Git deinem nächsten Commit geben wird. Ich zeige dir ein paar Befehle, die du ausführen kannst.

Schnellbefehle zum Anzeigen von user.name

Hier sind die Befehle, die deinen Git-Benutzernamen anzeigen:

# Show the active user.name for the current repo (or global if outside a repo)
git config user.name

# Show specifically the global username
git config --global user.name

# Show everything and scan for user.name and user.email
git config --list

Der erste Befehl – git config user.name – ist meistens der, den du brauchst. Es zeigt den Wert, den Git in diesem Repository tatsächlich verwenden wird. Wenn du dich in einem Repo mit einer lokalen Überschreibung befindest, siehst du den lokalen Wert. Wenn nicht, siehst du den globalen Fallback.

Wenn du die ganze Konfigurationsliste filtern willst, schick sie einfach durch „ grep “:

git config --list | grep user.name

git config --list | grep user.name

Das klappt unter Linux und macOS. Unter Windows nimmst du findstr statt grep.

Verstehen, was du siehst

Wenn „ git config user.name “ einen Wert innerhalb eines Repositorys ausgibt, wird dieser Wert von Git verwendet, wenn du dort ein Commit machst.

Aber „ git config --global user.name “ könnte was anderes zeigen. Git ignoriert den globalen Wert, wenn es eine lokale Einstellung gibt. Hier werden die Leute verwirrt. Sie ändern die globale Konfiguration und fragen sich, warum die Commits immer noch den alten Namen zeigen.

Benutz „ git config --list --show-origin “, um das zu debuggen:

git config --list --show-origin

git config --list --show-origin

Das zeigt den Dateipfad an, wo jede Einstellung herkommt: - gitconfig für lokale Einstellungen, ~/.gitconfig für globale Einstellungen oder /etc/gitconfig für Systemeinstellungen. Such nach „ user.name “ und du siehst genau, welche Konfigurationsdatei gerade aktiv ist.

Schritt für Schritt: Deinen Git-Benutzernamen einstellen

Die meisten Entwickler legen ihren Git-Benutzernamen einmal fest und denken dann nicht mehr daran. Du kannst es aber auch bei Bedarf pro Projekt anpassen.

Deinen Git-Benutzernamen global festlegen

Das ist die einmalige Einrichtung, die du auf einem neuen Gerät machst.

1. Öffne das Terminal (macOS/Linux) oder Git Bash (Windows).
2. Mach den Befehl „config“ mit deinem Namen:

git config --global user.name "Your Name"

3. Überprüfe, ob es geklappt hat:

git config --global user.name

Git benutzt jetzt diesen Namen für jeden Commit in jedem Repository auf deinem Rechner, es sei denn, du änderst ihn lokal.

Du solltest auch deine E-Mail-Adresse einrichten, während du hier bist:

git config --global user.email "your.email@example.com"

Beide Werte müssen eingestellt werden, damit Commits richtig funktionieren und mit deinem GitHub- oder GitLab-Konto verbunden werden können.

git config --global user.email "your.email@example.com"

Wenn du verschiedene Namen für verschiedene Projekte brauchst, zum Beispiel deinen echten Namen für Arbeitsrepositorys und ein Pseudonym für Open Source.

So kannst du die globale Einstellung für ein Repo überschreiben:

1. Geh ins Repository:

cd /path/to/your/repo

2. Lege den lokalen Benutzernamen fest:

git config user.name "Project-Specific Name"

3. Überprüfe, ob Git es benutzt:

git config user.name

Dieser Wert ist in der Datei .git/config in diesem Repository gespeichert und überschreibt deine globale user.name- -Einstellung nur für dieses Repository. Andere Repos auf deinem Rechner bleiben davon unberührt.

Tipp für Fortgeschrittene: Unterschiedliche Benutzernamen für verschiedene Ordner mit includeIf

Wenn du an mehreren Projekten mit unterschiedlichen Identitäten arbeitest, zum Beispiel alle Repos unter ~/work/ deinen Arbeitsnamen und alles unter ~/personal/ ein Pseudonym verwendet, kannst du das mit includeIf.

Füge das zu deinem ~/.gitconfig:

[includeIf "gitdir:~/work/"]
    path = ~/.gitconfig-work

[includeIf "gitdir:~/personal/"]
    path = ~/.gitconfig-personal

Dann machst du separate Konfigurationsdateien wie ~/.gitconfig-work:

[user]
    name = "Work Name"
    email = "work@company.com"

Und ~/.gitconfig-personal:

[user]
    name = "Personal Handle"
    email = "personal@email.com"

Git sucht automatisch die richtige Identität, je nachdem, wo sich das Repo befindet. Du musst nicht manuell umschalten.

Häufige Szenarien und bewährte Vorgehensweisen

Hier erfährst du, wie du mit den häufigsten Git-Benutzernamen-Situationen umgehst, ohne dass es chaotisch wird.

Arbeit und Privatleben trennen

Leg deinen persönlichen Namen global fest und überschreib ihn dann für Arbeitsprojekte. So wird in deinen persönlichen Repos standardmäßig deine bevorzugte Identität angezeigt, während in deinen Arbeits-Repos dein beruflicher Name verwendet wird.

Der sauberste Ansatz ist die Verwendung von includeIf , um die Identität automatisch je nach Ordner zu wechseln:

# In ~/.gitconfig
[user]
    name = "Personal Name"
    email = "personal@email.com"

[includeIf "gitdir:~/work/"]
    path = ~/.gitconfig-work

Erstell dann ~/.gitconfig-work mit deiner Arbeitsidentität. Jedes Repo unter ~/work/ kriegt automatisch den Namen „work“. Ich hab das im letzten Abschnitt erklärt.

Du kannst auch lokale Einstellungen pro Repo machen, wenn du nur ein paar Arbeitsprojekte hast, aber includeIf ist besser skalierbar, wenn du mehrere Identitäten über viele Repos hinweg verwaltest.

Ein Pseudonym oder einen Spitznamen benutzen

Git ist es egal, ob du deinen richtigen Namen benutzt.

Du kannst user.name auf einen Benutzernamen, einen Vornamen mit dem Anfangsbuchstaben des Nachnamens oder was auch immer du möchtest einstellen , je nachdem, was deinen Datenschutzpräferenzen entspricht. Das ist bei Open-Source-Projekten echt üblich, wo die Leute, die was beitragen, ein bisschen anonym bleiben wollen. Such dir einfach was aus, das deinem Team hilft, deine Commits zu erkennen.

Team- oder Bot-Identitäten

Automatische Commits sollten beschreibende Namen wie „CI Bot“ oder „Deploy Script“ haben, damit man sie im Verlauf leicht erkennen kann.

git config user.name "CI Bot"
git config user.email "ci@company.com"

Mit diesem Ansatz ist beim Scannen sofort klar, welche Commits von der Automatisierung und welche von menschlichen Entwicklern stammen. git log oder die Blame-Anmerkungen überprüfst.

Denk dran, den Namen und die E-Mail-Adresse auf den Hosting-Plattformen gleich zu machen.

GitHub und GitLab ordnen Commits deinem Konto anhand der E-Mail-Adresse zu, nicht anhand des Namens. Wenn deine Commit-E-Mail mit einer E-Mail in deinem GitHub-Konto übereinstimmt, verknüpft GitHub den Commit mit deinem Profil und zeigt deinen Avatar an.

Der Wert„user.name“ vom Typ „ “ wird als Text in der Benutzeroberfläche angezeigt – in Pull-Anfragen, Blame-Ansichten und der Commit-Historie. Mach es so, dass die Teamkollegen sehen können, wer die Änderung gemacht hat.

Fehlerbehebung bei Problemen mit dem Benutzernamen in der Git-Konfiguration

Wenn irgendwas mit deinem Git-Benutzernamen nicht klappt, findest du hier wahrscheinlich die Ursache und die Lösung.

Git sagt „Bitte sag mir, wer du bist“ oder kann deine Identität nicht automatisch erkennen.

Beim Versuch, die Änderungen zu speichern, wird folgende Fehlermeldung angezeigt:

*** Please tell me who you are.

Run
  git config --global user.email "you@example.com"
  git config --global user.name "Your Name"

Das heißt, Git hat dein „ user.email “ nicht gesetzt, und manchmal fehlt auch „ user.name “. Behebe das Problem, indem du beides global einstellst:

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

Danach funktionieren die Commits.

Meine Commits zeigen auf GitHub oder GitLab den falschen Namen an.

Schau mal nach, welchen Namen Git in diesem Repo wirklich benutzt:

git config user.name

Wenn der falsche Name angezeigt wird, könnte eine lokale Überschreibung eingestellt sein. Mach das mit diesem Befehl:

git config user.name "Correct Name"

Neue Commits werden den richtigen Namen verwenden, aber alte Commits, die du schon gepusht hast, behalten ihren ursprünglichen Autorennamen.

Ich hab meinen Git-Benutzernamen geändert, aber bei alten Commits steht immer noch der alte Name.

Die Metadaten des Commits werden beim Erstellen des Commits in die Git-Historie eingebaut.

Das Ändern von „ user.name “ wirkt sich nur auf zukünftige Commits aus. Wenn du die Namen der Autoren in alten Commits ändern musst, musst du die Historie mit „ git rebase --interactive or git filter-repo “ neu schreiben. Das ist ziemlich fortgeschritten, riskant bei geteilten Zweigen und meistens nicht die Mühe wert.

Ich verwechsle immer wieder Identitäten, wenn ich zwischen Projekten hin und her wechsle.

Verwenden includeIf , um die Identität automatisch zu wechseln, je nachdem, wo sich das Repo befindet.

Füge das hier hinzu ~/.gitconfig:

[includeIf "gitdir:~/company/"]
    path = ~/.gitconfig-company

[includeIf "gitdir:~/personal/"]
    path = ~/.gitconfig-personal

Dann mach dir ~/.gitconfig-company mit deiner Arbeits-ID und ~/.gitconfig-personal mit deiner privaten ID. Git sucht automatisch die richtige Version anhand des Speicherorts des Repositorys aus – so vermeidest du versehentliche Commits mit dem falschen Namen.

Fazit

Zusammenfassend lässt sich sagen, dass die richtige Einstellung deines Git-Benutzernamens deine Commit-Historie übersichtlich hält und die Zusammenarbeit erleichtert.

Wenn bei jedem Commit der richtige Name des Autors angezeigt wird, kann dein Team nachverfolgen, wer Änderungen vorgenommen hat. Code-Reviews laufen schneller ab, Schuldzuweisungen machen Sinn und die Projektgeschichte bleibt übersichtlich. Das wird immer wichtiger, je größer die Projekte werden und je mehr Leute mitmachen.

Wenn du zwischen beruflichen und privaten Projekten hin und her wechselst oder verschiedene Namen für verschiedene Kunden verwendest, musst du die Konfigurationen nicht jedes Mal manuell ändern. Richte es einmal mit lokalen Überschreibungen oder „ includeIf “ ein, und Git wird jedes Mal die richtige Version auswählen.

Wenn du bereit bist, über die Grundlagen hinauszugehen und alle Unklarheiten in Bezug auf Git und GitHub auszuräumen, sind diese DataCamp-Ressourcen genau das Richtige für dich:

• Git für Fortgeschrittene
• GitHub-Konzepte
• GitHub-Grundlagen