<?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 Jhegs on Medium]]></title>
        <description><![CDATA[Stories by Jhegs on Medium]]></description>
        <link>https://medium.com/@jhegs?source=rss-71a19812c570------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ovyVEh1Bhum2JL0noHtmPA.jpeg</url>
            <title>Stories by Jhegs on Medium</title>
            <link>https://medium.com/@jhegs?source=rss-71a19812c570------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 01:36:01 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jhegs/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[Código asíncrono en JavaScript]]></title>
            <link>https://medium.com/angular-bolivia/c%C3%B3digo-as%C3%ADncrono-en-javascript-27f82a3c94e5?source=rss-71a19812c570------2</link>
            <guid isPermaLink="false">https://medium.com/p/27f82a3c94e5</guid>
            <category><![CDATA[async-functions]]></category>
            <category><![CDATA[promises]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[asyncawait]]></category>
            <category><![CDATA[javascript-tips]]></category>
            <dc:creator><![CDATA[Jhegs]]></dc:creator>
            <pubDate>Tue, 23 Jan 2018 03:55:56 GMT</pubDate>
            <atom:updated>2018-02-01T20:09:08.861Z</atom:updated>
            <content:encoded><![CDATA[<h4>Comparando Callbacks, Promesas y Async/Await</h4><p>La programación asíncrona es una de las grandes ventajas de JavaScript, pero cuando no llegamos a comprender su funcionamiento genera bastantes errores y confusiones, tanto para los principiantes, como para los más expertos. Existen muchas maneras de manejar código asíncrono en Javascript; en este artículo, vamos a explorar las tres opciones más populares.</p><p>Generalmente cuando realizamos peticiones a un servidor las respuestas se manejan de manera asíncrona; para poder mostrar ejemplos con ventajas y desventajas entre estas opciones, vamos a utilizar el API que <a href="https://jsonplaceholder.typicode.com/">jsonplaceholder</a> ofrece.</p><h3>Usando funciones callback</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gVPyq2dXMBdMu6wH-UclXQ.jpeg" /></figure><p>Las funciones en JavaScript son <em>first-class</em>. Esto significa que puedes pasar funciones como argumentos y devolver como respuesta una función. Lo cual es muy conveniente. Cuando JavaScript fue lanzado por primera vez, utilizar <em>callbacks</em> era el método mas común para manejar operaciones asíncronas. Callbacks son conceptualmente simples — se pasa una función como parámetro que debería ser llamado después (una vez que el código asíncrono termina de ejecutarse).</p><p>En este ejemplo, estamos pasando un callback a <em>getPosts(). </em>Dentro de dicha función<em>,</em> estamos usando <a href="https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest">XMLHttpRequest</a> para hacer una llamada HTTP.</p><pre>getPosts(function(error, posts) {<br>  if (error) {<br>      console.log(error);<br>  } else {<br>      console.log(posts.length);<br>  }<br>});<br><br>function getPosts(callback) {<br>    const xhr = new XMLHttpRequest();<br>    xhr.responseType = &#39;json&#39;;<br>    xhr.onreadystatechange = function() {<br>        if (xhr.readyState == XMLHttpRequest.DONE) {<br>            callback(null, xhr.response); // llamada a getPosts()<br>        }<br>    }<br>    xhr.open(&quot;GET&quot;, &quot;https://jsonplaceholder.typicode.com/posts&quot;);<br>    try {<br>        xhr.send();<br>    } catch (error) {<br>        callback(error);<br>    }<br>}</pre><p>En este código estamos usando <em>callbacks</em> al estilo de Node, que implica controlar el error que puede ser enviado en el primer parámetro de la función <em>callback</em>. Cuando la solicitud HTTP se completa, el <em>callback</em> es llamado . Si ocurre algún error, un error es pasado a la función <em>callback</em>.</p><p><strong>Ventajas</strong></p><ul><li><strong>Simple</strong> — Callbacks son conceptualmente simples. Pasas una función que quieras que se ejecute después.</li><li><strong>Universal</strong> — Callbacks corren donde sea. No requiere de un transpilador o polyfill.</li></ul><p><strong>Desventajas</strong></p><ul><li><strong>Composición tosca </strong>— No se componen tan elegantemente como las alternativas que mostraremos después. Las llamadas anidadas pueden llevar a realizar un código con aun mas anidaciones dentro — comúnmente llamado <em>callbak</em> <em>hell</em>, aunque esta preocupación puede ser mitigada extrayendo código para separar las funciones.</li><li><strong>Flujo poco intuitivo</strong>— <em>callbacks</em> requieren que te muevas dentro del código para comprender el flujo del mismo. Los patrones alternativos que se presentan a continuación proporcionan una experiencia de lectura más lineal.</li><li><strong>Tosco manejo de errores</strong> —Como se pude ver en el ejemplo anterior, se tiene que pasar el error hacia otro función en vez de usar el tradicional try/catch.</li></ul><h3>Promesas</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/690/1*gfeeRIDb0EUrl5_AecDT-Q.png" /></figure><p>Una promesa es un objeto que representa la eventual finalización de una operación asíncrona y su valor resultante. Hoy en día, las promesas son muy populares para el manejo de funciones asíncronas. Las promesas son también la base para async/await (discutido más abajo), por lo que bien vale la pena dominarlas.</p><p>Muchas librerías ofrecen APIs basadas en promesas, como <a href="https://github.com/axios/axios">Axios</a> para llamadas HTTP y nativamente el navegador ofrece <a href="https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API"><em>fetch</em></a>. En este ejemplo, vamos a usar <em>fetch</em> para hacer una llamada HTTP en lugar de XMLHttpRequest porque <em>fetch</em> proporciona una API sencilla basada en promesas para llamadas HTTP. <em>Fetch</em> está soportado en muchos de los navegadores modernos.</p><pre>getPosts().then( posts =&gt; {<br>  console.log(posts.length);<br>});<br><br>function getPosts() {<br>  return fetch(&quot;https://jsonplaceholder.typicode.com/posts&quot;)<br>  .then(response =&gt; {<br>    return response.json();<br>  })<br>  .catch( error =&gt; console.log(error));<br>}</pre><p>Por convención, se maneja una promesa que completa su ejecución dentro de una función llamada <em>then()</em>. Por lo tanto, retornamos la promesa que proporciona <em>fetch</em> y manejamos la promesa resuelta dentro. Finalmente, se maneja cualquier error usando <em>.catch</em>, que también es parte de la especificación de una promesa.</p><p><strong>Ventajas</strong></p><ul><li><strong>Fácilmente enlazable</strong> — Las promesas se pueden enlazar fácilmente para manejar flujos asíncronos complejos sin tener que recurrir a mas anidaciones como se requieren en callbacks.</li><li><strong>Poderoso</strong> — Las promesas proporcionan un capacidad excepcional para componer operaciones asíncronas complejas. Puedes utilizar cualquier promesa que se resuelva primero a través de <em>.race()</em> y ejecutar múltiples operaciones asíncronas simultáneamente con <em>.all().</em></li></ul><p><strong>Desventajas</strong></p><ul><li><strong>Excepciones que desaparecen</strong> — Se debe declarar .catch() para manejar errores en lugar del tradicional try/catch. Sin un catch, algunos navegadores ignoran silenciosamente excepciones no manejadas en promesas.</li><li><strong>API propenso a errores</strong> — Debemos estar seguros de retornar la promesa (como en el ejemplo anterior). Sin el, se obtendrá un error confuso: <em>Cannot read property ‘then’ of undefined</em>. Las promesas son poderosas, pero es fácil equivocarse en su uso.</li><li><strong>Requiere Polyfill</strong> — Las promesas no son compatibles con Internet Explorer, así que debes asegurarte de usar un polyfill para promesas.</li></ul><h3>Async / Await</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*wnxL83lMXu2oFmzMtW-SRg.png" /></figure><p>Async/await es un nuevo enfoque que se agregó a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function">JavaScript en ES2017</a>. En realidad utiliza promesas internamente, por lo que se puede pensar que es solo una forma más elegante de escribirlas. Tomar en cuenta que al igual que las promesas usar async/await no es bloqueante.</p><p>Async/await es a menudo preferible sobre promesas o <em>callbacks</em> porque hace que el código asíncrono se parezca código síncrono.</p><pre>getPosts().then(posts =&gt; {<br>    console.log(posts.length);<br>});<br><br><strong>async</strong> function getPosts() {<br>  try {<br>    const response = <strong>await</strong> fetch(&quot;https://jsonplaceholder.typicode.com/posts&quot;);<br>    return response.json();<br>  } catch(error) {<br>    console.log(error);<br>  }<br>}</pre><p>Las funciones asíncronas son declaradas con la palabra reservada <strong><em>async. </em></strong>Luego declaramos una operación asíncrona usando la palabra reservada <strong><em>await</em></strong>. La función se detendrá en <strong><em>await</em></strong> hasta que la llamada asíncrona complete su ejecución.</p><p>Las funciones <strong><em>async</em></strong> devuelven una promesa, por lo que aun debemos usar promesas para manejar la respuesta. Y no se usa la palabra reservada <strong><em>await</em></strong> cuando realizamos un <em>return </em>por que una función <strong><em>async</em></strong> retorna el valor envuelto automáticamente dentro un <em>resolve().</em></p><p><strong>Ventajas</strong></p><ul><li><strong>Tradicional try/catch</strong> — A diferencia de promesas, async/await te permite usar try/catch para manejo de errores. Con <em>callbacks</em> y las promesas, las operaciones múltiples de asincronia pueden llevar a que el código sea más difícil de leer. Con async/await, sólo tienes que añadir otra palabra clave de espera. No se requiere anidación extra.</li><li><strong>Fácil de leer </strong>— La anidación de código se reduce a través de la palabra reservada <strong><em>await</em></strong>. Con callbacks y promesas multiples operaciones asíncronas llevan a que el código pierda legibilidad.</li></ul><p><strong>Desventajas</strong></p><ul><li><strong>Menos poder</strong> — Pierdes algo del poder de composición con async/await. Por ejemplo, Con async/await, cada vez que uses <strong><em>await </em></strong>se detendrá, por lo que no hay forma de ejecutar varias operaciones <strong><em>async</em></strong> simultáneamente. En contraste, con promesas, puede ejecutar varias operaciones <strong><em>async</em></strong> simultáneamente utilizando el método <em>all()</em> de promesas.</li><li><strong>Transpilacion inflada</strong> — Cuando utilizamos características de JavaScript que no todos los navegador son capaces de entender (en nuestro caso <em>async/await</em>), es necesario transpilar el código <em>(que consiste en tomar el código fuente escrito en un lenguaje y transformarlo en otro que tiene un nivel similar de abstracción)</em>. En nuestra implementación el código resultante se incrementa considerablemente. Por ejemplo con Babel 8, <a href="https://babeljs.io/repl/#?babili=false&amp;browsers=&amp;build=&amp;builtIns=false&amp;code_lz=IYZwngdgxgBAZgV2gFwJYHsIwOYFNkAK6IyIAguNABQCUMA3gFAwzIBOYDzLMUmJMNrhAAHfrhgBeGMADuwVMnj4oACyoAiVcmQiQALgD0hgFYhMIgDbAouVeksATXGwB0yMCNR9nrvgFtDMRIQDRoAbm4WIWQENiwhUXFXM0xaSJYAX15gZDUqFzZ0NjomHl5-B1xXS3RsArYikoyYTMZMoA&amp;debug=false&amp;circleciRepo=&amp;evaluate=false&amp;lineWrap=true&amp;presets=es2015,es2016,es2017,react,stage-1,stage-2&amp;targets=&amp;version=6.26.0">8 lineas de código se convierten en 37</a> . Sin embargo parte de este incremento en código solo se realiza una vez. Si usas async/await varias veces, el código en _asyncToGenerator es reutilizado.</li></ul><h3><strong>Conclusión</strong></h3><p>Luego de ver distintas formas de manejar código asíncrono, claramente el uso de <strong>async / await</strong> es el mecanismo más claro y fácil de comprender, plus, fácil de mantener; pero todavía necesitas entender promesas para usarlos. Espero que este contenido sea de utilidad.</p><p><em>This post is based on the next links:</em></p><ul><li><a href="https://codeburst.io/hey-i-just-met-you-and-this-is-crazy-but-heres-my-callback-so-call-me-maybe-79de5b56f264">Hey, I just met you / And this is crazy / But here’s my callback / So call me maybe</a></li><li><a href="https://hackernoon.com/moving-to-es6-babel-and-transpilers-337921c025b1">Moving to ES6 — Babel and Transpilers</a></li></ul><p><em>Translated from:</em></p><p><a href="https://stackify.com/async-javascript-approaches/">Three Async JavaScript Approaches</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=27f82a3c94e5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/angular-bolivia/c%C3%B3digo-as%C3%ADncrono-en-javascript-27f82a3c94e5">Código asíncrono en JavaScript</a> was originally published in <a href="https://medium.com/angular-bolivia">Angular Bolivia</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>