Descreve a parte prática da questão do uso do Git - sua instalação e registro no servidor Github.com.

Github.com é um serviço que oferece armazenamento do seu código e dados usando o sistema de controle de versão. Git.. O GitHub fornece um plano tarifário gratuito para armazenar dados de 300MB na forma aberta. Isso significa que qualquer usuário da Internet pode baixar seus dados. No GitHub pode ser colocado e fechado para outro repositório, pagando US $ 7 por mês. Na conta gratuita do Github, por padrão, ninguém pode alterar seus dados (só pode ler). Mas você pode insistir quem dos usuários do sistema GitHub tem o direito de gravar.

O artigo descreve em detalhes como fazer a configuração do Git no Windows e no sistema operacional Linux.

Instalando Git sob Linux

Usuários do Linux, acho que não faz sentido explicar como instalar o Git - isso é feito de maneiras diferentes. No sistema Debian (que vale a pena comigo), para instalar o Git, você pode usar o comando:

apt-get install git

Instalando Git no Windows

Nós vamos para a página oficial do Git http://git-scm.com, clique em Baixe para Windows.. Na janela que abre, clique em Instalador completo para git oficial. Execute o exe-shnik recebido.

No processo de instalação, esta questão será feita:

Eu recomendo escolher "Executar Git no prompt de comando do Windows". Todas as outras opções podem ser deixadas por padrão. Depois de instalar o Git, você precisa reiniciar ou concluir a sessão do usuário e fazer login para usar as alterações na variável do sistema de caminho.

Se você receber informações sobre a versão, o Git está instalado e em execução. Se obtivermos as informações que o programa GIT não é encontrado, entendemos o que eles fizeram de errado.

Configuração da chave SSH.

Antes de se registrar com o GitHub, você deve primeiro gerar uma criptografia de chave SSH. Essa chave é necessária para instalar rapidamente a conexão com o github, sem inserir a senha. Sem essa chave do github, não será fácil trabalhar.

Atenção!

No momento da geração de chave, a senha será solicitada. Este acesso à senha à tecla fechada, que é armazenado apenas no seu carro e em qualquer outro lugar. Esta senha é definida para títulos máximos, embora você possa fazer sem ele. Você precisa saber que, definindo uma senha para uma chave privada, você precisará inserir essa senha com cada servidor GitHub. Assim, ao especificar uma senha, toda a conveniência de usar chaves de criptografia desaparece.

Usuários de Mytetra: A interface de trabalhar com a linha de comando, que é usada para chamar Git durante a sincronização, não pode funcionar em inserir caracteres. Portanto, se você especificar a senha, a sincronização não funcionará.

Configurando chaves SSH no Linux

No sistema operacional Linux, primeiro é necessário olhar para o diretório ~ / .ssh. Se houver arquivos id_rsa e id_rsa.pub, então esta é as teclas SSH. Se não houver desse diretório ou esses arquivos, as teclas devem ser geradas. Deixe a equipe:

Em vez de [E-mail protegido] Você precisa especificar seu email. No processo de geração de chave, você perguntará onde colocar arquivos, simplesmente pressione ENTER. Ao solicitar uma senha, pressione ENTER. Após a geração, os arquivos ID_RSA e ID_RSA.Pub devem aparecer no diretório ~ / .ssh, eles serão adequados para nós mais tarde.

Configurando chaves SSH no Windows

No sistema operacional Windows, o gerador da chave SSH está incluído no pacote Git. Para gerar chaves, você deve executar para executar o arquivo C: \\ Arquivos de Programas \\ Git \\ Git Bash.vbs. Pode ser lançado como um exe-shnik comum. O programa do Git Console abre. Deve ser dado uma equipe:

ssh-keygen -t rsa -c " [E-mail protegido]"

Tenha cuidado, neste console, o PASTO COP notará, basta digitar o comando manualmente. Como um email, especifique sua caixa de correio. A pedido " Digite o arquivo no qual salvar a chave"Basta pressionar ENTER. Ao solicitar uma senha" Digite a Passphrase "e" Digite a mesma senha novamente ", basta pressionar ENTER. No processo de geração de chaves no console, aproximadamente as seguintes informações serão emitidas:

Gerando pares de chave RSA pública / privada.
Digite o arquivo no qual salvar a chave (/ c / documentos e configurações / username / .ssh / id_rsa)
Digite a Passphrase (vazio para sem fraseia):
Digite a mesma frase secreta novamente:
Sua identificação foi salva em / c / documentos e configurações / nome de usuário / .ssh / id_rsa.
Sua chave pública foi salva em / c / documentos e configurações / nome de usuário / .ssh / id_rsa.pub.
A chave digital é:
51: DB: 73: E9: 31: 9F: 51: A6: 7A: C5: 3D: DA: 9C: 35: 8F: 95 [E-mail protegido]

Depois de executar este programa, no catálogo C: \\ documentos e configurações \\ username \\ .ssh Os arquivos id_rsa e id_rsa.pub serão localizados, eles serão úteis para nós mais tarde.

Registro no github.com.

Agora tudo está pronto para registro. Vá para a página inicial do github.com. A interface é um pouco confusa, então eu darei um par de capturas de tela onde é pressionado. O design e o layout podem ser alterados a qualquer momento, então descrevo a lógica da ação no momento.

No menu superior, encontre item " Preços e inscrição."E clique nele:

A página de seleção do plano tarifário é aberta. Escolha uma conta gratuita " CRIAR UMA CONTA GRATUITA":

Instalando uma chave SSH no github

Imediatamente após o registro, é necessário registrar sua chave de criptografia de chave pública no sistema Guthub (Abrir a tecla SSH). Para adicionar uma chave, você precisa clicar no canto superior direito ". Configurações da conta":

Na janela que abre, você precisa clicar no item de menu " Chaves públicas ssh."e clique em" Adicione outra chave pública". Dois campos aparecerão - o nome chave ( Título) e conteúdo chave ( Chave).

No campo Título Você pode escrever o nome do computador no qual a chave pública é gerada. Você pode escrever em russo.

No campo Chave Você precisa inserir o conteúdo do arquivo id_rsa.pub. Lembre-se, em que catálogo são eles? Vá para este diretório, aberto por qualquer editor de texto ID_RSA.PUB (é com a extensão .pub, não confunda). Destacamos todo o texto, copie e insira na página do github no campo Chave.

Depois de adicionar uma chave, o computador pode se conectar ao github através do programa GIT, e nenhum erro deve ocorrer.

Criando um repositório no GitHub

Agora é hora de criar seu primeiro repositório no GitHub. O repositório pode ser visualizado simplesmente como um diretório no qual arquivos e subdiretórios sincronizados estarão mentindo. Você precisa criar um repositório na interface da Web do GitHub e poderá preenchê-lo com arquivos e trabalhar com ele usando o programa GIT no seu computador.

Para criar um repositório, você precisa clicar no canto superior direito " Painel.". Na janela que abre, você verá o item" Crie um repositório.":

Então, não precisamos deste item! Este item abre não a caixa de diálogo de criação de repositório e a página de ajuda. Em vez de clicar neste item, estamos procurando abaixo na página para um link improvável " Crie um repositório.". Ela também abrirá a caixa de diálogo para adicionar um novo repositório.

Na caixa de diálogo Adicionar um novo repositório, você precisa preencher pelo menos o campo Nome do projeto " Nome do Projeto."Em nome do projeto, é melhor não usar cirílico, já que o nome do projeto é o nome do diretório. Para evitar problemas, o nome do projeto contém apenas latim. Depois de pressionar o botão" Crie repositório.", o repositório será criado.

A referência operacional ao repositório no sistema GitHub é formada por isso. Se você se registrou no nome do nome de usuário, e seu repositório é chamado de Reponame, você poderá usar os seguintes links para acessar este repositório:

Na sintaxe do Git:

[E-mail protegido]: nome de usuário / reponame.git

Na sintaxe HTTPS:

https: // [E-mail protegido]/Username/reptoname.git.

Trabalhando com o repositório no GitHub através do programa GIT

A partir de agora, as danças ao redor da interface da Web do Github podem ser consideradas completas. Em seguida, você só pode trabalhar usando o programa GIT.

No começo, você precisa fazer uma pequena configuração do programa GIT: especificar o sistema Git local do usuário e e-mail. Isso é feito pelos seguintes comandos que podem ser executados durante qualquer diretório:

git config-global user.name "yourfullname"
Git Config --Global User.Email [E-mail protegido]

onde em vez de seu próprio nome, você precisa escrever seu nome e, em vez disso, [E-mail protegido] - seu email. Esses valores são usados \u200b\u200bpara o login no GitHub. Portanto, você precisa especificar seu login no github - no local [E-mail protegido] Você precisa especificar o e-mail inserido ao gerar chaves de criptografia.

Após essas configurações, você pode derramar seus arquivos para o repositório. Vá para o catálogo com o seu projeto e dê às equipes:

git commit -a -m "primeiro commito"

git Remote Adicionar origem [E-mail protegido]: nome de usuário / reponame.git

git push -u mestre de origem

Após esses comandos, uma cópia dos arquivos do diretório é formada no servidor GitHub, no qual os dados do comando foram executados. Em seguida, você já pode fazer comete, preencher as alterações do servidor GitHub, leia as alterações do servidor. Mas esta é uma história completamente diferente.

Para as pessoas, naturalmente resistem à mudança. Se o Git não o conheceu quando você começou a trabalhar com os sistemas de controle de versões, provavelmente se sentirá mais confortável no sistema Subversion (SVN).

Muitas vezes as pessoas dizem que o Git é muito complicado para iniciantes. No entanto, vou me permitir discordar disso.

Nesta lição, vou contar como usar o Git em seus projetos. Suponha que você crie um projeto a partir do zero e deseja gerenciá-lo usando o Git. Tendo andado na lista de comandos principais, você terá uma ideia de como colocar seu código na nuvem pelo GitHub.

Neste artigo, falaremos sobre o básico do Git - Como inicializar seus projetos, como gerenciar arquivos novos e existentes e como salvar seu código na nuvem.

Não vamos tocar partes relativamente complexas do Git, como ramificação, já que esta lição é projetada para iniciantes.

Instalando Git.

No site oficial Git é informação detalhadaem sua instalação no Linux, Mac e Windows. No nosso caso, usaremos para demonstrar o Ubuntu 13.04 para instalar o Git usando o apt-get:

sudo apt-get install git

Configuração inicial

Vamos criar um diretório dentro dos quais vamos trabalhar. Alternativamente, você pode usar o Git para gerenciar um dos projetos existentes; Nesse caso, você não precisará criar um diretório demo como mostrado abaixo:

mkdir my_git_project cd my_git_project

O primeiro passo é a inicialização do Git no diretório. Isso pode ser feito usando o comando init, que cria um diretório .GIT contendo todas as informações associadas ao Git para o seu projeto.

git config --global user.name "shaumik" git config-global user.email " [E-mail protegido]"Git config - global color.ui" auto "

É importante notar que, se você não especificar seu nome e endereço de e-mail, os valores padrão serão usados. No nosso caso, os valores padrão seriam donny username e endereço de e-mail [E-mail protegido].

Além disso, definimos o valor automático para a cor da interface do usuário, para que a saída do comando Git tenha uma luz de fundo.

O prefixo -global é necessário para não inserir esses comandos de configurações na próxima vez que iniciamos o projeto Git em nosso sistema.

Preparando arquivos de confirmação

O próximo passo é criar arquivos no diretório. Você pode usar, por exemplo, um editor de texto VIM. Note que se você for adicionar git a um diretório existente, não precisará executar esta etapa:

Verifique o status do repositório

Agora que temos vários arquivos em nosso repositório, vamos ver como o Git se vira para eles. Para verificar o status atual do repositório, você precisa usar o comando Git Status:

Adicionando arquivos ao git para rastrear

No momento, não temos arquivos para rastrear usando o Git. Precisamos adicionar arquivos especificamente no Git para especificar o git que você precisa rastrear.

Adicionar arquivos com o comando Adicionar:

Depois de verificar o estado do repositório, veremos que um arquivo foi adicionado:

Para adicionar vários arquivos, você pode usar a seguinte entrada de comando (note que adicionamos outro arquivo para a demonstração):

git adicionar myfile2 myfile3

Você pode usar o Git adicionar recursivamente, mas tenha cuidado com este comando. Existem alguns arquivos (por exemplo, arquivos compilados), que geralmente são armazenados fora do repositório Git.

Se você usar o comando Adicionar recursivamente, ele adicionará todos esses arquivos se eles existirem em seu repositório.

Excluindo arquivos

Mas a execução de um simples comando Git RM excluirá o arquivo não apenas do Git, mas também do seu sistema de arquivos local! Para

Git parou de acompanhar o arquivo, mas o próprio arquivo é preservado em seu sistema local, execute o seguinte comando:

git rm --cached.

Confirmar as alterações

Depois de colocar seus arquivos, você pode cumpri-los ao Git. Imagine que o commit é uma captura de um certo ponto para o qual você pode retornar para acessar seu repositório nesta fase.

Você pode se ligar a cada comitê uma mensagem que é adicionada usando o prefixo -m:

git cometer -m "meu primeiro compromisso"

Promove com mensagens úteis, porque ajudará você a determinar o que você mudou nesta com.

Evite mensagens muito comuns como " Bugs corrigidos" Se você tiver um rastreador de tarefas, poderá adicionar mensagens na forma de " Bug fixo # 234».

Boa prática é usar o nome da filial ou o nome da função como prefixo para o relatório de confirmação. Por exemplo, " Gerenciamento de ativos: Função adicionada para gerar arquivos de ativo PDF"É uma mensagem significativa.

Git identifica comete adicionando um longo número hexadecimal a cada confirmação. Como regra, você não precisa copiar a string inteira, para determinar seu comércio suficientemente primeiros 5-6 caracteres.

Por favor, note que na captura de tela, nosso primeiro compromisso é determinado pelo código 8DD76FC.

Mais compromete

Agora vamos alterar vários arquivos após o nosso primeiro compromisso. Após a mudança, veremos que, como resultado da execução do comando Git Status Git, descobri alterações nos arquivos que ele rastreia:

Você pode verificar as alterações nos arquivos de rastreamento feitos no último comentário usando o comando git diff. Se você quiser visualizar alterações em um arquivo específico, use o comando git diff :

Você precisa adicionar esses arquivos novamente para fazer alterações nos arquivos de rastreamento para o próximo commit. Você pode adicionar todos os arquivos monitorados executando o comando:

Você pode evitar usar este comando usando o prefixo -a para o comando Git Commit, que adicionará todas as alterações a rastrear arquivos.

Esse processo, no entanto, é muito perigoso, pois pode prejudicar o projeto. Por exemplo, digamos que você abriu o arquivo e mudou por engano.

Se você colocar seletivamente os arquivos, observe as alterações em cada arquivo. Mas se você adicionar prefixo -a ao seu commit, todos os arquivos serão cometidos e você não poderá identificar possíveis erros.

Depois de postar seus arquivos, você pode prosseguir para o commit. Eu mencionei que uma mensagem que introduzimos usando prefixo -m pode ser associada a cada comitê.

No entanto, é possível inserir uma mensagem em várias linhas usando o comando Git Commit, que abre um formulário interativo para gravação:

Gerenciamento de Projetos

Para visualizar o histórico do seu projeto, você pode executar o seguinte comando:

Portanto, toda a história do projeto será mostrada, que é uma lista de todos os commits e informações sobre eles. Informações sobre o commit inclui o código de comissão de Kesh, autor, tempo e mensagem de comutação. Existem várias opções para o log do Git, que você pode explorar assim que pesar o conceito do ramo (ramificação) no Git.

Para visualizar informações detalhadas sobre um comércio e arquivos específicos que foram alterados, execute o seguinte comando:

show git.

onde Este é um número hexadecimal associado a um commit. Como esta lição é projetada para recém-chegados, não vamos considerar como voltar ao estado de um certo commit ou como controlar os ramos.

Colocação de código na nuvem

Agora que você aprendeu a gerenciar o código em seu sistema, é hora de colocar o código na nuvem.

O Github é uma plataforma muito conhecida para armazenar, distribuir e gerenciar o código-fonte de projetos abertos. Este serviço usa muitos desenvolvedores em todo o mundo, entre os quais existem grandes empresas, como Microsoft, Redhat e muitos outros, também centenas de desenvolvedores de muitos projetos populares.

A plataforma oferece oportunidades não apenas para visualizar o código e sua distribuição, mas também a história das versões, ferramentas de desenvolvimento conjuntas, ferramentas para fornecer documentação, lançamentos e feedback. E a coisa mais interessante que você pode colocar em projetos abertos e privados. Neste artigo, vamos analisar como usar o GitHub para acomodar seu projeto. Então, falar, github para iniciantes.

Então, digamos, você tem seu próprio projeto e quer colocar seu código no GitHub em acesso público a outros usuários pode vê-lo e participar de desenvolvimento. A primeira coisa que você precisa fazer é criar uma conta.

1. Criando uma conta

Para criar uma nova conta no site abra a página principal do Github e imediatamente você pode inserir imediatamente os dados para uma nova conta. Você precisa especificar o nome de usuário, e-mail e senha:

Quando completar a entrada, clique em "INSCREVA-SE GRATUITAMENTE":

Na próxima etapa, você precisa selecionar o tipo de repositório. Os repositórios públicos são gratuitos, mas se você deseja criar um repositório privado, o código do qual estará disponível apenas para você, você terá que pagar US $ 7 por mês.

A conta está pronta, e você será redirecionado para a página onde você pode criar seu primeiro projeto. Mas antes que você possa fazer isso, você precisa confirmar seu endereço de e-mail. Para fazer isso, abra sua caixa de correio e siga o link na carta do GitHub.

Nenhuma configuração do Github é necessária, apenas alguns cliques com o mouse.

2. Criando um repositório

Na página que abre, esta é a página principal para usuários autorizados, clique em "Iniciar um projeto":

Você pode imediatamente inicializar o repositório criando um arquivo readme, pois isso precisa mencionar um tick "Inicialize este repositório com um readme" na parte inferior da página. Você também pode escolher uma licença:

Quando tudo estiver pronto, selecione "Criar projeto"Um novo projeto será criado com o arquivo README, que contém a descrição e arquivo de licença.

3. Adicionando filiais

Os ramos do GitHub permitem que você trabalhe com várias versões do projeto ao mesmo tempo. Por padrão, ao criar um repositório, o ramo principal é criado, este é o ramo de trabalho principal. Você pode criar galhos adicionais, por exemplo, para testar o software antes de ser publicado no ramo principal. Assim, você pode desenvolver simultaneamente um produto e fornecer aos usuários uma versão estável. Você também pode criar ramificações individuais para a versão do programa para diferentes sistemas.

Ramo atual é indicado no canto superior esquerdo após a palavra "Galho".Para criar uma nova filial, basta implantar esta lista e começar a digitar seu nome:

O site sugerirá que você crie uma nova filial, selecione "Criar filial".

Imediatamente após a criação, você trabalhará com apenas criado pelo ramo.

4. Altere arquivos e commits

Quaisquer alterações nos arquivos do GitHub são feitas usando commits. O commit é realizado fazendo as próprias correções e descrevendo essas correções. Isso é necessário para que você saiba disso e quando você mudou, e também facilita rastrear o trabalho da equipe. A palavra Commovai pode ser traduzida como "correção". Ou seja, podemos fazer alterações em vários arquivos e, em seguida, consertá-los. Vamos alterar o arquivo README para o exemplo. Para fazer isso, encontre o botão com uma borla no lado direito do painel e clique nele:

Um editor de texto será aberto, onde você pode inserir a correção necessária:

Depois de fazer tudo o que precisa, você precisa preencher o campo "COMPROMETER-SE" na parte inferior da página. Descreva brevemente o que foi alterado e, em seguida, clique em "Confirmar as alterações":

Essas alterações serão inseridas no ramo atual do projeto, pois agora estamos trabalhando com testes, as alterações serão enviadas a ele.

5. Criando consultas de fusões (solicitação de pull)

O github for iniciantes pode parecer muito difícil por causa de tais recursos, mas é muito conveniente se você descobrir. O pedido de confluência ou pedido de puxar é uma oportunidade, graças à qual qualquer desenvolvedor pode pedir outro, por exemplo, o criador do repositório para visualizar seu código e adicioná-lo ao projeto ou ramo principal. A ferramenta de trabalho com as solicitações de fusão usa a ferramenta de comparação diff, para que você possa ver todas as alterações, elas serão enfatizadas por outra cor. A solicitação de tração pode ser criada imediatamente após a criação de um commit. Vamos enviar solicitação de tração de nossos ramos de teste para o principal. Primeiro, abra a aba "Puxe a solicitação".

Aqui, clique "Criar solicitação de tração":

Nesta janela você pode ver todas as alterações, agora vemos uma linha:

6. Visualizar e aprovar solicitações de fusão

Agora, na mesma guia Solicitações, acabamos de fazer uma solicitação para uma fusão e só podemos levá-lo clicando "Mesclar pedido de puxar":

Mas se este pedido veio de outra pessoa, você deve verificar se ele mudou para lá e se é necessário fazer isso por isso, clique na descrição da consulta e você verá uma janela de visualização de mudança familiar:

O código será então importado para a filial principal e a ramificação de teste pode ser removida com segurança.

7. Relatórios de erro.

Também é conveniente que seja possível usar o Github não apenas para desenvolver e gerenciar código, mas também para feedback dos usuários. Na guia "Emitir" Os usuários podem deixar mensagens sobre os problemas com os quais encontraram ao usar seu produto. Aba aberta. "Questões"e clique no botão "NOVO PROBLEMA":

8. lançamentos

Este último que vamos considerar hoje são lançamentos. Quando o produto atingiu um determinado estágio, você pode liberar uma liberação para os usuários e você pode ter certeza de que tudo é estável lá e ninguém quebrou qualquer coisa errada de tração no mestre. Primeiro você precisa ir para a página principal do projeto, então na guia "Lançamentos":

Nesta página, você precisa especificar a versão no campo. "Tag versão", então o nome do lançamento e uma pequena descrição. Se você tem compilado arquivos com binário, eles também precisam anexar aqui. Então clique "Criar versão":

Depois de criar liberação, essa página será criada:

Conclusões

Neste artigo, revisamos como usar o GitHub para acomodar e gerenciar nosso projeto. Todo o sistema é em inglês, então o conhecimento básico da linguagem é muito desejável, mas mesmo sem que eles funcionem com o Github não serão muito difíceis. Espero que esta informação seja útil para você. Se você estiver interessado em como trabalhar com o Git da linha de comando, consulte o artigo para iniciantes.

Introdução detalhada para trabalhar com git

O que é git e por que ele é eu?

O Git é um sistema de controle de versão distribuído que permite salvar todas as alterações inseridas em arquivos armazenados no repositório. As alterações são armazenadas na forma de instantâneos, chamadas commits que podem ser colocadas em muitos servidores. Considere esta nuvem padrão para backups em esteróides - você não pode apenas restaurar o código em caso de falha, mas também para reverter o código para qualquer um dos estados salvos anteriores. Você também pode interagir facilmente com outros desenvolvedores - novamente, como algumas pessoas podem funcionar em um arquivo no Google Docs e desenvolvedores podem trabalhar simultaneamente em um repositório e manter suas alterações.

Em vista de todas as suas vantagens, o Git é uma ferramenta indispensável para todos que ou vão se desenvolver. Neste artigo, veremos os comandos Git mais úteis e a situação quando valem a pena usar. Também ajudará a refrescar seu conhecimento se você já estiver familiarizado com o Git.

Como trabalhar com git

Muitos comandos estão disponíveis no Git, por isso é útil dividi-los no assunto / motivo para usar. Primeiro, vamos olhar para o trabalho com o Git na máquina local, já que a maioria das operações ocorre exatamente lá, e depois vamos voltar para um formato multiplayer.

Com o Git, você pode trabalhar tanto através da linha de comando e através da interface gráfica como desktop do Github. Embora os desenvolvedores iniciantes da linha de comando possam assustar, ainda é melhor estudar, porque fornece mais oportunidades do que muitas ferramentas com a interface.

Como regra, as equipes do GIT tomam o tipo de git<команда> <аргументы> onde o argumento pode ser o caminho para o arquivo. As equipes também podem ser opções indicadas como -<опция> ou -<однобуквенная опция> . Eles permitem que você configure as ações de comando com mais detalhes. Neste artigo, a equipe será apresentada em geral, então tudo está em<> Você precisará substituir seus próprios significados.

Se você não souber como usar o comando, você pode abrir o guia usando a ajuda do Git<команда> e, se você precisar de um lembrete, use Git<команда> -h ou git.<команда> - Help (- Help e -h são equivalentes a).

Preparando Git.

Instalando Git.

Os usuários do Windows podem baixá-lo daqui.

O Git MacOS (OS X) vem como parte das ferramentas de linha de comando Xcode, então você precisa instalá-las. Para verificar a disponibilidade do Git, abra o terminal e insira o Git --version para verificar a versão.

Se você usa o Linux, use o comando Git-All Install APT SUDO ou sudo DNF Install Git-All (com base no RPM).

Configurando o arquivo de configuração.

A primeira coisa que você precisa fazer depois de instalar o Git é configurar o nome de usuário e e-mail, pois eles são usados \u200b\u200bpara identificar e armazenados em todas as fotos que você tirou. Essas configurações são armazenadas no arquivo de configuração com todo o resto.

Você pode editar diretamente o arquivo.gitconfig usando um editor de texto ou usando o comando git config --global --edit, e você pode editar campos separados usando o comando git config --global<поле> <значение> - Estamos interessados \u200b\u200bem campos de usuário e usuário.email.

Você também pode configurar um editor de texto para gravar mensagens de confirmação usando o campo Core.Editor. Inicialmente usa o editor de sistema padrão, por exemplo, VI para Linux / Mac. O campo Commit.Template permite que você especifique o modelo que será usado em cada COM.

Há muitos outros campos, mas um dos mais úteis é o alias, que liga a equipe ao pseudônimo. Por exemplo, o git config --global alias.t "status -s" permite que você use o Git St em vez de status Git -s

O comando git config -list exibirá todos os campos e seus valores do arquivo de configuração.

Crie repositório Git.

Para inicializar o novo repositório. O comando Git Init pode ser usado ou se você quiser copiar o clone git existente<адрес репозитория> .

História cometida no Git

Git armazena dados na forma de um conjunto de "instantâneos" leves conhecidos como commits. Eles armazenam o status do sistema de arquivos em um determinado momento no tempo, bem como um ponteiro para o (s) commit (s) anterior (s). Cada comitê contém uma soma de verificação exclusiva - um identificador que o Git usa para se referir ao commit. Para rastrear a história, o Git armazena o ponteiro da cabeça, o que indica o primeiro compromisso (seguimos a cadeia commit na ordem inversa para chegar aos committers anteriores).

Podemos nos referir ao cometido por meio de sua soma de verificação, ou através de sua posição em relação à cabeça, por exemplo, a cabeça ~ 4 refere-se ao commit, que é 4 commita mais cedo que a cabeça.

Sistema de arquivos git.

Git rastreia arquivos em três seções principais:

• diretório de trabalho (sistema de arquivos do seu computador);
• a área de arquivos preparados (área de preparação armazena o conteúdo do próximo commit);
• Cabeça (o último compromisso no repositório).

Todos os arquivos principais para trabalhar com arquivos são reduzidos para entender como Git controla essas três seções. Há um equívoco comum de que a área de arquivos preparados apenas armazena mudanças. É melhor pensar nessas três seções como sistemas de arquivos separados, cada um deles contém suas cópias dos arquivos.

Visualizar mudanças nos sistemas de arquivos

O comando Git Status exibe todos os arquivos que diferem entre três seções. Arquivos têm 4 estados:

1. Unteracted (não marcado) - está no diretório de trabalho, mas não há versão na cabeça ou no campo de arquivos preparados (Git não sabe sobre o arquivo).
2. Alterado (modificado) - há uma versão mais recente no diretório de trabalho em comparação com a cabeça armazenada ou no campo de arquivos preparados (as alterações não estão no próximo COM.
3. Preparado (encenado) - há uma versão mais recente no diretório de trabalho e na área de arquivos preparados em comparação com a cabeça (pronta para o commit).
4. Sem alteração - uma versão do arquivo em todas as seções, isto é, nos últimos commers contém a versão atual.

Observação O arquivo pode ser simultaneamente "alterado" e "preparado" se a versão no diretório de trabalho for mais recente do que no campo de arquivos preparados, que por sua vez é a versão mais recente na cabeça.

Podemos usar a opção -s para o comando Git Status para obter uma saída mais compacta (na linha ao arquivo). Se o arquivo não for rastreado, será exibido? ; Se ele foi mudado, seu nome será vermelho e se preparado - verde.

Para ver as próprias mudanças, e não modificar arquivos, você pode usar os seguintes comandos:

• git diff - comparação do diretório de trabalho com a área de arquivos preparados;
• git diff --staged - Comparação da área de arquivos preparados com a cabeça.

Se você usar um argumento<файл/папка> , Diff mostrará alterações apenas para arquivos / pastas especificados, como o Git Diff SRC /.

Atualização do sistema de arquivos

Team Git Add.<файл/папка> Atualiza a área dos arquivos de arquivos / pastas arquivados do diretório de trabalho.

O comando Git Commit atualiza a cabeça com um novo commit, que tira fotos de arquivos na área de arquivos preparados.

Git Redefinir Ação de Comando<коммит> Consiste em três etapas potenciais:

1. Mover o ponteiro da cabeça para<коммит> (Por exemplo, quando a reversão compita no diretório de trabalho e a área de arquivos preparados será mais novas versões de arquivos do que na cabeça). Além disso, o ponteiro da cabeça do ramo será movido para este commit.
2. Atualize a área de arquivos preparados pelo conteúdo do commit. Nesse caso, apenas o diretório de trabalho será as versões mais recentes dos arquivos.
3. Atualize o conteúdo do diretório de trabalho da área de arquivos preparados. Você precisa ter cuidado com isso, porque as alterações do arquivo serão eventualmente destruídas.

Por padrão, o comando Git Reset executa apenas as etapas 1 e 2, mas seu comportamento pode ser alterado usando as opções --soft (apenas 1 etapa) e --hard (todas as etapas).

Se você enviar o caminho para o arquivo / pasta, o comando será executado apenas para eles, por exemplo, Git Reset - Soft Head ~ 1 SRC /.

Cabeça de checkout da equipe Git<файл> leva ao mesmo resultado que o git reset - HEAD<файл> - Substitui uma versão do arquivo no campo de arquivos preparados e no diretório de trabalho da versão principal, ou seja, cancela as alterações após o último commit.

Por outro lado, checkout git<файл> (Já sem cabeça) substitui a versão do arquivo no diretório de trabalho da versão no campo de arquivos preparados, ou seja, cancela alterações desde a última versão preparada.

Finalmente git rm.<файл> Cancela o rastreamento do arquivo e exclui-o no diretório de trabalho, a opção --cached salvará o arquivo.

Ignorando arquivos

Muitas vezes, não precisamos de Git para rastrear todos os arquivos no repositório, porque seu número pode incluir:

• arquivos com informações confidenciais, como senhas;
• grandes arquivos binários;
• arquivos de montagem gerados após cada compilação;
• arquivos OS / IDE, por exemplo, .Ds_store. Para macos ou. .iml. Para a ideia do Intellij - precisamos do repositório para depender o mais pequeno possível do sistema.

Para ignorar o arquivo.gitignore. Para marcar os arquivos que queremos ignorar, você pode usar padrões de pesquisa (considerá-los simplificados expressões regulares):

• / ___ - evita a recursividade - atende aos arquivos somente no diretório atual;
• __ / - atende a todos os arquivos no diretório especificado;
• * ___ - atende a todos os arquivos com o final especificado;
• ! - ignorar arquivos caindo sob o padrão especificado;
• [__] - Corresponde a qualquer caractere daqueles especificados em colchetes quadrados;
• ? - corresponde a qualquer símbolo;
• / ** / - - Corresponde a diretórios aninhados, por exemplo, A / ** / D corresponde a A / D, A / B / D, A / B / C / D, etc. e assim por diante.

Podemos até usar padrões de pesquisa ao especificar um arquivo / pasta em outros comandos. Por exemplo, Git adicionar SRC / *. CSS adicionará todos os arquivos. CSS na pasta SRC.

Committ

Como as comissões são a base da história das versões, não serão supérfluas para aprender sobre eles um pouco mais.

O comando Git Commit irá abrir um editor de texto para inserir mensagens de confirmação. Além disso, esta equipe recebe vários argumentos comuns:

• -m Permite escrever uma mensagem com a equipe sem abrir o editor. Por exemplo, o Git comete -m "Fixing Bag";
• -a transfere todos os arquivos monitorados para a área de arquivos preparados e inclui-los na Commote (permite que você pule o Git Add antes do commit);
• --Amend substitui o último compromisso com um novo commit modificado, o que é útil se você digitou incorretamente a mensagem do último commit ou esqueci para incluir alguns arquivos nele.

Várias dicas para quem vale a pena ouvir:

• Comitê Frequentemente: Você não poderá reverter as alterações se você reverter para o que.
• Uma mudança é um commit: não coloque todas as mudanças em um comite, divida-os para que fosse mais fácil reverter.
• Formato da mensagem: O título deve estar em uma ignição imperativa, menos de 50 caracteres de comprimento e deve logicamente complementar a frase deste commit irá ___ (este confirmação corrigirá bugs - esse compromisso corrigirá bugs). A mensagem deve explicar por que o commit foi feito, e o próprio compromisso mostra o que mudou. Agendado em detalhes como escrever mensagens para commits.
• (Opcional) Não cometa pequenas alterações: Em um grande repositório, muitos pequenos commits podem entupir a história. Um bom tom é considerado para fazer tais como se desenvolver, e ao adicioná-los a um grande repositório para combiná-los em um comprometimento.

Ver alterações na história

Você pode usar o comando Git Log para visualizar o histórico de comissões anteriores na ordem cronológica inversa. Ela pode passar diferentes opções:

• -p mostra as alterações em cada com.
• - Astat mostra estatísticas abreviadas para commits, como arquivos alterados e o número de cordas adicionadas / remotas em cada uma delas;
• -N mostra n. Commits recentes;
• --Sínia \u003d ___ e --until \u003d ___ permite filtrar commits por um período de tempo, por exemplo --sínce \u003d "2019-01-01" mostrará commits de 1º de janeiro de 2019;
• --Pretty permite especificar o formato de log (por exemplo, --Pretty \u003d Oneline), você também pode usar --Pretty \u003d Format para maior personalização, por exemplo --Pretty \u003d Format: "% h% s";
• --Grep e filtro de filtro com mensagens / código de alteração que contêm a string especificada, por exemplo, Git Log -s_Name_Name permite que você visualize a adição / exclusão da função;
• --No-mescles passa commits com ramos de mesclagem;
• veta1..tel2 permite que você veja quais compromissos do ramo 2 não estão no ramo 1 (útil ao mesclar filiais). Por exemplo, o Git Log Master.Test mostrará o que comete do ramo de teste não está no mestre (fale com os galhos um pouco mais tarde).
• - Branch1 ... Branch2 mostra commits que estão em um ramo 1 ou em um ramo 2, mas não tanto em ambos; assinar< обозначает коммиты из ветка1 , а > - do ramo2. Carregar atenção: três pontos são usados, não dois;
• -L aceita um argumento começando, final: arquivo ou: arquivo: arquivo e mostra o histórico de alterações na linha de passagem ou função no arquivo.

Outra equipe útil é a git culpa<файл> , que para cada linha de arquivo mostra o autor e o valor da soma de verificação do último commit, que alterou esta sequência. -EU.<начало>, <конец> Permite limitar este comando a linhas especificadas. Isso pode ser usado, por exemplo, para descobrir quais comitês levaram a um bug específico (para que você possa reverter).

Finalmente, há um comando git grep que está procurando por todos os arquivos no histórico de commit (e não apenas no diretório de trabalho como grep) de acordo com a expressão regular especificada. Opção -N Exibe o número da linha correspondente no arquivo para cada correspondência, e --count mostra o número de correspondências para cada arquivo.

Nota Não confunda Git Grit com Git Log --grep! O primeiro está procurando por arquivos entre commits, e o último analisa as mensagens de log.

Servidores remotos

Até agora, discutimos o uso do Git apenas na máquina local. No entanto, podemos armazenar o histórico de compromissos de repositórios remotos, que podem ser monitorados e atualizados (considerar seus backups de nuvem remota do nosso histórico de cometimentos).

O comando git Remote -V exibe uma lista de repositórios remotos que rastreamos e os nomes que temos apropriados.

Ao usar o comando git clone Nós não apenas carregamos uma cópia do repositório, mas também monitoramos implicitamente o servidor remoto, que está no endereço especificado e que recebe a origem do nome.

Os comandos mais consumíveis:

• git Remote Adicionar.<имя> - Adiciona um repositório remoto com o nome especificado;
• git Remote Remover.<имя> - Remove um repositório remoto com o nome especificado;
• git Remote Rename.<старое имя> <новое имя> - renomeia repositório remoto;
• git Conjunto Remoto-URL<имя> - atribui um repositório chamado um novo endereço;
• show Remoto Git.<имя> - Exibe informações sobre o repositório.

Os seguintes comandos operam com ramos removidos:

• git buscar.<имя> <ветка> - recebe dados da ramificação do repositório especificado, mas não fundam as alterações;
• git pull<имя> <ветка> - Mescha os dados da filial do repositório especificado;
• push git.<имя> <ветка> - envia alterações na ramificação do repositório especificado. Se a filial local já estiver rastreando o controle remoto, você poderá usar apenas push git ou git.

Assim, várias pessoas podem solicitar alterações do servidor, fazendo alterações nas cópias locais e enviá-las para um servidor remoto, o que permite interagir uns com os outros dentro de um repositório.

Galho

Tudo isso é bom e ótimo se cada desenvolvedor estiver trabalhando em um projeto em momentos diferentes. Os gráficos mostrados acima deslocados somente situações com uma mudança no repositório original ou cópia local, mas não o trabalho de várias pessoas.

Isso nos leva à principal característica do Git - Ramificação, a capacidade de trabalhar em diferentes versões do projeto. Isso significa que, em vez de uma lista com commits encomendadas, a história divergem em certos pontos (o que a torna semelhante à árvore). Cada ramo no Git contém uma cabeça leve de cabeça para o último compromisso nesta discussão, o que permite criar muitos ramos sem custos extras. Dica: Ligue para uma filial de acordo com a funcionalidade desenvolvida nele. O ramo padrão é chamado de mestre.

Então temos um ponteiro geral Cabeça. E cabeça para cada ramo. Assim, trocar entre os ramos implica apenas mover Cabeça. Na cabeça do ramo correspondente.

Equipes padrão:

• ramo git.<имя ветки> - cria um novo ramo com a cabeça indicando Cabeça.. Se você não transmitir o argumento<имя ветки> , a equipe exibirá uma lista de todos os ramos locais;
• checkout Git<имя ветки> - Muda para este ramo. Você pode passar a opção -b para criar uma nova filial antes de alternar;
• git ramo -d.<имя ветки> - Remove o ramo.

Como nosso repositório local, e controle remoto, pode ter muitos ramos, portanto, quando você rastrear um repositório remoto, na verdade, monitorado um ramo removido (o clone do Git traz sua filial principal para a ramificação de origem / mestre do repositório remoto).

Encadernação ao ramo removido:

• git ramo -u.<имя удалённого репозитория>/<удалённая ветка> - Vincula a ramificação atual para o ramo remoto especificado;
• git checkout - track.<имя удалённого репозитория>/<удалённая ветка> - analógico do comando anterior;
• git checkout -b.<ветка> <имя удалённого репозитория>/<удалённая ветка> - cria uma nova filial local e começa a rastrear o controle remoto;
• git Branch --VV - mostra ramos remotos locais e monitorados;
• checkout Git<удалённая ветка> - Cria uma filial local com o mesmo nome do controle remoto e começa a rastreá-lo.

Em geral, o checkout Git está associado a uma localização do local que aponta a cabeça dos ramos, que se parece com a redefinição do Git move a cabeça geral.

Hypets e limpeza

Há uma sutileza - ao mudar de ramos do Git requer que o estado de trabalho esteja limpo, isto é, todas as alterações nos arquivos de rastreamento devem ser corrigidas.

Aproximadamente. Traduzir Isso não é tão. Em algumas circunstâncias, o Git pode transferir automaticamente a mudança não aliviada para outra filial.

No entanto, às vezes você tem mudanças inacabadas que não podem ser corrigidas. Em tal situação, eles podem ser salvos e "ocultar" usando o comando Git STASH. Para devolver as alterações, use o Git Stash se aplicar.

Talvez você queira apagar todas as alterações feitas. Neste caso, use o comando git limpo. A opção -d também excluirá arquivos não qualificados. Dica: Adicione a opção -n para ver o que acontece quando você inicia o Git Limpo sem uso direto.

Combinando ramos

Depois de discutirmos quais ramos e ambos entre eles, é hora de falar sobre como eles podem ser combinados após o desenvolvimento. O ramo em que queremos mesclar as mudanças será chamado de principal, e a filial a partir da qual os fundiremos - temáticos. Existem duas maneiras de fazer alterações de um ramo para outro: mesclar e mover.

Fusão

Inclui a criação de um novo commit, baseado em um ancestral geral de dois ramos e indica tanto a cabeça como comete anteriores. Para fusão, vamos ao ramo principal e usamos o comando Git Merge<тематическая ветка> .

Se ambos os ramos mudarem a mesma parte do arquivo, então o conflito surge - a situação em que o Git não sabe qual versão do arquivo salve, por isso é necessário resolver o conflito pessoalmente. Para ver arquivos conflitantes, use o status do Git.

Depois de abrir esses arquivos, você verá marcadores de resolução de conflitos semelhantes:

<<<<<<< HEAD:index.html Everything above the ==== is the version in master. ======= Everything below the ==== is the version in the test branch. >\u003e\u003e\u003e\u003e\u003e\u003e Teste: index.html

Substitua neste bloco tudo na versão que você deseja sair e preparar o arquivo. Depois de resolver todos os conflitos, você pode usar o Git comprometer-se para completar a mesclagem.

Mover

Em vez de combinar os dois ramos do Comitê de Incorporação, a mudança reproduz as comissões do ramo temático na forma de um conjunto de novos comités do ramo base, que é derramado em uma história mais limpa de commits.

O comando git rebase é usado para mover<основная ветка> <тематическая ветка> que reproduz mudanças no ramo temático no principal; Filial Head Thematic indica o último commit reproduzido.

Mover vs. fusão

Depois de mesclar o log com uma história, pode ficar bem aleatoriamente. Por outro lado, mover permite que você reescreva a história em uma forma normal e consistente.

Então, por que você precisa de uma fusão se puder usar o tempo todo? Infelizmente, a mudança não é uma panacéia de registros confusantes, já que as comissões deslocadas são realmente diferem do original, embora tenham o mesmo autor, a mensagem e a mudança.

Imagine um cenário:

• Em sua filial, você cria vários commits e as mescla no ramo principal.
• Alguém decide trabalhar com base em seus commits.
• Você decide mover seus commits e enviá-los para o servidor.
• Quando alguém tenta fundir seu trabalho com base em suas comissões iniciais, no final receberemos dois ramos paralelos com um autor, mensagens e mudanças, mas por diferentes commits.

Portanto, aqui está o Conselho:

Mova as alterações apenas no seu ramo local privado - não mova as comissões em que alguém depende.

Rollback do Comitê - Reverter e Redefinir

Debates semelhantes sobre o que é melhor usar, ocorrer quando você deseja reverter o comtoto. Team Git Reverter.<коммит> Cria um novo commit, cancelando alterações, mas preservando o histórico, enquanto o Git reset<коммит> Move o ponteiro da cabeça, fornecendo uma história mais limpa (como se esse commit nunca tivesse acontecido). É importante notar que também significa que você não estará mais de volta a essas mudanças, por exemplo, se você ainda decidir que o cancelamento do commit era desnecessário. Cleaner - não significa melhor!

Resumir

Nesta fase você tem quase tudo que você precisa para trabalhar com Git. Abaixo será vários (opcional) dicas avançadas para maior controle sobre commits e histórico. Além disso, depois afetamos casualmente o Github - uma das plataformas mais famosas que trabalham com o Git, que podem ser úteis para você.

Github.

O GitHub é uma plataforma que armazena o repositório Git em seus vários servidores. Como usuário do Github, você pode armazenar seus repositórios remotos em seus servidores, bem como contribuir para outro repositório de código aberto. O GitHub complementa o uso do Git com alguns novos recursos.

Por exemplo, você pode fazer um repositório remoto do garfo, ou seja, criar sua cópia do repositório no norte do GitHub. Isso é útil nos casos em que você não tem o direito de criar uma filial no repositório original. Quando você usa o comando Git Clone, seu repositório local rastreará o formulário remoto como origem e o repositório original como upstream.

Depois disso, talvez seja necessário drenar a filial temática do repositório remoto no ramo principal do original. Para fazer isso, você pode criar uma nova solicitação de tração - uma solicitação para fazer alterações, onde o Github verifica a presença de conflitos antes de você representar uma mesclagem. Muitas vezes há outros verificações antes de mesclar, como visualizar e aprovar o código ou até mesmo iniciar testes. Na consulta, você pode discutir o código e todas as comissões enviadas para a filial temática remota serão automaticamente adicionadas à solicitação, mesmo que tenha sido criada antes de elas.

Uso Avançado: Preparação Interativa

Você pode gerenciar facilmente a área de arquivos preparados (por exemplo, ao corrigir vários pequenos commits em vez de um grande) usando um console interativo que o Git Add -i pode ser lançado. 8 equipes disponíveis nele:

• status - mostra uma breve descrição para cada arquivo que (não) preparado;
• atualização - Prepara arquivos de rastreamento;
• reverter - Remova um ou mais arquivos da área preparada;
• adicione os Estados Unidos - prepara o arquivo não qualificado;
• patch - Prepara apenas parte do arquivo (útil quando você, por exemplo, alterou várias funções, mas deseja quebrar as alterações em vários commits). Depois de selecionar o arquivo, você será mostrado para você fragmentos e apresentará possíveis comandos: Estágio este pedaço? . Posso entrar? Para descobrir o que faz com que cada equipe;
• diff - mostra uma lista de arquivos preparados e permite visualizar mudanças para cada um deles;
• quit - sai do console interativo;
• ajuda - mostra uma breve descrição de cada equipe.

O símbolo * ao lado do arquivo significa que o comando alterará seu status (preparado / despreparado, dependendo se a atualização ou a reversão ocorre). Se você pressionar Enter sem inserir qualquer coisa em qualquer um dos menu de comando, todos os arquivos mudarão para (não) estado preparado.

Por favor, note que a criação de patches (preparação de apenas uma parte do arquivo) está disponível não apenas no console interativo, mas também através do comando git add -p.

Uso Avançado: Histórico de Regras

Para maior controle sobre a história da filial local Commit, você pode usar o comando git rebase -i head ~ n. que abrirá o console interativo para mover o conjunto do último n. Commits listados em ordem de antiga para novo (isto é, na ordem em que serão movidos). Então você pode "editar o histórico", no entanto, lembre-se de que os commits originais não podem ser alterados, apenas para se mover.

Você pode alterar a ordem de commits alterando a ordem em que eles estão listados.

Alterar a mensagem Commit / Sell Commits

Para especificar o comitê que você deseja alterar, o comando Editar é usado. Então, quando Git se moverá, ele vai parar neste com. Depois disso, você pode usar o cometido Git - Jumendo para alterar a mensagem ou preparar arquivos esquecidos. Se você quiser dividir a comtaça, depois de parar, insira a cabeça de redefinição do Git ^ (como resultado de cabeça, ele será movido para um cometente e todos os arquivos foram alterados neste commit mudarão para o status de despreparado). Em seguida, você pode corrigir os arquivos em commits individuais da maneira usual.

Após a conclusão de edição, insira o git rebase --continue.

Substituir vários comitores

Às vezes, você pode precisar sobrescrever vários commits - em tais casos, você pode usar o ramo de filtro do Git. Por exemplo, para excluir um arquivo gravado aleatoriamente, você pode inserir o Git Filter-Branch - Tree-Filter "Git RM -F<имя файла>"Cabeça. No entanto, considere que, ao mesmo tempo, toda a história se move.

Combinando vários commits

Enquanto trabalhava em um novo recurso no projeto, você pode gravar gradualmente mesmo as menores mudanças no ramo temático. No entanto, por isso, a história é entupida por pequenas commits, o que pode contradizer as regras do projeto. Isso pode ser corrigido combinando vários commits para um grande. Para fazer isso, primeiro use o comando pick para selecionar o primeiro compromisso e, em seguida, squash para subseqüente. O Git aplicará todas as alterações em um começo e pedir-lhe para editar a mensagem do commit geral.

Transferir uma comtate separada

Além da fusão / movimento de todas as commits no ramo temático, você só pode estar interessado em um certo commit. Suponha que você tenha um ramo de rascunhos local, onde trabalha em vários artigos em potencial, mas deseja publicar apenas um deles. Para fazer isso, você pode usar o comando Git Cherry-Pick. Para obter certas commits do qual queremos escolher, você pode usar o log do Git<основная ветка>..<тематическая> .

Por favor, note que um novo commit é criado dessa maneira, que só repete a diferença do commit selecionado (ou seja, a diferença entre este commit e o anterior), mas não sua condição.

Conclusão

Então revisamos os conceitos básicos do Git. Você pode usar este artigo como um breve livro de referência, e você pode ler o livro "Pro Git", que é muito mais (~ 450 páginas) e descreve Git mais profundamente.

Quer cavar mais fundo no Git, mas você tem pouco (ou vice-versa, muito) de um grande livro? Então você deve olhar para o nosso.

Confronto de mudanças - a principal característica de uma pessoa. Se em um momento em que você começou a trabalhar com os sistemas de controle de versões, não havia git - é muito provável que você tenha começado com o Subversion. Muitas vezes as pessoas dizem que o Git é muito complicado para iniciantes. No entanto, vou me permitir discordar de você.

Neste artigo, vou dizer-lhe como usar o Git em trabalhar com seus projetos. Assumimos que você cria um projeto a partir do zero e deseja usar o Git como um sistema de controle de versão. Depois de ler os principais comandos, leremos como você pode colocar seu código no GitHub.

Este artigo falará sobre coisas básicas - como inicializar o projeto, como gerenciar arquivos novos e existentes e como armazenar seu código na nuvem. Nós diminuiremos algumas coisas complexas como ramificação, já que o artigo é orientado para iniciantes.

Instalando Git.

No site oficial Git está em vários sistemas - Linux, Mac, Windows. No nosso caso, usaremos o Ubuntu 13.04 e o Git, seremos instalados por meio de apt-get.

Sudo apt-get install git

Configuração inicial

Crie um diretório no qual vamos trabalhar. Você também pode usar o Git para trabalhar com um projeto existente e, neste caso, não criará um diretório de demonstração conforme descrito abaixo.

Mkdir my_git_project cd my_git_project

Primeiro de tudo, é necessário inicializar o repositório Git no diretório do projeto. Você pode fazer isso pelo comando init, que cria um diretório.Git com todas as informações sobre o seu projeto.

Git config --global user.name "shaumik" git config-global user.email " [E-mail protegido]"Git config - global color.ui" auto "

Vale a pena notar que, se você não especificar seu endereço e o nome, os valores padrão serão usados. No nosso caso, os valores padrão serão donny e [E-mail protegido]

Também definimos a cor da interface para o valor automático, para que a saída dos comandos Git seja cor. Adicionamos prefixo -global a esses comandos para que esses valores sejam usados \u200b\u200bem todo o sistema, e não havia necessidade de configurá-los para cada projeto individual.

Preparando arquivos de confirmação

A próxima etapa que criaremos vários arquivos. Você pode usar qualquer editor de texto para isso. Observe que se você inicializar o Git em um projeto existente, você não precisa fazer esta etapa.

Verifique o estado do repositório

Agora que existem arquivos em seu projeto, vamos ver como o git apela com eles. Para verificar o status do repositório atual, use o comando Git Status.

Adicionar arquivos ao git

Nesta fase, o Git não segue um dos nossos arquivos. É necessário adicionar especificamente arquivos ao Git para que isso acontecesse. Para fazer isso, use o comando Adicionar.

Git adicionar my_file.

Depois de verificar o status do repositório, vemos que um dos arquivos já foi adicionado a ele.

Para adicionar vários arquivos, usamos o seguinte (aviso que adicionamos o primeiro arquivo anteriormente, então adicionamos apenas os dois restantes).

Git adicionar myfile2 myfile3

Você pode usar o Git adicionar recursivamente, mas tenha cuidado com este comando. Existem alguns arquivos (por exemplo, programas compilados) que não devem ser adicionados ao sistema de controle de versão. Se você usar o Git adicionar recursivamente, esses arquivos também cairão no repositório.

Deletar arquivos

Imagine que você acidentalmente adicionou um arquivo ao repositório, que não deveria ter chegado lá. Ou você deseja remover qualquer arquivo do sistema de controle de versão. Em geral, o comando git RM não será simplesmente excluir o arquivo do repositório, mas também exclui fisicamente do disco. Para o Git Stop rastreando o arquivo, mas permaneceu no disco, use o seguinte comando:

Git rm - cache [nome do arquivo]

Mudanças Commimim.

Depois de adicionar todos os arquivos necessários, você pode comentar (consertar) no Git. Imagine que o commit seja um instantâneo do status do projeto em um determinado estágio ao qual você pode retornar a qualquer momento e ver o status do projeto naquele momento. Com cada comitê, uma mensagem está associada à qual o argumento é definido após o prefixo -m

Git cometer -m "meu primeiro compromisso"

Especifique uma mensagem que conterá informações úteis, pois ajudam a entender o que foi alterado dentro desse compromisso. Evite algumas mensagens comuns, como "regras de bugs". Se você tiver um rastreador de bugs, poderá especificar um tipo de mensagem "Bug # 123". Boas práticas - indique o nome do ramo ou melhoria. Por exemplo, "Gerenciamento de Ativos - Adicionado a capacidade de gerar PDF com base no ativo" - uma mensagem clara e inteligível.

Git determina o número hexadecimal longo etoto. Normalmente, não há necessidade de copiar a linha inteira, os primeiros 5-6 caracteres suficientes para identificar um compromisso específico. Na captura de tela, pode-se ser visto que nossa comtaça é identificada pelo número 8DD76FC.

Mais compromete

Vamos mudar vários arquivos depois que os preparamos. Depois de alterá-los, o status do Git informará que mudamos os arquivos.

Você pode ver o que mudou nesses arquivos desde o comando anterior, usando o comando git diff. Se você deseja visualizar alterações para um arquivo específico, você pode usar o Git Diff<файл> .

É necessário indexar as mudanças e os remover. Todos os arquivos de projeto modificados podem ser adicionados ao seguinte comando para o commit:

Você pode evitar usar este comando se você adicionar um parâmetro ao commit git. Este comando indexa todos os arquivos modificados e os acusam. Mas essa abordagem pode ser bastante perigosa, por isso, por engano, você pode compensar o fato de que não queria. Por exemplo, digamos que você abriu o arquivo e mudou acidentalmente. Ao indexar arquivos modificados, você será notificado sobre as alterações em cada arquivo. Mas se você enviar todos os arquivos modificados sem olhar para a ajuda. Git commit -a, então todos os arquivos serão comprometidos, incluindo aqueles que você não se compromete.

Assim que você indexou arquivos, você pode prosseguir para o commit. Como mencionado anteriormente, você pode especificar uma mensagem para o commit usando a tecla -m. Mas você também pode especificar comentários multi-line usando o comando Git Commit, que abre o Editor do Console para inserir um comentário.

Gerenciamento de problemas

Para visualizar o histórico do projeto, você pode usar o seguinte comando:

Ele exibirá o histórico de histórico completo na forma de uma lista de confirmação e informações sobre eles. Informações sobre o commit Contém cometido Hash, autor, tempo e mensagem de comutação. Existem muitos tipos de equipes de log do Git, que terão que se familiarizar no caso de usar ramificação no Git. Para ver os detalhes de um commit específico e arquivos modificados, execute o seguinte comando:

Show git.<хеш_коммита>

onde<хеш_коммита> - Número hexadecimal associado a um commit. Como este manual é projetado para iniciantes, não vamos considerar como devolver o estado no momento de um determinado commit, ou como controlar os ramos.