Escrito por: Daniel Deutsch

Em um projeto de código aberto para o qual comecei a contribuir, o conceito de "arquitetura limpa" me foi apresentando.

No começo, era demais para se entender. Após um pouco de leitura, no entanto, passou a fazer sentido. Acho que será de ajuda a outros se eu escrever meus aprendizados.

Tabela de conteúdos

• Representações visuais
• O conceito – apresentado em tópicos
• Código de exemplo
• Recursos

Representações visuais

Eu acho que sempre é bom começar com um pouco de visualização.

Aqui estão as imagens mais comuns deste conceito.

O conceito — apresentado em tópicos

Estendido da fonte e créditos: Mattia Battiston, sob a licença Creative Commons BY 4.0

O valor que pode entregar

• Uma estratégia de teste eficaz que segue a pirâmide de testes
• Frameworks são isolados em módulos individuais. Quando mudarmos de ideia, só precisamos mudar uma coisa em um lugar. A aplicação tem casos de uso em vez de estar vinculada a um sistema de CRUD
• Arquitetura gritante, ou seja, ela grita seu uso pretendido. Ao olhar para a estrutura, você tem uma ideia do que a aplicação faz, em vez de ver detalhes técnicos
• Toda a lógica de negócios está em um caso de uso. Por isso, é fácil de encontrar e não é duplicada em nenhum outro lugar
• É difícil fazer a coisa errada, porque os módulos impõem dependências de compilação. Se você tentar usar algo que não deveria, o app não compilará
• Sempre pronta para ser implantada, deixando as conexões do objeto para o final. Também é possível usar flags de recursos para obter todos os benefícios da integração contínua
• Vários trabalhos em histórias para que pares diferentes possam trabalhar facilmente na mesma história ao mesmo tempo para concluí-la mais rapidamente
• Um bom monolito com casos de uso claros que você pode dividir em microsserviços mais tarde, depois de aprender mais sobre eles

Entidades

• Representam os objetos do domínio
• Aplicam somente lógica que é aplicável em geral à entidade inteira (exemplo: validar o formato do nome de um host)
• Objetos simples: sem frameworks, sem anotações

Casos de uso

• Representam suas ações de negócio: é o que você pode fazer com a aplicação. Espere um caso de uso para cada ação de negócios
• Lógica de negócios pura, código simples (exceto talvez algumas bibliotecas de utilitários)
• O caso de uso não sabe quem o acionou e como os resultados serão apresentados (por exemplo, pode ser em uma página da web, retornado como JSON ou simplesmente registrado e assim por diante).
• Lançam exceções de negócio

Interfaces/adaptadores

• Recuperam e armazenam dados de e para várias fontes (banco de dados, dispositivos de rede, sistema de arquivos, terceiros e assim por diante).
• Definem interfaces para os dados que eles precisam para aplicar alguma lógica. Um ou mais provedores de dados implementarão a interface, mas o caso de uso não sabe de onde vêm os dados
• Implementam as interfaces definidas pelo caso de uso
• Existem maneiras de interagir com a aplicação e, geralmente, envolvem um mecanismo de entrega (por exemplo, APIs REST, trabalhos agendados, GUI, outros sistemas)
• Acionam um caso de uso e convertem o resultado em um formato adequado para o mecanismo de entrega
• São o controller em um MVC

Interfaces externas

• Use qualquer estrutura que seja mais apropriada (elas serão isoladas aqui, de qualquer maneira)

Código de exemplo

Veja este exemplo no GitHub.

Em primeiro lugar, é importante entender que a arquitetura limpa é um conjunto de princípios de organização. Portanto, tudo está aberto a ajustes pessoais, desde que as ideias centrais sejam mantidas intactas. O repositório vinculado é um fork do projeto original que trouxe essa ideia de design de arquitetura para mim. Sinta-se à vontade para conferir o projeto original também, pois ele reflete outras melhorias.

O diretório webminer é estruturado nas camadas básicas:

1. entities
2. use_cases
3. interfaces_adapters
4. external_interfaces

Deve refletir a abordagem básica para o padrão de projeto.

• Começando em entities, você pode ver que o modelo central deste projeto é o arxiv_document
• A próxima pasta, use_cases, mostra nosso caso de uso – especificamente, requisitar a página arxiv
• Depois disso, passamos pela pasta interface_adapters que providencia adaptadores para processos de requisição em uma aplicação REST ou para serialização
• A última camada é a external_interfaces. Aqui é onde usamos o servidor flask para implementar a funcionalidade REST

Todas essas camadas dependem das camadas centrais, mas não o contrário.

Uma observação importante: isso não está implementado de modo totalmente correto no repositório.

Por quê? Porque os casos de uso são realmente diferentes. Na realidade, o principal caso de uso é fornecer os dados estruturados. Outro caso de uso é obter os dados da página arxiv.

Você notou esse erro na arquitetura? Se notou, parabéns! Você não apenas veio a este artigo com bastante curiosidade, mas, provavelmente, entendeu os princípios bem o suficiente para construir seu próprio caso e aplicar os conceitos na realidade!

Você concorda? Se não, por quê? Obrigado pela leitura do meu artigo!

Recursos

Aqui estão alguns artigos que considerei úteis para entender o conceito de "arquitetura limpa" (textos em inglês):

• https://8thlight.com/blog/uncle-bob/2012/08/13/the-clean-architecture.html
• https://www.codingblocks.net/podcast/clean-architecture-make-your-architecture-scream/
• https://github.com/mattia-battiston/clean-architecture-example
• https://medium.com/@tiagoflores_23976/how-choose-the-appropriate-ios-architecture-mvc-mvp-mvvm-viper-or-clean-architecture-2d1e9b87d48
• https://de.slideshare.net/HimanshuDudhat1/mvp-clean-architecture
• https://softwareengineering.stackexchange.com/questions/336677/what-is-the-difference-between-mvp-and-clean-architecture
• https://engineering.21buttons.com/clean-architecture-in-django-d326a4ab86a9
• https://gist.github.com/ygrenzinger/14812a56b9221c9feca0b3621518635b
• https://medium.freecodecamp.org/how-to-write-robust-apps-consistently-with-the-clean-architecture-9bdca93e17b
• https://marconijr.com/posts/clean-architecture-practice/

Daniel Deutsch é mestrando em direito comercial, trabalha como engenheiro de software e é organizador de eventos relacionados à tecnologia em Viena. Seus esforços atuais de aprendizado pessoal se concentram em aprendizagem de máquina.

Siga o autor em suas redes sociais:

• LinkedIn
• Github
• Medium
• Twitter
• Steemit
• Hashnode

Este artigo é baseado no desafio de algoritmos "Encontre a maior palavra em uma string", do FreeCodeCamp.

Neste algoritmo, queremos verificar cada palavra e contar quantas letras há em cada uma. Depois disso, comparamos as contagens para determinar qual palavra tem mais caracteres e retornamos o comprimento da maior palavra.

Neste artigo, vou explicar três abordagens. A primeira usará um laço FOR, a segunda usará o método sort() e a terceira usará o método reduce().

Desafio de algoritmos

Retorne o comprimento da maior palavra na frase selecionada.

Sua resposta deve ser um número.

Casos de testes fornecidos

• findLongestWord("The quick brown fox jumped over the lazy dog") deve retornar um número
• findLongestWord("The quick brown fox jumped over the lazy dog") deve retornar 6
• findLongestWord("May the force be with you") deve retornar 5
• findLongestWord("Google do a barrel roll") deve retornar 6
• findLongestWord("What is the average airspeed velocity of an unladen swallow") deve retornar 8
• findLongestWord("What if we try a super-long word such as otorhinolaryngology") deve retornar 19

function findLongestWord(str) {
  return str.length;
}
findLongestWord("The quick brown fox jumped over the lazy dog");

1. Encontrar a maior palavra com um laço FOR

Para esta solução, usaremos o método String.prototype.split()

O método split() divide um objeto de string em um array de strings, separando-as em substrings.

Vamos precisar adicionar um espaço em branco entre os parênteses do método split(),

var strSplit = "The quick brown fox jumped over the lazy dog".split(' ');

que gerará como saída um array de palavras separadas:

var strSplit = ["The", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog"];

Se você não adicionar o espaço entre os parênteses, você obterá essa saída:

var strSplit = 
["T", "h", "e", " ", "q", "u", "i", "c", "k", " ", "b", "r", "o", "w", "n", " ", "f", "o", "x", " ", "j", "u", "m", "p", "e", "d", " ", "o", "v", "e", "r", " ", "t", "h", "e", " ", "l", "a", "z", "y", " ", "d", "o", "g"];

function findLongestWord(str) {
  // Passo 1. Dividir a string em um array de strings
  var strSplit = str.split(' ');
  // var strSplit = "The quick brown fox jumped over the lazy dog".split(' ');
  // var strSplit = ["The", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog"];
	
  // Passo 2. Iniciar uma variável que contenha o tamanho da maior palavra
  var longestWord = 0;

  // Passo 3. Criar o laço FOR
  for(var i = 0; i < strSplit.length; i++){
    if(strSplit[i].length > longestWord){ // Se strSplit[i].length for maior do que a palavra com a qual ela se compara...
	longestWord = strSplit[i].length; // ...longestWord recebe esse novo valor
     }
  }
  /* Aqui, strSplit.length = 9
     Para cada iteração: i = ?   i < strSplit.length?   i++  if(strSplit[i].length > longestWord)?   longestWord = strSplit[i].length
     1a iteração:        0             sim             1   if("The".length > 0)? => if(3 > 0)?     longestWord = 3
     2a iteração:        1             sim             2   if("quick".length > 3)? => if(5 > 3)?   longestWord = 5   
     3a iteração:        2             sim             3   if("brown".length > 5)? => if(5 > 5)?   longestWord = 5   
     4a iteração:        3             sim             4   if("fox".length > 5)? => if(3 > 5)?     longestWord = 5  
     5a iteração:        4             sim             5   if("jumped".length > 5)? => if(6 > 5)?  longestWord = 6 
     6a iteração:        5             sim             6   if("over".length > 6)? => if(4 > 6)?    longestWord = 6 
     7a iteração:        6             sim             7   if("the".length > 6)? => if(3 > 6)?     longestWord = 6
     8a iteração:        7             sim             8   if("lazy".length > 6)? => if(4 > 6)?    longestWord = 6 
     9a iteração:        8             sim             9   if("dog".length > 6)? => if(3 > 6)?     longestWord = 6 
     10a iteração:       9             não               
     Fim do laço FOR*/

  //Passo 4. Retornar o tamanho da maior palavra
  return longestWord; // 6
}

findLongestWord("The quick brown fox jumped over the lazy dog");

Sem comentários:

function findLongestWord(str) {
  var strSplit = str.split(' ');
  var longestWord = 0;
  for(var i = 0; i < strSplit.length; i++){
    if(strSplit[i].length > longestWord){
	longestWord = strSplit[i].length;
     }
  }
  return longestWord;
}
findLongestWord("The quick brown fox jumped over the lazy dog");

2. Encontrar a maior palavra com o método sort()

Para esta solução, usaremos o método Array.prototype.sort() para ordenar o array por algum critério e retornaremos o tamanho do primeiro elemento do array.

• O método sort() orderna os elementos em um array na hora e, então, o retorna.

No nosso caso, se apenas ordenarmos o array:

var sortArray = ["The", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog"].sort();

a saída será:

var sortArray = ["The", "brown", "dog", "fox", "jumped", "lazy", "over", "quick", "the"];

Em Unicode, números vêm antes de letras maiúsculas, e essas últimas vêm antes das letras minúsculas.

Precisamos de algum critério para ordenar os elementos:

[].sort(function(firstElement, secondElement) {     return secondElement.length — firstElement.length; })

Esse critério será comparar o comprimento do segundo elemento com o do primeiro.

function findLongestWord(str) {
  // Passo 1. Dividir a string em um array de strings
  var strSplit = str.split(' ');
  // var strSplit = "The quick brown fox jumped over the lazy dog".split(' ');
  // var strSplit = ["The", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog"];
  
  // Passo 2. Ordenar os elementos no array
  var longestWord = strSplit.sort(function(a, b) { 
    return b.length - a.length;
  });
  /* Processo de ordenação
    a           b            b.length     a.length     var longestWord
  "The"      "quick"            5            3         ["quick", "The"]
  "quick"    "brown"            5            5         ["quick", "brown", "The"]  
  "brown"    "fox"              3            5         ["quick", "brown", "The", "fox"]
  "fox"      "jumped"           6            3         ["jumped", quick", "brown", "The", "fox"]
  "jumped"   "over"             4            6         ["jumped", quick", "brown", "over", "The", "fox"]
  "over"     "the"              3            4         ["jumped", quick", "brown", "over", "The", "fox", "the"]
  "the"      "lazy"             4            3         ["jumped", quick", "brown", "over", "lazy", "The", "fox", "the"]
  "lazy"     "dog"              3            4         ["jumped", quick", "brown", "over", "lazy", "The", "fox", "the", "dog"]
  */
  
  // Step 3. Retornar o tamanho do rprimeiro elemento do array
  return longestWord[0].length; // var longestWord = ["jumped", "quick", "brown", "over", "lazy", "The", "fox", "the", "dog"];
                                // longestWord[0]="jumped" => jumped".length => 6
}

findLongestWord("The quick brown fox jumped over the lazy dog");

Sem comentários:

function findLongestWord(str) {
  var longestWord = str.split(' ').sort(function(a, b) { return b.length - a.length; });
  return longestWord[0].length;
}
findLongestWord("The quick brown fox jumped over the lazy dog");

3. Encontrar a maior palavra com o método reduce()

Para esta solução, usaremos o método Array.prototype.reduce().

• O método reduce() aplica a função com um acumulador e cada valor do array (da esquerda para a direita) para reduzi-lo a um único valor.

reduce() executa uma função de callback uma vez para cada elemento do array.

Você pode providenciar um valor inicial como o segundo parâmetro a reduzir. Aqui, adicionaremos uma string vazia "".

[].reduce(function(previousValue, currentValue) {...}, "");

function findLongestWord(str) {
  // Passo 1. Dividir a string em um array de strings
  var strSplit = str.split(' ');
  // var strSplit = "The quick brown fox jumped over the lazy dog".split(' ');
  // var strSplit = ["The", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog"];

  // Step 2. Usar o método reduce
  var longestWord = strSplit.reduce(function(longest, currentWord) {
    if(currentWord.length > longest.length)
       return currentWord;
    else
       return longest;
  }, "");
  
  /* Processo de reduce
  currentWord      longest       currentWord.length     longest.length    if(currentWord.length > longest.length)?   var longestWord
  "The"             ""                  3                     0                              yes                          "The"
  "quick"           "The"               5                     3                              yes                         "quick"
  "brown"           "quick"             5                     5                              no                          "quick"
  "fox"             "quick"             3                     5                              no                          "quick"
  "jumped"          "quick"             6                     5                              yes                         "jumped"
  "over"            "jumped"            4                     6                              no                          "jumped"
  "the"             "jumped"            3                     6                              no                          "jumped"
  "lazy"            "jumped"            4                     6                              no                          "jumped"
  "dog"             "jumped"            3                     6                              no                          "jumped"
  */
  
  // Passo 3. Retornar o tamanho de longestWord
  return longestWord.length; // var longestWord = "jumped" 
                             // longestWord.length => "jumped".length => 6
}

findLongestWord("The quick brown fox jumped over the lazy dog");

Sem comentários:

function findLongestWord(str) {
  var longestWord = str.split(' ').reduce(function(longest, currentWord) {
    return currentWord.length > longest.length ? currentWord : longest;
  }, "");
  return longestWord.length;
}
findLongestWord("The quick brown fox jumped over the lazy dog");

Espero que este artigo tenha sido útil. Ele é parte da minha série de artigos "Como resolver os desafios de algoritmos do freeCodeCamp", onde eu proponho diversas soluções e explico passo a passo o que acontece por baixo dos panos.

Alguns outros artigos desta série:

Três maneiras de repetir uma string em JavaScript (ainda não traduzido)

Duas maneiras de confirmar o fim de uma string em JavaScript (ainda não traduzido)

Três maneiras de colocar a primeira letra de todas as palavras de uma string em maiúsculas em JavaScript (ainda não traduzido)

Três maneiras de inverter uma string em JavaScript

Três maneiras de encontrar o fatorial de um número em JavaScript

Duas maneiras de conferir palíndromos em JavaScript

Três maneiras de encontrar o maior número em um array em JavaScript

Você pode seguir a autora no Medium, no Twitter, no Github e no LinkedIn 😜

‪#‎StayCurious‬, ‪#‎KeepOnHacking‬ e ‪#‎MakeItHappen‬!

Recursos

• split() method — MDN
• sort() method — MDN
• reduce() — MDN
• String.length — MDN
• for — MDN

É fácil dizer a um amigo onde encontrá-lo caso você esteja em um local com um endereço de verdade. Porém, se vocês estiverem tentando se encontrar em um parque enorme, ou se você está tentando dar a ele direções para um local supersecreto de um acampamento naquela estrada de terra sem nome, como fazer?

Tem um jeito mais fácil do que dizer "virar à esquerda na vaca, após a árvore grande": usando um marcador (em inglês, pin) no Google Maps.

O que isso significa?

Quando você deixa um marcador na sua localização exata, você está dando ao GPS as coordenadas exatas daquele lugar.

Assim, quando você o compartilhar com seu amigo, você estará dizendo a ele exatamente onde você está – e não o logradouro mais próximo (que pode estar a metros de distância).

Como se faz, então?

Vamos seguir o passo a passo para adicionar (e remover) um marcador no Google Maps, tanto no seu PC, quanto no seu telefone.

Como deixar um marcador no PC:

Passo 1: Abre seu navegador favorito e vá para o Google Maps.

Passo 2: Vá para uma localização mais específica.

No campo "Pesquisar no Google Maps", insira uma localização mais específica para reduzir seu escopo de procura.

Agora, você está mais perto. Porém, ainda não é perto o suficiente. Barton Creek Greenbelt, em Austin, é um lugar ligeiramente vasto. Então, dê um pouco de zoom.

Passo 3: Ponha seu marcador

Quando tiver dado zoom o suficiente, selecione a localização que você quer marcar. Clique com o botão direito do mouse e selecione "Direções até aqui" no menu que aparecer:

Será, então, solicitado que você ponha um ponto de partida (de onde seu amigo está vindo?) e serão dadas instruções de direção para aquele local.

Passo 4: Compartilhe suas direções

Agora, você só precisa dizer ao seu amigo aonde ir – então, será necessário compartilhar as direções.

Clique no menu de hambúrguer (aquele com três barras horizontais) no canto superior esquerdo, e selecione "Compartilhar ou incorporar mapas" da lista suspensa que será aberta.

Você terá a opção de compartilhar por alguma rede social ou, se preferir mantê-lo privado, de copiar o link e enviá-lo diretamente a seu amigo:

Pronto! Seu amigo terá uma chance muito maior de encontrar você agora.

Como remover o marcador

Se você quiser remover o marcador do Google Maps, simplesmente clique com o botão direito nele e selecione "Remover este destino." Pronto! Ele se foi.

Como pôr um marcador com seu telefone.

É muito fácil adicionar um marcador com seu iPhone. Basta abrir a aplicação do Google Maps e navegar até a área geral onde você está/quer estar.

Passo 1: Encontre seu lugar

Dê um zoom, como fizemos antes, até que você possa ver o lugar que você quer marcar. Depois, basta apertar e segurar até o pequeno marcador vermelho aparecer:

Quando tiver posicionado o marcador, você verá algumas opções. Você pode escolher:

• Obter direções de um local específico para aquele lugar
• Nomear o lugar para usar futuramente
• Compartilhar as coordenadas de GPS (por um link) por texto, e-mail etc.
• Baixar o mapa para acessá-lo quando não tiver internet

Passo 2: Compartilhe seu marcador

Você pode compartilhar seu marcador com um amigo do mesmo modo que fizemos acima. Por exemplo, você pode enviar as coordenadas/link via texto:

Você também pode obter a direção de um local para o marcador. Se você escolher esta opção, basta selecionar a guia "direções" e inserir um ponto de partida.

Viu? Bem fácil! :)

Como remover o marcador

Se você quiser remover este marcador, basta clicar no x no campo de pesquisa e ele desaparecerá.

Agora, você pode encontrar seus amigos (ou ser encontrado) a qualquer hora – mesmo se estiver no meio do nada.