version-control Git para iniciantes: o guia prático definitivo





15 Answers

GUIs para git

GUI do Git

Incluído no git - Execute git gui na linha de comando e o instalador do msysgit do Windows o adiciona ao menu Iniciar.

O Git GUI pode fazer a maioria do que você precisa fazer com o git. Incluindo mudanças de palco, configure git e repositórios, empurre alterações, crie / faça o check-out / delete branches, mescle e muitas outras coisas.

Um dos meus recursos favoritos é o atalho "stage line" e "stage hunk" no menu do botão direito, que permite que você confirme partes específicas de um arquivo. Você pode conseguir o mesmo via git add -i , mas eu acho mais fácil de usar.

Não é a aplicação mais bonita, mas funciona em quase todas as plataformas (sendo baseada em Tcl / Tk)

Screenshots | um screencast

GitK

Também incluído com o git. É um visualizador de histórico do git e permite visualizar o histórico de um repositório (incluindo ramificações, quando elas são criadas e mescladas). Você pode ver e pesquisar commits.

Combina bem com git-gui.

Gitnub

Aplicação Mac OS X Principalmente um equivalente do git log , mas tem alguma integração com o github (como o "Network view").

Parece bonito e se encaixa com o Mac OS X. Você pode pesquisar repositórios. A maior crítica do Gitnub é que ele mostra a história de maneira linear (um único branch de cada vez) - não visualiza ramificações e fusões, o que pode ser importante com o git, embora seja uma melhoria planejada.

Gitnub | github

GitX

Pretende ser um "clone gitk para o OS X".

Ele pode visualizar o histórico de ramificação não-linear, realizar commits, ver e pesquisar commits, e possui alguns outros recursos interessantes como poder "Quicklook" qualquer arquivo em qualquer revisão (pressionar espaço na visualização da lista de arquivos), exportar qualquer arquivo (arrastar e soltar).

É muito melhor integrado ao OS X que o git-gui / gitk , e é rápido e estável, mesmo com repositórios excepcionalmente grandes.

O repositório git original pieter não atualizou recentemente (mais de um ano no momento da escrita). Um branch mais ativamente mantido está disponível em brotherbard/gitx - ele adiciona "barra lateral, busca, pull, push, add remote, mesclar, cherry-pick, rebase, clone, clone para"

Download | Screenshots | repositório git | brotherbard/gitx | garfo laullon

SmartGit

Na página inicial:

O SmartGit é um front-end para o sistema de controle de versão distribuído Git e é executado no Windows, Mac OS X e Linux. O SmartGit é destinado a desenvolvedores que preferem uma interface gráfica do usuário em um cliente de linha de comando, para ser ainda mais produtivo com o Git - o DVCS mais poderoso da atualidade.

Você pode baixá-lo em SmartGit .

Download

TortoiseGit

Versão do TortoiseSVN Git para usuários do Windows.

Ele está portando TortoiseSVN para TortoiseGit A última versão 1.2.1.0 Esta versão pode completar tarefas regulares, como commit, show log, diff duas versões, criar branch e tag, Create patch e assim por diante. Veja ReleaseNotes para detalhes. Bem-vindo a contribuir com este projeto.

Download

QGit

QGit é um visualizador de GUI git construído em Qt / C ++.

Com o qgit, você poderá navegar pelo histórico de revisões, visualizar o conteúdo do patch e arquivos alterados, seguindo graficamente os diferentes ramos de desenvolvimento.

Download

gitg

O gitg é um visualizador de repositório git que segmenta gtk + / GNOME. Um de seus principais objetivos é fornecer uma experiência de usuário mais unificada para frontends do git em vários desktops. Ele não cria um aplicativo de plataforma cruzada, mas sim uma colaboração próxima com clientes semelhantes para outros sistemas operacionais (como o GitX para OS X).

Características

  • Navegue pelo histórico de revisões.
  • Manipule repositórios grandes (carrega o repositório linux, 17.000+ revisões, menos de 1 segundo).
  • Confirmar alterações.
  • Estágio / unstage pedaços individuais.
  • Reverter alterações.
  • Mostrar diferenças de alterações nas revisões.
  • Navegue na árvore para uma determinada revisão.
  • Exportar partes da árvore de uma determinada revisão.
  • Forneça qualquer refspec que um comando como 'git log' possa entender para construir o histórico.
  • Mostrar e alternar entre filiais na exibição do histórico.

Download: releases ou source

Gitbox

O Gitbox é uma interface gráfica do Mac OS X para o sistema de controle de versão do Git. Em uma única janela, você vê ramificações, histórico e status do diretório de trabalho.

As operações cotidianas são fáceis: alterações de estágio e de desmembramento com uma caixa de seleção. Confirme, puxe, mescle e pressione com um único clique. Clique duas vezes em uma alteração para mostrar um diff com o FileMerge.app.

Gitbox

Gity

O site do Gity não tem muita informação, mas a partir das capturas de tela, parece ser um OS X git gui de código aberto e cheio de recursos.

Download ou source

Meld

Meld é uma ferramenta visual de comparação e mesclagem. Você pode comparar dois ou três arquivos e editá-los no lugar (diffs update dinamicamente). Você pode comparar duas ou três pastas e iniciar comparações de arquivos. Você pode navegar e visualizar uma cópia de trabalho de sistemas de controle de versão populares, como CVS, Subversion, Bazaar-ng e Mercurial [ e Git ].

Downloads

Katana

Um Git GUI for OSX por Steve Dekorte.

Em um piscar de olhos, veja quais ramificações remotas têm alterações para puxar e se os repositórios locais têm alterações no push. Os git ops de add, commit, push, pull, tag e reset são suportados, assim como diferenças visuais e navegação visual da hierarquia do projeto que realça as mudanças e adições locais.

Grátis para 1 repositório, US $ 25 para mais.

Katana

Sprout (anteriormente GitMac)

Foca em tornar o Git fácil de usar. Possui uma interface de usuário nativa do Cocoa (mac-like), navegação rápida em repositórios, clonagem, push / pull, ramificação / fusão, diff visual, ramificações remotas, fácil acesso ao Terminal e muito mais.

Ao tornar as ações Git mais usadas intuitivamente e fáceis de executar, o Sprout (anteriormente GitMac) torna o Git fácil de usar. Compatível com a maioria dos fluxos de trabalho Git, o Sprout é ótimo para designers e desenvolvedores, colaboração em equipe e usuários avançados e novatos.

Download | Local na rede Internet

Tower

Uma GUI Git rica em recursos para Mac OSX. Avaliação gratuita de 30 dias, US $ 59 para uma licença de usuário único.

Download | Tower

EGit

EGit é um provedor Eclipse Team para o sistema de controle de versão Git. O Git é um SCM distribuído, o que significa que todo desenvolvedor tem uma cópia completa de todo o histórico de cada revisão do código, tornando as consultas contra o histórico muito rápidas e versáteis.

O projeto EGit está implementando o conjunto de ferramentas Eclipse no topo da implementação JGit Java do Git.

Download | EGit

Extensões do Git

Open Source for Windows - instala tudo o que você precisa para trabalhar com o Git em um único pacote, fácil de usar.

Git Extensions é um kit de ferramentas para tornar o trabalho com o Git no Windows mais intuitivo. A extensão do shell será integrada no Windows Explorer e apresenta um menu de contexto em arquivos e diretórios. Há também um plugin do Visual Studio para usar o git do Visual Studio.

Download

Muito obrigado ao dbr por elaborar o material do git gui.

SourceTree

O SourceTree é um cliente Mac gratuito para Git, Mercurial e SVN. Construído pela Atlassian, o pessoal por trás do BitBucket, parece funcionar igualmente bem com qualquer sistema de VC, que permite que você domine uma única ferramenta para uso com todos os seus projetos, mas eles são controlados por versão. Recheado de recursos e GRÁTIS.

Especialista-pronto e repleto de recursos para usuários iniciantes e avançados:

Revise changesets de saída e de entrada. Cherry-escolha entre filiais. Patch manuseio, rebase, stash / shelve e muito mais.

Download | SourceTree

git version-control

Ok, depois de ver este post por PJ Hyett , decidi pular para o final e ir com o Git .

Então, o que eu preciso é de um guia prático para iniciantes do Git. "Iniciante" sendo definido como alguém que sabe como lidar com seu compilador, entende em algum nível o que é um Makefile e tocou no controle de código-fonte sem compreendê-lo muito bem.

"Prático" sendo definido como essa pessoa não quer entrar em detalhes sobre o que o Git está fazendo em segundo plano, e nem se importa (ou sabe) que é distribuído. Suas respostas podem sugerir as possibilidades, mas tente apontar para o iniciante que deseja manter um repositório 'principal' em um 'servidor' que seja armazenado em backup e seguro, e tratar seu repositório local como meramente um recurso 'cliente'.

Assim:

Instalação / Configuração

Trabalhando com o código

Marcação, ramificação, releases, linhas de base

De outros

  • Descreva e crie um link para uma boa GUI, um plugin IDE, etc., que torne o Git um recurso de linha de não-comando, mas, por favor, liste suas limitações bem como as boas.
    • msysgit - Plataforma cruzada, incluída com o Git
    • msysgit - Visualizador de histórico entre plataformas, incluído no Git
    • msysgit - Mac OS X
    • msysgit - visualizador de histórico do Mac OS X
    • msysgit - Plataforma cruzada, comercial, beta
    • GUI do console do tig para Linux
    • qgit - GUI para Windows, Linux
    • msysgit - pacote para Windows, inclui amigável GUI
  • Quaisquer outras tarefas comuns que um iniciante deve saber?
  • Como trabalho efetivamente com um repositório subversion definido como minha fonte de controle de origem?

Outras referências do Git para iniciantes

Investigando no Git

Eu irei através das entradas de tempos em tempos e 'arrume' elas para que elas tenham uma aparência consistente e seja fácil escanear a lista - sinta-se à vontade para seguir um simples "cabeçalho - breve explicação - lista de instruções - dicas e informação extra "modelo. Eu também vou ligar para as entradas da lista de marcadores acima, então é fácil encontrá-las mais tarde.




Como configurá-lo para ignorar arquivos:

A habilidade de fazer com que o git ignore arquivos que você não deseja rastrear é muito útil.

Para ignorar um arquivo ou conjunto de arquivos, você fornece um padrão. A sintaxe padrão do git é bastante simples, mas poderosa. É aplicável a todos os três arquivos diferentes que mencionarei abaixo.

  • Uma linha em branco não ignora arquivos, geralmente é usada como um separador.
  • Linhas com # servem como comentários.
  • O ! prefixo é opcional e negará o padrão. Qualquer padrão negado que corresponda substituirá os padrões de precedência mais baixos.
  • Suporta expressões avançadas e curingas
    • Ex: O padrão: *. [Oa] irá ignorar todos os arquivos no repositório terminados em .o ou .a (arquivos de objetos e arquivos)
  • Se um padrão tiver um diretório que termine com um slit git, ele corresponderá apenas a esse diretório e a caminhos abaixo dele. Isso exclui arquivos regulares e links simbólicos da partida.
  • Uma barra inicial corresponderá a todos os arquivos nesse nome de caminho.
    • Ex: O padrão /*.c irá corresponder ao arquivo foo.c mas não bar / awesome.c

Ótimo exemplo da página gitignore(5) do gitignore(5) :

$ git status
[...]
# Untracked files:
[...]
#       Documentation/foo.html
#       Documentation/gitignore.html
#       file.o
#       lib.a
#       src/internal.o
[...]
$ cat .git/info/exclude
  # ignore objects and archives, anywhere in the tree.
  *.[oa]
$ cat Documentation/.gitignore
# ignore generated html files,
*.html
# except foo.html which is maintained by hand
!foo.html
$ git status
[...]
# Untracked files:
[...]
#       Documentation/foo.html
[...]

Geralmente, existem três maneiras diferentes de ignorar arquivos não acompanhados.

1) Ignorar para todos os usuários do repositório:

Adicione um arquivo chamado .gitignore à raiz da sua cópia de trabalho.

Edite .gitignore para corresponder às suas preferências para quais arquivos devem / não devem ser ignorados.

git add .gitignore 

e comprometer quando estiver pronto.

2) Ignore apenas sua cópia do repositório:

Adicione / Edite o arquivo $ GIT_DIR / info / exclude em sua cópia de trabalho, com seus padrões preferidos.

Ex: Minha cópia de trabalho é ~ / src / project1, então eu editaria ~ / src / project1 / .git / info / exclude

Você está feito!

3) Ignore em todas as situações, no seu sistema:

Global ignore padrões para o seu sistema pode ir em um arquivo chamado o que você quiser.

O meu pessoalmente é chamado ~ / .gitglobalignore

Eu posso então deixar o git saber deste arquivo editando meu arquivo ~ / .gitconfig com a seguinte linha:

core.excludesfile = ~/.gitglobalignore

Você está feito!

Eu acho a página man do gitignore(5) como o melhor recurso para mais informações.




Exemplo de fluxo de trabalho com o GIT.

O Git é extremamente flexível e se adapta bem a qualquer fluxo de trabalho, mas não impor um fluxo de trabalho específico pode ter o efeito negativo de dificultar a compreensão do que você pode fazer com o git além do fluxo de trabalho de "backup" linear e como pode ser útil. .

Esta postagem do blog explica muito bem um fluxo de trabalho muito simples, mas eficaz, que é realmente fácil de configurar usando o git.

citando a postagem do blog: Consideramos origem / mestre como a ramificação principal em que o código-fonte de HEAD sempre reflete um estado pronto para produção:

O fluxo de trabalho se tornou popular o suficiente para ter feito um projeto que implementa esse fluxo de trabalho: git-flow

Boa ilustração de um fluxo de trabalho simples, no qual você desenvolve todas as alterações e apenas envia para o mestre quando o código está em um estado de produção:

Agora, digamos que você queira trabalhar em um novo recurso ou em refatorar um módulo. Você poderia criar uma nova ramificação, o que poderíamos chamar de uma ramificação "feature", algo que levaria algum tempo e poderia quebrar algum código. Uma vez que seu recurso é "estável o suficiente" e deseja movê-lo "mais próximo" para a produção, você mescla o seu branch de recursos em desenvolvimento. Quando todos os bugs são resolvidos após a mesclagem e seu código passa em todos os testes, você empurra suas alterações para o master.

Durante todo esse processo, você encontra um terrível bug de segurança, que precisa ser consertado imediatamente. Você poderia ter uma ramificação chamada hotfixes, que faz com que as mudanças sejam colocadas mais rapidamente de volta à produção do que a ramificação normal "desenvolver".

Aqui você tem uma ilustração de como esse fluxo de trabalho de feature / hotfix / develop / production pode parecer (bem explicado no post do blog, e repito, o post do blog explica todo o processo com muito mais detalhes e muito melhor do que eu .




Como instalar o Git

No Windows:

Instale o msysgit

Existem vários downloads:

  • Git: Use isso, a menos que você especificamente precise de uma das outras opções abaixo.
  • PortableGit: Use isto se você quer rodar o Git em um PC sem instalar no PC (por exemplo, rodando o Git de um drive USB)
  • msysGit: Use isto se você quiser desenvolver o próprio Git. Se você quer apenas usar o Git para o seu código-fonte, mas não quer editar o código-fonte do Git , você não precisa disso.

Isto também instala um shell bash do Cygwin, assim você pode usar o git em um shell mais bonito (que o cmd.exe), e também inclui git-gui (acessível via git gui , ou o menu Start > All Programs > Git )

Mac OS X

Use o git-osx-installer , ou você também pode instalar a partir da fonte

Através de um gerenciador de pacotes

Instale o git usando seu gerenciador de pacotes nativo. Por exemplo, no Debian (ou Ubuntu):

apt-get install git-core

Ou no Mac OS X, via MacPorts :

sudo port install git-core+bash_completion+doc

… Ou fink:

fink install git

… Ou Homebrew :

brew install git

Em distribuições baseadas no Red Hat, como o Fedora:

yum install git

No Cygwin, o pacote Git pode ser encontrado na seção "devel"

Da fonte (Mac OS X / Linux / BSD / etc.)

No Mac OS X, se você tiver as Ferramentas de Desenvolvedor instaladas, poderá compilar o Git a partir do código-fonte com muita facilidade. Faça o download da versão mais recente do Git como .tar.bz ou .tar.gz de http://git-scm.com/ e extraia-a (clique duas vezes no Finder)

No Linux / BSD / etc. deveria ser o mesmo. Por exemplo, no Debian (e no Ubuntu), você precisa instalar o pacote build-essential via apt .

Em seguida, em um terminal, cd para onde você extraiu os arquivos (Running cd ~/Downloads/git*/ deve funcionar) e, em seguida, execute ..

./configure && make && sudo make install

Isto irá instalar o Git no lugar padrão ( /usr/local - assim o git estará em /usr/local/bin/git )

Ele solicitará que você digite sua senha (para sudo ), isso é para que ele possa gravar no /usr/local/ , que só pode ser acessado pelo usuário "root", então o sudo é necessário!

Se você quiser instalá-lo em algum lugar separado (para que os arquivos do Git não sejam misturados com outras ferramentas), use --prefix com o comando configure:

./configure --prefix=/usr/local/gitpath
make
sudo make install

Isto irá instalar o binário do git em /usr/local/bin/gitpath/bin/git - assim você não precisa digitar isso toda vez que você, você deve adicionar em seu $PATH adicionando a seguinte linha no seu ~/.profile :

export PATH="${PATH}:/usr/local/bin/gitpath/bin/"

Se você não tem acesso ao sudo, você pode usar --prefix=/Users/myusername/bin e instalar em seu diretório home. Lembre-se de adicionar ~/bin/ a $PATH

O script x-git-update-to-latest-version automatiza muito isso:

Este script atualiza meu clone local do repositório git (localy em ~/work/track/git ), e então configura, instala (em /usr/local/git - git describe ) e atualiza o link simbólico /usr/local/git .

Dessa forma, eu posso ter /usr/local/git/bin no meu PATH e estou sempre usando a última versão.

A versão mais recente deste script também instala as páginas do manual. Você precisa ajustar o seu MANPATH para incluir o /usr/local/git/share/man .




Como você configura um repositório de equipe compartilhado?

Como configurar um repositório normal é descrito here - mas como você configura um repositório de equipe que todos podem puxar e empurrar de e para?

Usando um sistema de arquivos NFS compartilhado

Supondo que sua equipe já tenha, por exemplo, uma associação de grupo compartilhada que possa ser usada.

mkdir /your/share/folder/project.git
cd /your/share/folder/project.git
newgrp yourteamgroup # if necessary
git init --bare --shared

Para começar a usar este repositório, o mais fácil é iniciar a partir de um repositório local que você já utilizou:

cd your/local/workspace/project
git remote add origin /your/share/folder/project.git
git push origin master

Outros agora podem clonar isso e começar a trabalhar:

cd your/local/workspace
git clone /your/share/folder/project.git

Usando o SSH

Configure uma conta de usuário no servidor de destino. Se você usa uma conta sem senha, uma conta com uma senha ou use authorized_keys realmente depende do seu nível de segurança exigido. Dê uma olhada em Configurando o Git sobre SSH para mais algumas informações.

Se todos os desenvolvedores usam a mesma conta para acessar este repositório compartilhado, você não precisa usar a opção --shared como acima.

Depois de iniciar o repositório da mesma forma acima, você faz o push inicial assim:

cd your/local/workspace/project
git remote add origin user@server:/path/to/project.git
git push origin master

Veja a semelhança com o acima? A única coisa que pode acontecer além disso é o SSH pedir uma senha se a conta tiver uma senha. Se você receber este aviso em uma conta sem uma senha, o servidor SSH provavelmente desativou o PermitEmptyPasswords .

Clonagem agora se parece com isso:

cd your/local/workspace
git clone user@server:/path/to/project.git



Confirmar alterações

Depois de editar um arquivo, você precisa confirmar suas alterações no git. Quando você executa este comando, ele pede por uma mensagem de commit - que é apenas um simples pedaço de texto que diz a todos o que você mudou.

$ git commit source/main.c

Irá cometer o arquivo main.c no diretório ./source/

$ git commit -a # the -a flag pulls in all modified files

irá comprometer todos os arquivos alterados (mas não novos arquivos, eles precisam ser adicionados ao índice com git-add). Se você quer cometer apenas alguns arquivos, então você precisará encená-los primeiro com git-add e, em seguida, confirmar sem o sinalizador -a.

O commit apenas altera seu repositório local, embora não os repositórios remotos. Se você quiser enviar os commits para o repositório remoto, então você precisará fazer um push.

$ git push <remote> <branch> # push new commits to the <branch> on the <remote> repository

Para alguém vindo do CVS ou do SVN, isso é uma mudança, pois o commit no repositório central agora requer duas etapas.




Obtendo o código mais recente

$ git pull <remote> <branch> # fetches the code and merges it into 
                             # your working directory
$ git fetch <remote> <branch> # fetches the code but does not merge
                              # it into your working directory

$ git pull --tag <remote> <branch> # same as above but fetch tags as well
$ git fetch --tag <remote> <branch> # you get the idea

Isso cobre praticamente todos os casos para obter a cópia mais recente do código do repositório remoto.




Git Magic é tudo o que você precisa. Garantido ou seu dinheiro de volta!




Eu também achei o Git Internals muito útil. É escrito por Scott Chacon (autor de Pro Git e mantenedor do Git Community Book). O que eu gosto sobre o Git Internals é que ele foca nos conceitos primeiro e depois nos comandos , e sendo ~ 100 pequenas páginas, é rapidamente digerível.




Como rastrear filiais remotas

Supondo que haja um repositório remoto do qual você clonou seu repositório local e também assumindo que existe uma ramificação chamada 'some_branch' nesse repositório remoto, veja como rastreá-lo localmente:

# list remote branches
git branch -r

# start tracking one remote branch
git branch --track some_branch origin/some_branch

# change to the branch locally
git checkout some_branch

# make changes and commit them locally
....

# push your changes to the remote repository:
git push



Como você compara duas revisões de um arquivo ou seu arquivo atual e uma revisão anterior?

Compare o comando é git diff.

Para comparar duas revisões de um arquivo:

$ git diff <commit1> <commit2> <file_name>

Isso difere commit1 contra commit2; Se você alterar a ordem, os arquivos serão divididos ao contrário, o que pode não ser o esperado ...

Para comparar o arquivo preparado atualmente com o repositório:

$ git diff --staged <file_name>

Para comparar o arquivo atual não sincronizado com o repositório:

$ git diff <file_name>



UI do console - Tig

Instalação:

apt-get install tig

Uso

Enquanto dentro de um repositório git, digite 'tig', para visualizar um log interativo, pressione 'enter' em qualquer log para ver mais informações sobre ele. h para ajuda, que lista a funcionalidade básica.

Trivialidades

"Tig" é "Git" para trás.




Eu comecei com o tutorial oficial do Git . Eu acho que é prático o suficiente para iniciantes (eu era, e ainda sou, um iniciante, pela sua definição! Eu mal compreendo makefiles, eu apenas joguei um pouco com o Apache Subversion, etc.).




Empurre e puxe as mudanças

De uma forma simplificada, basta fazer git pushe git pull. As mudanças são mescladas e se houver um conflito, o git informará e você poderá resolvê-lo manualmente.

Quando você envia primeiro para um repositório remoto, você precisa fazer um git push origin master(mestre sendo o ramo mestre). A partir de então você apenas faz o git push.

Empurre tags com git push --tags.




Gity: Gity






Related