One place for hosting & domains

      Projeto

      Como configurar um projeto de nó com o Typescript


      Introdução

      O Node é um ambiente de de execução que permite escrever JavaScript do lado do servidor. Desde seu lançamento em 2011, ele vem sendo adotado amplamente. Escrever JavaScript do lado do servidor pode ser uma tarefa desafiadora à medida que a base de código cresce. Isso ocorre devido à natureza da linguagem JavaScript; é dinâmica e fracamente tipada.

      Deselvolvedores que vêm para o JavaScript de outra linguagem geralmente reclamam da falta de uma tipagem estática forte e é por isso que o TypeScript existe – para preencher essa lacuna.

      O TypeScript é um superconjunto tipado (opcional) de JavaScript que pode auxiliar na construção e gerenciamento de projetos em JavaScript em larga escala. Ele pode ser considerado um JavaScript com funcionalidades adicionais, tais como uma tipagem estática forte, compilação e programação orientada a objetos.

      Nota: o TypeScript é tecnicamente um superconjunto de JavaScript, o que significa que todo o código de JavaScript é também um código de TypeScript válido.

      Aqui estão alguns benefícios de usar o TypeScript:

      1. Tipagem estática opcional.
      2. Inferência de tipo.
      3. Capacidade de usar interfaces.

      Neste tutorial, você irá configurar um projeto do Node com o TypeScript. Você irá construir um aplicativo Express usando o TypeScript e transcompilá-lo em um código JavaScript organizado e confiável.

      Pré-requisitos

      Antes de iniciar este guia, é necessário possuir o Node.js instalado em sua máquina. Você pode fazer isso seguindo o guia Como instalar o Node.js e criar um ambiente de desenvolvimento local para seu sistema operacional.

      Passo 1 — Inicializando um projeto npm

      Para começar, crie uma nova pasta chamada node_project e vá até esse diretório.

      • mkdir node_project

      • cd node_project

      Em seguida, inicialize-o como um projeto npm:

      Depois de executar o npm init, será necessário fornecer informações sobre o seu projeto ao npm. Caso prefira deixar que o npm assuma padrões sensatos, adicione o sinalizador y para ignorar os prompts para obter informações adicionais:

      Agora que seu espaço de projeto está configurado, podemos seguir para a instalação das dependências necessárias.

      Passo 2 — Instalando as dependências

      Com um projeto básico do npm inicializado, o próximo passo é instalar as dependências que são necessárias para executar o TypeScript.

      Execute os seguintes comandos a partir do diretório do seu projeto para instalar as dependências:

      O sinalizador -D é o atalho para: --save-dev. Aprenda mais sobre esse sinalizador na documentação do npmjs.

      Agora, é hora de instalar o framework Express:

      O segundo comando instala os tipos do Express para o suporte do TypeScript. Os tipos no TypeScript são arquivos, normalmente com uma extensão .d.ts. Os arquivos são usados para fornecer informações de tipo sobre uma API, neste caso, o framework Express.

      Este pacote é necessário porque o TypeScript e o Express são pacotes independentes. Sem o pacote @types/express, o TypeScript não é capaz de saber sobre os tipos das classes do Express.

      Passo 3 — Configurando o TypeScript

      Nesta seção, você irá configurar o TypeScript e configurar uma função de linting para ele. O TypeScript usa um arquivo chamado tsconfig.json para configurar as opções do compilador para um projeto. Crie um arquivo tsconfig.json na raiz do diretório do projeto e adicione o seguinte trecho de código:

      tsconfig.json

      {
  "compilerOptions": {
    "module": "commonjs",
    "esModuleInterop": true,
    "target": "es6",
    "moduleResolution": "node",
    "sourceMap": true,
    "outDir": "dist"
  },
  "lib": ["es2015"]
}

      Vamos rever algumas das chaves presentes no código JSON acima:

      • module: define o método de geração de código do módulo. O Node usa o commonjs.
      • target: especifica o nível de linguagem de saída.
      • moduleResolution: isso ajuda o compilador a descobrir a que uma importação se refere. O valor node imita o mecanismo de resolução de módulo do Node.
      • outDir: essa é a localização onde serão gerados os arquivos .js após a transcompilação. Neste tutorial, você irá salvá-lo como dist.

      Ao invés de criar e preencher manualmente o arquivo tsconfig.json, uma alternativa é executar o comando a seguir:

      Esse comando irá gerar um arquivo tsconfig.json comentado de maneira satisfatória.

      Para aprender mais sobre as opções de valor chave disponíveis, a documentação oficial do TypeScript oferece explicações de todas as opções.

      Agora, configure o linting do TypeScript para o projeto. Em um terminal em execução na raiz do diretório do seu projeto, que este tutorial estabeleceu como sendo node_project, execute o comando a seguir para gerar um arquivo tslint.json:

      • ./node_modules/.bin/tslint --init

      Abra o arquivo tslint.json recém-gerado e adicione a regra no-console adequadamente:

      tslint.json

      {
  "defaultSeverity": "error",
  "extends": ["tslint:recommended"],
  "jsRules": {},
  "rules": {
    "no-console": false
  },
  "rulesDirectory": []
}

      Por padrão, o linter do TypeScript impede a depuração usando declarações de console. Dessa forma, é necessário dizer explicitamente ao linter para revogar a regra no-console padrão.

      Passo 4 — Atualizando o arquivo package.json

      Neste ponto do tutorial, é possível executar funções no terminal individualmente, ou criar um script npm para executá-las.

      Neste passo, você criará um script start que irá compilar e transcompilar o código TypeScript e então executar o aplicativo .js resultante.

      Abra o arquivo package.json e atualize-o adequadamente:

      package.json

      {
  "name": "node-with-ts",
  "version": "1.0.0",
  "description": "",
  "main": "dist/app.js",
  "scripts": {
    "start": "tsc && node dist/app.js",
    "test": "echo "Error: no test specified" && exit 1"
  },
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "@types/express": "^4.16.1",
    "tslint": "^5.12.1",
    "typescript": "^3.3.3"
  },
  "dependencies": {
    "express": "^4.16.4"
  }
}

      No código acima, você atualizou o caminho main e adicionou o comando start à seção de scripts. Se observar o comando start, você verá que primeiro o comando tsc é executado e, em seguida, o comando node. Isso irá compilar e então executar a saída gerada com o node.

      O comando tsc diz ao TypeScript para compilar o aplicativo e colocar a saída .js gerada no diretório outDir especificado, da forma como está definido no arquivo tsconfig.json.

      Passo 5 — Criando e executando um servidor básico do Express

      Agora que o TypeScript e seu linter estão configurados, é hora de construir um servidor do Node Express.

      Primeiro, crie uma pasta src na raiz do diretório do seu projeto:

      Em seguida, crie um arquivo chamado app.ts dentro dela:

      Neste ponto, a estrutura da pasta deve se parecer com esta:

      ├── node_modules/
├── src/
  ├── app.ts
├── package-lock.json
├── package.json
├── tsconfig.json
├── tslint.json

      Abra o arquivo app.ts com um editor de texto da sua escolha e adicione o trecho de código a seguir:

      src/app.ts

      import express from 'express';

const app = express();
const port = 3000;
app.get('/', (req, res) => {
  res.send('The sedulous hyena ate the antelope!');
});
app.listen(port, err => {
  if (err) {
    return console.error(err);
  }
  return console.log(`server is listening on ${port}`);
});

      O código acima cria um servidor Node que escuta na porta 3000 para solicitações. Execute o aplicativo usando o comando a seguir:

      Se ele for executado com sucesso, uma mensagem será registrada no terminal:

      Output
      • server is listening on 3000

      Agora, visite http://localhost:3000 em seu navegador e você verá esta mensagem:

      Output
      • The sedulous hyena ate the antelope!

      Janela do navegador com a mensagem: The sedulous hyena ate the antelope!

      Abra o arquivo dist/app.js e você encontrará a versão transcompilada do código do TypeScript:

      dist/app.js

      "use strict";

var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const express_1 = __importDefault(require("express"));
const app = express_1.default();
const port = 3000;
app.get('/', (req, res) => {
    res.send('The sedulous hyena ate the antelope!');
});
app.listen(port, err => {
    if (err) {
        return console.error(err);
    }
    return console.log(`server is listening on ${port}`);
});

//# sourceMappingURL=app.js.map

      Neste ponto, você terminou de configurar com sucesso seu projeto Node para usar o TypeScript.

      Conclusão

      Neste tutorial, você aprendeu sobre a razão pela qual o TypeScript é útil para escrever códigos em JavaScript confiáveis. Você também aprendeu sobre alguns dos benefícios de trabalhar com o TypeScript.

      Por fim, você configurou um projeto Node usando o framework Express, mas compilou e executou o projeto usando o TypeScript.



      Source link

      Como adicionar o teste de unidade ao seu projeto Django


      O autor selecionou a Open Internet/Free Speech Fund para receber uma doação como parte do programa Write for DOnations.

      Introdução

      É quase impossível desenvolver sites que funcionem perfeitamente na primeira vez, sem erro algum. Por este motivo, você deve testar seu aplicativo Web em busca de erros e trabalhar neles proativamente. Para melhorar a eficiência dos testes, é comum dividir os testes em unidades que testam funcionalidades específicas de um aplicativo Web. Esta prática é conhecida como teste de unidade. Esta prática facilita a detecção de erros, pois os testes focam em partes menores (unidades) do seu projeto, independentemente das outras.

      O teste de um site pode ser uma tarefa complexa de se realizar, pois um site é composto de várias camadas lógicas, como o processamento de solicitações HTTP, validação do formulário e renderização de modelos. No entanto, o Django fornece um conjunto de ferramentas que simplifica o teste de seu aplicativo Web. No Django, o melhor método de escrever os testes é através do uso do módulo unittest do Python, embora seja possível utilizar outros frameworks de teste.

      Neste tutorial, você configurará um conjunto de testes em seu projeto Django e escreverá os testes de unidade para os modelos e visualizações em seu aplicativo. Você executará esses testes, analisará os resultados e aprenderá como encontrar as causas das falhas dos testes.

      Pré-requisitos

      Antes de começar este tutorial será necessário:

      Passo 1 — Adicionando um conjunto de testes para seu aplicativo Django

      Um conjunto de teste é uma coleção de todos os casos de teste em todos os aplicativos em seu projeto. Para que seja possível que o utilitário de testes do Django descubra os casos de teste que você possui, escreva os casos de teste em scripts cujos nomes comecem com test. Neste passo você criará a estrutura do diretório e os arquivos para seu conjunto de testes e criará um caso de teste vazio nele.

      Se você seguiu o a série de tutoriais de desenvolvimento do Django, você terá consigo um aplicativo Django chamado blogsite.

      Vamos criar uma pasta para armazenar todos os nossos scripts de testes. Primeiro, ative o ambiente virtual:

      • cd ~/my_blog_app

      • . env/bin/activate

      Em seguida, vá até o diretório do aplicativo chamado blogsite. Esta é a pasta que contém os arquivos models.py e views.py. Crie nela uma nova pasta chamada tests:

      • cd ~/my_blog_app/blog/blogsite

      • mkdir tests

      Depois disso, você transformará esta pasta em um pacote Python. Por este motivo, adicione um arquivo __init__.py:

      • cd ~/my_blog_app/blog/blogsite/tests

      • touch __init__.py

      Agora, você adicionará um arquivo para testar seus modelos e outro arquivo para testar suas visualizações:

      • touch test_models.py

      • touch test_views.py

      Por fim, você criará um caso de teste vazio em test_models.py. Você precisará importar a classe Django TestCase e torná-la uma superclasse de sua própria classe de caso de teste. Mais à frente, você adicionará métodos para este caso de teste para testar a lógica em seus modelos. Abra o arquivo test_models.py​​​:

      Agora, adicione o código a seguir ao arquivo:

      ~/my_blog_app/blog/blogsite/tests/test_models.py

      from django.test import TestCase

class ModelsTestCase(TestCase):
    pass

      Você adicionou um conjunto de testes ao aplicativo blogsite. Em seguida, você preencherá os detalhes do modelo do caso de teste vazio criado aqui.

      Passo 2 — Testando o código Python

      Neste passo você testará a lógica do código escrito no arquivo models.py. Você estará testando especificamente o método save do modelo Post para garantir que ele crie o campo de dados dinâmico correto do título de uma postagem quando ela for chamada.

      Vamos começar analisando o código que você já tem em seu arquivo models.py para o método save do modelo Post:

      • cd ~/my_blog_app/blog/blogsite

      • nano models.py

      Você verá o seguinte:

      ~/my_blog_app/blog/blogsite/models.py

      class Post(models.Model):
    ...
    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.title)
        super(Post, self).save(*args, **kwargs)
    ...

      Como podemos ver, ele verifica se a postagem que está prestes a ser salva possui algum valor do campo de dados dinâmico. Se não tiver, ele chama o slugify para criar um valor do campo de dados dinâmico. Esta é lógica que queremos para testar e garantir que os campos de dados dinâmicos sejam criados ao salvar uma postagem.

      Feche o arquivo.

      Para testar isso, volte para o test_models.py:

      Em seguida, atualize-o para o seguinte, adicionando as partes destacadas:

      ~/my_blog_app/blog/blogsite/tests/test_models.py

      from django.test import TestCase
from django.template.defaultfilters import slugify
from blogsite.models import Post


class ModelsTestCase(TestCase):
    def test_post_has_slug(self):
        """Posts are given slugs correctly when saving"""
        post = Post.objects.create(title="My first post")

        post.author = "John Doe"
        post.save()
        self.assertEqual(post.slug, slugify(post.title))

      Este novo método test_post_has_slug cria uma nova postagem com o título "My first post" e, em seguida, fornece um autor à postagem e a salva. Após isso, use o método assertEqual do módulo unittest do Python para verificar se o campo de dados dinâmico para a postagem está correto. O método assertEqual verifica se os dois argumentos passados a ele são iguais aos argumentos determinados pelo operador "==". Caso não sejam iguais, o método gera um erro.

      Salve e saia do test_models.py​​​.

      Este é um exemplo do que pode ser testado. Quanto mais lógica você adicionar ao seu projeto, mais conteúdo haverá para testar. É aconselhável que você crie mais testes caso adicione mais lógica ao método save ou crie novos métodos para o modelo Post. Você pode adicioná-los ao método test_post_has_slug ou criar novos métodos de teste, mas os nomes devem começar com test.

      Você criou um caso de teste para o modelo Post com êxito, onde você definiu que os campos de dados dinâmicos foram criados corretamente após salvar. No próximo passo você escreverá um caso de teste para testar as visualizações.

      Passo 3 — Utilizando o cliente de teste do Django

      Neste passo, você escreverá um caso de teste que testa uma visualização utilizando o cliente de testes do Django. O test client é uma classe Python que age como um navegador Web fictício. Ele permite que você teste suas visualizações e interaja com seu aplicativo Django da mesma forma que um usuário faria. Você pode acessar o cliente de teste referindo-se ao self.client em seus métodos de teste. Por exemplo, vamos criar um caso de teste em test_views.py. Primeiro, abra o arquivo test_views.py​​​:

      Depois, adicione o seguinte:

      ~/my_blog_app/blog/blogsite/tests/test_views.py

      from django.test import TestCase


class ViewsTestCase(TestCase):
    def test_index_loads_properly(self):
        """The index page loads properly"""
        response = self.client.get('your_server_ip:8000')
        self.assertEqual(response.status_code, 200)

      O ViewsTestCase contém um método test_index_loads_properly que utiliza o cliente de teste do Django para visitar a página inicial do site (http://your_server_ip:8000, onde o your_server_ip é o endereço IP do servidor que você está utilizando). Em seguida, o método de teste verifica se a resposta tem um código de status 200, o que significa que a página respondeu sem erros. Pelo resultado do teste, podemos concluir que quando os usuários visitarem a página, ela responderá sem erros também.

      Além do código de status, você pode ler sobre outras propriedades da resposta do cliente de teste que você confere na página de respostas de testes da documentação do Django.

      Neste passo, você criou um caso de teste para conferir se a renderização da visualização da página inicial funciona sem erros. Agora, existem dois casos de teste em seu conjunto. No próximo passo, você os executará para ver os resultados.

      Passo 4 — Executando seus testes

      Agora que você terminou de desenvolver um conjunto de testes para o projeto, é hora de executá-los e ver os resultados. Para executar os testes, vá para a pasta blog (que contém o arquivo manage.py do aplicativo):

      Em seguida, execute-os com:

      Você verá um resultado parecido com o seguinte em seu terminal:

      Output
      Creating test database for alias 'default'...
System check identified no issues (0 silenced).
..
----------------------------------------------------------------------
Ran 2 tests in 0.007s

OK
Destroying test database for alias 'default'...

      Neste resultado, existem dois pontos .., cada um dos quais representa um caso de teste aprovado. Agora, você modificará o test_views.py para acionar uma falha no teste. Primeiro, abra o arquivo com:

      Em seguida, altere o código destacado para:

      ~/my_blog_app/blog/blogsite/tests/test_views.py

      from django.test import TestCase


class ViewsTestCase(TestCase):
    def test_index_loads_properly(self):
        """The index page loads properly"""
        response = self.client.get('your_server_ip:8000')
        self.assertEqual(response.status_code, 404)

      Aqui, você alterou o código de status de 200 para 404. Agora, execute o teste novamente do diretório com o manage.py:

      Você verá o seguinte resultado:

      Output
      Creating test database for alias 'default'...
System check identified no issues (0 silenced).
.F
======================================================================
FAIL: test_index_loads_properly (blogsite.tests.test_views.ViewsTestCase)
The index page loads properly
----------------------------------------------------------------------
Traceback (most recent call last):
  File "~/my_blog_app/blog/blogsite/tests/test_views.py", line 8, in test_index_loads_properly
    self.assertEqual(response.status_code, 404)
AssertionError: 200 != 404

----------------------------------------------------------------------
Ran 2 tests in 0.007s

FAILED (failures=1)
Destroying test database for alias 'default'...

      Veja que existe uma mensagem de erro informando o script, o caso de teste e o método que falhou. Ele também diz a causa da falha, o código de status diferente de 404 neste caso, com a mensagem AssertionError: 200 ! = 404. O AssertionError é criado na linha de código destacada no arquivo test_views.py:

      ~/my_blog_app/blog/blogsite/tests/test_views.py

      from django.test import TestCase


class ViewsTestCase(TestCase):
    def test_index_loads_properly(self):
        """The index page loads properly"""
        response = self.client.get('your_server_ip:8000')
        self.assertEqual(response.status_code, 404)

      Ele informa a você que a afirmação é falsa, ou seja, o código de status da resposta (200) não era o esperado (404). Antes da mensagem de falha, vemos que os dois pontos .. foram modificados para . F, que diz que o primeiro caso de teste foi aprovado enquanto o segundo falhou.

      Conclusão

      Neste tutorial, você criou um conjunto de testes em seu projeto Django, adicionou casos de teste para testar o modelo e a lógica de visualização. Também aprendeu como executar testes e analisou o resultado deles. Como um próximo passo, você pode criar novos scripts de teste para código Python que não sejam do models.py e do views.py.

      Em seguida, temos alguns artigos que podem ser úteis ao desenvolver e testar sites com o Django:

      Você também pode verificar nossa página de tópicos relacionados ao Django para obter mais tutoriais e projetos.



      Source link

      Como usar o Git para Gerenciar seu Projeto de Redação


      Introdução

      O controle de versão não é apenas para código. É para qualquer coisa que você queira acompanhar, incluindo conteúdo. Usar o Git para gerenciar o seu próximo projeto de redação permite a você exibir vários rascunhos ao mesmo tempo, ver diferenças entre esses rascunhos e até reverter para uma versão anterior. E se você estiver confortável com isso, poderá compartilhar seu trabalho com outras pessoas no GitHub ou em outros repositórios centrais do Git.

      Neste tutorial, você usará o Git para gerenciar um pequeno documento Markdown. Você armazenará uma versão inicial, fará o commit ou confirmação dela, fará alterações, visualizará a diferença entre essas alterações e revisará a versão anterior. Quando terminar, você terá um fluxo de trabalho que poderá aplicar aos seus próprios projetos de redação.

      Pré-requisitos

      Passo 1 — Criando um Espaço de Trabalho para Seu Projeto de Redação

      Para gerenciar suas alterações, você criará um repositório Git local. Um repositório Git vive dentro de um diretório existente; portanto, comece criando um novo diretório para o seu artigo:

      Mude para o novo diretório artigo:

      O comando git init cria um novo repositório Git vazio no diretório atual. Execute esse comando agora:

      Você verá a seguinte saída que confirma que seu repositório foi criado:

      Output
      Initialized empty Git repository in /Users/sammy/artigo/.git/

      O arquivo .gitignore permite que você informe ao Git que alguns arquivos devem ser ignorados. Você pode usar isso para ignorar arquivos temporários que seu editor de texto possa criar ou arquivos de sistemas operacionais. No macOS, por exemplo, o aplicativo Finder cria arquivos .DS_Store em diretórios. Crie um arquivo .gitignore que os ignore:

      Adicione as seguintes linhas ao arquivo:

      .gitignore

      # Ignore Finder files
.DS_store

      A primeira linha é um comentário, que o ajudará a identificar o que você está ignorando no futuro. A segunda linha especifica o arquivo a ser ignorado.

      Salve o arquivo e saia do editor.

      À medida que você descobrir mais arquivos que deseja ignorar, abra o arquivo .gitignore e adicione uma nova linha para cada arquivo ou diretório que deseja ignorar.

      Agora que seu repositório está configurado, você pode começar a trabalhar.

      Passo 2 — Salvando Seu Rascunho Inicial

      O Git só conhece os arquivos que você conta para ele. Só porque um arquivo existe no diretório que contém o repositório não significa que o Git irá rastrear suas alterações. Você precisa adicionar o arquivo ao repositório e confirmar as alterações.

      Crie um novo arquivo Markdown chamado artigo.md:

      Adicione algum texto ao arquivo:

      artigo.md

      # Como Usar o Git para Gerenciar seu Projeto de Redação

### Introdução

O controle de versão não é apenas para código. É para qualquer coisa que você queira acompanhar, incluindo conteúdo. Usar o [Git](https://git-scm.com) para gerenciar o seu próximo projeto de redação permite a você exibir vários rascunhos ao mesmo tempo, ver diferenças entre esses rascunhos e até reverter para uma versão anterior. E se você estiver confortável com isso, poderá compartilhar seu trabalho com outras pessoas no GitHub ou em outros repositórios centrais do Git. 

Neste tutorial, você usará o Git para gerenciar um pequeno documento Markdown. Você armazenará uma versão inicial, fará o commit ou confirmação dela, fará alterações, visualizará a diferença entre essas alterações e revisará a versão anterior. Quando terminar, você terá um fluxo de trabalho que poderá aplicar aos seus próprios projetos de redação.

      Salve as alterações e saia do editor.

      O comando git status mostrará o estado do seu repositório. Ele mostrará quais arquivos precisam ser adicionados para que o Git possa rastreá-los. Execute este comando:

      Você verá esta saída:

      Output
      On branch master

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)

    .gitignore
    artigo.md

nothing added to commit but untracked files present (use "git add" to track)

      Na saída, a seção Untracked files mostra os arquivos que o Git não está vendo. Esses arquivos precisam ser adicionados ao repositório para que o Git possa observá-los quanto a alterações. Use o comando git add para fazer isso:

      • git add .gitignore

      • git add artigo.md

      Agora execute o git status para verificar se esses arquivos foram adicionados:

      Output
      On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)

    new file:   .gitignore
    new file:   artigo.md

      Agora os dois arquivos estão listados na seção Changes to be committed, ou seja, alterações a serem confirmadas. O Git sabe sobre eles, mas ainda não criou um instantâneo do trabalho. Use o comando git commit para fazer isso.

      Quando você cria um novo commit, você precisa fornecer uma mensagem de commit. Uma boa mensagem de commit fala sobre quais são as suas alterações. Quando você está trabalhando com outras pessoas, quanto mais detalhadas forem suas mensagens de commit, melhor.

      Use o comando git commit para confirmar suas alterações:

      • git commit -m "Adicionar arquivo gitignore e versão inicial do artigo"

      A saída do comando mostra que os arquivos foram confirmados:

      Output
      [master (root-commit) 95fed84] Adicionar arquivo gitignore e versão inicial do artigo
 2 files changed, 9 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 artigo.md

      Use o comando git status para ver o estado do repositório:

      A saída mostra que não há alterações que precisam ser adicionadas ou confirmadas.

      Output
      On branch master
nothing to commit, working tree clean

      Agora vamos ver como trabalhar com alterações.

      Passo 3 — Salvando Revisões

      Você adicionou sua versão inicial do artigo. Agora você adicionará mais texto para poder ver como gerenciar alterações com o Git.

      Abra o artigo no seu editor:

      Adicione um pouco mais de texto ao final do arquivo:

      ## Pré-requisitos

* Git instalado em seu computador local. O tutorial [How to Contribute to Open Source: Getting Started with Git](https://www.digitalocean.com/community/tutorials/how-to-contribute-to-open-source-getting-started-with-git) orienta você na instalação do Git e cobre algumas informações básicas que você pode achar úteis.

      Salve o artigo

      Use o comando git status para ver onde estão as coisas no seu repositório:

      A saída mostra que há alterações:

      Output
      On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

    modified:   artigo.md

no changes added to commit (use "git add" and/or "git commit -a")

      Como esperado, o arquivo artigo.md sofreu alterações.

      Use git diff para ver o quais são elas:

      A saída mostra as linhas que você adicionou:

      diff --git a/artigo.md b/artigo.md
index 77b081c..ef6c301 100644
--- a/artigo.md
+++ b/artigo.md
@@ -5,3 +5,7 @@
 O controle de versão não é apenas para código. É para qualquer coisa que você queira acompanhar, incluindo conteúdo. Usar o [Git](https://git-scm.com) para gerenciar o seu próximo projeto de redação permite a você exibir vários rascunhos ao mesmo tempo, ver diferenças entre esses rascunhos e até reverter para uma versão anterior. E se você estiver confortável com isso, poderá compartilhar seu trabalho com outras pessoas no GitHub ou em outros repositórios centrais do Git. 

 Neste tutorial, você usará o Git para gerenciar um pequeno documento Markdown. Você armazenará uma versão inicial, fará o commit ou confirmação dela, fará alterações, visualizará a diferença entre essas alterações e revisará a versão anterior. Quando terminar, você terá um fluxo de trabalho que poderá aplicar aos seus próprios projetos de redação.
+
+## Pré-requisitos
+
+* Git instalado em seu computador local. O tutorial [How to Contribute to Open Source: Getting Started with Git](https://www.digitalocean.com/community/tutorials/how-to-contribute-to-open-source-getting-started-with-git) orienta você na instalação do Git e cobre algumas informações básicas que você pode achar úteis.

      Na saída, linhas começando com um sinal de mais (+) são linhas que você adicionou. As linhas removidas apareceriam com um sinal de menos (-). As linhas inalteradas não teriam nenhum desses caracteres na frente.

      Usar git diff e git status é uma maneira útil de ver o que você mudou. Você também pode salvar o diff em um arquivo para visualizá-lo mais tarde com o seguinte comando:

      • git diff artigo.md > artigo_diff.diff

      O uso da extensão .diff ajudará seu editor de texto a aplicar o realce apropriado da sintaxe.

      Salvar as alterações no seu repositório é um processo de duas etapas. Primeiro, adicione o arquivo artigo.md novamente e depois faça o commit. O Git quer que você diga a ele explicitamente quais arquivos estão em cada commit, portanto, mesmo que você tenha adicionado o arquivo antes, você deve adicioná-lo novamente. Note que a saída do comando git status lembra você disso.

      Adicione o arquivo e faça o commit das alterações, fornecendo uma mensagem de commit:

      • git add artigo.md

      • git commit -m "adicionada seção de pré-requisitos"

      A saída verifica que o commit funcionou:

      Output
      [master 1fbfc21] adicionada seção de pré-requisitos
 1 file changed, 4 insertions(+)

      Use git status para ver o status do seu repositório. Você verá que não há mais nada a fazer.

      Output
      On branch master
nothing to commit, working tree clean

      Continue esse processo enquanto revisa seu artigo. Faça as alterações, verifique-as, adicione o arquivo e faça o commit das alterações com uma mensagem detalhada. Faça commit de suas alterações com a frequência que desejar. Você pode realizar um commit depois de concluir cada rascunho ou antes de fazer uma grande reformulação da estrutura do seu artigo.

      Se você enviar um rascunho de um documento para outra pessoa e ela fizer alterações, pegue a cópia e substitua o arquivo pelo dela. Em seguida, use git diff para ver rapidamente as alterações que ela fez. O Git verá as alterações, tenha você digitado diretamente ou substituido o arquivo por um que você baixou da web, e-mail ou outro local.

      Agora, vamos analisar o gerenciamento das versões do seu artigo.

      Passo 4 — Gerenciando Alterações

      Às vezes, é útil olhar para uma versão anterior de um documento. Sempre que você usou o git commit, você forneceu uma mensagem útil que resume o que você fez.

      O comando git log mostra o histórico de commit do seu repositório. Toda mudança que você fez commit tem uma entrada no log.

      Output
      commit 1fbfc2173f3cec0741e0a6b21803fbd0be511bc4
Author: Sammy Shark <sammy@digitalocean>
Date:   Thu Sep 19 16:35:41 2019 -0500

    adicionada seção de pré-requisitos

commit 95fed849b0205c49eda994fff91ec03642d59c79
Author: Sammy Shark <sammy@digitalocean>
Date:   Thu Sep 19 16:32:34 2019 -0500

    Adicionar arquivo gitignore e versão inicial do artigo

      Cada commit possui um identificador específico. Você usa esse número para referenciar as alterações de um commit específico. Você só precisa dos primeiros caracteres do identificador. O comando git log --oneline fornece a você uma versão condensada do log com identificadores mais curtos:

      Output
      1fbfc21 adicionada seção de pré-requisitos
95fed84 Adicionar arquivo gitignore e versão inicial do artigo

      Para visualizar a versão inicial do seu arquivo, use git show e o identificador do commit. Os identificadores no seu repositório serão diferentes dos que estão nesses exemplos.

      • git show 95fed84 artigo.md

      A saída mostra os detalhes do commit, bem como as alterações que ocorreram durante esse commit:

      Output
      commit 95fed849b0205c49eda994fff91ec03642d59c79
Author: Sammy Shark <sammy@digitalocean>
Date:   Thu Sep 19 16:32:34 2019 -0500

    Adicionar arquivo gitignore e versão inicial do artigo

diff --git a/artigo.md b/artigo.md
new file mode 100644
index 0000000..77b081c
--- /dev/null
+++ b/artigo.md
@@ -0,0 +1,7 @@
+# Como Usar o Git para Gerenciar seu Projeto de Redação
+
+### Introdução
+
+O controle de versão não é apenas para código. É para qualquer coisa que você queira acompanhar, incluindo conteúdo. Usar o [Git](https://git-scm.com) para gerenciar o seu próximo projeto de redação permite a você exibir vários rascunhos ao mesmo tempo, ver diferenças entre esses rascunhos e até reverter para uma versão anterior. E se você estiver confortável com isso, poderá compartilhar seu trabalho com outras pessoas no GitHub ou em outros repositórios centrais do Git.
+
+Neste tutorial, você usará o Git para gerenciar um pequeno documento Markdown. Você armazenará uma versão inicial, fará o commit ou confirmação dela, fará alterações, visualizará a diferença entre essas alterações e revisará a versão anterior. Quando terminar, você terá um fluxo de trabalho que poderá aplicar aos seus próprios projetos de redação.

      Para ver o próprio arquivo, modifique o comando levemente. Em vez de um espaço entre o identificador do commit e o arquivo, substitua por :./ assim:

      • git show 95fed84:./artigo.md

      Você verá o conteúdo desse arquivo, nessa revisão:

      Output
      ### Introdução

O controle de versão não é apenas para código. É para qualquer coisa que você queira acompanhar, incluindo conteúdo. Usar o [Git](https://git-scm.com) para gerenciar o seu próximo projeto de redação permite a você exibir vários rascunhos ao mesmo tempo, ver diferenças entre esses rascunhos e até reverter para uma versão anterior. E se você estiver confortável com isso, poderá compartilhar seu trabalho com outras pessoas no GitHub ou em outros repositórios centrais do Git. 

Neste tutorial, você usará o Git para gerenciar um pequeno documento Markdown. Você armazenará uma versão inicial, fará o commit ou confirmação dela, fará alterações, visualizará a diferença entre essas alterações e revisará a versão anterior. Quando terminar, você terá um fluxo de trabalho que poderá aplicar aos seus próprios projetos de redação.

      Você pode salvar essa saída em um arquivo se precisar disso para outra coisa:

      • git show 95fed84:./artigo.md > old_artigo.md

      À medida que você fizer mais alterações, seu log aumentará e você poderá revisar todas as alterações feitas no seu artigo ao longo do tempo.

      Conclusão

      Neste tutorial, você usou um repositório Git local para rastrear as alterações no seu projeto de redação. Você pode usar essa abordagem para gerenciar artigos individuais, todas as postagens do seu blog ou até mesmo seu próximo romance. E se você enviar seu repositório para o GitHub, poderá convidar outras pessoas para ajudá-lo a editar seu trabalho.



      Source link

      Forgot Your Password ?