Transcrições
1. Apresentação: Olá e seja bem-vindo ao curso Git e
GitHub para iniciantes. Neste curso, você
aprenderá o básico de ambos obter como pedágio e o GitHub é
um software que podemos usar. Você aprenderá muitos recursos de ambas as tecnologias. Comandos que recebem ouvidos
ou GitHub Pages e as ferramentas de desktop do GitHub para gerenciar
mais facilmente nossos projetos. Ao final deste curso, você obterá o conhecimento
necessário para começar a usar
as duas tecnologias. À medida que você aprenderá os principais
conceitos de repositórios, ramificações e ramificações e
divergência de código ao lado do
trabalho que faremos, você também verá apresentações
diferentes como eu
gostaria de ilustrar para você, como os desvios de código funcionam e como eles devem
ser tratados também. Mas agora, quem sou eu? Meu nome é Stefano matter, que acabam com
mais de sete anos de experiência em desenvolvimento
web. Também sou instrutor online. E ao lado deste
curso você pode encontrar muitos outros cursos de
mim aqui no Skillshare. Portanto, certifique-se de verificar
esses também. Se você quiser ver mais tutoriais fora
do Skillshare, você sempre pode visitar meu canal do YouTube lá, você
encontrará muitos tutoriais, cursos
intensivos e todo o projeto para vários
tecnologias diferentes. E se você quiser
entrar em contato comigo, você sempre pode visitar
meu site lá. Você pode ler mais sobre mim, mas também ver todos os meus tutoriais e
cursos em um só lugar. Agora, seja bem-vindo mais uma vez e vamos aprender mais sobre
as versões de código e código.
2. Versões de código e código: Antes de iniciar o curso, gostaria de
falar sobre o código em si e as versões de código. Você verá que nós, como desenvolvedores,
desenvolveremos, criaremos e implantaremos sites,
aplicativos, aplicativos móveis
e software padrão também. Tudo isso requer código e muitas vezes não apenas uma
pessoa trabalhando nele, mas muitos de nós em equipes pequenas e
mais significativas. Agora, você poderia imaginar apenas dez pessoas trabalhando
no mesmo aplicativo? Quão difícil pode ser para
eles apenas compartilhar o código mais recente,
mantendo a qualidade
desse aplicativo. Além disso, eles geralmente
funcionam em várias tarefas,
vários recursos e correções de bugs. Ou seja, quando
precisamos cuidar do nosso código e
das versões dele também. Para fazer isso, podemos usar software, um produto que pode
rastrear nossas alterações de código, manter nossas versões de código, dividi-las na dose de
fusão como desejarmos. Existem muitos desses, mas neste curso, aprenderemos como usar o Git
em combinação com o GitHub. E falarei mais sobre
aqueles no vídeo a seguir. Mas o que podemos obter
com esse software? Bem, agora essa mesma equipe de dez pessoas pode combinar versões de código de
manipulação mais fáceis. Por exemplo, cada
membro da equipe pode usar similar, talvez até mesmo o mesmo
código e construir sobre ele. Cada pessoa dessa
equipe pode trabalhar em uma tarefa específica ou
corrigir um bug específico. Uma vez terminado, o próprio sistema mesclará
todas essas alterações. E se houver alguma
inconsistência no código, o sistema
os capturará e apresentará esses conflitos
aos membros da equipe. Assim, eles podiam juntos
dose fixa e não muito
sobre isso também. Agora, vamos aprender mais
sobre esse sistema. Vamos ver o que é bom
e o que é o GitHub.
3. O que é Git & Github: Agora, o que nosso Git
e GitHub, bem, recebem é um software que nos
ajuda a rastrear as
mudanças de nosso código. Ao lado de chamar as alterações, git enganará todas as outras
alterações em nossos arquivos. Então, se você adicionar uma
imagem ao nosso projeto, saiba mais sobre isso. Agora, obtém
o principal objetivo é garantir a colaboração e a coordenação
entre os desenvolvedores. Ao lado desse portão
também nos apoiará com a rapidez da integridade dos dados na distribuição
de nossos projetos. Agora, o GitHub é
essencialmente um provedor. Ele nos fornece a postagem
para desenvolvimento de software, o que significa que agora nossas alterações de código e código
podem ser hospedadas no GitHub. Ao lado disso, o GitHub nos dará suporte com controles de
versão. E ele faz isso
usando o Git como uma ferramenta. Então, essencialmente, podemos
usar git para gerenciar nossas versões enquanto também usamos o
GitHub para apresentá-las, para vê-las ao vivo. Github
nos dará a plataforma para ver nosso projeto, nosso código e todas as nossas
mudanças ao lado disso, GitHub terá outros
recursos que podemos usar, mas esse não é o
foco deste curso. Por enquanto, estamos nos concentrando apenas
nas versões de código e código. E a melhor maneira de aprender sobre o GitHub é começar a
trabalhar com ele. Então, antes do vídeo a
seguir, faça-me um favor. Acesse um
site oficial do GitHub. Certifique-se de se inscrever se você já tiver uma
conta no GitHub, isso não é uma tarefa para você. Mas se você não
tiver uma conta, certifique-se de criar uma, para acompanhar bem
este curso. Agora, vamos instalar isso, obtenha.
4. Instalação do Git: Obter como uma ferramenta deve ser instalada. Para instalar o Git, você pode
simplesmente procurar por obter seu navegador ou
visitante preferido site Get-scm.com. Você também terá o link para este site nos
recursos deste curso, o site em si pode ser uma excelente referência para
aprender sobre o bom final. É seu porque o bom
tem a documentação. Mas estamos aqui para baixar o portão para que
possamos instalá-lo. Para baixar o Git. Clique neste botão de downloads. Isso deve levar você
à página de downloads. Aqui você pode simplesmente selecionar uma opção para seu próprio sistema. Para mim,
selecionarei o Windows aqui. Para o Windows,
ouvirei várias opções. Mas a
opção boa o suficiente para mim é esse instalador autônomo
para um sistema de 64 bits, seu sistema pode ser diferente, então certifique-se de selecionar
o caminho certo aqui. Quando o download estiver concluído, podemos simplesmente executá-lo e instalação para ele deve
ser bastante simples. Nesta primeira etapa, basta selecionar a próxima. Agora, devemos ver
diferentes componentes aqui. Então, vá em seguida aqui também. Esta é uma nova opção em entidades de
instalação para
selecionar como usar o OpenSSH. Portanto, não se preocupe muito
com isso. Por enquanto, você pode selecionar
essa opção pré-selecionada. O próximo passo pode ser complicado, mas a instalação nos dará a versão normal
do Git. Aguarde até que ele seja instalado agora. E quando terminar, podemos desmarcar o bot para Opções e clicar em Concluir. Agora, eu tenho uma pasta que preparei para este
curso, o portão. Você também pode criar
o seu próprio para manter todo o curso em
um só lugar, se quiser. Clique com o botão direito do mouse nesta pasta, você deve estar
obtendo opções para bom gooey e o Git Bash. Ambas as ferramentas também foram instaladas
com o portão. Assim, você pode abrir qualquer um deles ou abrir o terminal de
sistemas também. Para ser honesto, isso realmente não
importa. O que você quer fazer
em seu terminal é usado o comando
da boa versão. Se os gateways forem instalados corretamente, você verá a
versão instalada, o que é bom. Se não houver versão, você precisará repetir
todo o processo de instalação. Além disso, o desvio pode
diferir do meu aqui dependendo de quando
você estiver assistindo a
este curso ao lado da boa versão, você pode usar o comando de bom, que deve mostrar
os diferentes comandos que podemos usar
com uma boa ferramenta. E muito em breve começaremos a
usar esses comandos. Agora, sobre as ferramentas que
foram instaladas com o good, se você abriu a GUI do Git, você veria uma ferramenta que
poderia gerenciar nossos repositórios. E falaremos mais
sobre aqueles doloridos. Se você abrir o Git Bash, você verá que um terminal
específico para obter este terminal funcionará com seu sistema e outros passeios
se você tiver algum instalado. Mas, ao lado disso, você também
pode usar seu próprio terminal padrão
se estiver acostumado a ele. E isso é sobre o processo
de instalação. Então, agora podemos começar a
trabalhar com ele. Vamos visitar o GitHub em nosso
próximo vídeo e criar nosso primeiro projeto,
nosso primeiro repositório.
5. Criação de primeiro projeto (Repo): Você se lembra que
eu pedi para você criar sua própria conta do GitHub
se você não tiver uma. Bem, espero que você tenha feito. Isso, agora vamos trabalhar
com o GitHub, faça login em sua própria conta do GitHub e
entraremos neste painel principal. Bem, seu perfil onde você
deve ver seus projetos. Obviamente, se sua
conta acabou de ser criada, você não terá nenhum projeto. Bem, qualquer repositório aqui. Agora, certifique-se
de abrir isso, fique gooey aqui também. Queremos usá-lo, mas eu quero mostrar
algo com ele. Você vê que essa GUI pode
lidar com nosso repost. Podemos criar os repositórios locais ou usar alguns
relatórios externos também. Faremos a mesma coisa por nós, mas isso nos dará mais opções e interface de usuário mais amigável. E neste vídeo,
criaremos nosso primeiro repositório. Primeiro de tudo, o que
é o repositório? Um repositório ou um repositório é lugar
centralizado para
nosso código e ativos. Portanto, se quisermos construir um
site ou o aplicativo, ter um repositório para
tal projeto seria
sábio porque o repositório
é um sábio porque o repositório lugar centralizado para o nosso código. Isso significa que
poderemos gerenciar nossas versões gravadas diretamente
nele. Então, por dívidas, você verá
como esse conjunto de ferramentas, Git e GitHub, pode ser
útil para nós. Agora, para criar o relatório, você terá esse ícone de mais
no canto superior direito. Basta clicar nele e selecionar
este novo repositório. Crie um novo repositório. Precisaríamos
configurá-lo para nós. Primeiro de tudo,
precisaremos de um nome para o nosso repositório. É vital nomear seu repositório
exclusivamente com sua conta. Como você não pode ter dois
repositórios com os mesmos nomes. Vou nomear meu
repo primeiro projeto que você pode chamar de seu como quiser. A próxima coisa que podemos
adicionar é nossa descrição, mas esse campo também é opcional, então vou ignorá-lo por enquanto. A próxima opção é definir nosso repositório para ser
público ou privado. Se você defini-lo para público, bem, todos vão vê-lo. Privado estará
disponível apenas para você, acabe com pessoas que você convidar. Então, se você planeja construir
algo como um código aberto, o público é uma boa opção. Embora a
opção privada seja mais para projetos
pessoais e
em produção, vou definir o
relatório mental para ser público, pois desejo que todos vocês possam acessar esses três por
sempre que quiserem. Ao lado disso,
adicionarei este arquivo leia-me, mas vou pular esse arquivo de
ponto gitignore. Readme é o arquivo que nos
serve para descrever nosso repositório e
informações adicionais e assim por diante. Enquanto este
arquivo gitignore que
lemos, poderemos ignorar
alguns de nossos arquivos, o que significa que esses
arquivos não serão rastreados, não serão enviados para o
nosso repositório mais tarde. Mas neste momento, posso simplesmente criar meu repositório. Depois de criar seu relatório, você verá essas etapas para obter esse repositório localmente
em sua máquina, o que significa que agora você pode
tentar fazer isso sozinho. Mas no vídeo a seguir, vamos clonar nosso
relatório juntos.
6. Clonando O Repo: Temos nosso repositório para
nosso projeto agora. Podemos cloná-lo para obter nosso
repositório localmente em nossa máquina. Quero que você entre em seu
perfil no GitHub e vá para a seção
desses repositórios aqui você deve ver todos os
seus repositórios. Portanto, certifique-se de selecionar o que você criou
para este curso. Para mim, é esse primeiro
projeto no meu repositório. Não vejo muito. Eu ouço meu
arquivo readme e posso ver o conteúdo desse arquivo
ReadMe abaixo. Armazenaremos todos os
arquivos que criamos uma atualização aqui
dentro do nosso repositório, pois este será o nosso
lugar central para o nosso projeto, podemos criar
arquivos diretamente aqui, mas isso não é tal
experiência amigável. Então, vamos puxar nosso
repositório para tê-lo localmente, pois será muito mais fácil trabalhar
com ele dessa maneira. O comando para isso
é chamado de clone, pois clonaremos nosso
repositório do GitHub em nossa máquina local para
usar esse comando clone. Embora isso seja simples
o suficiente, a primeira coisa que precisamos
fazer é clicar nisso, este botão verde, que
aparecerá um menu para nós. Neste menu, certifique-se de
selecionar a opção HTTP S, que nos apresentará
esse URL. Url é o
URL oficial do nosso repositório. Assim, você pode copiá-lo ou clicar neste ícone no
lado direito para copiar esse URL. Agora, abra seu terminal e decida a rota para
a pasta desejada. Bem, onde você
quer armazenar seu repositório, eu tenho uma pasta boa, então vou usar o comando do CD, entrar nessa pasta se
você precisar voltar para trás a pasta use barra
ou barra de ponto para nossa pasta atual. Quando você estiver dentro de sua pasta, vamos verificar novamente se o bom
foi instalado corretamente. Então você pode usar aqui o comando
GET para isso. Como posso ver, todos
esses comandos, posso ter certeza de que ele foi
realmente instalado corretamente. Além disso, nesta lista de comandos, posso ver o comando clone. E descreve
que ele clonará o repositório em
um novo diretório. Então, precisamos desse comando. Aqui. Vou usar o comando claro, bem para limpar meu terminal. E agora posso usar git clone e colar meu URL para meu repositório
que copiamos anteriormente. Pressione Enter e
aguarde que ele brilhe. Quando terminar, posso usar o projeto CD first dash para entrar no meu repositório
que acabei de clonar. Podemos ver que esse comando
funcionou porque estou dentro
dos meus primeiros projetos. Mas ao lado do caminho da minha pasta aqui, posso ver esse mestre, depois a seta, depois a origem. Isso aqui se refere a um ramo, e falaremos mais
sobre isso um pouco mais tarde. Agora, também
colocarei minha pasta onde meu repositório está armazenado para
verificar o conteúdo interno. Bem, parece que eu tenho meu arquivo README que foi
criado por padrão, e sei que também tenho o arquivo no meu repositório
no GitHub. isso, podemos confirmar que nosso repositório foi clonado
com sucesso. Antes de terminarmos e iniciar
o vídeo a seguir, você precisará de algo
chamado editor de código. É um software onde
geralmente escreveremos nosso
código e há muitas opções para você
que você pode usar
se quiser usar o mesmo de cada vez usando código de
visita, esse
Visual Studio.com. Este editor
de código é da própria Microsoft e é de código aberto, o que significa que
ele é gratuito para uso. Portanto, certifique-se de baixar e instalar a versão correta
para o seu sistema operacional. A partir do vídeo a seguir, usaremos essa ferramenta.
7. Fazer alterações e acompanhamento: Espero que você tenha instalado o Visual
Studio Code conforme precisamos dele. Agora, certifique-se de abrir sua diretiva de projeto
neste código do Visual Studio. Antes de começarmos. Só para mencionar que
seu código do Visual Studio pode parecer diferente do meu. Como provavelmente tenho
mais extensões instaladas e também equipe
diferente. Você não precisa se preocupar
porque este bloqueia você de
seguir as pontuações. À medida que clonamos nosso repositório
no último vídeo dentro
do seu projeto aqui, devemos ver apenas
esse arquivo leia-me. Se você abrir esse arquivo, verá algum conteúdo
escrito na linguagem markdown, que não é um
idioma complexo para aprender. O bom desse código
visual do Studio é que podemos usar o
terminal diretamente dentro. Dessa forma, podemos escrever
nosso código enquanto também lidamos com nosso repositório para
abrir o terminal aqui, clicar nesta visualização e, em seguida, você terá a opção
para o terminal. Vamos verificar se tudo
funciona aqui como mostrou. Usarei o comando de
clear para limpar este terminal. Agora usarei o Git
e, em seguida, o status. Status ou status
é um comando que nos
dará o
status mais recente de nossa filial, qual estamos trabalhando
atualmente. E como mencionei, falaremos mais sobre as
filiais no futuro. Aqui podemos ver que nossa ramificação é mestre e tudo
está atualizado, o que significa que
puxamos todas as nossas últimas alterações quando
clonamos nosso repositório do GitHub. Para esclarecer ainda mais, nossa diretiva local é
a mesma diretiva, mesmo repositório que temos no
nosso GitHub, o que é bom. Mas agora como o Git
sabe sobre isso, você verá que get é uma ferramenta
que rastreia nosso código. Então, ele saberá sobre nossas
mudanças que também fazemos. Por exemplo, se eu quiser
criar um arquivo para o meu site, geralmente esse arquivo é
chamado index.html. Para fazer isso, basta clicar neste novo ícone de arquivo e no
nome do arquivo index.html. O Visual Studio Code
é inteligente o suficiente para colorir esse arquivo em verde. Por que ele faz isso? Bem, o código do Visual Studio sabe que o bom é rastrear
nossas alterações aqui. E agora esse arquivo é uma
mudança que fizemos. Portanto, nossa diretiva local
não é mais
a mesma que nosso repositório, como nosso repositório que
temos no GitHub. Também podemos verificar isso
com o GitHub também. Neste terminal, podemos novamente
usar um comando, git status. E agora devemos ver
saídas diferentes. Ainda mostra que
nosso lado local, nossa filial local que
temos está atualizada, mas mostra mais. Isso mostra que temos alguns arquivos não rastreados
em mudanças de trilha, o que significa que existem arquivos
diferentes do
nosso repositório do GitHub. E é por causa
desse index.HTML. Temos este index.html localmente, mas não em um GitHub. E entenda isso, saberá sobre essas mudanças mesmo que essas
não sejam mudanças rastreadas ainda. Então, mesmo que as pessoas
excluam essas mudanças, nada crucial aconteceria. O próximo a isso, nos
dá informações, bem, informações sobre como
rastrear corretamente esses arquivos com o bem, que é a história para
a seguinte palestra.
8. Commiting alterações: Para continuar onde
paramos no último vídeo, agora
temos nossa mudança
em nosso diretório, mas essa mudança não está
sendo rastreada pelo Git que todos conhecem essa mudança, mas ainda não está rastreando
essa mudança, o que significa que a mudança em
si não acabará em nosso repositório
para acompanhar nossas alterações. Bem, devemos fazer isso manualmente. Bem, pelo menos para todos os
novos arquivos. Para fazer tal coisa,
primeiro limparei meu terminal. Agora posso usar git add
e, em seguida, podemos especificar um arquivo que desejamos
rastrear, como nosso index.html. Isso adicionará nosso
arquivo para rastrear arquivos. Mas e se tivéssemos
dez arquivos diferentes? Ainda desejamos adicionar um por um. Bem, em vez de
passar um nome de arquivo, podemos simplesmente usar um ponto
aqui que irá pegar todas as nossas alterações não rastreadas
e movê-las para o trato. Isso meio que
encenará essas mudanças. Agora, vamos usar git
status mais uma vez. Aqui o que podemos ver é que nosso arquivo HTML de índice não é mais
vermelho, mas verde. Isso significa que o bom
Now rastreia esse arquivo, mas isso ainda está em
nossa máquina local, nada relacionado ao
nosso repositório principal que temos no GitHub. Para informar o repositório
principal sobre nossas alterações. Devemos armazenar, bem, devemos comprometer essas alterações. Onde comprometermos
essas alterações, bem, elas estarão prontas para serem publicadas em nosso repositório
principal. Para fazer tal coisa, devemos usar esse comando chamado git commit. Para este comando de commit, podemos passar esse sinalizador, que pode especificar
com o traço m. Sinalizador representa uma mensagem, o que significa que
depois desse sinalizador, também
podemos passar alguma mensagem. Para passar uma mensagem, você deve usar aspas duplas e, geralmente, exibir esses tipos de mensagens para especificar a que nossas últimas alterações
estão se referindo. Para mim, definirei minha
mensagem para criar o arquivo HTML de índice porque
fizemos exatamente isso. Agora que
comprometemos nosso código, uma alteração que podemos ver em nosso Visual Studio Code é que esse arquivo index.html não
está mais verde. É porque get se refere
a ele como arquivo de atração, mas sem novas alterações. E não temos novas
alterações porque
todas as alterações que fizemos já estão confirmadas e prontas
para serem implantadas. Se você deseja
confirmar tal coisa. Mais uma vez, podemos
usar git status novamente. Agora podemos ver uma mensagem que
dirá que nossa ramificação, enquanto nosso
branch local é um chefe de nosso branch master de nosso
repositório por um commit, se você visitar
seu repositório no GitHub. Bem, nada
mudou lá é porque nossas mudanças
estavam todas ligadas localmente, em nossa máquina local. E essa é a
razão pela qual o git nos dirá que nosso ramo local está à frente de nosso branch master
em nosso repositório principal. E sim, rastreamos nossas alterações e também
comprometemos nossas alterações, mas ainda assim não as
implantamos no GitHub. E para implantá-los, faremos isso na palestra a
seguir.
9. Código de envio: Como você viu, nossas alterações agora
são rastreadas e confirmadas, mas ainda não em nosso repositório do
GitHub. Para implantar nossas alterações no GitHub, devemos enviar nosso código e, sim, termo é chamado de push,
bem como o comando. Então, no meu terminal, posso simplesmente
usar o comando de um bom impulso. O resultado desse
comando manterá as informações sobre nossas alterações de
postagem e assim por diante. Mas isso não é tão importante
, pois é principalmente automatizado. Mas neste ponto, se visitássemos nosso
repositório em nosso GitHub, veremos o
arquivo index.HTML ao lado do nosso arquivo
leia-me também. Isso significa que
nossas últimas alterações foram
implantadas com sucesso em nosso repositório. E também neste canto
superior direito, podemos ver que
temos dois commits. Se você quiser. Você pode até clicar nesses commits para vê-los, podemos ver, por exemplo,
nosso commit inicial. Bem, esse foi o nosso
primeiro comitê quando criamos nosso repositório. E para mim,
também posso ver esse cometa aqui onde adicionei
o arquivo HTML. Aqui, poderíamos até
entrar neste commit. Posso ver aqui esse arquivo
HTML vazio que foi adicionado, que foi a mudança em si. Agora, como o Git sabe
sobre nossas mudanças? Como ele sabe sobre nossos commits são arquivos rastreados
e não rastreados. E como também conectou nosso repositório do GitHub ao nosso
repositório que temos localmente. Bem, deixe-me mostrar como o Git funciona em segundo plano
para fazer isso, vá para o seu diretório que você tem localmente neste menu Exibir, você deve selecionar
esses arquivos ocultos. Um desses arquivos ocultos é essa pasta chamada
The Dark good. Você verá quando clonarmos
nosso repositório do nosso GitHub, a pasta veio com
esse repositório também. E como temos essa boa ferramenta
instalada em nossa máquina, ela sabe como trabalhar
com essa pasta. Então, nesta combinação, o
parafuso nos permitirá trabalhar com nosso repositório e rastrear
todas as nossas mudanças. Mas ainda assim, tudo isso é bom e muito fácil de manusear
quando você está sozinho. Mas quando você tem mais pessoas em sua equipe e você está
trabalhando juntos, bem, trabalhar apenas
neste ramo mestre
pode ser bastante agitado. Então deixe-me mostrar como
você pode criar outro ramo.
10. Criar uma nova filial: Agora vou voltar para o terminal
principal que eles usam. Aqui, o plano é
criar outro ramo. Para criar o branch, podemos usar git checkout. Git checkout é o
comando usado para verificar nossas
diferentes ramificações. Se usarmos somente esse comando, teríamos a opção de
mover de ramo para ramo. Mas como eu gostaria de
criar um novo ramo, posso passar um traço B. Esta é uma bandeira que representa um ramo ao lado dessa bandeira. Também devemos passar
outro argumento aqui, e esse é o
nome do nosso ramo. Bem, as marcas
que você deseja
fazer para isso um
pouco de ajuda aqui. Tente sempre nomear suas ramificações Pelo futuro que você está trabalhando no
momento. E isso seria uma convenção de
nomenclatura padrão para filiais. Como eu gostaria de adicionar algum conteúdo HTML ao
meu arquivo HTML por delta, vamos nomear o conteúdo HTML
da minha filial. Depois de enviar seu comando, você pode ver que agora
minha ramificação não está mais
dominada,
mas o conteúdo HTML. Mesmo se eu visitar meu Visual Studio Code
no canto inferior esquerdo, posso ver o
conteúdo HTML como uma ramificação. Com isso aqui você pode ver que o
Visual Studio Code é inteligente o suficiente para reconhecer em qual ramificação estamos trabalhando
atualmente. Só para mencionar que no
seu terminal você pode até usar um comando
chamado git branch. Esse comando
fornecerá a lista de ramificações para o repositório
atual. Para mim aqui, eu tenho
apenas duas ramificações e essas ramificações destacadas são minha ramificação atual em que
estou atualmente. Agora, vamos criar algum conteúdo
HTML para isso. Abra o arquivo HTML de índice
e use o HTML dois pontos cinco aqui. Ao usar dívidas, bem, automaticamente
criaremos algum código HTML, e isso é apenas
mais um recurso, apenas mais uma grande coisa
sobre o Visual Studio Code. Agora, neste código HTML, no corpo do meu HTML, adicionarei uma tag H1, que dirá Olá mundo. Assim, poderíamos ter pelo
menos parte
do conteúdo por isso aqui, como temos esse conteúdo HTML, podemos nos certificar de que
implantamos esses conteúdos
em nosso repositório. Para isso,
abrirei meu terminal no Visual Studio Code e
usarei o comando git status. Aqui podemos ver que index.HTML, nosso arquivo é vermelho, o que significa que ele
é um arquivo modificado, mas as alterações ainda não são
preparadas, bem, não rastreadas, vendidas para
encenar essas mudanças, vou precisar usar git
add e, em seguida, isso. Agora, novamente, podemos
usar o git status para confirmar que nossas alterações
foram adequadamente preparadas. Ao lado de preparar nossas alterações, também
devemos
confirmar nossas alterações. E para fazer isso, usarei git
commit com a mensagem
específica. Minha mensagem dirá, adicionando conteúdo a um arquivo HTML. Como última coisa, precisamos enviar esse código
que criamos para nosso repositório. Então, agora, não podemos
usar o comando git push porque GitHub não sabe atualmente sobre nossa ramificação que
criamos localmente, porque essa ramificação de conteúdo HTML é minha
ramificação local. Ainda não está no GitHub. Então, precisarei ter certeza de
que na próxima vez que eu mudar, eu também empurre meu branch
diretamente no GitHub. Para fazer isso,
usarei o comando git, push than dash u flag. E depois disso usarei palavra-chave
Origin e, em seguida,
o nome da minha ramificação, que é conteúdo HTML. Com este comando, definiremos o upstream para
nossa ramificação remota e criaremos a
mesma ramificação em nosso GitHub, que será meio
a ramificação de origem
de nossa ramificação local. Agora, em nosso GitHub, podemos ver que a nova
ramificação foi criada. Mesmo que eu alterne esse
menu suspenso para ramos, podemos ver que agora
temos esses dois ramos. E se você selecionar essa ramificação de conteúdo HTML e
entrar no arquivo HTML de índice, poderemos ver algum conteúdo enquanto
ainda estiver em nossa ramificação principal. Nosso arquivo index.HTML não
tem conteúdo. Isso obviamente é
bom porque com isso podemos dividir nosso
código, trabalhar nele
e, uma vez que tudo esteja concluído, também
podemos mover esse código de
volta para o mestre. E falando sobre isso, você pode ver esse pop-up em
que somos meio solicitados para criar uma
nova pull request. Bem, vamos trabalhar com isso
nos seguintes vídeos. Por enquanto, gostaria de
falar mais sobre as filiais para que você possa entender o termo corretamente.
11. O que são ramos: O termo dos ramos
e todo o futuro dos galhos é criado
com base em uma árvore. Aqui a árvore,
poderíamos ter nosso principal, nosso ramo mestre, que poderia
ser o corpo da nossa árvore. Este ramo principal ou principal do corpo pode se ramificar em
várias outras ramificações. E, ao lado disso, até esses
ramos podem fazer o mesmo. Agora, no GitHub, isso é
apresentado de forma um pouco diferente. Ainda temos nosso ramo principal
ou principal, mas parece apenas
como uma linha dele. Podemos ramificar para
outros ramos e todos
eles podem ser movidos de volta para o nosso branch principal. Enquanto trabalhamos
nessas outras ramificações, teríamos nossos
commits e cada um
desses gametas será
apresentado nesses ramos. E cada gameta terá seu próprio ID específico que
podemos explorar continuamente. Agora, para mostrar isso um
pouco com uma equipe de pessoas. Digamos que temos
três pessoas em nossa equipe. Começamos o
projeto e cada uma
dessas pessoas
trabalhará em uma tarefa específica. Cada uma dessas tarefas ou recursos
deve ser uma nova ramificação. Então, agora nossa equipe possui o código
mais recente enquanto trabalha em novos recursos e nenhum de seus ramos
ainda sabe um sobre o outro. Agora, digamos que
cada um deles tivesse pelo
menos três commits
enquanto trabalhava por conta própria. No final, não
conseguimos mesclar essas alterações e recursos
que nossa equipe de trabalho realizou. E nesse ponto, nossa ramificação principal manterá
todas as últimas alterações. Agora, obviamente,
essa fusão pode causar conflitos, pois o frio
poderia ser interferido. Especialmente se duas
pessoas que trabalharam em um recurso semelhante ou
o mesmo, mas você vê que o get são inteligentes o suficiente para mesclar
código de acordo. E se houver algum
conflito, bem, o portão os apontará para nós para que possamos consertá-los. Um. Também um caso de uso muito comum de nossas filiais, especialmente
várias ramificações. Bem, esse caso de uso pode ser
sobre vários ambientes. Como exemplo,
digamos que temos nosso ramo principal, que é nossa produção. Isso significa que nosso
código mais recente no branch master é nosso código ao vivo em nosso site ou um aplicativo ao lado deste mestre, que está diretamente
conectado ao nosso site. Bem, geralmente desejamos criar algum
ambiente de desenvolvimento por dívida. Também podemos ter um branch de
desenvolvedor sentado ao lado do
nosso branch principal. Agora, neste ponto, quando
trabalhamos em recursos adicionais, vamos ramificar do
desenvolvimento e do trabalho nesses recursos
e,
em seguida, mesclar esses códigos
bem gerenciados de
volta ao desenvolvimento. Então isso nos permitirá testar
nosso código, não desenvolver. Talvez até implantado em algum ambiente de
desenvolvimento com seu próprio servidor enquanto seu
próprio banco de dados e assim por diante. E uma vez que o código esteja completamente testado e pronto para ser
implantado, podemos gerenciar
nosso desenvolvimento bem o código a partir do desenvolvimento
em nosso mestre e dívida. Atualizamos nosso
site ou aplicativo ao vivo. Isso significa que nosso
site ou aplicativo nunca ou pelo menos não
deve ter bugs. Agora, esse fluxo que eles
acabaram de ver também é chamado git flow e é
altamente personalizável. Agora, essa personalização, bem, isso depende de uma escala de equipe e também do software
que você está construindo. Portanto, para aplicações maiores, você quer apenas ter seu ambiente de desenvolvimento e
produção, mas talvez algum ambiente de
preparação, ambiente teste e assim por diante. Agora, neste vídeo também
mencionei conflitos. Então, vamos ver como eles podem
ser causados e também resolvidos.
12. Tratamento de conflitos: Resolver um conflito,
devemos primeiro criar um. Os conflitos geralmente acontecem
se o mesmo código for atualizado de duas ramificações
ou se o código for excluído? Dessa forma, bom. Um para saber qual
cor deve ser mesclada e cabe a nós
resolver esse problema. Como temos nossa ramificação de
conteúdo HTML aqui, podemos criar outra ramificação e fazer semelhante ao conteúdo HTML. Dessa forma, teremos
conteúdo HTML em ramificações. E quando tentamos
mesclar esses, bem, isso falhará
por causa desse conflito. Então, para fazer isso, voltarei para o
meu branch master e voltarei para o branch master. Vou precisar usar o
comando de um bom checkout e, em seguida, o nome da minha
marca, que é mestre. Agora, a partir do branch master, criarei uma nova ramificação. Da mesma forma que fizemos
para o nosso conteúdo HTML, criarei um ramo de
conteúdo do site é, os
sites geralmente são
escritos em código HTML. Agora, nesta ramificação, meu index.HTML estará novamente vazio porque nós nos
ramificamos do nosso branch master. Então, neste arquivo, usarei novamente esse HTML dois pontos cinco para criar o código
inicial para HTML. E agora farei
novamente o elemento HTML no meu corpo com o texto do
conteúdo do site dentro. Agora temos aqui
nosso conteúdo HTML. É muito semelhante ao nosso conteúdo que temos
em nosso outro ramo. Então, vamos nos
certificar de enviar esse código como fizemos para nossa ramificação de conteúdo
HTML. Para fazer isso,
primeiro usarei git add dot. Dessa forma, vou encenar
todas as minhas mudanças. Em seguida, podemos usar git commit com a mensagem do
novo conteúdo do site. E, finalmente, podemos usar o
comando git, push,
dash u, depois origin
e, em seguida, nosso branch, que é o conteúdo do site. Dessa forma,
enviaremos nossa ramificação e nosso conteúdo em nosso repositório
do GitHub. Em nosso GitHub, agora podemos ver que realmente temos
nossos três ramos. Adorável. Vamos causar o conflito. Agora. Para causar o conflito, precisaremos voltar para
nossa ramificação de conteúdo HTML. Então, git checkout conteúdo HTML. Agora podemos usar git merge
para mesclar duas ramificações. E usarei uma mesclagem, a origem do ramo de conteúdo do meu
site. E aqui está, o conflito existe nesta
mensagem que nos foi mostrada, podemos até ver
onde o conflito existe e está em
nosso arquivo index.html. Então, vamos abrir esse arquivo. No meu Visual Studio Code, já
podemos ver o conflito pois ele é obviamente
destacado para nós, chamado assim,
não deve ser mesclado,
pois pode causar muitos
bugs para nós aqui. Bem, teríamos
dois títulos diferentes, mas para ser honesto, eu realmente desejo ter apenas um. Então, precisaremos
resolver esse conflito. Agora, eu gostaria de ir aqui com
este título do Hello World. Então, vou precisar ir
com a mudança atual. Caso contrário, eu selecionaria
essa alteração recebida. O outro título agora desapareceu porque selecionamos
a alteração atual. E com isso também
resolvemos o conflito. Agora, vamos nos certificar de que nossas últimas alterações agora estão
confirmadas e também enviadas. Então, no meu terminal, mais
uma vez,
usarei git add dot. Depois disso,
usarei git commit com a mensagem de
corrigir conflitos. E, finalmente, posso
simplesmente usar git push. Obviamente, não precisamos
criar a nova origem aqui pois já temos nossa
ramificação no repositório do GitHub. No nosso GitHub, ainda
vemos nossas ramificações e agora o conteúdo HTML
contém o código mais recente. Então, como podemos mesclar essas
mudanças em nosso branch master? Bem, falaremos sobre
isso no vídeo a seguir.
13. Criar solicitação de tração: À medida que planejamos mesclar
nossas alterações do ramo de conteúdo
HTML em nosso branch principal,
o que você acha? Se fizermos isso da mesma
forma que no último vídeo, mesclar manualmente o conteúdo do nosso conteúdo HTML em
nossa ramificação principal. Bem, por enquanto, não haverá conflitos porque já os
corrigimos. E sim, podemos mesclar
ramos assim. Não será nenhum problema. Mas também não é a
melhor prática também. Quando você tem suas próprias ramificações
principais, como master ou uma
ramificação de desenvolvedor para desenvolvimento, ou até mesmo testar a
ramificação para testes. Bem, você não deseja apenas
gerenciar o código dentro. Uma solução muito melhor
para isso é criar uma pull request de seu próprio branch para o branch
master, por exemplo. Dessa forma, podemos rever
nosso código mais uma vez, verificar se está tudo bem. Além disso, podemos comentar nosso
código e podemos fazer muito, muito mais para fazer tal coisa. Clique nessas pull requests
no repositório do GitHub. Agora, a partir daqui, podemos
selecionar esta nova pull request. Agora somos solicitados a
selecionar duas ramificações. O primeiro
ramo é o ramo que, bem de onde desejamos
gerenciar nosso código. E a outra ramificação é, em qual ramificação
queremos mesclar nosso código? Então, eu gostaria de mesclar meu
código no mestre e sairei o código
do conteúdo HTML abaixo. Agora podemos vê-lo confirmado que está na frente do nosso
branch principal, o que significa que quando
mesclamos esses códigos juntos, todos esses commits
e conteúdo que foi alterado também estarão
no branch master . Por enquanto. Não temos conflitos. E mesmo se tivéssemos
conflitos além desse botão, para mesclar nosso código, mostraremos aqueles que são para nós. Então, vamos simplesmente
criar nossa pull request. Uma vez que fizermos isso, somos redirecionados para
nosso pedido polar. Aqui, podemos verificar nosso código, meio que revisar o
código mais uma vez. Além disso, podemos adicionar outras
pessoas para revisar nosso código. Como outros revisores, também
podemos rotular nossa pull request e
também muito, muito mais. Então, por que esses pull
requests são uma boa ideia? Bem, poderíamos fazer com que os membros da equipe viessem e revisem nosso código. Talvez eles pudessem identificar
algo que não percebemos, para que pudéssemos refatorá-lo. Agora vamos clicar nesta
solicitação de mesclagem e confirmá-la. Não deve demorar muito. Mas, voltando para
nossa página de código, veremos que
nossa ramificação principal contém nosso arquivo HTML de índice. Se inserirmos esse arquivo, podemos ver que as alterações internas são as últimas
alterações que tivemos. Agora que você sabe sobre o
fluxo de trabalho com o Git e o GitHub, vamos praticar um pouco. O que eu quero que você faça é
criar o novo ramo. Esta ramificação deve nos servir
para criar o arquivo CSS. Nesse arquivo,
gostaria que você
colorisse nossa tag H1 ou vermelha. Em seguida, certifique-se de preparar
e confirmar suas alterações. E
depois de terminar, você poderá criar sua
própria pull request e gerenciar todas essas
alterações no mestre. E não se preocupe, se você
ainda não tiver certeza de suas habilidades. Faremos isso juntos
no vídeo a seguir.
14. Fluxo de trabalho habitual com Git & Github: Então você teve algum sucesso? Não se preocupe, se não o fez, você está aqui para aprender. Então, vamos fazer isso agora juntos. A primeira coisa que
precisamos fazer é criar nossa ramificação onde
faremos nosso arquivo CSS. E o código é que estamos atualmente
em uma ramificação diferente. Vamos conferir nosso
branch principal e garantir que tenhamos nossas últimas
alterações a partir desse ponto, deve ser fácil
criar uma nova ramificação. Então, para ir ao nosso branch master, precisamos usar o comando
git checkout master. Agora, como nosso branch principal local está por trás do nosso branch
master do GitHub, devemos fazer as
alterações mais recentes para que nosso código seja o mesmo e não
causemos nenhum conflito. Isso é muito simples, basta usar o pool Git
abaixo agora podemos até ver as alterações que foram extraídas do repositório do GitHub. E agora, como temos
nossas últimas alterações, podemos criar nosso ramo
onde adicionaremos nosso CSS. Para isso, usarei
o comando git, checkout dash B, então o nome da ramificação
será o conteúdo CSS dash. Então, vamos abrir nosso
editor de código e adicionar algum CSS. A primeira coisa a fazer é
criar nosso arquivo CSS. Então, vou nomear um
meu styles.css. Também importarei meu CSS
para meu HTML com uma tag de link. E, finalmente, o que eu
gostaria de fazer é colorir minha tag H1 na cor vermelha. Então, para isso, pule
para o arquivo CSS, segmente sua tag H1 e use a cor vermelha nele. Neste ponto, estamos
praticamente acabados com nossa tarefa. Podemos até testá-lo para
ter certeza de que tudo está bem. Para testá-lo, basta
clicar duas vezes no arquivo
index.html para
abri-lo em seu próprio navegador. E aqui está. Parece que nosso título é vermelho, o que significa que podemos
publicar nossas alterações agora, vendidas para publicar nossas alterações, temos várias etapas. Precisaremos
encenar essas alterações, comprometê-las, empurrá-las
e, finalmente, criar
nossa pull request. Primeiro de tudo, vou
prepará-los com git add dot. Agora posso confirmá-los com
o comando git commit, e a mensagem será
colorir o título em vermelho. Finalmente, podemos enviar essas
alterações com o comando do conteúdo CSS
git push origin. Neste ponto, temos todas as
nossas mudanças em nosso GitHub, mas não atualmente em
nosso branch master. Então, vamos criar a pull
request para isso aqui. Agora, podemos criar nossa pull request e também
devemos selecionar nossas ramificações de
onde desejamos
monitorar nosso
código e em qual ramificação. Então, selecionarei o conteúdo
CSS de onde
desejo mesclar meu código. E selecionarei
a ramificação principal em qual ramificação eu
desejo mesclar meu código. Certifique-se de verificar suas alterações
e, se tudo estiver bem, você pode simplesmente
mesclá-las e isso deve
ser praticamente isso. Este é o fluxo de trabalho usual
com o Git e o GitHub. E não se preocupe se você não
conseguir na primeira vez. Experimente algumas vezes. E quando você trabalha
em um projeto real , deveria estar tudo bem. Também só para mencionar
que trabalhar em projetos
mais significativos
ou em uma equipe maior. Bem, nesse ponto, obter fluxo pode variar. Então, esse
fluxo git usual que você acabou ver pode ser muito mais complexo, mas isso é algo com o qual todos
precisamos lidar. Agora, deixe-me mostrar a
ferramenta que você pode usar. Então, você nem precisa usar seu terminal quase em tudo.
15. Desktop Github: A ferramenta que eu gostaria de mostrar
é chamada GitHub Desktop. Para isso, visite,
a área de trabalho que GitHub.com para ter acesso
à ferramenta aqui, certifique-se de baixar e também instalou a ferramenta para o
seu sistema operacional. E depois de fazer isso, você pode
continuar com este vídeo. Se você tiver o GitHub
Desktop instalado, não
se esqueça de abri-lo. Primeiro de tudo, vamos
falar sobre o que é. Bem, o GitHub Desktop é um excelente
aplicativo de desktop que podemos usar para ver nossos repositórios. Além disso, podemos trabalhar
com nossos repositórios e
poderemos usar todos os comandos sem usar o terminal. Assim, podemos
clicar em Exibir nádegas entrando
nesta área de trabalho do GitHub, você não verá muito,
mas você deve ter a opção de
adicionar seu próprio repositório. A partir daqui, você pode
criar um novo repositório ou obter um do GitHub ou
até mesmo no repositório local. Neste exemplo, vamos adicionar nosso repositório local porque dessa forma
usaremos o local, mas também usaremos
o em um GitHub pois nosso repositório local
também é armazenado no GitHub. Ao selecionar o repositório
local, certifique-se de escolher o caminho para repositório em sua
máquina e enviá-lo. Agora já podemos ver nossa filial atual
aqui e também repo. Então, vamos fazer algumas alterações. Entrarei no meu Visual
Studio Code e
adicionarei uma cor de fundo
ao meu corpo para ficar verde. Isso definitivamente parecerá feio, mas este não é
o curso de design. O que é importante
aqui é que, quando você visita seu GitHub Desktop, você pode ver sua mudança com
muita clareza a partir daqui. Agora, podemos confirmar nosso código e passar alguma mensagem
para esse commit. Quando fazemos isso,
isso deve encenar e comprometer nosso código em uma meta. Se você fizer algo assim, depois disso, você deve ter
essa opção para a Porsche. E é obviamente
para empurrar nosso código. Então, com apenas este simples
clique de um botão, podemos pressionar imediatamente
nossas alterações para o nosso GitHub. Quando isso for concluído, imediatamente obteremos a
opção de uma pull request. Então, vamos fazer isso também. Clicar em obter essa opção
lerá os eleitores para o GitHub. Já podemos criar
uma pull request, para que possamos verificar tudo
e mesclá-lo juntos. Com isso, você pode ver que talvez GitHub Desktop seja a opção
mais fácil para você. Mas ainda assim, eu
aconselho você
a aprender a usar o terminal
com os comandos, porque o terminal
não será usado apenas para
muitas tecnologias. Usaremos o terminal com comandos
específicos para instalar, atualizar, excluir
seus próprios recursos. Então você deve se acostumar com isso. Agora para a próxima
palestra, bifurcação.
16. Forking: bifurcação é um termo específico
e o futuro também. Ele é usado quando você deseja
criar algo público para que todos possam ver e também
todos possam acessar isso. Então, como exemplo, se você deseja permitir que
outras pessoas clonem seu código e também continuem
trabalhando com seu código. Bem, então a bifurcação
virá no lugar. A única coisa que você
precisa fazer é garantir que seu repositório
seja repo público. E com o Git e o GitHub, você poderá
bifurcar esses relatórios. Essa bifurcação é um futuro inteiro melhora bastante nossa
comunidade de desenvolvimento. Agora, vamos nos
certificar de bifurcar nosso projeto. Bem, como é tão bom
bifurcar o repositório, primeiro
vou sair do
meu perfil do GitHub
porque, caso contrário não
poderei bifurcar meu próprio repositório, pois
sou o proprietário dele. Uma vez que eu estiver desconectado, poderei ver meu repositório. Bem, ainda vejo meu repositório
mesmo que eu não esteja
entrando na minha conta, porque meu repositório, quando
criei meu repositório, eu o defini como público. Se você definir o seu próprio como um repositório privado, basta acessar
as configurações
desse repositório e
alterá-lo também. Caso contrário, você pode mantê-lo como privado e apenas assistir
este vídeo. No canto superior direito, terei este botão de formulário. Como não estou conectado
em nenhuma conta. E para bifurcar o
repositório de alguém, preciso estar logado. Bem, eu serei
lido automaticamente direcionado para o login. Mais uma vez, desta vez, vou fazer login com outra
conta para poder bifurcar o repositório da
minha primeira conta assim que selecionar essa opção de bifurcação, bem, tudo a partir daí, estaremos bastante automático. Às vezes, o GitHub
pode perguntar sobre algumas permissões
específicas, mas é direto. Uma vez que o repositório foi
bifurcado, ele é seu. Então você pode fazer com
isso o que quiser. Por exemplo, você pode
continuar construindo sobre ele. Ou você pode confirmar
seu código e criar a pull request diretamente
para o repositório principal. Além disso, é assim que o software de
código aberto funcionará. Nós, como comunidade, podemos pegar bem o código de alguém, código-fonte aberto,
podemos corrigir alguns bugs. Poderíamos adicionar recursos
adicionais, sugerir recursos adicionais. E podemos novamente confirmar
esse código e criar nossa própria pull request a partir de nosso próprio repositório bifurcado
no repositório principal. O proprietário desse repositório
principal pode aceitar nossa pull request, o que significa que
juntos melhoramos essa ferramenta, melhoramos
esse software. E com essa bifurcação, estamos quase acabados. Desejo apenas
mostrar mais um recurso. Esse recurso está relacionado
apenas ao GitHub e é chamado de GitHub Pages.
17. Páginas de Github: Um dos melhores recursos
que o GitHub possui e também um dos recursos
mais recentes é chamado GitHub Pages. Github Pages
nos permitirá hospedar facilmente nosso conteúdo em um domínio que o
GitHub preparará para nós. Esse domínio geralmente é
nomeado pelo nosso repositório. E isso exige que tenhamos
o arquivo HTML de índice
no nível raiz do nosso
repositório para que ele possa ler e também extrair
o conteúdo desse arquivo. Vamos agora juntos implantar
e publicar bem nosso código, nosso projeto que criamos
no GitHub Pages para fazer isso, visite seu repositório e
clique nesta guia Configurações. Agora, no lado esquerdo
dessas configurações, existem muitas opções
diferentes, mas certifique-se de
selecionar as páginas aqui. Aqui podemos configurar e
configurar nossas Páginas do GitHub. E para ser honesto, não precisaremos executar nenhum script para isso. Ele fará tudo por nós. A primeira coisa que
precisamos fazer é selecionar
a ramificação de onde
desejamos implantar nosso conteúdo. Bem, para nós, este
será o nosso ramo principal. Também não se esqueça de selecionar a
raiz do projeto é que nosso arquivo index.HTML
está na raiz dele. Agora, basta salvar isso e você deve ver o
link para o seu domínio. O link em si deve conter
o conteúdo do seu site. Também dê
um pouco de tempo, pois às vezes ele precisa de alguns
minutos para apresentá-lo ao vivo. Mas quando tudo estiver terminado e o
site for implantado, você deve ver o que eu vejo aqui. Bem, meu conteúdo,
e para ser honesto, é um ótimo site. Bem, é outro
tutorial sobre isso, mas sobre o Git e o GitHub. Mas com esse recurso, páginas
do GitHub, estamos
praticamente acabados. Vamos apenas entrar no vídeo
a seguir para dizer um adeus adequado também.
18. Obrigado e adeus: Bem, acho que é
isso pessoal. Terminamos este curso juntos e eu realmente
desejo agradecer a vocês. Você está fazendo este curso
significa muito para mim. Agora, o que você pode fazer
também é deixar um comentário também. A revisão em si pode ser simples e também ser
honesta sobre isso. Este curso foi muito
cuidadoso para você? Também? Foi feito sob medida para iniciantes? E você aprendeu algo
útil e sobre isso, espero que você tenha feito ou
pelo menos tenha melhorado um pouco seu
conhecimento. À medida que
passamos por muitos recursos. Como exemplo,
passamos pelo Git e GitHub em geral será
instalado o Git como uma ferramenta. E você também foi
apresentado a ele. Você viu o que é para
o que podemos usá-lo, e também o
fluxo de trabalho usual com o Git. Esse fluxo de trabalho usual
incluiu a criação um repositório, clonagem
desse repositório ,
preparando nossas alterações,
rastreamento dessas alterações , confirmação e envio de
nosso código também. Obviamente, não aprendemos, basta chegar aqui, mas também
usamos o GitHub. Github nos ajudou a
gerenciar nossas filiais, também fazer o checkout de alterações
e confirmar, enquanto também
pudemos mesclar
nosso código quando queríamos, você também entendeu
o termo das ramificações. Você viu como
você pode gerenciá-los? Você também viu o que
é pull request. Usamos algumas solicitações de
enquete também. Ao lado disso, corrigimos conflitos e também
bifurcamos nosso repositório. Finalmente, terminamos
o discurso com dois ótimos
recursos do GitHub, GitHub Pages e GitHub Desktop. Usamos o desktop para gerenciar nosso
repositório sem um terminal. E também usamos as páginas
para implantar nosso código, nosso site em um domínio
fornecido pelo GitHub. Agora, se você gostou deste
curso de mim e gostaria de assistir a mais
conteúdo de mim também. Bem, não deixe de visitar meu canal
do YouTube para isso. No meu canal do YouTube, você pode encontrar tutoriais para várias tecnologias como
Bootstrap, Angular, JS aninhado. Além disso, há cursos
intensivos, bem
como todo o projeto. Aqui no Skillshare. Você também pode encontrar muitos projetos
diferentes de mim. Então, se você estiver
interessado neles, bem, não se esqueça de
conferir isso. E, finalmente, você sempre pode visitar meu
site oficial lá você encontrará todos os meus tutoriais e cursos que eu tenho também. Obrigado mais uma vez por assistir e terminar
este curso. Espero que eu o veja
em outros cursos também. Adeus.