{"id":720,"date":"2024-06-24T09:57:38","date_gmt":"2024-06-24T12:57:38","guid":{"rendered":"https:\/\/adrianosantostreina.com.br\/blog\/?p=720"},"modified":"2024-08-19T13:42:44","modified_gmt":"2024-08-19T16:42:44","slug":"codigo-limpo-parte-2-funcoes-pequenas","status":"publish","type":"post","link":"https:\/\/adrianosantostreina.com.br\/blog\/codigo-limpo-parte-2-funcoes-pequenas\/","title":{"rendered":"C\u00f3digo-Limpo Parte 2: Fun\u00e7\u00f5es Pequenas"},"content":{"rendered":"\n

No mundo do desenvolvimento de software, a qualidade do c\u00f3digo \u00e9 um fator determinante para a manuten\u00e7\u00e3o, evolu\u00e7\u00e3o e sucesso de um projeto. Uma das pr\u00e1ticas fundamentais para alcan\u00e7ar um c\u00f3digo-limpo \u00e9 a utiliza\u00e7\u00e3o de fun\u00e7\u00f5es pequenas e focadas. Conforme discutido por Robert C. Martin em seu livro “C\u00f3digo-Limpo”, fun\u00e7\u00f5es pequenas s\u00e3o essenciais para criar um c\u00f3digo mais leg\u00edvel, test\u00e1vel e sustent\u00e1vel. Neste artigo, vamos explorar a import\u00e2ncia das fun\u00e7\u00f5es pequenas, as vantagens de adot\u00e1-las e como implement\u00e1-las de forma eficaz.<\/p>\n\n\n\n\n\n\n\n

Por que \u00e9 importante um c\u00f3digo-limpo?<\/h4>\n\n\n\n

C\u00f3digo-limpo \u00e9 aquele que \u00e9 f\u00e1cil de ler, entender e modificar. Manter um c\u00f3digo-limpo traz v\u00e1rias vantagens, incluindo:<\/p>\n\n\n\n

    \n
  1. Legibilidade<\/strong>: Um c\u00f3digo f\u00e1cil de ler \u00e9 mais f\u00e1cil de entender, o que \u00e9 crucial para a colabora\u00e7\u00e3o entre desenvolvedores.<\/li>\n\n\n\n
  2. Manuten\u00e7\u00e3o<\/strong>: C\u00f3digo claro e bem-estruturado facilita a manuten\u00e7\u00e3o e a refatora\u00e7\u00e3o, reduzindo o tempo e esfor\u00e7o necess\u00e1rios para essas tarefas.<\/li>\n\n\n\n
  3. Colabora\u00e7\u00e3o<\/strong>: Facilita a colabora\u00e7\u00e3o entre desenvolvedores, permitindo que todos possam rapidamente entender a l\u00f3gica e o fluxo do c\u00f3digo.<\/li>\n\n\n\n
  4. Redu\u00e7\u00e3o de Erros<\/strong>: C\u00f3digo bem-organizado e leg\u00edvel \u00e9 menos propenso a erros, pois \u00e9 mais f\u00e1cil identificar e corrigir problemas.<\/li>\n<\/ol>\n\n\n\n

    Os principais pilares<\/h4>\n\n\n\n

    Os principais pilares do c\u00f3digo-limpo s\u00e3o pr\u00e1ticas e princ\u00edpios que guiam os desenvolvedores na cria\u00e7\u00e3o de c\u00f3digo de alta qualidade. Cada pilar aborda um aspecto espec\u00edfico do desenvolvimento de software, contribuindo para a cria\u00e7\u00e3o de um sistema que \u00e9 f\u00e1cil de entender, manter e evoluir. Aqui est\u00e3o os principais pilares do c\u00f3digo-limpo:<\/p>\n\n\n\n

      \n
    1. Nomes significativos<\/li>\n\n\n\n
    2. Fun\u00e7\u00f5es pequenas e focadas<\/li>\n\n\n\n
    3. Coment\u00e1rios eficientes<\/li>\n\n\n\n
    4. Formata\u00e7\u00e3o consistente<\/li>\n\n\n\n
    5. Tratamento adequado de erros<\/li>\n\n\n\n
    6. Estrutura coesa e baixo acoplamento<\/li>\n\n\n\n
    7. Testes automatizados<\/li>\n\n\n\n
    8. Refatora\u00e7\u00e3o cont\u00ednua<\/li>\n\n\n\n
    9. C\u00f3digo simples e direto<\/li>\n\n\n\n
    10. Princ\u00edpios SOLID<\/li>\n<\/ol>\n\n\n\n

      Neste artigo, focaremos no segundo pilar: Fun\u00e7\u00f5es Pequenas<\/strong>.<\/p>\n\n\n\n

      Segundo pilar: Fun\u00e7\u00f5es Pequenas e Focadas<\/h4>\n\n\n\n

      Fun\u00e7\u00f5es pequenas e focadas s\u00e3o essenciais para a legibilidade e manutenibilidade do c\u00f3digo. A ideia \u00e9 que cada fun\u00e7\u00e3o deve realizar uma \u00fanica tarefa ou ter uma \u00fanica responsabilidade, tornando-a mais f\u00e1cil de entender, testar e manter.<\/p>\n\n\n\n

      Vantagens de Fun\u00e7\u00f5es Pequenas<\/h4>\n\n\n\n
        \n
      1. Legibilidade<\/strong>: Fun\u00e7\u00f5es pequenas s\u00e3o mais f\u00e1ceis de ler e entender. Quando uma fun\u00e7\u00e3o \u00e9 curta, \u00e9 mais prov\u00e1vel que um desenvolvedor consiga entender o que ela faz rapidamente.<\/li>\n\n\n\n
      2. Manuten\u00e7\u00e3o<\/strong>: Fun\u00e7\u00f5es pequenas s\u00e3o mais f\u00e1ceis de manter. Alterar uma pequena parte do c\u00f3digo em uma fun\u00e7\u00e3o curta \u00e9 mais seguro e menos propenso a introduzir erros do que modificar uma grande fun\u00e7\u00e3o que realiza muitas tarefas.<\/li>\n\n\n\n
      3. Testabilidade<\/strong>: Fun\u00e7\u00f5es pequenas s\u00e3o mais f\u00e1ceis de testar. \u00c9 mais simples escrever testes unit\u00e1rios para fun\u00e7\u00f5es que t\u00eam uma \u00fanica responsabilidade, o que melhora a cobertura de testes e a confiabilidade do software.<\/li>\n\n\n\n
      4. Reutiliza\u00e7\u00e3o<\/strong>: Fun\u00e7\u00f5es focadas podem ser reutilizadas em diferentes partes do c\u00f3digo. Quando uma fun\u00e7\u00e3o realiza uma tarefa espec\u00edfica, ela pode ser chamada em diferentes contextos, evitando a duplica\u00e7\u00e3o de c\u00f3digo.<\/li>\n<\/ol>\n\n\n\n

        Implementa\u00e7\u00e3o de Fun\u00e7\u00f5es Pequenas e Focadas<\/h4>\n\n\n\n
          \n
        1. Identificar Responsabilidades<\/strong>: O primeiro passo \u00e9 identificar as diferentes responsabilidades dentro de uma fun\u00e7\u00e3o grande. Cada bloco de c\u00f3digo que realiza uma tarefa distinta deve ser extra\u00eddo para uma fun\u00e7\u00e3o separada.<\/li>\n\n\n\n
        2. Nomear Fun\u00e7\u00f5es de Forma Clara<\/strong>: As fun\u00e7\u00f5es devem ter nomes que descrevam claramente o que fazem. Nomes bem escolhidos aumentam a legibilidade e tornam o c\u00f3digo mais autoexplicativo.<\/li>\n\n\n\n
        3. Manter o Tamanho Ideal<\/strong>: Embora n\u00e3o haja uma regra r\u00edgida sobre o tamanho exato de uma fun\u00e7\u00e3o, um bom guia \u00e9 que a fun\u00e7\u00e3o deve caber na tela sem precisar rolar. Idealmente, uma fun\u00e7\u00e3o deve ter entre 5 e 15 linhas de c\u00f3digo.<\/li>\n\n\n\n
        4. Evitar Par\u00e2metros Excessivos<\/strong>: Fun\u00e7\u00f5es pequenas e focadas tendem a ter poucos par\u00e2metros. Se uma fun\u00e7\u00e3o precisa de muitos par\u00e2metros, isso pode ser um sinal de que ela est\u00e1 fazendo mais do que deveria e pode ser subdividida ainda mais.<\/li>\n\n\n\n
        5. Refatora\u00e7\u00e3o Cont\u00ednua<\/strong>: A cria\u00e7\u00e3o de fun\u00e7\u00f5es pequenas \u00e9 um processo cont\u00ednuo. \u00c0 medida que o c\u00f3digo evolui, novas oportunidades para extrair fun\u00e7\u00f5es menores podem surgir. Refatorar regularmente para manter fun\u00e7\u00f5es pequenas \u00e9 uma pr\u00e1tica recomendada.<\/li>\n<\/ol>\n\n\n\n
          \"\"<\/a><\/figure>\n\n\n\n

          04 exemplos em Delphi com Antes e Depois<\/strong><\/p>\n\n\n\n

            \n
          1. Processamento de Dados<\/strong><\/li>\n<\/ol>\n\n\n\n

            Antes<\/strong>: Fun\u00e7\u00f5es longas que processam dados de v\u00e1rias formas.<\/p>\n\n\n\n

            procedure TForm1.ProcessarDados;\nvar\n  Arquivo: TextFile;\n  Linha: string;\nbegin\n  if FileExists('dados.txt') then\n  begin\n    AssignFile(Arquivo, 'dados.txt');\n    Reset(Arquivo);\n    while not Eof(Arquivo) do\n    begin\n      Readln(Arquivo, Linha);\n      \/\/ Processar a linha\n      if Linha <> '' then\n      begin\n        \/\/ L\u00f3gica complexa aqui\n      end;\n    end;\n    CloseFile(Arquivo);\n  end;\nend;\n<\/pre><\/div>\n\n\n\n
            Depois<\/strong>: Fun\u00e7\u00f5es menores e focadas em tarefas espec\u00edficas.<\/p>\n\n\n\n
            procedure TForm1.ProcessarDados;\nbegin\n  if ArquivoExiste('dados.txt') then\n    ProcessarArquivo('dados.txt');\nend;\n\nfunction TForm1.ArquivoExiste(const NomeArquivo: string): Boolean;\nbegin\n  Result := FileExists(NomeArquivo);\nend;\n\nprocedure TForm1.ProcessarArquivo(const NomeArquivo: string);\nvar\n  Arquivo: TextFile;\n  Linha: string;\nbegin\n  AssignFile(Arquivo, NomeArquivo);\n  Reset(Arquivo);\n  try\n    while not Eof(Arquivo) do\n    begin\n      Readln(Arquivo, Linha);\n      ProcessarLinha(Linha);\n    end;\n  finally\n    CloseFile(Arquivo);\n  end;\nend;\n\nprocedure TForm1.ProcessarLinha(const Linha: string);\nbegin\n  if Linha <> '' then\n    ExecutarLogicaComplexa(Linha);\nend;\n\nprocedure TForm1.ExecutarLogicaComplexa(const Linha: string);\nbegin\n  \/\/ L\u00f3gica complexa aqui\nend;\n<\/pre><\/div>\n\n\n\n
            Perceba nesse primeiro exemplo, que criamos outros m\u00e9todos que possuem suas pr\u00f3prias responsabilidades. A fun\u00e7\u00e3o principal “ProcessarDados” ficou apenas com 02 linhas, diferentemente da vers\u00e3o anterior, onde fazia mais do que apenas processar os arquivos.<\/p>\n\n\n\n
              \n
            1.  C\u00e1lculo de Total<\/strong><\/li>\n<\/ol>\n\n\n\n
                \n
              1. <\/li>\n<\/ol>\n\n\n\n
                Antes<\/strong>: Fun\u00e7\u00f5es que calculam total de v\u00e1rias formas em um \u00fanico m\u00e9todo.<\/p>\n\n\n\n
                procedure TForm1.CalcularTotal;\nvar\n  i, total: Integer;\nbegin\n  total := 0;\n  for i := 0 to ContagemItens - 1 do\n    total := total + Itens[i].Valor;\n  ShowMessage('Total: ' + IntToStr(total));\nend;\n<\/pre><\/div>\n\n\n\n
                Depois<\/strong>: Fun\u00e7\u00f5es separadas para c\u00e1lculos espec\u00edficos.<\/p>\n\n\n\n
                procedure TForm1.CalcularTotal;\nvar\n  total: Integer;\nbegin\n  total := CalcularTotalDosItens;\n  ExibirTotal(total);\nend;\n\nfunction TForm1.CalcularTotalDosItens: Integer;\nvar\n  i: Integer;\nbegin\n  Result := 0;\n  for i := 0 to ContagemItens - 1 do\n    Result := Result + Itens[i].Valor;\nend;\n\nprocedure TForm1.ExibirTotal(total: Integer);\nbegin\n  ShowMessage('Total: ' + IntToStr(total));\nend;\n<\/pre><\/div>\n\n\n\n
                Tenho certeza que est\u00e1 pensando: Mas a fun\u00e7\u00e3o j\u00e1 era pequena antes. Pois bem, reduzimos ainda mais e separamos as responsabilidades.<\/p>\n\n\n\n
                  \n
                1. Conex\u00e3o com Banco de Dados<\/strong><\/li>\n<\/ol>\n\n\n\n
                  Antes<\/strong>: Fun\u00e7\u00e3o \u00fanica que lida com conex\u00e3o, consulta e processamento de resultados.<\/p>\n\n\n\n
                  procedure TForm1.ConectarEBuscarDados;\nvar\n  Conn: TADOConnection;\n  Query: TADOQuery;\n  ConnectionString: string;\nbegin\n  \/\/ Configurar a conex\u00e3o\n  Conn := TADOConnection.Create(nil);\n  try\n    ConnectionString := 'Provider=SQLOLEDB.1;Integrated Security=SSPI;Persist Security Info=False;Initial Catalog=MeuBanco;Data Source=MeuServidor';\n    Conn.ConnectionString := ConnectionString;\n    Conn.LoginPrompt := False;\n    Conn.Open;\n\n    \/\/ Configurar e executar a consulta\n    Query := TADOQuery.Create(nil);\n    try\n      Query.Connection := Conn;\n      Query.SQL.Text := 'SELECT * FROM MinhaTabela';\n      Query.Open;\n\n      \/\/ Processar os resultados\n      while not Query.Eof do\n      begin\n        \/\/ Processar cada linha de resultados\n        ShowMessage(Query.FieldByName('MeuCampo').AsString);\n        Query.Next;\n      end;\n    finally\n      Query.Free;\n    end;\n  finally\n    Conn.Free;\n  end;\nend;\n<\/pre><\/div>\n\n\n\n
                  Depois<\/strong>: Fun\u00e7\u00f5es separadas para cada responsabilidade.<\/p>\n\n\n\n
                  procedure TForm1.ConectarEBuscarDados;\nvar\n  Conn: TADOConnection;\nbegin\n  Conn := ConectarAoBancoDeDados;\n  try\n    BuscarEDisplayDados(Conn);\n  finally\n    Conn.Free;\n  end;\nend;\n\nfunction TForm1.ConectarAoBancoDeDados: TADOConnection;\nvar\n  ConnectionString: string;\nbegin\n  Result := TADOConnection.Create(nil);\n  ConnectionString := 'Provider=SQLOLEDB.1;Integrated Security=SSPI;Persist Security Info=False;Initial Catalog=MeuBanco;Data Source=MeuServidor';\n  Result.ConnectionString := ConnectionString;\n  Result.LoginPrompt := False;\n  Result.Open;\nend;\n\nprocedure TForm1.BuscarEDisplayDados(Conn: TADOConnection);\nvar\n  Query: TADOQuery;\nbegin\n  Query := TADOQuery.Create(nil);\n  try\n    Query.Connection := Conn;\n    Query.SQL.Text := 'SELECT * FROM MinhaTabela';\n    Query.Open;\n    ProcessarResultados(Query);\n  finally\n    Query.Free;\n  end;\nend;\n\nprocedure TForm1.ProcessarResultados(Query: TADOQuery);\nbegin\n  while not Query.Eof do\n  begin\n    \/\/ Processar cada linha de resultados\n    ShowMessage(Query.FieldByName('MeuCampo').AsString);\n    Query.Next;\n  end;\nend;\n<\/pre><\/div>\n\n\n\n
                    \n
                  1. Envio de Email<\/li>\n<\/ol>\n\n\n\n
                    Antes<\/strong>: Fun\u00e7\u00e3o \u00fanica que lida com a constru\u00e7\u00e3o e envio de email.<\/p>\n\n\n\n
                    procedure TForm1.EnviarEmail(destinatario, assunto, mensagem: string);\nvar\n  SMTP: TIdSMTP;\n  Msg: TIdMessage;\nbegin\n  SMTP := TIdSMTP.Create(nil);\n  Msg := TIdMessage.Create(nil);\n  try\n    \/\/ Configurar o servidor SMTP\n    SMTP.Host := 'smtp.exemplo.com';\n    SMTP.Port := 25;\n    SMTP.Username := 'usuario';\n    SMTP.Password := 'senha';\n\n    \/\/ Configurar a mensagem\n    Msg.From.Address := 'meuemail@exemplo.com';\n    Msg.Recipients.EmailAddresses := destinatario;\n    Msg.Subject := assunto;\n    Msg.Body.Text := mensagem;\n\n    \/\/ Enviar o email\n    SMTP.Connect;\n    try\n      SMTP.Send(Msg);\n    finally\n      SMTP.Disconnect;\n    end;\n  finally\n    SMTP.Free;\n    Msg.Free;\n  end;\nend;\n<\/pre><\/div>\n\n\n\n
                    Depois<\/strong>: Fun\u00e7\u00f5es separadas para construir e enviar o email.<\/p>\n\n\n\n
                    procedure TForm1.EnviarEmail(destinatario, assunto, mensagem: string);\nvar\n  email: TIdMessage;\nbegin\n  email := ConstruirEmail(destinatario, assunto, mensagem);\n  try\n    EnviarEmailSMTP(email);\n  finally\n    email.Free;\n  end;\nend;\n\nfunction TForm1.ConstruirEmail(destinatario, assunto, mensagem: string): TIdMessage;\nvar\n  Msg: TIdMessage;\nbegin\n  Msg := TIdMessage.Create(nil);\n  try\n    Msg.From.Address := 'meuemail@exemplo.com';\n    Msg.Recipients.EmailAddresses := destinatario;\n    Msg.Subject := assunto;\n    Msg.Body.Text := mensagem;\n    Result := Msg;\n  except\n    Msg.Free;\n    raise;\n  end;\nend;\n\nprocedure TForm1.EnviarEmailSMTP(email: TIdMessage);\nvar\n  SMTP: TIdSMTP;\nbegin\n  SMTP := TIdSMTP.Create(nil);\n  try\n    \/\/ Configurar o servidor SMTP\n    SMTP.Host := 'smtp.exemplo.com';\n    SMTP.Port := 25;\n    SMTP.Username := 'usuario';\n    SMTP.Password := 'senha';\n\n    \/\/ Enviar o email\n    SMTP.Connect;\n    try\n      SMTP.Send(email);\n    finally\n      SMTP.Disconnect;\n    end;\n  finally\n    SMTP.Free;\n  end;\nend;\n<\/pre><\/div>\n\n\n\n
                    Conclus\u00e3o<\/strong><\/p>\n\n\n\n
                    Fun\u00e7\u00f5es pequenas e focadas s\u00e3o essenciais para alcan\u00e7ar um c\u00f3digo-limpo e de alta qualidade. Elas melhoram significativamente a legibilidade, facilitam a manuten\u00e7\u00e3o e aumentam a testabilidade do c\u00f3digo. Ao dividir responsabilidades em fun\u00e7\u00f5es menores, os desenvolvedores criam um c\u00f3digo mais modular e f\u00e1cil de entender, o que, por sua vez, promove uma maior colabora\u00e7\u00e3o e efici\u00eancia dentro da equipe. Implementar fun\u00e7\u00f5es pequenas n\u00e3o s\u00f3 reduz a complexidade, mas tamb\u00e9m permite uma melhor reutiliza\u00e7\u00e3o de c\u00f3digo e uma refatora\u00e7\u00e3o cont\u00ednua mais segura. Ao adotar essa pr\u00e1tica, os desenvolvedores garantem que seu software n\u00e3o apenas funcione bem hoje, mas tamb\u00e9m possa evoluir e se adaptar \u00e0s necessidades futuras com mais facilidade e menos risco de introduzir novos problemas. No pr\u00f3ximo artigo, exploraremos o terceiro pilar do c\u00f3digo-limpo: Coment\u00e1rios Eficientes.<\/p>\n\n\n\n
                    Comunidade no Telegram<\/a><\/p>\n\n\n\n
                    \ud83d\ude80Comente no campo abaixo \ud83d\udc47\ud83d\udc47\ud83d\udc47 o que achou e qual sua d\u00favida.<\/p>\n\n\n\n
                    Te vejo na pr\u00f3xima<\/p>\n\n\n\n
                    Adriano Santos<\/p>\n\n\n\n
                    Demais Artigos:<\/strong><\/p>\n\n\n\n
                    Parte 1: Nomes Significativos<\/a>
                    Parte 2: Fun\u00e7\u00f5es Pequenas<\/a>
                    Parte 3: Coment\u00e1rios Eficientes<\/a>
                    Parrte 4: Formata\u00e7\u00e3o Consistente<\/a>
                    Parte 5: Tratamento de Erros<\/a>
                    Parte 6: Estrutura de Classes<\/a>
                    Parte 7: Testes Automatizados<\/a>
                    Parte 8: Refatora\u00e7\u00e3o Cont\u00ednua<\/a>
                    Parte 9: C\u00f3digo Simples e Direto<\/a>
                    Parte 10: SOLID<\/a><\/p>\n\n\n\n
                    <\/p>\n\n\n\n
                    <\/p>\n\n\n\n
                    <\/p>\n\n\n\n
                    <\/p>\n\n\n\n
                    <\/p>\n\n\n\n
                    <\/p>\n\n\n\n
                    <\/p>\n","protected":false},"excerpt":{"rendered":"
                    No mundo do desenvolvimento de software, a qualidade do c\u00f3digo \u00e9 um fator determinante para a manuten\u00e7\u00e3o, evolu\u00e7\u00e3o e sucesso de um projeto. Uma das pr\u00e1ticas fundamentais para alcan\u00e7ar um c\u00f3digo-limpo \u00e9 a utiliza\u00e7\u00e3o de fun\u00e7\u00f5es pequenas e focadas. Conforme discutido por Robert C. Martin em seu livro “C\u00f3digo-Limpo”, fun\u00e7\u00f5es pequenas s\u00e3o essenciais para criar […]<\/p>\n","protected":false},"author":1,"featured_media":722,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1,62],"tags":[47,45,46,61,14,17,37],"class_list":["post-720","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-blog","category-codigo-limpo","tag-inovacao","tag-programacao-2","tag-tecnologia","tag-codigolimpo","tag-delphi","tag-desenvolvimento","tag-dev"],"_links":{"self":[{"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/posts\/720","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/comments?post=720"}],"version-history":[{"count":3,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/posts\/720\/revisions"}],"predecessor-version":[{"id":818,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/posts\/720\/revisions\/818"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/media\/722"}],"wp:attachment":[{"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/media?parent=720"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/categories?post=720"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/adrianosantostreina.com.br\/blog\/wp-json\/wp\/v2\/tags?post=720"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}