DEV Community: Lucas

O básico de Git

Lucas — Tue, 21 Nov 2023 12:36:42 +0000

O que é Git?

Git é um versionador de código, gratuito e de código aberto. Um versionador de código serve para que possamos criar um histórico de tudo o que fazemos no código, isso é ótimo porque podemos trabalhar em equipe e todas as alterações ficam registradas de forma padronizada, facilitando o entendimento do que a outra pessoa fez no código e tendo a possibilidade de "voltar no tempo", para uma determinada versão do código.

Configuração básica

Depois de instalar o Git é importante fazer algumas configurações básicas. Primeiro vamos definir o email e username, isso serve para identificar quem fez alguma alteração no código.

$ git config --global user.email "<seu-email>"
$ git config --global user.name "<seu-nome>"

Agora vamos definir um editor que será utilizado para resolver conflitos.

$ git config --global core.editor "<seu-editor>"

Para finalizar vamos definir o nome padrão da branch quando inicializamos o Git.

$ git config --global init.defaultBranch "main"

Agora podemos visualizar as configurações que fizemos com $ git config --list.

$ git config -list

user.email="<seu-email>"
user.name="<seu-nome>"
init.defaultBranch="main"
core.editor="<seu-editor>"

Inicializando um novo repositório local

Antes de inicializar um novo repositório Git vamos criar um diretório para podermos trabalhar.

$ mkdir my-project
$ cd my-project

Agora com o diretório criado podemos inicializar um novo repositório Git.

$ git init

Note que foi criado um diretório .git que contém todos os arquivos de repositório necessários, portando não mexa nestes arquivos, eles são necessários para o funcionamento do Git.

Trabalhando com arquivos

Depois de inicializar um novo repositório Git no diretório que criamos, vamos começar criando um novo arquivo com o nome de a.txt com um conteúdo qualquer dentro.

$ touch a.txt
$ echo "Conteúdo do arquivo a.txt" >> a.txt

O Git possuí um comando muito importante para que possamos visualizar o status do nosso repositório que é o $ git status. Executando ele agora podemos ver algumas informações.

$ git status

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

Aqui o Git está informando que exite um ou mais arquivos que não estão sendo rastreados, ou seja, caso fizermos alterações nesse arquivo não vamos conseguir ter um histórico do que foi alterado ou adicionado.

Para criar um commit você precisa separar os arquivos que irão para o commit e para isso usamos o comando $ git add <nome-do-arquivo>..., no nosso caso vamos adicionar o arquivo a.txt e rodar $ git status para ver o que mudou.

Mas antes vamos entender o que é um commit. Commits são a parte essencial do Git, basicamente um commit é o estado do seu repositório em um determinado momento, normalmente commits são feitos a cada nova pequena funcionalidade. Neles contém informações sobre a data, quem fez a alteração e a mensagem informando sobre o que foi alterado ou adicionado.

$ git add a.txt
$ git status

On branch main

No commits yet

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

Nesse caso o Git está informando os arquivos que irão para o próximo commit e o status do arquivo, se ele é novo, foi deletado ou alterado.

Agora vamos fazer o commit com $ git commit -m "<mensagem-do-commit>".

$ git commit -m "adicionado arquivo a.txt"
$ git status

On branch main
nothing to commit, working tree clean

Para visualizar o histórico de commits feitos, podemos usar o comando $ git log.

$ git log

commit de75b4a5e0affac9c36e70ffdfbcc43f4edd1fb4 (HEAD -> main)
Author: <seu-nome> <seu-email>
Date:   Sun Oct 29 19:18:37 2023 -0300

    adicionado arquivo a.txt

Aqui está apresentado todas as informações sobre os commits feitos, data, nome e email de quem fez, a mensagem indicando a mudança e o identificador do commit que fica logo na primeira linha após a palavra "commit". Para sair dessa tela pressione a tecla "q".

Agora vamos fazer uma alteração no arquivo a.txt adicionado mais conteúdo e vamos marcar essa alteração para o próximo commit.

$ echo "Novo conteúdo do arquivo a.txt" >> a.txt
$ git add a.txt

Agora vamos supor que eu adicionei um arquivo errado ou que eu não queira que esse arquivo vá para o próximo commit. Como reverter isso? Simples, é só executar o comando $ git restore --staged <nome-do-arquivo>.

$ git restore --staged a.txt
$ git status

On branch main
Your branch is up to date with 'origin/main'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
    modified:   a.txt

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

Caso você queira descartar as alterações que você fez no arquivo você pode executar o comando $ git restore <nome-do-arquivo>, perceba que aqui não temos a parte --staged.

$ git restore a.txt
$ git status

On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean

Branch

Com o que foi visto até agora podemos trabalhar tranquilamente com Git, mas ainda falta um último tópico a ser visto que é sobre branch.

Branch é basicamente uma ramificação no repositório onde podemos ter, por exemplo, uma branch que trabalhamos na funcionalidade "abc" e outra branch para trabalhar na funcionalidade "def" e quando a funcionalidade estiver pronta podemos fazer um merge para a branch principal, que em todo repositório Git se chama main. O ponto aqui é que quando criamos branchs não vamos comprometer a branch principal do repositório caso a funcionalidade não fique boa ou as coisas não deem certo.

Voltando ao repositório que estamos trabalhando, vamos começar com o comando $ git branch que mostra todas as branchs criadas nesse repositório.

* main
(END)

Podemos ver que temos uma branch criada, que se chama main essa branch é criada pelo próprio Git na inicialização do repositório e é onde todo o código principal do projeto está, o que estiver na produção é o que está na branch main.

Agora vamos supor que queremos fazer um teste de uma nova funcionalidade mas não queremos comprometer nada do fizemos até agora, para isso vamos criar uma nova branch com o comando $ git branch <nome-da-branch>.

$ git branch funcionalidade-abc
$ git branch

  funcionalidade-abc
* main
(END)

Note que criamos uma nova branch e depois listamos as branchs existentes no repositório e agora temos duas. Para mudar de branch usamos o comando $ git checkout <nome-da-branch>

$ git checkout funcionalidade-abc
Switched to branch 'funcionalidade-abc'

$ git branch

* funcionalidade-abc
  main
(END)

Com o comando $ git branch podemos notar que o * que estava no main mudou para funcionalidade-abc indicando em qual branch estamos trabalhando.

A partir de agora podemos trabalhar normalmente como antes, vamos adicionar mais algum conteúdo no arquivo a.txt, vamos marcar essa alteração para o próximo commit e depois vamos fazer o commit.

$ echo "Novo conteúdo do arquivo a.txt" >> a.txt
$ git add a.txt
$ git commit -m "adicionado novo conteúdo no arquivo a.txt"
$ git log

commit d26ed7a5fde35bb229cf0f3ade3171ac886f44ca (HEAD -> funcionalidade-abc)
Author: <seu-nome> <seu-email>
Date:   Fri Nov 17 09:43:40 2023 -0300

    adicionado novo conteúdo no arquivo a.txt

commit de75b4a5e0affac9c36e70ffdfbcc43f4edd1fb4 (main)
Author: <seu-nome> <seu-email>
Date:   Sun Oct 29 19:18:37 2023 -0300

    adicionado arquivo a.txt
(END)

Depois de rodar $ git log para ver o histórico de commits, podemos ver que temos agora dois commits, o primeiro (de baixo para cima) é o que fizemos no início desse artigo e o último commit é o que acabamos de fazer. Note que o primeiro foi feito na branch main e o último foi feito na branch funcionalidade-abc.

Voltando para a branch principal main podemos notar que as modificações que fizemos na outra branch não estão lá.

$ git checkout main
Switched to branch 'main'
$ git log

commit de75b4a5e0affac9c36e70ffdfbcc43f4edd1fb4 (main)
Author: <seu-nome> <seu-email>
Date:   Sun Oct 29 19:18:37 2023 -0300

    adicionado arquivo a.txt
(END)

Aqui está o poder de usar branchs, as modificações ficam separadas, não comprometendo a branch principal. Agora vamos supor que a funcionalidade que fizemos está de acordo, ocorreu tudo bem e é uma boa funcionalidade para adicionar no projeto, como juntar as modificação feitas, na branch principal? Para isso vamos usar o comando $ git merge <nome-da-branch.

$ git merge funcionalidade-abc

Updating de75b4a..d26ed7a
Fast-forward
 a.txt | 1 +
 1 file changed, 1 insertion(+)

$ git log

commit d26ed7a5fde35bb229cf0f3ade3171ac886f44ca (HEAD -> main, funcionalidade-abc)
Author: <seu-nome> <seu-email>
Date:   Fri Nov 17 09:43:40 2023 -0300

    adicionado novo conteúdo no arquivo a.txt

commit de75b4a5e0affac9c36e70ffdfbcc43f4edd1fb4
Author: <seu-nome> <seu-email>
Date:   Sun Oct 29 19:18:37 2023 -0300

    adicionado arquivo a.txt
(END)

Agora podemos ver que os dois commit estão apontando para a branch main. A branch que criamos ainda está criada e você pode manter uma branch para apenas desenvolvimento, a medida que novas funcionalidade são desenvolvidas na branch de desenvolvimento, você faz o merge para a branch principal.

Caso você tenha criado uma branch para apenas fazer algum teste e não deu certo e você queira deletar esta branch, você pode usar o comando $ git branch -D <nome-da-branch>. Caso você já vez o merge e queira deletar esta branch pois não vai mais usá-la, você pode usar o mesmo comando só que com o "d" minúsculo $ git branch -d <nome-da-branch>.

$ git branch -d funcionalidade-abc
Deleted branch funcionalidade-abc (was d26ed7a).

* main
(END)

Resumo do que foi visto

$ git init - Inicializar um novo repositório.
$ git status - Visualizar o status do repositório.
$ git add <nome-do-arquivo> - Adiciona um ou mais arquivos para iram para o próximo commit.
$ git restore --staged <nome-do-arquivo> - Remove o arquivo para ir para o próximo commit.
$ git restore <nome-do-arquivo> - Descarta as alterações feitas no arquivos.
$ git commit -m "<mensagem-do-commit>" - Cria um commit.
$ git branch - Lista as branchs criadas.
$ git branch <nome-da-branch> - Cria uma nova branch.
$ git checkout <nome-da-branch> - Muda de branch.
$ git branch -d <nome-da-branch> - Deleta uma branch que já fez o marge.
$ git branch -D <nome-da-branch> - Deleta uma branch que não fez o marge.
$ git merge <nome-da-branch> - Faz o merge da branch atual com a indicada.

Estrutura de Dados - Parte 1

Lucas — Mon, 13 Nov 2023 22:15:54 +0000

Introdução

Nessa primeira parte vamos falar sobre o que é uma estrutura de dados, para que serve e sobre alguns dos tipos de estrutura de dados, array, linked list, stack e queue. Na segunda parte vou falar sobre hash table, graph e tree.

O que é uma estrutura de dados

Uma estrutura de dados é a forma de como organizamos os dados para que possamos guardá-los, acessá-los e modificá-los com frequência e eficiência.

Principais estrutura de dados

Array
Linked List
Stack
Queue
Hash Table
Graph
Tree

Array

O array é um tipo de estrutura de dados básica que temos já implementado na maioria das linguagens de programação. Sua principal característica é que seu tamanho é fixo, não podemos aumentar e nem diminuir seu tamanho e o tipo de dado dos valores armazenados devem ser todos iguais. Para acessar algum valor armazenado utilizamos índices que sempre começa com 0.

Arrays são armazenados de forma contígua na memória, isso explica o fato de que não podemos aumentar ou diminuir o seu tamanho, pois caso aumentarmos o seu tamanho não saberemos se vamos conseguir usar o próximo local de memória gratuitamente.

Exemplo de um array com 1 elemento.

Exemplo de um array com 5 elementos.

Linked List

Linked list em português significa "lista ligada", basicamente esta estrutura de dados é uma lista onde cada elemento aponta para o próximo elemento e também pode apontar para o elemento anterior, isso significa que, diferente de arrays, os dados são armazenados de forma não contígua na memória, permitindo que modifiquemos o tamanho da lista.

Cada elemento pode ser chamado de node este node contem um atributo data para armazenar o valor e outro atributo para armazenar o endereço do próximo node chamado next e/ou do node anterior prev. Além disso temos também um atributo chamado head este é responsável por armazenar uma referência para o primeiro node da lista.

Singly Linked List

Em uma singly linked list, cada node possuí dois atributos, um deles é o valor que queremos armazenar na lista e o outro atributo é a referência ao próximo node da lista.

Em uma representação gráfica ele se parece com isso:

Aqui está um exemplo de uma singly linked list, com letras de 'A' até 'E' (poderia ser uma lista de compras, uma lista de livros, etc. Foi colocado letras para facilitar o exemplo). Nesse tipo de linked list o último node aponta para null, pois não tem nenhum outro valor após ele.

Implementação

Principais métodos:

add(data) - Para adicionar um elemento.
remove(data) - Para remover um elemento.
get(data) - Retorna true ou false caso encontre ou não o elemento.

/*
    Exemplo totalmente manual, o certo é
    criar os métodos básicos para que
    tudo fique dinâmico.
*/
public class SinglyLinkedList {
    public Node head;

    public static class Node {
        public String data;
        public Node next;
    }

    public static void main(String[] args) {
        // Crio os nodes.
        Node node1 = new Node("a");
        Node node2 = new Node("b");
        Node node3 = new Node("c");

        // Coloco eles em ordem.
        node1.next = node2;
        node2.next = node3;
        node3.next = null;

        // Crio a lista e adiciono o primeiro elemento no head.
        SinglyLinkedList list = new SinglyLinkedList();
        list.head = node1;
    }
}

Circular Singly Linked List

Este tipo de linked list é basicamente uma singly linked list só que com uma diferença, o último node em vez de apontar para null, ele aponta para o primeiro elemento da lista, por isso o nome "circular".

Implementação

Principais métodos:

add(data) - Para adicionar um elemento.
remove(data) - Para remover um elemento.
get(data) - Retorna true ou false caso encontre ou não o elemento.

/*
    Exemplo totalmente manual, o certo é
    criar os métodos básicos para que
    tudo fique dinâmico.
*/
public class CircularSinglyLinkedList {
    public Node head;

    public static class Node {
        public String data;
        public Node next;
    }

    public static void main(String[] args) {
        // Crio os nodes.
        Node node1 = new Node("a");
        Node node2 = new Node("b");
        Node node3 = new Node("c");

        // Coloco eles em ordem.
        node1.next = node2;
        node2.next = node3;
        node3.next = node1; // Note que este último node aponta para o primeiro.

        // Crio a lista e adiciono o primeiro elemento no head.
        CircularSinglyLinkedList list = new CircularSinglyLinkedList();
        list.head = node1;
    }
}

Doubly Linked List

Nesse tipo de linked list além de termos um campo next que aponta para o próximo node, também temos um campo prev que aponta para o node anterior. O último node aponta para null como próximo node e o primeiro node da lista aponta para null como node anterior.

Exemplo do node de uma doubly linked list:

Exemplo de uma doubly linked list com os elementos:

Implementação

Principais métodos:

add(data) - Para adicionar um elemento.
remove(data) - Para remover um elemento.
get(data) - Retorna true ou false caso encontre ou não o elemento.

/*
    Exemplo totalmente manual, o certo é
    criar os métodos básicos para que
    tudo fique dinâmico.
*/
public class DoublyLinkedList {
    public Node head;

    public static class Node {
        public String data;
        public Node prev;
        public Node next;
    }

    public static void main(String[] args) {
        // Crio os nodes.
        Node node1 = new Node("a");
        Node node2 = new Node("b");
        Node node3 = new Node("c");

        // Coloco eles em ordem.
        node1.prev = null;
        node1.next = node2;

        node2.prev = node1;
        node2.next = node3;

        node3.prev = node2;
        node3.next = null;

        // Crio a lista e adiciono o primeiro elemento no head.
        DoublyLinkedList list = new DoublyLinkedList();
        list.head = node1;
    }
}

Circular Doubly Linked List

Aqui o funcionamento é como a circular singly linked list, mas como estamos falando de um circular doubly linked list vamos ter o campo prev. O primeiro elemento aponta para o último elemento da lista no campo prev e o último elemento da lista aponta para o primeiro elemento de lista no campo next.

Implementação

Principais métodos:

add(data) - Para adicionar um elemento.
remove(data) - Para remover um elemento.
get(data) - Retorna true ou false caso encontre ou não o elemento.

/*
    Exemplo totalmente manual, o certo é
    criar os métodos básicos para que
    tudo fique dinâmico.
*/
public class CircularDoublyLinkedList {
    public Node head;

    public static class Node {
        public String data;
        public Node next;
    }

    public static void main(String[] args) {
        // Crio os nodes.
        Node node1 = new Node("a");
        Node node2 = new Node("b");
        Node node3 = new Node("c");

        // Coloco eles em ordem.
        node1.prev = node3; // Note que este primeiro node aponta (prev) para o último.
        node1.next = node2;

        node2.prev = node1;
        node2.next = node3;

        node3.prev = node2;
        node3.next = node1; // Note que este último node aponta (next) para o primeiro.

        // Crio a lista e adiciono o primeiro elemento no head.
        CircularDoublyLinkedList list = new CircularDoublyLinkedList();
        list.head = node1;
    }
}

Stack

Stack em português significa "pilha", imagine essa estrutura de dados como uma pilha de livros ou como uma pilha de pratos. Essa Estrutura de Dados tem um princípio chamado de LIFO (Last In First Out/Último a Entrar Primeiro a Sair).

Vamos com um exemplo simples, imagine que estamos lavando pratos e a medida que os pratos são lavados vamos empilhando eles, quando terminamos temos que guardá-los e aqui o princípio LIFO entra em ação, o último prato empilhado será o primeiro prato a sair.

Implementação

Principais métodos:

push(data) - Para adicionar um elemento no topo.
pop() - Para remover o elemento do top.
isEmpty() - Para verificar se a stack está vazia.
peek() - Retorna o elemento do topo da stack.

O funcionamento de uma Stack é da seguinte maneira:

Para implementar um Stack podemos usar dois tipos de abordagens em relação à forma de armazenamento dos dados, a primeira é utilizando um node como em uma linked list para armazenar os dados com os ponteiros para os próximos elementos, a segunda forma é utilizando um array, tudo depende de como a Stack irá funcionar, caso ela precise mudar de tamanho a abordagem com node vai funcionar melhor, caso não mude de tamanho, utilizando array vai funcionar muito bem.

Um ponto importante é que caso utilize a abordagem utilizando node em vez de termos um atributo head como em uma linked list que aponta para o primeiro elemento da lista, vamos ter um chamado top que irá apontar para o último elemento adicionado na pilha.

Aqui está um exemplo de uma implementação utilizando node com seu funcionamento totalmente manual:

/*
    Exemplo totalmente manual, o certo é
    criar os métodos básicos para que
    tudo fique dinâmico.
*/
public class Stack {
    public Node top;

    public static class Node {
        public String data;
        public String next;
    }

    public static void main(String[] args) {
        // Crio 3 nodes.
        Node node1 = new Node("a");
        Node node2 = new Node("b");
        Node node3 = new Node("c");

        // Coloco eles em ordem.
        node3.next = node2;
        node2.next = node1;
        node1.next = null;

        // Crio a stack adicionando o último node no top.
        Stack stack = new Stack();
        stack.top = node3;
    }
}

Queue

Queue em português significa "fila", você pode imaginar esta estrutura de dados como uma fila de pessoas para entrar em um show ou qualquer outra fila. Essa estrutura de dados segue princípio FIFO (First In First Out/Primeiro a Chegar Primeiro a Sair), ou seja, a primeira pessoa a entrar em uma fila será a primeira a sair dela.

Implementação

Principais métodos:

enqueue(data) - Adiciona um elemento no final da fila.
dequeue() - Remove o primeiro elemento da fila.
isEmpty() - Retorna true ou false para caso a fila esteja vazia ou não.

O funcionamento de uma queue é da seguinte maneira:

Para implementar uma queue podemos usar duas abordagens para a foram de armazenamento dos dados, uma utilizando node para os elementos assim como em uma linked list ou podemos fazer a implementação utilizando array. Caso sua queue mude de tamanho pode ser mais interessante implementar utilizando node, mas caso não mude de tamanho, com array vai se sair muito bem.

Para implementar utilizando nodevamos ter dois atributos importantes, o front que aponta para o primeiro elemento da fila e o rear que aponta para o último elemento da fila. Aqui está um exemplo:

/*
    Exemplo totalmente manual, o certo é
    criar os métodos básicos para que
    tudo fique dinâmico.
*/
public class Queue {
    public Node front;
    public Node rear;

    public static class Node {
        public String data;
        public Node prev;
    }

    public static void main(String[] args) {
        // Crio 3 nodes.
        Node node1 = new Node("a");
        Node node2 = new Node("b");
        Node node3 = new Node("c");

        // Coloco eles em ordem.
        node1.prev = node2;
        node2.prev = node3;
        node3.prev = null;

        // Crio a stack.
        Queue queue = new Queue();
        queue.front = node1; // Adiciono o primeiro node no front.
        queue.rear = node3; // Adiciono o último node no front.
    }
}

Conclusão

Nesse artigo vimos o que são estrutura de dados e alguns dos principais tipos, um ponto importante é que as implementações estão totalmente de forma manual, isto é, temos que criar cada node (nos tipos de precisam) e dependendo da quantidade de dados isso se torna inviável. O correto é criar métodos que vão automatizar todo o processo da criação da estrutura de dados e métodos para adicionar, remover, alterar, etc.