DEV Community: Gustavo Aguiar

Como utilizar o Makefile

Gustavo Aguiar — Sun, 19 Dec 2021 13:09:58 +0000

Se você nunca utilizou Makefile, este artigo vai te ajudar a ter uma noção básica de como criar suas primeiras tarefas e como utilizar.

O que é o makefile?

O Makefile é um arquivo que pode conter varias tarefas (comandos/atalhos) e para executar essas tarefas é utilizado a ferramenta make do GNU.

O make é uma ferramenta responsável por controlar a geração de executáveis.

Eu vou demonstrar alguns exemplos de uso, mas primeiro é necessário que seja criado um arquivo com o nome Makefile

Depois de criado o arquivo você pode copiar e colar esse trecho abaixo

olar:
   @echo "Olar Gustavo"

Essa tarefa que se chama olar vai ser responsável por imprimir Olar Gustavo

Para executar a tarefa, certifique-se que esteja na pasta que foi criado o arquivo Makefile e depois execute no terminal de preferência o comando: make olar

O resultado é:

Olar Gustavo

Uma observação o @ é para esconder o comando de saida, caso não coloque o resultado seria assim:

echo "Olar Gustavo"
Olar Gustavo

Você pode também passar parâmetros

olar:
   @echo "Olar $(name)"

Para executar o comando: make olar name="Gustavo Aguiar"

Você pode também executar várias tarefas ao mesmo tempo

test:
   @go mod vendor
   @go test ./...

Você pode criar comandos para construir sua aplicação e rodar projetos

start: build run ## Inicia a criação da aplicação
build: 
    @echo "Building app..."
    @docker build . -t app
run:
   @echo "Running app..."
   @docker run --rm -it app

Detalhes a mais

Agora vamos criar um comando chamado help

help:
    @grep -E '^[0-9a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | grep ^help -v | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-22s\033[0m %s\n", $$1, $$2}'

Esse comando tem como objetivo imprimir todos os atalhos que estão criados dentro do Makefile, mas para imprimir deve colocar um comentário na frente do comando, por exemplo:

olar: ## Comando responsável por imprimir o nome, Olar {valor}
        @echo "Olar $(name)"

No começo do arquivo, coloque o comando .PHONY, ele será
responsável por indicar para o Makefile que o comando help não é um arquivo, porque por padrão o make vai tentar executar o help como se fosse um arquivo.

.PHONY: help

Comando para imprimir o nome do projeto

define TITLE_ART

  ____  _               _____           _                   
 / __ \| |             / ____|         | |                  
| |  | | | __ _ _ __  | |  __ _   _ ___| |_ __ ___   _____  
| |  | | |/ _` | '__| | | |_ | | | / __| __/ _` \ \ / / _ \ 
| |__| | | (_| | |    | |__| | |_| \__ \ || (_| |\ V / (_) |
 \____/|_|\__,_|_|     \_____|\__,_|___/\__\__,_| \_/ \___/ 

endef
export TITLE_ART

welcome:
    @echo "$$TITLE_ART"

Gerador de títulos:

https://www.kammerl.de/ascii/AsciiSignature.php

Conclusão

Eu demonstrei exemplos simples, mas que podem facilitar o dia a dia de qualquer desenvolvedor, como evitar ficar escrevendo comandos extensos e até mesmo utilizar como uma documentação de instruções de como rodar o projeto.

Espero que essa leitura tenha sido útil!

Documentação do Make:

https://www.gnu.org/software/make/
https://www.gnu.org/software/make/manual/make.html

Introdução ao TypeScript

Gustavo Aguiar — Fri, 21 May 2021 13:21:57 +0000

O que é o TypeScript?

TypeScript é um superconjunto (superset) que tem como um dos objetivos fazer o JavaScript ser tipado, desta forma facilitando o desenvolvimento, refatorações de código e correções de bugs.

Como utilizar TypeScript?

Para utilizar o TypeScript é necessário instalá-lo usando npm:

npm install -g typescript

Depois de instalar, é necessário criar um arquivo com a extensão .ts

Exemplo: hello-world.ts

let languague = 'Javascript'
languague = 9;

O código acima é ES6. Agora vamos precisar compilá-lo usando o compilador tsc:

tsc hello-world

Vamos ter o seguinte "erro":

hello-world.ts:2:1 - error TS2322: Type 'number' is not assignable to type 'string'.
2 languague = 9
Found 1 error.

Mesmo com esse alerta gerado, na pasta no qual criamos o arquivo, veremos que foi gerado um arquivo
hello-world.js com o conteúdo

var languague = 'JavaScript';
languague = 9;

O código gerado é ES6 mas mesmo com o alerta de erro, ele não impede que o copilador gere código JavaScript. Através disso já podemos obter um código JavaScript com menos chances de ter erros ou bugs.

Inferência de tipo

É muito comum ver código como este quando trabalhamos com TypeScript

Exemplo de uso:

let age: number = 20;
let existsFlag: boolean = true;
let language: string = 'JavaScript';

É possível atribuir um tipo a uma variável. No entanto o código anterior "pode ser verboso". O TypeScript tem inferência de tipos, o que significa que ele verificará e aplicará um tipo a uma variável automaticamente, com base no valor atribuído a ela.

Exemplo de uso:

let age = 20; // number
let existsFlag = true; // boolean
let language = 'Javascript'; // string

Mas em casos que apenas declaramos uma variável e não a inicializarmos com o valor, é recomendável atribuir-lhe um tipo.

Exemplo de uso:

let favoriteLanguage: string;
let langs = ['Golang', 'JavaScript', 'Python'];
let favoriteLanguage = langs[0]

Se não especificarmos um tipo para uma variável, ela será automaticamente tipada com any o que significa que poderá receber qualquer valor, como ocorre no JavaScript.

Interfaces

Interface é um contrato que descreve os atributos e os métodos que um objeto deve ter.

Fazendo uma analogia com o ECMAScript:

ECMAScript seria a interface para a linguagem JavaScript, ela diz ao JavaScript quais funcionalidades ela deve ter, mas cada navegador pode ter uma implementação diferente.

Exemplo do uso de interface:

interface Person {
    name: string
    age: number
}

function printName(person: Person) {
    console.log(person.name)
}

Isso Permite que editores como o VSCODE tenham preenchimento automático com o IntelliSense

Exemplo do IntelliSense no VSCODE:

Agora vamos testar a função printName

const gustavo = { name: 'Gustavo', age: 29 };
const maria = { name: 'Maria', age: 30, phone: '123-45678' };
printName(gustavo);
printName(maria);

O código não terá nenhum erro de compilação. A variável gustavo tem name e age conforme o esperado. A variável maria tem name e age, mas também tem phone.

O erro não ocorre porque o TypeScript trabalha com um conceito chamado Duck typing (tipagem pato). Se algo se parece com um pato, nada como um pato, faz quack como um pato, então deve ser um pato! nesse caso, se tem name e tem age então deve ser um Person.

Genéricos (Generics)

Generic é utilizado em casos que você precisa ter uma função que possa passar um valor de qualquer tipo.

Exemplo de uso do Generic:

function printLog<T>(value: T) :T {
    return value;
}
console.log(printLog<Number>(10)) // 10
console.log(printLog<String>('Gustavo')) // Gustavo

Conclusão

Este post tem a ideia de mostrar uma visão introdutória sobre o TypeScript, com o seu uso você pode evitar runtime errors, bugs em produção e etc...

Caso deseje explorar mais sobre o assunto pode acessar a documentação do TypeScript
https://www.typescriptlang.org/docs/