<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Henrique Corraro on Medium]]></title>
        <description><![CDATA[Stories by Henrique Corraro on Medium]]></description>
        <link>https://medium.com/@rick.corraro?source=rss-edf2348a968b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*DGYRD_6NLPbKR2HyZift3w@2x.jpeg</url>
            <title>Stories by Henrique Corraro on Medium</title>
            <link>https://medium.com/@rick.corraro?source=rss-edf2348a968b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 08:43:57 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rick.corraro/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[O custo da IA não é o mesmo custo para você e para o modelo]]></title>
            <link>https://medium.com/@rick.corraro/o-custo-da-ia-n%C3%A3o-%C3%A9-o-mesmo-custo-para-voc%C3%AA-e-para-o-modelo-8c05f8b9a2d7?source=rss-edf2348a968b------2</link>
            <guid isPermaLink="false">https://medium.com/p/8c05f8b9a2d7</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[brasil]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Henrique Corraro]]></dc:creator>
            <pubDate>Tue, 27 Jan 2026 14:10:45 GMT</pubDate>
            <atom:updated>2026-01-27T14:10:45.082Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>O que é caro para o desenvolvedor não é necessariamente o que é caro para a provedora (openai, claude e similares).</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lRgFC5bHHLSjvQP_lIGbzw.png" /></figure><h3>1. O custo para <strong>nós, desenvolvedores</strong></h3><p>Do nosso lado, a conta é simples e dói no bolso:</p><ul><li><strong>Output tokens são muito mais caros</strong></li><li>Cada palavra que o modelo “fala” custa</li><li>Pedir respostas longas, explicações, raciocínio passo a passo = dinheiro</li></ul><p>Exemplo mental fácil:</p><blockquote>Eu mando uma pergunta curta e recebo um texto enorme.<br> Quem pagou caro fui eu.</blockquote><p>Para nós:</p><ul><li>Output = <strong>custo direto</strong></li><li>Falar é caro</li><li>Silêncio é barato</li></ul><h3>2. O custo para <strong>a IA / provedor</strong></h3><p>Para o modelo, o que pesa mais <strong>não é falar</strong>, é <strong>processar contexto</strong>.</p><p>Quando você manda:</p><ul><li>histórico grande</li><li>logs</li><li>JSON gigante</li><li>documentos</li><li>múltiplas instruções</li><li>exemplos longos</li></ul><p>O modelo precisa:</p><ul><li>carregar tudo na memória</li><li>aplicar atenção em cada token contra todos os outros</li><li>recalcular relações internas</li></ul><p>Frase forte:</p><blockquote>“Para o modelo, o caro é <strong>ler</strong>, não <strong>falar</strong>.”</blockquote><h4>Por que isso acontece?</h4><p>Em modelos de linguagem:</p><ul><li>O <strong>output</strong> cresce de forma quase linear</li><li>O <strong>input</strong> afeta todo o processo de atenção e inferência</li></ul><p>Ou seja:</p><ul><li>cada token de input “interage” com os outros</li><li>contexto grande custa <strong>computação</strong>, não só texto</li></ul><p>É por isso que:</p><ul><li>input pode ser barato no pricing</li><li>mas caro na infraestrutura</li><li>e por isso caching existe</li></ul><h3><strong>E assim temos um paradoxo do “pricing”</strong></h3><p>O pricing reflete quem paga a conta — não quem tem o maior custo computacional.</p><blockquote>Para <strong>desenvolvedores — </strong>output é caro → <em>incentiva respostas mais curtas</em></blockquote><blockquote>Para <strong>provedores — </strong>input é caro → <em>incentiva cache, prefix reuse, limites de contexto</em></blockquote><p>Se quiser trocar uma ideia, me siga nas redes: <a href="https://www.instagram.com/henriquecorraro">Instagram</a> | L<a href="https://www.linkedin.com/in/henrique-corraro/">inkedin</a> | <a href="https://www.tiktok.com/@henriquecorraro">Tiktok</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8c05f8b9a2d7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tokens: o que são (e por que seu custo com IA pode explodir)]]></title>
            <link>https://medium.com/@rick.corraro/tokens-o-que-s%C3%A3o-e-por-que-seu-custo-com-ia-pode-explodir-c133bc93f1b5?source=rss-edf2348a968b------2</link>
            <guid isPermaLink="false">https://medium.com/p/c133bc93f1b5</guid>
            <category><![CDATA[brasil]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Henrique Corraro]]></dc:creator>
            <pubDate>Mon, 26 Jan 2026 17:13:20 GMT</pubDate>
            <atom:updated>2026-01-26T17:13:20.328Z</atom:updated>
            <content:encoded><![CDATA[<p>Muita gente acha que usar LLM é:</p><blockquote><strong>mandar uma mensagem e receber uma resposta</strong></blockquote><p>Na prática, não é assim que a conta fecha.</p><p>Modelos de linguagem (LLMs) trabalham com <strong>tokens</strong> — e é por tokens que você paga (e é por tokens que você bate no limite de contexto).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dvBDmHEkCwCLU15b4c_suw.png" /></figure><h3>O que é um token?</h3><p>Um token é uma unidade de texto usada pelo modelo para processar linguagem. <br>Ele não “lê” letras como a gente. <br>Ele “quebra” texto em pedaços (subwords).</p><p>Por isso:</p><ul><li>uma palavra pode virar <strong>1 token</strong></li><li>ou pode virar <strong>vários tokens</strong></li><li>espaços e pontuação entram na conta</li><li>números e strings longas também</li></ul><p>Um exemplo típico de tokenização seria algo como:</p><pre>[&quot;com&quot;, &quot;put&quot;, &quot;ador&quot;]</pre><blockquote><strong>Importante:</strong> isso não é regra fixa, é um exemplo didático.</blockquote><p>Você não precisa decorar tokenização para começar, mas precisa entender a consequência:</p><blockquote>Tokens = custo + limite técnico.</blockquote><h3>Você paga por input e por output</h3><p>Quase todo provedor cobra tokens em duas partes:</p><ol><li><strong>Input tokens</strong>: tudo que você envia</li><li><strong>Output tokens</strong>: tudo que o modelo gera</li></ol><h4>E aqui está o ponto que mais pega em produto:</h4><p><strong>Tudo que você envia</strong> não é só o prompt, ormalmente entram junto:</p><ul><li>instruções de sistema (se você usa)</li><li>histórico de conversa (se você reenvia)</li><li>contexto extra (docs, logs, código, respostas anteriores)</li></ul><p>Ou seja: o custo não cresce só porque a resposta ficou maior.<br> Ele cresce porque o seu <strong>contexto foi ficando maior</strong>.</p><h3>Janela de contexto: o limite invisível</h3><p>Além do custo, tokens definem a <strong>janela de contexto</strong>:</p><p>Se você coloca texto demais:</p><ul><li>o modelo pode “perder” coisas importantes (porque alguma parte fica fora do limite)</li><li>pode ficar mais lento</li><li>pode ficar mais caro</li><li>e a qualidade cai (porque ele precisa “navegar” em ruído)</li></ul><blockquote>E no próximo vamos refletir sobre a frase:</blockquote><blockquote>O que é caro para o desenvolvedor não é necessariamente o que é caro para a IA.</blockquote><p>Se quiser trocar uma ideia, me siga nas redes: <a href="https://www.instagram.com/henriquecorraro">Instagram</a> | L<a href="https://www.linkedin.com/in/henrique-corraro/">inkedin</a> | <a href="https://www.tiktok.com/@henriquecorraro">Tiktok</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c133bc93f1b5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Você já usa LLMs todos os dias — mesmo sem saber]]></title>
            <link>https://medium.com/@rick.corraro/voc%C3%AA-j%C3%A1-usa-llms-todos-os-dias-mesmo-sem-saber-c2407b81d586?source=rss-edf2348a968b------2</link>
            <guid isPermaLink="false">https://medium.com/p/c2407b81d586</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[brasil]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Henrique Corraro]]></dc:creator>
            <pubDate>Sun, 25 Jan 2026 12:46:30 GMT</pubDate>
            <atom:updated>2026-01-25T12:52:55.876Z</atom:updated>
            <content:encoded><![CDATA[<h3>Você já usa LLMs todos os dias — mesmo sem saber</h3><p>Se você acha que LLM é “coisa do ChatGPT”, dá pra apostar que você já usou um hoje… e provavelmente mais de uma vez.</p><p>A diferença é que, na maior parte do tempo, a gente não percebe, porque LLM <strong>não é um aplicativo</strong>, é <strong>uma tecnologia</strong> que aparece “por trás” de várias interfaces.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*omoMiXen28uvZO4uDFYCpQ.png" /></figure><h3>O que é um LLM?</h3><p>LLM significa <strong>Large Language Model</strong> (Modelo de Linguagem em Larga Escala).</p><p>De forma direta: um LLM é treinado para <strong>prever a próxima parte de um texto</strong> com base no que veio antes.</p><p>Isso parece simples, mas é justamente o que permite o modelo:</p><ul><li>continuar uma frase</li><li>responder uma pergunta</li><li>reescrever um texto</li><li>resumir conteúdo</li><li>traduzir</li><li>simular uma conversa</li></ul><blockquote>Um LLM não “entende” como um humano. Ele calcula probabilidades de quais tokens vêm a seguir.</blockquote><p><em>(Tokens eu vou detalhar no próximo post, porque isso muda tudo em custo e qualidade.)</em></p><h3>Onde você encontra LLMs sem perceber?</h3><p>Hoje, LLMs aparecem em vários lugares do dia a dia, principalmente onde existe texto:</p><ul><li><strong>Sugestão de escrita e autocomplete</strong>: quando seu app “adivinha” o resto da frase</li><li><strong>Respostas prontas</strong>: aquele “responder e-mail em 1 clique”</li><li><strong>Correção e reescrita</strong>: ajustar tom, gramática, clareza</li><li><strong>Tradução mais natural</strong>: menos literal, mais contextual</li><li><strong>Chats de suporte</strong>: FAQs mais inteligentes, atendimento com linguagem natural</li><li><strong>Busca por intenção</strong>: quando a busca parece “entender” o que você quis dizer</li></ul><blockquote>A experiência parece mágica, mas por trás quase sempre tem o mesmo conceito: <strong>geração de texto condicionada a um contexto</strong>.</blockquote><h3>Por que isso explodiu agora?</h3><p>Modelos de linguagem existem há bastante tempo. O que mudou foi a combinação de fatores:</p><ul><li>mais poder computacional disponível</li><li>arquiteturas melhores</li><li>muito mais dados</li><li>e principalmente: acesso via APIs e produtos fáceis de usar</li></ul><p>Ferramentas como as da OpenAI ajudaram a popularizar o uso, mas a tendência é maior: LLM virou “infraestrutura” — igual banco de dados, fila, cache… só que para linguagem.</p><h3>O que isso muda para desenvolvedores?</h3><p>Se você é dev, entender LLM não é “curiosidade”: é o que define se você vai construir algo previsível e escalável ou um projeto que funciona só em demo.</p><p>Quando você entende o básico, você começa a fazer melhores escolhas sobre:</p><ul><li><strong>custo</strong></li><li><strong>performance</strong></li><li><strong>limites de contexto</strong></li><li><strong>qualidade de respostas</strong></li><li><strong>quando usar LLM e quando não usar</strong></li><li><strong>quando usar LLM e quando não usar</strong></li></ul><p>Na próxima vou falar sobre tokens, explicar o que são, como são calculados e porque muita gente confunde o que realmente custa quando uma IA te envia umas resposta.</p><p>Se quiser trocar uma ideia, me siga nas redes: <a href="https://www.instagram.com/henriquecorraro">Instagram</a> | L<a href="https://www.linkedin.com/in/henrique-corraro/">inkedin</a> | <a href="https://www.tiktok.com/@henriquecorraro">Tiktok</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c2407b81d586" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Manipulando o DOM com JavaScript]]></title>
            <link>https://medium.com/@rick.corraro/manipulando-o-dom-com-javascript-165f7f5e84df?source=rss-edf2348a968b------2</link>
            <guid isPermaLink="false">https://medium.com/p/165f7f5e84df</guid>
            <category><![CDATA[dom]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[brasil]]></category>
            <dc:creator><![CDATA[Henrique Corraro]]></dc:creator>
            <pubDate>Sat, 26 Oct 2024 01:12:08 GMT</pubDate>
            <atom:updated>2024-10-26T01:12:08.001Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*odIMnO7PHNJrEMfr_QVSpg.jpeg" /></figure><p>Muitas vezes quando começamos a desenvolver para web, pulamos direto para bibliotecas e frameworks que simplificam o trabalho, sem realmente entender o que está acontecendo “por trás dos panos”. Ter noções básicas de JavaScript puro permite que você compreenda os fundamentos da linguagem e como o navegador realmente funciona. Entender esses conceitos ajuda a depurar problemas, otimizar o desempenho e ter controle total sobre o comportamento da página. Além disso, conhecer as bases facilita a transição para qualquer ferramenta ou biblioteca que você escolher usar no futuro, tornando você um desenvolvedor mais versátil e confiante.</p><p>JavaScript é uma das linguagens mais populares para criar experiências dinâmicas na web, e uma de suas principais forças está na manipulação do DOM (Document Object Model). Manipular o DOM significa interagir diretamente com os elementos da página, seja para alterar o conteúdo, o estilo ou adicionar funcionalidades interativas.</p><p>Vamos explorar algumas das principais técnicas de manipulação de DOM usando JavaScript puro (sem bibliotecas como React ou jQuery). Essas técnicas são essenciais para quem deseja entender o funcionamento da web mais a fundo.</p><h3>Código HTML Base</h3><p>Para os exemplos a seguir, vamos utilizar um código HTML simples:</p><pre>&lt;!DOCTYPE html&gt;<br>&lt;html lang=&quot;pt-BR&quot;&gt;<br>&lt;head&gt;<br>  &lt;meta charset=&quot;UTF-8&quot;&gt;<br>  &lt;meta name=&quot;viewport&quot; content=&quot;width=device-width, initial-scale=1.0&quot;&gt;<br>  &lt;title&gt;Manipulação de DOM&lt;/title&gt;<br>  &lt;style&gt;<br>    .destaque {<br>      color: red;<br>      font-weight: bold;<br>    }<br>    .ativo {<br>      background-color: yellow;<br>    }<br>  &lt;/style&gt;<br>&lt;/head&gt;<br>&lt;body&gt;<br>  &lt;h1 id=&quot;titulo-principal&quot;&gt;Título Original&lt;/h1&gt;<br>  &lt;p&gt;Este é um parágrafo de exemplo.&lt;/p&gt;<br>  &lt;button id=&quot;meu-botao&quot;&gt;Clique em mim&lt;/button&gt;<br><br>  &lt;script src=&quot;script.js&quot;&gt;&lt;/script&gt;<br>&lt;/body&gt;<br>&lt;/html&gt;</pre><h3>1. Selecionando Elementos do DOM</h3><p>Para manipular qualquer elemento da página, primeiro precisamos selecioná-lo. Existem algumas funções muito úteis em JavaScript que permitem essa seleção:</p><ul><li>document.getElementById()</li><li>document.querySelector()</li><li>document.querySelectorAll()</li></ul><p><strong>Exemplo:</strong></p><pre>const titulo = document.getElementById(&quot;titulo-principal&quot;);<br>const botoes = document.querySelectorAll(&quot;button&quot;);<br><br>console.log(titulo); // Seleciona o elemento com id &quot;titulo-principal&quot;<br>console.log(botoes); // Seleciona todos os elementos &lt;button&gt; e os coloca em um array</pre><h3>2. Alterando Conteúdo e Estilos</h3><p>Depois de selecionar um elemento, é possível alterar seu conteúdo de texto ou modificar seu estilo diretamente via JavaScript.</p><p><strong>Exemplo: Alterando Conteúdo de Texto</strong></p><pre>titulo.textContent = &quot;Novo Título!&quot;;</pre><p><strong>Exemplo: Alterando Estilos</strong></p><pre>titulo.style.color = &quot;blue&quot;;<br>titulo.style.fontSize = &quot;24px&quot;;</pre><h3>3. Adicionando e Removendo Classes</h3><p>Para aplicar estilos predefinidos em CSS, você pode adicionar ou remover classes do elemento. O objeto classList permite fazer isso de maneira simples.</p><p><strong>Exemplo: Manipulando Classes</strong></p><pre>titulo.classList.add(&quot;destaque&quot;);<br>titulo.classList.remove(&quot;destaque&quot;);<br>titulo.classList.toggle(&quot;ativo&quot;); // Adiciona a classe se não estiver presente, remove se já existir</pre><h3>4. Criando e Adicionando Elementos ao DOM</h3><p>Também é possível criar novos elementos e adicioná-los à página dinamicamente.</p><p><strong>Exemplo: Criando um Botão e Adicionando ao DOM</strong></p><pre>const novoBotao = document.createElement(&quot;button&quot;);<br>novoBotao.textContent = &quot;Clique Aqui&quot;;<br><br>document.body.appendChild(novoBotao); // Adiciona o botão ao final do body</pre><h3>5. Respondendo a Eventos</h3><p>Eventos permitem que seu site seja interativo. Você pode adicionar eventos como “click”, “mouseover”, “keydown” e muitos outros para reagir às ações do usuário.</p><p><strong>Exemplo: Adicionando um Evento de Clique</strong></p><pre>novoBotao.addEventListener(&quot;click&quot;, () =&gt; {<br>  alert(&quot;Você clicou no botão!&quot;);<br>});</pre><h3>6. Removendo Elementos do DOM</h3><p>Às vezes, você precisará remover elementos da página. Para isso, você pode usar removeChild() ou remove().</p><p><strong>Exemplo: Removendo um Elemento</strong></p><pre>const paragrafo = document.querySelector(&quot;p&quot;);<br>paragrafo.remove(); // Remove o parágrafo do DOM</pre><h3>Conclusão</h3><p>Manipular o DOM é uma habilidade essencial para qualquer desenvolvedor web. Entender como selecionar elementos, alterar seus conteúdos, manipular classes e responder a eventos permite que você crie aplicações dinâmicas e interativas sem depender de frameworks. Essas são apenas as bases, mas já é suficiente para criar muita coisa legal no seu próximo projeto!</p><p>Explore esses conceitos e experimente aplicá-los no seu código. Com o tempo, a manipulação do DOM se tornará uma ferramenta poderosa no seu arsenal de desenvolvedor.</p><p>Se quiser trocar uma ideia, me siga nas redes: <a href="https://www.instagram.com/henriquecorraro">Instagram</a> | <a href="https://www.linkedin.com/in/henrique-corraro/">linkedin</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=165f7f5e84df" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Promises e funções assíncronas]]></title>
            <link>https://medium.com/@rick.corraro/promises-e-fun%C3%A7%C3%B5es-ass%C3%ADncronas-8dc85de4faba?source=rss-edf2348a968b------2</link>
            <guid isPermaLink="false">https://medium.com/p/8dc85de4faba</guid>
            <category><![CDATA[node]]></category>
            <category><![CDATA[brasil]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Henrique Corraro]]></dc:creator>
            <pubDate>Fri, 18 Oct 2024 01:02:29 GMT</pubDate>
            <atom:updated>2024-10-18T01:02:29.140Z</atom:updated>
            <content:encoded><![CDATA[<p>São conceitos fundamentais no desenvolvimento JavaScript moderno, e muitos programadores já os utilizam, talvez até sem perceber ou sem compreender completamente o que realmente são e como funcionam. Neste artigo, vamos explorar em detalhes tanto as Promises quanto as funções assíncronas, explicando de forma clara e acessível o que cada uma delas representa, como operam e quais são suas principais diferenças e vantagens. Nosso objetivo é não só elucidar esses conceitos, mas também proporcionar uma compreensão prática que você poderá aplicar imediatamente no seu código.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SIbo_6QnFuU42lVXhq5kXQ.jpeg" /></figure><h3>Promises:</h3><p>Uma <strong>Promise</strong> (promessa) é um objeto em JavaScript que representa a eventual conclusão ou falha de uma operação assíncrona e seu valor resultante. Quando trabalhamos com operações que demoram, como requisições de API ou leitura de arquivos, usamos Promises para manipular os resultados quando a operação for concluída.</p><h4>Estados de uma Promise:</h4><ol><li><strong>Pending</strong> (Pendente): o estado inicial, ainda não foi resolvida ou rejeitada.</li><li><strong>Fulfilled</strong> (Cumprida): significa que a operação foi bem-sucedida e a Promise foi resolvida.</li><li><strong>Rejected</strong> (Rejeitada): significa que a operação falhou e a Promise foi rejeitada.</li></ol><h4>Criando uma Promise:</h4><pre>const myPromise = new Promise((resolve, reject) =&gt; {<br>  // Simula uma operação assíncrona, como uma requisição a um servidor<br>  setTimeout(() =&gt; {<br>    const success = true; // Alterar para &#39;false&#39; para simular falha<br><br>    if (success) {<br>      resolve(&quot;Operação bem-sucedida!&quot;); // Chama resolve se a operação foi bem-sucedida<br>    } else {<br>      reject(&quot;Erro na operação.&quot;); // Chama reject se algo deu errado<br>    }<br>  }, 2000); // Simula uma operação de 2 segundos<br>});<br><br>// Usando a Promise<br>myPromise<br>  .then((result) =&gt; {<br>    console.log(result); // &quot;Operação bem-sucedida!&quot;<br>  })<br>  .catch((error) =&gt; {<br>    console.error(error); // &quot;Erro na operação.&quot;<br>  });</pre><p><strong>Explicação:</strong></p><ul><li>resolve: chama-se quando a operação assíncrona for bem-sucedida.</li><li>reject: chama-se quando houver uma falha na operação.</li><li>then(): método que executa o código quando a Promise é resolvida com sucesso.</li><li>catch(): método que executa o código quando a Promise é rejeitada, ou seja, em caso de erro.</li></ul><p>Exemplo real com Promises:</p><pre>const fetchUser = (userId) =&gt; {<br>  return new Promise((resolve, reject) =&gt; {<br>    setTimeout(() =&gt; {<br>      if (userId === 1) {<br>        resolve({ id: 1, name: &quot;Henrique&quot;, city: &quot;São Paulo&quot; });<br>      } else {<br>        reject(&quot;Usuário não encontrado.&quot;);<br>      }<br>    }, 1000);<br>  });<br>};<br><br>fetchUser(1)<br>  .then(user =&gt; console.log(user)) // { id: 1, name: &quot;Henrique&quot;, city: &quot;São Paulo&quot; }<br>  .catch(error =&gt; console.error(error)); // Em caso de erro, imprime &quot;Usuário não encontrado.&quot;</pre><h3>Async/Await:</h3><p>O async e o await são recursos introduzidos no ES2017 que tornam o trabalho com código assíncrono mais simples e legível. Eles permitem escrever código assíncrono de maneira mais parecida com código síncrono, eliminando a necessidade de usar then() e catch() o tempo todo, tornando o código mais fácil de ler e manter.</p><h4>Como funciona?</h4><ul><li><strong>async</strong>: Usado para declarar uma função assíncrona. Ele transforma uma função comum em uma Promise.</li><li><strong>await</strong>: Pausa a execução de uma função assíncrona até que a Promise seja resolvida ou rejeitada. Deve ser usado dentro de funções declaradas com async.</li></ul><h4>Exemplo básico de Async/Await:</h4><pre>async function getData() {<br>  const promise = new Promise((resolve, reject) =&gt; {<br>    setTimeout(() =&gt; resolve(&quot;Dados recebidos!&quot;), 2000);<br>  });<br><br>  const result = await promise; // Espera até que a Promise seja resolvida<br>  console.log(result); // &quot;Dados recebidos!&quot;<br>}<br><br>getData();</pre><p><strong>Explicação</strong>:</p><ul><li>A função getData foi marcada como async, o que significa que podemos usar await dentro dela.</li><li>await faz a função &quot;esperar&quot; até que a Promise seja resolvida, e então a execução continua.</li></ul><h4>Exemplo real de Async/Await:</h4><p>Vamos usar o mesmo exemplo de fetchUser, mas agora com async/await.</p><pre>const fetchUser = (userId) =&gt; {<br>  return new Promise((resolve, reject) =&gt; {<br>    setTimeout(() =&gt; {<br>      if (userId === 1) {<br>        resolve({ id: 1, name: &quot;Henrique&quot;, city: &quot;São Paulo&quot; });<br>      } else {<br>        reject(&quot;Usuário não encontrado.&quot;);<br>      }<br>    }, 1000);<br>  });<br>};<br><br>async function getUserData() {<br>  try {<br>    const user = await fetchUser(1); // Espera a Promise ser resolvida<br>    console.log(user); // { id: 1, name: &quot;Henrique&quot;, city: &quot;São Paulo&quot; }<br>  } catch (error) {<br>    console.error(error); // &quot;Usuário não encontrado.&quot;<br>  }<br>}<br><br>getUserData();</pre><p><strong>Explicação:</strong></p><ul><li>A função getUserData usa async para ser declarada como assíncrona, o que permite o uso de await.</li><li>await fetchUser(1) faz a função &quot;esperar&quot; até que a Promise retornada por fetchUser seja resolvida.</li><li>O bloco try...catch é usado para capturar possíveis erros da Promise rejeitada, assim como o .catch() nas Promises.</li></ul><h4>Comparação entre Promises e Async/Await</h4><p>Usando Promises (com .then() e .catch()):</p><pre>fetchUser(1)<br>  .then(user =&gt; {<br>    console.log(user);<br>    return fetchPosts(user.id); // Chama outra função baseada no resultado<br>  })<br>  .then(posts =&gt; {<br>    console.log(posts); // Usa o resultado da segunda Promise<br>  })<br>  .catch(error =&gt; {<br>    console.error(error); // Captura erros de qualquer uma das Promises<br>  });</pre><p>Usando Async/Await:</p><pre>async function getUserDataAndPosts() {<br>  try {<br>    const user = await fetchUser(1); // Espera o resultado da primeira Promise<br>    console.log(user);<br><br>    const posts = await fetchPosts(user.id); // Chama a segunda função<br>    console.log(posts);<br>  } catch (error) {<br>    console.error(error); // Captura erros<br>  }<br>}<br><br>getUserDataAndPosts();</pre><h4>Diferenças:</h4><ul><li><strong>Promises</strong>: Usar then() e catch() é mais tradicional, mas o código pode se tornar mais difícil de ler quando há muitas operações encadeadas, levando ao chamado &quot;Promise Hell&quot; (falaremos sobre isso em um post futuro).</li><li><strong>Async/Await</strong>: Torna o código mais legível e direto, especialmente quando você tem várias operações assíncronas dependentes uma da outra, como requisições de API encadeadas.</li></ul><h3>Quando usar Async/Await ou Promises?</h3><ul><li><strong>Async/Await</strong> é ideal para operações assíncronas que têm várias etapas, tornando o código mais legível e fácil de depurar.</li><li><strong>Promises</strong> são mais flexíveis quando você quer trabalhar com várias Promises de forma paralela ou encadear resultados de forma mais complexa (embora isso também possa ser feito com async/await).</li></ul><p>Ambos os recursos são poderosos e complementares. Saber quando usar um ou outro dependerá do contexto e da complexidade da lógica assíncrona que você está implementando.</p><p>Por hoje paramos por aqui e lembre-se, a prática e a experimentação são a chave para se tornar um desenvolvedor cada vez melhor.</p><p>Se quiser trocar uma ideia, me siga nas redes: <a href="https://www.instagram.com/henriquecorraro">Instagram</a> | <a href="https://www.linkedin.com/in/henrique-corraro/">linkedin</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8dc85de4faba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[PT/BR] Alguns “tricks” importantes de JavaScript — parte 2]]></title>
            <link>https://medium.com/@rick.corraro/pt-br-alguns-tricks-importantes-de-javascript-parte-2-7bfc33aaf972?source=rss-edf2348a968b------2</link>
            <guid isPermaLink="false">https://medium.com/p/7bfc33aaf972</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[brasil]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Henrique Corraro]]></dc:creator>
            <pubDate>Mon, 07 Oct 2024 14:32:06 GMT</pubDate>
            <atom:updated>2024-10-07T14:46:14.384Z</atom:updated>
            <content:encoded><![CDATA[<h3>Alguns “tricks” importantes de JavaScript — parte 2</h3><p>Demorei pra aparecer por aqui novamente, mas vamos ao que interessa.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*odIMnO7PHNJrEMfr_QVSpg.jpeg" /></figure><h4>Template Literals</h4><p>Facilita a construção de strings complexas.</p><pre>const name = &quot;Henrique&quot;;<br>const age = 30;<br>const greeting = `Meu nome é ${name} e eu tenho ${age} anos.`;<br>console.log(greeting); <br>// Meu nome é Henrique e eu tenho 30 anos.</pre><h4>Default Parameters</h4><p>Define valores padrão para parâmetros de funções.</p><pre>const greet = (name = &quot;convidado&quot;) =&gt; `Bem vindo, ${name}!`;<br>console.log(greet()); // Bem vindo, convidado!<br>console.log(greet(&quot;Henrique&quot;)); // Bem vindo, Henrique!</pre><h4>Rest Parameters</h4><p>O <strong>Rest Parameters</strong> é um recurso do JavaScript que nos permite capturar um número indefinido de argumentos passados para uma função e os armazene em um array.</p><h4>Quando usar Rest Parameters?</h4><ul><li>Quando você quer permitir que uma função aceite um número variável de argumentos.</li><li>Quando você precisa capturar todos os argumentos passados para uma função que não foram explicitamente nomeados.</li></ul><pre>// Exemplo: Somando números com Rest Parameters<br>function sum(...numbers) {<br>  // numbers é um array contendo todos os números passados como argumentos<br>  return numbers.reduce((acc, curr) =&gt; acc + curr, 0);<br>}<br><br>console.log(sum(1, 2, 3, 4)); // Output: 10</pre><pre>// Exemplo: vários sobrenomes<br>function greet(firstName, city, ...lastNames) {<br>  // firstName e city capturam os dois primeiros argumentos<br>  // lastNames captura o restante dos sobrenomes em um array<br>  console.log(`Olá, ${firstName} de ${city}!`);<br>  console.log(`Seus sobrenomes: ${lastNames.join(&quot;, &quot;)}`);<br>}<br><br>greet(&quot;Henrique&quot;, &quot;São Paulo&quot;, &quot;Silva&quot;, &quot;Souza&quot;, &quot;Almeida&quot;);<br>// Output:<br>// Olá, Henrique de São Paulo!<br>// Seus sobrenomes: Silva, Souza, Almeida</pre><h4>Object Property Shorthand</h4><p>Esse recurso do JavaScript permite que você crie objetos de forma mais concisa quando o nome da chave (propriedade) é o mesmo nome da variável que você está passando.</p><pre>const x = 1;<br>const y = 2;<br><br>const obj = {<br>  x: x,<br>  y: y<br>};<br><br>console.log(obj); // Output: { x: 1, y: 2 }</pre><p>Aqui, não é necessário repetir x: x, pois o JavaScript entende que estamos atribuindo a variável x ao campo x.</p><h4>Optional Chaining</h4><p>É um recurso que facilita o acesso a propriedades de objetos que podem não existir. Ele previne erros quando tentamos acessar propriedades de objetos que podem ser null ou undefined.</p><p><strong>Sem Optional Chaining:</strong></p><pre>const user = {<br>  name: &quot;Henrique&quot;,<br>  address: {<br>    city: &quot;São Paulo&quot;<br>  }<br>};<br><br>console.log(user.address.city); // Output: São Paulo</pre><p>Agora, e se address fosse undefined? O código acima causaria um erro, pois estaríamos tentando acessar .city de algo que não existe.</p><p><strong>Com Optional Chaining:</strong></p><pre>const user = {<br>  name: &quot;Henrique&quot;,<br>  address: null<br>};<br><br>console.log(user.address?.city); // Output: undefined (sem erro)</pre><p><strong>Como funciona:</strong></p><ul><li>O operador ?. verifica se user.address existe. Se address for null ou undefined, ele imediatamente retorna undefined, sem lançar um erro.</li><li>Caso address exista, ele prossegue e tenta acessar a propriedade .city.</li></ul><p>Esse recurso é muito útil em grandes estruturas de dados, onde nem todas as propriedades estão garantidas.</p><h4>Nullish Coalescing Operator</h4><p>O <strong>Nullish Coalescing Operator</strong> (??) é utilizado para fornecer um valor padrão quando o valor da esquerda é null ou undefined. Ele é uma alternativa mais precisa ao operador ||, que também pode ser usado para valores padrões, mas considera false, 0, ou &quot;&quot; como falsos.</p><pre>//Exemplo com Nullish Coalescing Operator<br>const name = null ?? &quot;Henrique&quot;;<br>console.log(name); // Output: Henrique<br><br>const age = 0 ?? 25;<br>console.log(age); // Output: 0 (0 é considerado um valor válido)<br><br>const age = 0 || 25;<br>console.log(age); // Output: 25 (0 é considerado &quot;falsy&quot; com ||)</pre><p><strong>Como funciona:</strong></p><ul><li>O operador ?? só retorna o valor à direita se o da esquerda for null ou undefined.</li><li>No exemplo acima, como name é null, o valor &quot;Henrique&quot; é retornado.</li><li>No segundo caso, age é 0, e como 0 não é null nem undefined, ele é mantido como o valor.</li><li>Já no terceiro caso o operador || retorna o valor da direita se o valor da esquerda for considerado &quot;falso&quot;, incluindo 0, false, &quot;&quot;, null, undefined, etc.</li></ul><h4>Short-circuit Operator (&amp;&amp;)</h4><p>O operador &amp;&amp; é utilizado para encadear condições e executa o código da direita apenas se a condição da esquerda for verdadeira.</p><pre>const isLoggedIn = true;<br>const userName = isLoggedIn &amp;&amp; &quot;Henrique&quot;;<br><br>console.log(userName); // Output: Henrique</pre><p><strong>Como funciona:</strong></p><ul><li>Se isLoggedIn for true, ele avalia e retorna o valor à direita, que é &quot;Henrique&quot;.</li><li>Se isLoggedIn fosse false, o JavaScript simplesmente retornaria false e o lado direito não seria avaliado.</li></ul><p>Outro exemplo com false:</p><pre>const isAvailable = false;<br>const message = isAvailable &amp;&amp; &quot;Disponível&quot;;<br><br>console.log(message); // Output: false</pre><p>Com certeza ao entender e conseguir aplicar esses “tricks” seu código será mais legível e eficiente! E lembre-se de que a prática e a experimentação são a chave para se tornar um desenvolvedor cada vez melhor.</p><p>Se quiser trocar uma ideia, me siga nas redes: <a href="https://www.instagram.com/henriquecorraro">Instagram</a> | <a href="https://www.linkedin.com/in/henrique-corraro/">linkedin</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7bfc33aaf972" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Alguns “tricks” importantes de JavaScript — parte 1]]></title>
            <link>https://medium.com/@rick.corraro/alguns-tricks-importantes-de-javascript-parte-1-65398cb8b177?source=rss-edf2348a968b------2</link>
            <guid isPermaLink="false">https://medium.com/p/65398cb8b177</guid>
            <category><![CDATA[js]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Henrique Corraro]]></dc:creator>
            <pubDate>Thu, 21 Mar 2024 18:15:30 GMT</pubDate>
            <atom:updated>2026-01-25T12:36:44.719Z</atom:updated>
            <content:encoded><![CDATA[<h3>[PT/BR|EN] Alguns “tricks” importantes de JavaScript</h3><p>Primeiramente gostaria de dizer que este é meu primeiro post aqui no Medium, então qualquer feedback referente ao formato, por favor deixem nos comentários.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8veacBNGrNWhUHtC2hWIwA.png" /></figure><p>JavaScript é uma linguagem de programação versátil e poderosa que se tornou indispensável para o desenvolvimento web. E hoje vou trazer alguns truques e dicas que podem ser muito úteis para o pessoal que está começando na linguagem e também relembrar alguns conceitos para quem é mais experiente, bora lá.</p><h3>Spread syntax</h3><p>Spread syntax é um recurso que permite estender os elementos de um array ou objeto para outro array ou objeto, o que pode ser útil de várias formas, como copiar/mesclar arrays e objetos e passar vários argumentos para uma função.</p><pre>// Spread em Arrays<br>const arr1 = [1, 2, 3];<br>const arr2 = [4, 5, 6];<br>const mergedArray= [...arr1, ...arr2];<br>console.log(mergedArray); // Output: [1, 2, 3, 4, 5, 6]<br><br>// Spread em Objects<br>const obj1 = { x: 1, y: 2 };<br>const obj2 = { z: 3 };<br>const mergedObject = { ...obj1, ...obj2 };<br>console.log(mergedObject); // Output: { x: 1, y: 2, z: 3 }<br><br>// Copiando Arrays e Objects<br>const array= [1, 2, 3];<br>const copyOfArray = [...array];<br>console.log(copyOfArray); // Output: [1, 2, 3]<br><br>const object= { x: 1, y: 2 };<br>const copyOfObject = { ...object};<br>console.log(copyOfObject); // Output: { x: 1, y: 2 }<br><br>// Spread em chamadas de função<br>const numbers = [1, 2, 3, 4, 5];<br>console.log(Math.max(...numbers)); // Output: 5<br><br><br>//Outro Exemplo<br>function sum(a, b, c) {<br>  return a + b + c;<br>}<br><br>const numbers = [1, 2, 3];<br><br>console.log(sum(...numbers)); // Output: 6<br></pre><h3><strong>Destructuring assignment</strong></h3><p>Destructuring assignment é um recurso que permite extrair valores de arrays, objetos ou outras estruturas de dados e atribuí-los a variáveis ​​de forma concisa e legível.</p><pre>// Desestruturação de array, combinado com spread para receber o resto do array<br>const array = [1, 2, 3, 4, 5];<br>const [a, b, ...rest] = array;<br><br>console.log(a); // Output: 1<br>console.log(b); // Output: 2<br>console.log(rest); // Output: [3, 4, 5]<br><br>// Desestruturação de objeto<br>const obj = { x: 1, y: 2, z: 3 };<br>const { x, y, z } = obj;<br><br>console.log(x); // Output: 1<br>console.log(y); // Output: 2<br>console.log(z); // Output: 3<br><br>// Também podemos usar alias para alterar o nome da nossa const<br>const { x:a, rest} = obj<br>console.log(a); // Output: 1<br>console.log(rest); // Output: {y: 2, z: 3}</pre><h3>Arrow functions</h3><p>As Arrow functions são uma forma mais concisa de escrever funções em JavaScript e foram introduzidas no ECMAScript 6 (ES6). Fornecem uma sintaxe mais curta em comparação com expressões de função tradicionais e vinculam o “this” automaticamente ao contexto da mesma.</p><p>Vamos comparar as duas formas.</p><pre>// Function tradicional<br>function add(a, b) {<br>  return a + b;<br>}<br><br>// Arrow function<br>const add = (a, b) =&gt; a + b;<br><br>// Arrow function com um return implícito<br>const greet = name =&gt; `Hello, ${name}!`;<br><br>// Arrow function como um callback<br>const numbers = [1, 2, 3];<br>const squaredNumbers = numbers.map(num =&gt; num * 2);<br>console.log(squaredNumbers); // Output: [2, 4, 6]</pre><h3>Some important JavaScript tricks — part 1</h3><p>Firstly, I would like to say that this is my first post here on Medium, so any feedback regarding the format, please leave it in the comments.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8veacBNGrNWhUHtC2hWIwA.png" /></figure><p>JavaScript is a versatile and powerful programming language that has become indispensable for web development. And today I’m going to bring some tricks and tips that can be very useful for people who are just starting out in the language and also remind some concepts for those who are more experienced, let’s go.</p><h3>Spread syntax</h3><p>Spread syntax is a feature that allows you to extend the elements of an array or object to another array or object, which can be useful in several ways, such as copying/merging arrays and objects and passing multiple arguments to a function.</p><pre>// Spread in Arrays<br>const arr1 = [1, 2, 3];<br>const arr2 = [4, 5, 6];<br>const mergedArray= [...arr1, ...arr2];<br>console.log(mergedArray); // Output: [1, 2, 3, 4, 5, 6]<br><br>// Spread in Objects<br>const obj1 = { x: 1, y: 2 };<br>const obj2 = { z: 3 };<br>const mergedObject = { ...obj1, ...obj2 };<br>console.log(mergedObject); // Output: { x: 1, y: 2, z: 3 }<br><br>// Copying Arrays and Objects<br>const array= [1, 2, 3];<br>const copyOfArray = [...array];<br>console.log(copyOfArray); // Output: [1, 2, 3]<br><br>const object= { x: 1, y: 2 };<br>const copyOfObject = { ...object};<br>console.log(copyOfObject); // Output: { x: 1, y: 2 }<br><br>// Spread on function calls<br>const numbers = [1, 2, 3, 4, 5];<br>console.log(Math.max(...numbers)); // Output: 5<br><br><br>//another example<br>function sum(a, b, c) {<br>  return a + b + c;<br>}<br><br>const numbers = [1, 2, 3];<br><br>console.log(sum(...numbers)); // Output: 6</pre><h3>Destructuring assignment</h3><p>Destructuring assignment is a feature that allows you to extract values ​​from arrays, objects or other data structures and assign them to variables in a concise and readable way.</p><pre>// Array destructuring, with spread to receive the rest of the array<br>const array = [1, 2, 3, 4, 5];<br>const [a, b, ...rest] = array;<br><br>console.log(a); // Output: 1<br>console.log(b); // Output: 2<br>console.log(rest); // Output: [3, 4, 5]<br><br>// Object destructuring<br>const obj = { x: 1, y: 2, z: 3 };<br>const { x, y, z } = obj;<br><br>console.log(x); // Output: 1<br>console.log(y); // Output: 2<br>console.log(z); // Output: 3<br><br>// We can also use aliases to change the name of our const<br>const { x:a, rest} = obj<br>console.log(a); // Output: 1<br>console.log(rest); // Output: {y: 2, z: 3}</pre><h3>Arrow functions</h3><p>Arrow functions are a more concise way of writing functions in JavaScript and were introduced in ECMAScript 6 (ES6). They provide a shorter syntax compared to traditional function expressions and automatically bind “this” to the function context.</p><p>Let’s compare the two ways.</p><pre>// Traditional function<br>function add(a, b) {<br>  return a + b;<br>}<br><br>// Arrow function<br>const add = (a, b) =&gt; a + b;<br><br>// Arrow function with an implicit return<br>const greet = name =&gt; `Hello, ${name}!`;<br><br>// Arrow function as a callback<br>const numbers = [1, 2, 3];<br>const squaredNumbers = numbers.map(num =&gt; num * 2);<br>console.log(squaredNumbers); // Output: [2, 4, 6]</pre><p>Com certeza ao entender e conseguir aplicar esses “tricks” seu código será mais legível e eficiente! E lembre-se de que a prática e a experimentação são a chave para se tornar um desenvolvedor cada vez melhor.</p><p>Se quiser trocar uma ideia, me siga nas redes: <a href="https://www.instagram.com/henriquecorraro">Instagram</a> | <a href="https://www.linkedin.com/in/henrique-corraro/">linkedin</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=65398cb8b177" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>