Nome de usuário da configuração do Git: O guia completo para um commit limpo

Resposta rápida: Como definir seu nome de usuário Git

Aqui estão os dois comandos que você precisa:

# 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"

A configuração global vale para todos os repositórios no seu computador, a menos que um repositório específico a substitua.

O comando simples git config (sem --global) só afeta o repositório em que você está agora.

Execute este comando para verificar o que o Git usará para o seu próximo commit:

git config user.name

Isso mostra o nome de usuário ativo para a sua localização atual - seja a configuração do repositório local ou o fallback global, caso não exista uma configuração local.

git config user.name

Isso mostra o nome de usuário ativo para a sua localização atual - seja a configuração do repositório local ou o fallback global, caso não exista uma configuração local.

Sobre nomes de usuário e identidade no Git

O Git inclui duas informações em cada commit que você faz: um nome do autor e um e-mail do autor.

Esses vêm direto de user.name e user.email na sua configuração do Git. Quando você executa o comando ` git commit`, o Git pega todos os valores definidos e os grava permanentemente nos metadados desse commit. Seus colegas de equipe veem essas informações em git log, visualizações de blame e pull requests.

O Git não valida nada disso.

Você pode colocar seu nome como “Batman”, “Linus Torvalds” ou só seu primeiro nome com a inicial do sobrenome. Os desenvolvedores que se preocupam com a privacidade costumam usar pseudônimos ou apelidos em vez de seus nomes legais completos, principalmente em trabalhos públicos de código aberto. O Git simplesmente não liga. Ele só grava o que você mandar.

A única coisa que você precisa lembrar é que seu nome de usuário no Git não é o mesmo que seu nome de usuário no GitHub.

Seu nome de usuário Git (user.name) é o que você configurar localmente. Seu nome de usuário no GitHub é o nome da sua conta, ou o que aparece em URLs como github.com/your-handle. São sistemas completamente separados e não precisam ser iguais.

Plataformas de hospedagem como GitHub e GitLab usam seu endereço de e-mail para vincular commits à sua conta. O nome é só pra mostrar. Se o seu e-mail de commit combinar com um e-mail da sua conta do GitHub, o GitHub vai mostrar sua foto de perfil e um link para sua conta. O nome que você definiu em user.name aparece como texto, mas o e-mail é que faz o trabalho real de vincular os commits a você.

Alterar o user.name só afeta os commits que você fizer daqui pra frente. Os commits antigos que você já enviou mantêm o nome original do autor.

Como o git config funciona para user.name

O Git guarda as configurações em três lugares diferentes. Agora vou mostrar o que são, pra você não acabar com nomes inesperados.

• A configuração em nível de sistema (--system) vale para todo mundo que usa a máquina. Isso é raro na prática e a maioria dos desenvolvedores nunca mexe nisso.

• A configuração global (--global) vale para a sua conta de usuário do sistema operacional e abrange todos os seus repositórios.

• Configuração local (--local) fica dentro do arquivo .git/config de um único repositório e só afeta esse repositório.

O Git usa regras de precedência para decidir qual valor prevalece.

As configurações locais substituem as configurações globais, que substituem as configurações do sistema. Se você definir user.name em todos os três níveis, o Git vai usar o valor local quando você estiver dentro desse repositório e ignorar os outros.

Digamos que você tenha:

• Sistema: user.name = "System User"

• Global: user.name = "Global User"

• Local (dentro de um repositório específico): user.name = "Local User"

Quando você faz um commit dentro desse repositório, o Git usa “Usuário local” porque local é o mais específico aqui. Fora desse repositório, o Git volta para o “Usuário Global” da sua configuração global.

Você pode ver todos os seus valores de configuração e de onde eles vêm:

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

A bandeira ` --show-origin ` mostra o caminho do arquivo ao lado de cada configuração. É assim que você depura "por que o Git está usando esse nome?" — você vai ver exatamente qual arquivo de configuração está definindo o valor.

Esses arquivos de configuração ficam em lugares fáceis de achar: ~/.gitconfig para configurações globais e .git/config dentro de cada repositório para configurações locais. A configuração do sistema normalmente fica em /etc/gitconfig no Linux e no macOS.

Quando você executa git config --global user.name "Your Name", o Git grava em ~/.gitconfig e esse valor se torna o padrão para todos os repositórios, a menos que você o substitua localmente.

Como verificar seu nome de usuário Git atual

Você precisa saber qual nome o Git vai colocar no seu próximo commit. Vou te mostrar alguns comandos para executar.

Comandos rápidos para ver o nome do usuário.

Aqui estão os comandos que mostram seu nome de usuário Git:

# 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

O primeiro comando — git config user.name — é o que você vai usar na maioria das vezes. Mostra o valor que o Git vai realmente usar nesse repositório. Se você estiver dentro de um repositório com uma substituição local, verá o valor local. Se não, você vai ver o fallback global.

Se você quiser filtrar a lista completa de configurações, basta passar por um pipe através de grep:

git config --list | grep user.name

git config --list | grep user.name

Isso funciona no Linux e no macOS. No Windows, use findstr em vez de grep.

Entendendo o que você está vendo

Se git config user.name imprimir um valor dentro de um repositório, é isso que o Git vai usar quando você fizer o commit lá.

Mas git config --global user.name pode mostrar algo diferente. O Git ignora o valor global se tiver uma configuração local. É aí que as pessoas ficam confusas. Eles mudam a configuração global e ficam se perguntando por que os commits ainda mostram o nome antigo.

Use git config --list --show-origin para depurar isso:

git config --list --show-origin

git config --list --show-origin

Isso mostra o caminho do arquivo de onde cada configuração vem: - gitconfig para local, ~/.gitconfig para global ou /etc/gitconfig para sistema. Procure por “ user.name ” e você vai ver exatamente qual arquivo de configuração está prevalecendo.

Passo a passo: Definindo seu nome de usuário Git

A maioria dos desenvolvedores define seu nome de usuário Git uma vez e esquece dele. Mas você também pode personalizar por projeto, se precisar.

Definindo seu nome de usuário Git globalmente

Essa é a configuração única que você faz em uma máquina nova.

1. Abra o Terminal (macOS/Linux) ou o Git Bash (Windows)
2. Execute o comando de configuração com o seu nome:

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

3. Confira se funcionou:

git config --global user.name

O Git agora vai usar esse nome para cada commit em todos os repositórios na sua máquina, a menos que você o substitua localmente.

Você também deve configurar seu e-mail enquanto estiver aqui:

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

Os dois valores precisam ser definidos para que os commits funcionem direitinho e se conectem com a sua conta do GitHub ou GitLab.

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

Se você precisar de nomes diferentes para projetos diferentes, como seu nome verdadeiro para repositórios de trabalho e um pseudônimo para código aberto, por exemplo.

Veja como substituir a configuração global para um repositório:

1. Navegue até o repositório:

cd /path/to/your/repo

2. Defina o nome de usuário local:

git config user.name "Project-Specific Name"

3. Confira se o Git vai usar isso:

git config user.name

Esse valor fica em .git/config dentro desse repositório e substitui seu nome de usuário global (user.name) e nome do usuário ( ) só para esse repositório. Outros repositórios na sua máquina não são afetados.

Dica avançada: Nomes de usuário diferentes para pastas diferentes com includeIf

Se você trabalha em vários projetos com identidades diferentes, tipo, todos os repositórios sob ~/work/ use seu nome profissional e tudo sob ~/personal/ usar um pseudônimo, você pode automatizar isso com includeIf.

Adicione isso ao seu ~/.gitconfig:

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

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

Depois, crie arquivos de configuração separados, tipo ~/.gitconfig-work:

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

E ~/.gitconfig-personal:

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

O Git escolhe automaticamente a identidade certa com base na localização do repositório. Não precisa trocar manualmente.

Cenários comuns e melhores práticas

Veja como lidar com as situações mais comuns relacionadas a nomes de usuário no Git sem criar confusão.

Manter as identidades profissional e pessoal separadas

Defina seu nome pessoal globalmente e, em seguida, substitua-o para projetos de trabalho. Assim, seus repositórios pessoais usam sua identidade preferida por padrão, e os repositórios de trabalho usam seu nome profissional.

A maneira mais simples é usar includeIf para alternar automaticamente as identidades com base na pasta:

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

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

Depois, crie ~/.gitconfig-work com sua identidade profissional. Cada repositório em ~/work/ recebe automaticamente o nome do trabalho. Expliquei isso na seção anterior.

Você também pode definir uma configuração local por repositório se tiver apenas alguns projetos de trabalho, mas includeIf é mais escalável quando você está lidando com várias identidades em muitos repositórios.

Usando um pseudônimo ou apelido

O Git não liga se você usa seu nome legal.

Você pode definir user.name como um apelido, um nome próprio com a inicial do sobrenome ou o que for melhor para suas preferências de privacidade. Isso é comum em trabalhos de código aberto, onde os colaboradores querem um pouco de anonimato. Escolha algo que ajude sua equipe a identificar seus commits.

Identidades de equipe ou robô

Os commits automatizados devem usar nomes descritivos como “CI Bot” ou “Deploy Script” para que se destaquem no histórico.

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

Com essa abordagem, fica claro quais commits vieram da automação e quais vieram de desenvolvedores humanos quando você está verificando o git log ou revisando as anotações de culpa.

Lembre-se de alinhar o nome e o e-mail nas plataformas de hospedagem.

O GitHub e o GitLab combinam os commits com a sua conta usando o endereço de e-mail, não o nome. Se o seu e-mail de commit corresponder a um e-mail da sua conta GitHub, o GitHub vai ligar o commit ao seu perfil e mostrar o seu avatar.

O valordo nome de usuário aparece como texto na interface do usuário - em solicitações de pull, visualizações de blame e histórico de commits. Defina algo claro para que os colegas de equipe saibam quem fez a alteração.

Resolução de problemas com o nome de usuário do git config

Se alguma coisa relacionada ao nome de usuário do git não estiver funcionando, você provavelmente encontrará a causa e a solução aqui.

O Git diz “por favor, diga quem você é” ou não consegue detectar automaticamente sua identidade

Você vai ver um erro assim quando tentar fazer o commit:

*** Please tell me who you are.

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

Isso quer dizer que o Git não tem seu user.email definido e, às vezes, o user.name também está faltando. Conserte isso definindo ambos globalmente:

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

Depois disso, os commits vão funcionar.

Meus commits aparecem com o nome errado no GitHub ou GitLab

Dá uma olhada em qual nome o Git tá usando nesse repositório:

git config user.name

Se aparecer o nome errado, pode ser que tenha uma substituição local configurada. Dá um jeito com esse comando:

git config user.name "Correct Name"

Os novos commits usarão o nome correto, mas os commits antigos que você já enviou manterão o nome original do autor.

Eu atualizei meu nome de usuário no Git, mas os commits antigos ainda mostram o nome antigo.

Os metadados do commit são incorporados ao histórico do Git quando você cria o commit.

Alterar o user.name só afeta os commits futuros. Se você precisar alterar os nomes dos autores em commits antigos, terá que reescrever o histórico usando git rebase --interactive or git filter-repo. Isso é avançado, arriscado em ramos compartilhados e geralmente não vale a pena.

Eu fico misturando identidades quando troco de projeto.

Use includeIf para trocar automaticamente de identidade com base na localização do repositório.

Adicione isso a ~/.gitconfig:

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

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

Depois, crie ~/.gitconfig-company com sua identidade profissional e ~/.gitconfig-personal com sua identidade pessoal. O Git escolhe automaticamente o nome certo com base na localização do repositório — sem mais commits acidentais com o nome errado.

Conclusão

Pra fechar, definir seu nome de usuário Git corretamente mantém seu histórico de commits organizado e facilita a colaboração.

Quando cada commit mostra o nome correto do autor, sua equipe pode acompanhar quem fez as alterações. As revisões de código ficam mais rápidas, as anotações de responsabilidade fazem sentido e o histórico do projeto continua legível. Isso se torna mais importante à medida que os projetos crescem e mais pessoas contribuem.

Se você estiver alternando entre projetos profissionais e pessoais, ou usando nomes diferentes para clientes diferentes, não precisa mudar manualmente as configurações toda vez. Configure uma vez com substituições locais ou includeIf, e o Git vai escolher a opção certa sempre.

Se você está pronto para ir além do básico e tirar todas as dúvidas sobre Git e GitHub, esses recursos do DataCamp são a sua próxima parada:

• Git intermediário
• Conceitos do GitHub
• Fundamentos do GitHub