<?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 polbac on Medium]]></title>
        <description><![CDATA[Stories by polbac on Medium]]></description>
        <link>https://medium.com/@polbac?source=rss-a7a647ae29f5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ilZlWmTAHFu2ov9PuktZhA.png</url>
            <title>Stories by polbac on Medium</title>
            <link>https://medium.com/@polbac?source=rss-a7a647ae29f5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 22:18:56 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@polbac/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[Redux: hooks, performance & selectors]]></title>
            <link>https://medium.com/@polbac/redux-hooks-performance-selectors-368f25bfd4c7?source=rss-a7a647ae29f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/368f25bfd4c7</guid>
            <category><![CDATA[redux]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[hooks]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[polbac]]></dc:creator>
            <pubDate>Fri, 20 Sep 2019 19:00:30 GMT</pubDate>
            <atom:updated>2019-09-20T20:44:05.369Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8aWlmlWnapyHRPMN1wDo2A.jpeg" /></figure><h3><a href="https://es.wikipedia.org/wiki/TL;DR">TL;DR</a></h3><p>Conclusiones a partir de useSelector(), mapStateToProps, reselect y tips de performance.</p><h3>Nuestra app</h3><p>Supongamos que tenemos una app en React con estos <strong>componentes</strong>:</p><pre>&lt;App&gt;<br>    &lt;SelectedPerson /&gt;<br>    &lt;Team&gt;<br>      &lt;Person /&gt;<br>      &lt;Person /&gt;<br>      ...<br>    &lt;Team /&gt;<br>&lt;/App&gt;</pre><p>Donde se visualiza un equipo de personas, y una de ellas está seleccionada en el primer componente.</p><p>También tendríamos un <strong>store</strong> con el estado de la aplicación:</p><pre>const initState = {<br>   selected: {<br>     id: 4,<br>     name: ‘alan’,<br>     mail: ‘alan@email.com’,<br>     image: ‘https://placeimg.com/640/481/animals&#39;<br>   },<br>   people: [<br>     {<br>        id: 2,<br>        name: ‘pablo’,<br>        mail: ‘pablo@email.com’,<br>        image: ‘https://placeimg.com/640/481/animals&#39;<br>     },<br>     ...<br>],</pre><h3>Componente &lt;Team /&gt;</h3><p>Nuestro componente principal, lo que debería hacer es generar una lista de <strong>&lt;Person /&gt;</strong> por cada uno de los items del store. Tiempo atrás había una única manera de hacer esto, pero como en el universo de JS todo avanza de manera muy rápida, hoy en día hay varias formas de hacerlo.</p><p>Lo primero que debemos hacer es conectar nuestro componente a redux:</p><h4>connect()</h4><p>Podemos utilizar <strong>connect()</strong> y pasarle la función <strong>mapStateToProps</strong> que lo que hace es tomar del store lo que el componente necesita. Esta función recibe como argumento el store total.</p><p>Hay distintas formas de hacer lo mismo (supongamos que también queremos saber la cantidad de elementos en el atributo <strong>total</strong>):</p><pre>const mapStateToProps = (store) =&gt; ({<br>   people: store.people,<br>   total: store.people.length<br>})</pre><p>Esta función devolverá un objeto con los dos atributos. Luego deberemos conectar nuestro componente:</p><pre>class Team extends React.PureComponent {<br>   render() {<br>      const { people, total } = <em>this</em>.props</pre><pre>      return &lt;React.Fragment&gt;<br>               &lt;div&gt;<br>                 {people.map((person, index) =&gt;<br>                    &lt;Person key={index} data={person} /&gt;<br>                 )}<br>               &lt;/div&gt;<br>               &lt;p&gt;Total: {total}&lt;/p&gt;<br>             &lt;/React.Fragment&gt;<br>   }<br>}<br>export default connect(mapStateToProps)(Team)</pre><p>De esta manera cada vez que se actualice <strong>people</strong> dentro del store el componente se renderizará nuevamente. Cuando hablamos de actualizar people, necesitamos retornar una nueva versión del array, y no el mismo modificado, de lo contrario nuestros componentes no serán reactivos:</p><pre>// por ejemplo</pre><pre>people.push(new People())<br>people: { ...people }</pre><pre>// o</pre><pre>people: {<br>  ...people,<br>  [people.length]: new People()<br>}</pre><p>Otra forma de hacer lo mismo es utilizando <strong>selectores</strong>:</p><pre>export const selectPeople = store =&gt; store.people<br>export const selectTotalPeople = store =&gt; store.people.length</pre><pre>const mapStateToProps = (store) =&gt; ({<br>    people: selectPeople(store),<br>    total: selectTotalPeople(store)<br>})</pre><p>Los selectores son funciones que las generamos para desacoplar la lógica de seleccionar elementos del store y reutilizarlos en distintos componentes.</p><p>Mientras el store de la aplicación vaya <strong>mutando</strong> nuestro componente no se actualizará (llamaremos actualizar a la ejecución del <strong>render()</strong>) mientras no se actualice el vector <strong>people</strong>.</p><p>Ahora bien, si dentro de nuestro mapStateToProps nosotros tenemos otro item que sí va variando, el render() se ejecutará.</p><p>Por ejemplo, si nosotros hacemos esto:</p><pre>const mapStateToProps = store =&gt; ({<br>    people: selectPeople(store),<br>    total: selectTotalPeople(store),<br>    <strong>random: Math.random()</strong><br>})</pre><p>Nuestro componente se ejecutará por más que <strong>people</strong> o <strong>total</strong> no varíen. Por esto, sería una mala práctica hacer esto mismo ya que la variación de <strong>random</strong> entrará en la comparación que hace redux. Si un componente necesita muchos elementos del store sería conveniente desarmarlo en distintos componentes.</p><h4>Reselect</h4><p>Una librería que pertenece a todo este mundo es <a href="https://github.com/reduxjs/reselect">reselect</a>: permite componer y agregar m<a href="https://en.wikipedia.org/wiki/Memoization">emoization</a> a nuestros selectors.</p><pre>export const selectPeopleReselect = createSelector(<br>      selectPeople,<br>      people =&gt; people<br>)</pre><pre>const selectTotalPeopleReselect = createSelector(<br>         selectPeopleReselect, <br>         people =&gt; people.length<br>)</pre><pre>const selectPeopleWithTotal = createSelector(<br>      selectPeopleReselect,<br>      selectTotalPeopleReselect,<br>      (people, total) =&gt; ({ people, total })<br>)</pre><pre>// y en el mapStateToProps<br>const mapStateToProps = store =&gt; selectPeopleWithTotal(store)</pre><p>Con <strong>createSelector()</strong> podemos pasar como argumento todos los selectors (planos o reselectors) y luego una función que devolverá un objeto plano con los atributos &gt; valores que queremos que devuelva.</p><p>Lo interesante es que si un selector está compuesto por otros selectores, reselect irá guardando el estado y haciendo memoize cuidando la performance.</p><h4>Hooks</h4><p>El último grito de la moda no escapó al mundo de redux y en vez de utilizar connect() tenemos el paliativo de hooks. Principalmente tenemos dos funciones <strong>useSelector()</strong> y <strong>useDispatch()</strong>.</p><pre>import { useSelector } from &#39;react-redux&#39;</pre><pre>export default () =&gt; {<br>   const { people, total } = useSelector(state =&gt; ({<br>      people: state.people,<br>      total: state.people.length<br>   }))</pre><pre>   return &lt;React.Fragment&gt;<br>             &lt;div&gt;<br>              {people.map((person, index) =&gt;<br>                &lt;Person key={index} data={person} /&gt;)}</pre><pre>             &lt;/div&gt;<br>             &lt;p&gt;Total: {total}&lt;/p&gt;<br>           &lt;/React.Fragment&gt;<br>}</pre><p>De esta manera remplazamos mapDispatchToProps a <strong>useSelector()</strong>. Sólamente podemos utilizar los hooks en FunctionalComponents es decir que no podremos utilizar métodos de Lifecycle de React ni generar métodos dentro de nuestros componentes ya que no son clases.</p><p>❌ Nuestro componente por más que <strong>people o total no cambien</strong>, cada vez que se dispare una acción<strong> se renderizará</strong>, esto es porque no estamos haciendo una buena implementación de performance. Para resolver esto tenemos como mínimo dos formas:</p><p>✅ Usar varios <strong>useSelector</strong> (uno por cada elemento que queremos extraer)</p><pre>const people = useSelector(selectPeople)<br>const total = useSelector(selectTotalPeople)</pre><p>✅ Usar la librería reselect</p><p>✅ Hacer una <strong>función de comparación propia</strong> o utilizar <strong>shallowEqual</strong></p><h4>ShallowEqual</h4><p>Por default <strong>useSelector</strong> hace una comparación === con la versión anterior del store para actualizar o no. En cambio connect() hace una comparación más profunda con <strong>mapState</strong>.</p><pre>const <strong>refEquality</strong> = (a, b) =&gt; a === b</pre><pre>export function useSelector(selector, equalityFn = <strong>refEquality</strong>) {<br>    ...<br>}</pre><p>Dicho esto, es necesario entender que useSelector se actualizará en todo momento si no tomamos los recaudos necesarios y podríamos tener problemas de performance. Para tener más control sobre este problema podemos pasarle a useSelector otra función que chequee si se hizo update y debemos volver a renderizar el componente.</p><p>Redux trae un helper, que hará una comparación más profunda y se implementa de la siguiente manera</p><pre>import { <strong>shallowEqual</strong>, useSelector } from &#39;react-redux&#39;</pre><pre>const selectedData = useSelector(selectorReturningObject, <strong>shallowEqual)</strong></pre><p>La comparación que hace este helper es la siguiente:</p><pre>export default function <strong>shallowEqual</strong>(objA, objB) {<br>    if (is(objA, objB)) return true<br>    if (<br>        typeof objA !== &#39;object&#39; ||<br>        objA === null || <br>        typeof objB !== &#39;object&#39; ||<br>        objB === null) {<br>            return false<br>     }</pre><pre>    const keysA = Object.keys(objA)<br>    const keysB = Object.keys(objB)<br>    <br>    if (keysA.length !== keysB.length) return false<br>    for (let i = 0; i &lt; keysA.length; i++) {<br>        if (<br>            !hasOwn.call(objB, keysA[i]) ||<br>            !is(objA[keysA[i]], objB[keysA[i]])<br>           ) {<br>          return false<br>        }<br>     }<br>     <br>     return true<br>}</pre><p>También podemos hacer una función custom para validar si son iguales o no el estado anterior del siguiente, por ejemplo si nos interesa saber si la propiedad <strong>isActive</strong> varió lo haríamos de la siguiente manera:</p><pre><strong>const</strong> selectedData = useSelector(<br>              selectorReturningObject,<br>              <strong>(a, b) =&gt; a.active === b.active)<br>)</strong></pre><h3>Performance Tools</h3><p>Cuando hablamos de performance en nuestra aplicación react-redux, podemos dividirlo en los siguientes grupos:</p><ul><li>Cuán pesada es la ejecución de un render() en un componente.</li><li>Si el render() realmente tiene que re-renderizarse o no.</li><li>Si el <strong>selector</strong> es muy pesado y por otro lado si realmente tiene que ejecutarse o podría estar memoizado.</li><li>Si podemos reutilizar código para consumir menos memoria.</li></ul><p>Ahora, ¿cómo hacemos para saber si nuestros componentes se están renderizando cuando no deberían hacerlo?</p><p>El add-on de Chrome <a href="https://chrome.google.com/webstore/detail/react-developer-tools/fmkadmapgofadopljbjfkapdkoienihi">React Developer Tools</a> posee una configuración que nos permite saber cuando un componente hizo update:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rk1fuUoLw-iMD_y-AEEXPg.png" /></figure><p>Primero debemos habilitarlo haciendo click en el ícono de configuración y activando <strong>Highlight Updates</strong>.</p><p>De esta manera cada vez que se actualiza un componente hará un destello alrededor del componente</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hzhQ_tuRWT6YFLz7X2zW8A.png" /></figure><h3>Largas listas &amp; Performance</h3><p>Cuando necesitamos armar una vista que genera un listado seguramente estaremos utilizando un array y a partir de cada uno de los elementos del array montaremos un componente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/634/1*zAZVsAQyrdsHzbf-MvotwA.gif" /></figure><p>Cuando no tenemos muchos elementos que renderizar seguramente no tendremos problemas de performance. Pero si tenemos que renderizar cientos o miles de elementos, y los mismos deberían ir haciendo update, cada vez que nuestro array se modifique, ya sea enteramente o cambie sólo un elemento de nuestro array, <strong>toda</strong> la lista se generará de nuevo.</p><p>Por ejemplo, si tenemos este store:</p><pre>const initialStore = {<br>     movies: [<br>       { id: 1, title: &#39;Barbarella&#39;, active: false},<br>       { id: 2, title: &#39;La noche del terror ciego&#39;, active: false},<br>       { id: 3, title: &#39;The Rocky Horror Picture Show&#39;, active: false}<br>       ....<br>     ]</pre><pre>}</pre><p>Seguramente tengamos dos componentes <strong>&lt;List /&gt;</strong> y otro de <strong>&lt;Detail /&gt;</strong></p><pre>export const <strong>List</strong> = () =&gt; {<br>    const movies = useSelector(state =&gt; state.movies)<br>    return (<br>        &lt;React.Fragment&gt;<br>          {movies.map(m =&gt; &lt;Detail movie={m} /&gt;)}<br>         &lt;/React.Fragment&gt;<br>   )<br>}</pre><p>Y <strong>Detail</strong> recibirá como props la información para renderizar la card de la película.</p><p>❌ Esta forma de hacer las cosas funcionará pero cada vez que cualquier elemento de cualquier item del array varíe, se volverá a renderizar la lista.</p><p>¿Cómo podemos hacer para resolver este problema?<strong> desnormalizar el store y trabajar sin arrays:</strong></p><p>De esta forma podríamos tener el siguiente store:</p><pre>const initialStore = {<br>     moviesId: [ 1, 2, 3 ],<br>     moviesById: {<br>       1: { id: 1, title: &#39;Barbarella&#39;},<br>       2: { id: 2, title: &#39;La noche del terror ciego&#39;},<br>       3: { id: 3, title: &#39;The Rocky Horror Picture Show&#39;}<br>       ....<br>     }<br>}</pre><p>Para hacer esto podríamos utilizar la funcionalidad <strong>_.groupBy(</strong>) de <strong>lodash</strong></p><p>Nuestros componentes tendrían otra forma:</p><pre>export const <strong>List</strong> = () =&gt; {<br>    const movies = useSelector(state =&gt; <strong>state.moviesId</strong>)<br>    return (<br>        &lt;React.Fragment&gt;<br>          {movies.map(movieId =&gt; &lt;Detail movieId={movieId} /&gt;)}<br>         &lt;/React.Fragment&gt;<br>   )<br>}</pre><p>Y el detail debería estar conectado con el el objeto con el detalle:</p><pre>export const <strong>Detail</strong> = () =&gt; {<br>    const movieDetail = useSelector(state =&gt;<br>                                 state.moviesById[props.movieId])<br>    return (<br>        &lt;React.Fragment&gt;<br>          &lt;h2/&gt;{movieDetail.title}&lt;h2/&gt;<br>         &lt;/React.Fragment&gt;<br>   )<br>}</pre><p><strong>¿Por qué de esta manera será más performante?</strong></p><p><strong>List</strong> no se volverá a renderizar a menos que agreguemos o eliminemos un id de dentro de su array.</p><p>Detail sólo se volverá a renderizar cuando cambie algo de su contenido, y únicamente el elemento que se modificó</p><h3>Conclusiones</h3><h4>connect()</h4><ul><li>Es la forma vieja de acceder, pero si nuestro componente necesita métodos específicos deberíamos utilizarla ya que deberíamos usar una clase.</li><li>Utiliza una comparación de estados más profunda que useSelector (shallow equality).</li></ul><h4>useSelector()</h4><ul><li>Es la nueva forma de conectar nuestros componentes, se lee de una forma mucho más linda.</li><li>Utiliza una comparación <strong>a === b</strong> para chequear un re-render. De este modo podríamos tener problemas de performance.</li><li>Utilizar <strong>shallowEqual</strong> para comparaciones más profundas al primer nivel.</li><li>Utilizar métodos propios para saber si se actualizó o no el estado.</li><li>Utilizar multiples <strong>useSelector()</strong> por cada elemento que necesitamos del store.</li><li>Utilizar <strong>reselect</strong> para resolver el problema anterior.</li></ul><h4>reselect</h4><ul><li>Es una librería que permite componer selectors.</li><li>Nos ayuda a organizar nuestros selectores.</li><li>Aplica memoize y ayuda en la performance del re-render de nuestros componentes.</li></ul><h4>Performance</h4><ul><li>Utilizar la herramienta de <strong>React Developer Tools</strong> para saber si se re-renderiza o no un componente.</li><li>Des-normalizar el store para grandes listas.</li><li>Utilizar la propiedad <strong>key</strong> en los componentes de listados.</li></ul><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2F3oFzmqN1xHwaEXGl7q%2Ftwitter%2Fiframe&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2F3oFzmqN1xHwaEXGl7q%2Fsource.mp4&amp;image=https%3A%2F%2Fi.giphy.com%2Fmedia%2F3oFzmqN1xHwaEXGl7q%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="232" frameborder="0" scrolling="no"><a href="https://medium.com/media/9b22da870e1fc05196e548f8914e3e69/href">https://medium.com/media/9b22da870e1fc05196e548f8914e3e69/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=368f25bfd4c7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[React vs Angular. La historia detrás de una elección.]]></title>
            <link>https://medium.com/trocafone/react-vs-angular-la-historia-detr%C3%A1s-de-una-elecci%C3%B3n-5b955ad9be70?source=rss-a7a647ae29f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/5b955ad9be70</guid>
            <category><![CDATA[vue]]></category>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[js]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[trocafone]]></category>
            <dc:creator><![CDATA[polbac]]></dc:creator>
            <pubDate>Mon, 11 Feb 2019 19:20:55 GMT</pubDate>
            <atom:updated>2019-02-14T20:45:38.247Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong>TL;DR</strong> Resultados y conclusiones post realización de un Proof of Concept: Angular 7 vs React + MobX para una plataforma específica.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1_76aIUSfEOOX40-C9UXNA.jpeg" /></figure><p>En <strong>Trocafone</strong> comenzamos un interesante proyecto:<br>el relanzamiento de nuestra plataforma de <strong>Trade-in</strong> con el objetivo de mejorar la experiencia de usuario y performance.</p><p>Optamos por realizar una <strong>webapp</strong> y necesitábamos elegir una tecnología de front-end moderna y adaptable a nuestras necesidades. Las opciones eran bastante claras: <strong>React</strong> o <strong>Angular</strong>. Evaluamos en un momento <strong>VUE</strong> pero creímos que todavía le faltaba algo de maduración.</p><p>Si bien la comunidad front-end está <em>pusheando</em> con <strong>React</strong> como la mejor opción y al mismo tiempo hay grandes casos de éxito, en el equipo de Trocafone no tomamos decisiones sin hacer análisis y testeos.</p><p>Decidimos ir un poco más allá e invertir tiempo en un Proof of Concept de ambas tecnologías: un mismo proyecto prototipo en dos versiones: Angular 7 y React + MobX (como state manager)</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2F3WPKHcTih1xwQ%2Ftwitter%2Fiframe&amp;url=https%3A%2F%2Fgiphy.com%2Fgifs%2Fshawbrothersuniverse-kung-fu-shaw-brothers-my-rebellious-son-3WPKHcTih1xwQ&amp;image=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2F3WPKHcTih1xwQ%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="226" frameborder="0" scrolling="no"><a href="https://medium.com/media/a28a785e354c5c6d42c7db433c01a0da/href">https://medium.com/media/a28a785e354c5c6d42c7db433c01a0da/href</a></iframe><h3>Proof of Concept</h3><p>Los aspectos que queríamos analizar eran varios: modularización y componentización, <em>data binding, interacciones con APIs, validación de formularios y modelos de datos, seguridad y protección de módulos, traducciones, asincronismos, entre otros.</em></p><p>Luego de unas semanas, llegamos exitosamente a generar los dos prototipos y sacar nuestras conclusiones.</p><h3>React</h3><p>React es una librería creada por <strong>Facebook</strong> enfocada en <strong>UI</strong>, su paradigma se asemeja bastante a la programación funcional y propone una sintaxis propia, <strong>JSX,</strong> que mezcla Javascript con XML para la creación de componentes. Estos componentes poseen un <strong>state</strong> (donde se almacenan los datos contextuales del componente) y también pueden recibir configuraciones de sus componentes padres a través de las <strong>props</strong>.</p><p>Como React está diseñado principalmente para realizar componentes <strong>UI</strong>, muchas veces no alcanza para una arquitectura compleja. Un ejemplo de esto es cuando necesitamos comunicar dos componentes que se encuentren en profundidades muy lejanas: todo se vuelve confuso y el código spaghetti aparece.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FkDEF5wel7n9hC%2Ftwitter%2Fiframe&amp;url=https%3A%2F%2Fgiphy.com%2Fgifs%2Ffunimation-food-porn-kDEF5wel7n9hC&amp;image=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2FkDEF5wel7n9hC%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="244" frameborder="0" scrolling="no"><a href="https://medium.com/media/c4583c369ce8b920dcd12af896e2cbc4/href">https://medium.com/media/c4583c369ce8b920dcd12af896e2cbc4/href</a></iframe><p>Para resolver este problema básicamente hay tres opciones: <strong>Redux</strong>, <strong>MobX</strong> o <strong>React Context Api</strong>.</p><p><strong>Redux</strong></p><p>Es un merge entre <strong>Flux</strong> (patrón que propone un flow de 1-way-communication, donde los datos viajan en una única dirección) y las conocidas funciones <strong>reducers.</strong> Luego están los <strong>actions</strong> que envían payloads a los <strong>reducers</strong> y estos generan una nueva instancia inmutable del <strong>store</strong>. Los componentes están conectados a Redux y reciben los datos del <strong>store</strong> como propiedades.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/792/1*rg6WfwgrnR2FRX7pRXw_dg.png" /><figcaption>Los datos viajan en una única dirección y de esa manera hay una clara división de responsabilidades.</figcaption></figure><p><strong>MobX</strong></p><p>Es una solución un poco más reciente y el paradigma que propone está dentro de los nuevos conceptos de <strong>TFRP</strong> (Transparently Applying Functional Reactive Programming).</p><p>En <strong>MobX</strong> también esta la capa de <strong>store </strong>el cuál es formado por diferentes elementos:</p><ul><li><em>Observable</em>: se utilizan cuando necesitamos trabajar con arrays, objects, numbers, booleans o instancias de clases. Un observable es una referencia a ese tipo de datos que definamos y lo que posibilita es una reacción reactiva a cualquier campo contenido dentro del mismo (row de array, atributo de objeto o clase).</li><li><em>Computed</em>: la manera más fácil de familiarizarnos con este tipo de dato es pensarlo como una celda de una planilla de cálculo que está referenciada a otras celdas, como por ejemplo una operación.</li><li><em>Action</em>: son funciones que modifican el state del <strong>store</strong>.</li></ul><p>Algo interesante es que esta tipificación se hace a través del uso de <strong>decorators</strong>.</p><p>Los componentes reciben todo el <strong>store</strong> como <strong>props</strong> a través de una inyección de dependencia y desde ahí la comunicación se hace a través de <strong>actions</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OIp6oR8R_BiPVNCFBAMKxQ.png" /></figure><p><strong>React Context Api</strong></p><p>Esta <strong>API</strong> viene implementada a partir de la versión 16 de React y lo que propone son dos componentes nuevos en la librería: &lt;<strong>Provider /&gt;</strong> y &lt;<strong>Consumer /&gt;</strong>.</p><p>La idea de un <strong>provider</strong> es la definición es un contenedor de datos (state) que se utilizará en otros componentes dentro del árbol de renderización. Este es un componente que funciona como un <strong>High Order Component</strong> generando un contexto para los componentes hijos.</p><p>Los componentes hijos se conectan a los providers a través un componente <strong>consumer</strong>. De esta manera, sin implementar una nueva librería y con el core de React podríamos interactuar entre componentes que se encuentran distantes en el árbol de nuestra aplicación.</p><p><strong>Angular 7</strong></p><p>Es un Framework front-end mantenido por <strong>Google</strong> que posee una gran cantidad de objetos para la realización de una webapp. Es importante destacar que durante los distintos releases que fueron lanzándose fue cambiando mucho y la versión actual es muy diferente a la versión 1, utilizada durante mucho tiempo y muy conocida. A partir de la versíon 2 son todas compatibles entre sí, pero no hay una retrocompatibilidad con la 1.</p><p>Algo interesante es que Angular funciona con <strong>Typescript</strong>, destacándose como una solución de sintaxis fuertemente tipada.</p><p>Los objetos que angular propone son varios:</p><ul><li><strong>Modules: </strong>permite agrupar distintos objetos como componentes, servicios, pipes, etc generando así la organización de nuestro código por features.</li><li><strong>Components:</strong> conceptualmente se basa en parte en los componentes de <em>React</em> y otro poco en <em>Web Components</em>. Son el conjunto de un controlador y un template (vista), donde además en esta versión pueden recibir propiedades de Input y Ouput.</li><li><strong>Templates</strong>: si bien en Angular no podemos inyectar JS como en el caso de React, las directivas y utilidades que trae son más que suficientes para realizar cualquier tarea.</li><li><strong>Inject</strong>: Es un <em>decorator</em> que nos permite configurar servicios inyectables y disponibles en otros objetos de nuestros módulos. Es el modo que utiliza el framework para manejar las inyección de dependencias.</li><li><strong>HttpClient: </strong>Este servicio ofrece un funcionalidades para conectarnos a cualquier API. Incluye también un <em>Iterceptor</em> que nos sirve como middleware para intervenir cualquier llamada.</li><li><strong>Routing: </strong>es un módulo donde se definen las rutas de nuestra aplicación y las características. Si bien es bastante similar a cualquier utilidad de routing, trae consigo los dos items siguientes que son bastante interesantes.</li><li><strong>Lazy Modules:</strong> En el routing además de definir rutas para componentes, se puede matchear una ruta con un módulo y que su carga sea Lazy. Para esto utiliza los beneficios de <em>Webpack</em> y genera un chunk js que se cargara únicamente cuando ingresamos en la ruta definida.</li><li><strong>Guards</strong>: Estos objetos son súper útiles. Cuando estamos realizando una webapp seguramente necesitamos que haya una capa de seguridad y protección de ciertos módulos / features. Los <em>guards</em> se implementan en las rutas y son unas interfaces que nos permiten definir funciones bypass para que un usuario con cierta configuración ingrese o no a un módulo. También permiten que estas funciones sean asincrónicas (como <em>Observables</em>).</li><li><strong>Observables:</strong> Esto no es un simple feature nuevo que se implementó en esta versión. Aquí podemos decir que Angular (viniendo de la versión 1 — AngularJS) cambió completamente su paradigma. Abandonó su propuesta de MVC (o MV*) clásica y la remplazó por una solución fuertemente <em>reactiva. </em>Para eso incorporó la librería <em>RxJS</em> (que trabaja con flujos asincrónicos, transformaciones, buses de eventos, etc) y la utiliza en varios de sus objetos.</li><li><strong>Pipes:</strong> esta funcionalidad es parte de los templates y permite transformar/procesar strings dentro de nuestos templates. Un hermoso Pipe que trae esta versión de Angular es el pipe <em>‘async’</em> que nos permite hacer data-binding de objetos asincrónicos (ya sean Promises u Observables)</li><li><strong>Testing: </strong>viene configurado y andando perfectamente <em>KarmaJS</em>, en el cual podemos correr browsers (de distintos vendors) y en ellos correr los tests que definamos. Trabaja con <em>Jasmin</em> y es super ágil. También podemos hacer <em>Shallow Test</em> de los componentes y sus elementos.</li><li><strong>CLI:</strong> además de levantar un server dev para poder desarrollar o para buildear nuestra aplicación, el cli brinda la posibilidad de generar nuevos módulos, componentes, etc. De esta manera hace más fácil la generación de nuevos objetos.</li></ul><h3>La decisión</h3><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2F2gtoSIzdrSMFO%2Ftwitter%2Fiframe&amp;url=https%3A%2F%2Fgiphy.com%2Fgifs%2Fwinner-2gtoSIzdrSMFO&amp;image=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2F2gtoSIzdrSMFO%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="326" frameborder="0" scrolling="no"><a href="https://medium.com/media/cbb9e11a672068405d632b19c3e548b7/href">https://medium.com/media/cbb9e11a672068405d632b19c3e548b7/href</a></iframe><p>Luego de generar los dos POCs, terminamos eligiendo <strong>Angular </strong>para este proyecto.</p><p>Para nuestra plataforma necesitábamos una tecnología integral que nos provea un contexto ordenado, estable y escalable para poder generar un código mantenible y de calidad. Creemos con seguridad que Angular era el camino correcto más que nada por el tema de seguridad de módulos. Sin embargo, para otros proyectos (como por ejemplo el ecommerce) decidimos usar <strong>React</strong>.</p><h3>UI Library</h3><p>Luego de elegir la tecnología migramos todos nuestros componentes presentacionales (aka Trocafone Base UI) que teníamos codeados anteriormente en CSS/Vainilla a Angular. Estos son:</p><ul><li>Input</li><li>Search</li><li>Dropdown</li><li>Alert</li><li>Radio</li><li>Logo</li><li>Navigation</li><li>Button</li><li>Checkbox</li><li>Textarea</li><li>Table</li><li>Icon</li></ul><p>Generando un repositorio (y npm) independiente para poder utilizar desde distintos proyectos.</p><h3>Conclusión</h3><p>Lo único <em>constante</em> que hay mundo del front-end, es el <em>cambio</em>. Y cada vez los cambios son más rápidos. Lo que hoy usamos, seguramente en cinco meses será algo viejo. Las tecnologías, los paradigmas, los flujos, etc.</p><p>Sin embargo, para encarar cualquier tipo de proyecto, siempre es importante detenerse, tomar un tiempo, y analizar cuál es la mejor opción y no dejarse llevar únicamente por lo <em>hype</em>.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FeE26mRFGxnasU%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2FeE26mRFGxnasU%2Fgiphy.gif&amp;image=https%3A%2F%2Fi.giphy.com%2Fmedia%2FeE26mRFGxnasU%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="244" frameborder="0" scrolling="no"><a href="https://medium.com/media/5aa27d56f534fbf8a0a1710b6a7cb722/href">https://medium.com/media/5aa27d56f534fbf8a0a1710b6a7cb722/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5b955ad9be70" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trocafone/react-vs-angular-la-historia-detr%C3%A1s-de-una-elecci%C3%B3n-5b955ad9be70">React vs Angular. La historia detrás de una elección.</a> was originally published in <a href="https://medium.com/trocafone">Trocafone</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Angular: Pipe `async` en profundidad]]></title>
            <link>https://medium.com/@polbac/angular-pipe-async-en-profundidad-1954f3b481ba?source=rss-a7a647ae29f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/1954f3b481ba</guid>
            <category><![CDATA[angular2]]></category>
            <category><![CDATA[angular-6]]></category>
            <category><![CDATA[async]]></category>
            <dc:creator><![CDATA[polbac]]></dc:creator>
            <pubDate>Mon, 10 Sep 2018 03:32:39 GMT</pubDate>
            <atom:updated>2018-09-10T03:45:28.177Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Con este nuevo pipe podrás hacer data binding con capas de datos asincrónicas sin tener que subscribirte a sus respuestas.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vvdZmjNC2xc7e9pTs0v0Dw.jpeg" /></figure><h3><strong>Background</strong></h3><p>Cuando estamos creando un componente, sea en el framework/librería que sea, es muy común hacer data-binding a variables dentro de la lógica.</p><pre>&lt;p&gt;Resultados encontrados: {{ results.length }}&lt;/p&gt;</pre><p>De esta manera nuestro contenido es dinámico y cuando nuestra capa de datos actualiza automáticamente se actualiza el markup.</p><p>También en algunos frameworks, como Angular podemos hacer <strong>Two-ways data binding</strong>.</p><pre>import { Component } from &#39;@angular/core&#39;;<br><br>@Component({<br>  selector: &#39;my-form&#39;,<br>  template: `<br>    &lt;input type=&quot;text&quot; [(ngModel)]=&quot;name&quot;/&gt;<br>  `<br>})<br>export class AppComponent { <br>  name: string = &lt;string&gt;&#39;&#39;;<br>}</pre><p>En este caso cuando definimos que el input tendrá como modelo la variable <strong>name,</strong> los datos se propagan en dos direcciones:</p><ul><li>Cada vez que la capa de datos actualiza el valor de <strong>name</strong> el input se actualizará.</li><li>Cada vez que el usuario escriba en el input modificará la variable <strong>name</strong>.</li></ul><h3>El problema</h3><p>Cuando tenemos que utilizar datos asincrónicos, como por ejemplo hacer un <strong>get()</strong> tenemos que realizar un trabajo adicional.</p><pre>import { Component, OnInit } from &#39;@angular/core&#39;;<br>import { <a href="https://angular.io/api/common/http/HttpClient">HttpClient</a> } from &#39;@angular/common/http&#39;;</pre><pre>import { Item } from &#39;types/item&#39;;</pre><pre>@Component({<br>  selector: &#39;my-list&#39;,<br>  template: `<br>    &lt;ul&gt;<br>        &lt;li *ngFor=&quot;let item of items&quot;&gt;{{item.name}}&lt;li&gt;<br>    &lt;/ul&gt;`<br>})<br>export class AppComponent implements OnInit {</pre><pre>  public items: Item[] = [];<br>  <br>  constructor(private http: <a href="https://angular.io/api/common/http/HttpClient">HttpClient</a>)){ }</pre><pre><br>  ngOnInit() {<br>    this.fetchItems();<br>  }</pre><pre>  fetchItems() {<br>     this.http.get&lt;Item[]&gt;(&#39;api/items&#39;)<br>              .subscribe((items: Item[]) =&gt; this.items = items);<br>  }</pre><pre>}</pre><p>Implementar un <strong>get()</strong> a partir del servicio <strong>HttpClient</strong> que nos provee Angular, y luego guardamos la respuesta dentro de nuestra variable <strong>items</strong>.</p><h3><strong>AsyncPipe</strong></h3><p>Este nuevo pipe nos resuelve este gran problema de una manera muy simple y al mismo tiempo potente.</p><p>Puede ser utilizado con dos tipos de datos:</p><ul><li>&lt;Observable&gt;</li><li>&lt;Promise&gt;</li></ul><h4>Observable</h4><p>Como el servicio <strong>HttpClient </strong>devuelve un Observable podemos utilizarlo como ejemplo:</p><pre>import { Component, OnInit } from &#39;@angular/core&#39;;<br>import { <a href="https://angular.io/api/common/http/HttpClient">HttpClient</a> } from &#39;@angular/common/http&#39;;</pre><pre>import { Item } from &#39;types/item&#39;;</pre><pre>@Component({<br>  selector: &#39;my-list&#39;,<br>  template: `<br>    &lt;ul&gt;<br>        &lt;li *ngFor=&quot;let item of (getItems() | async)&quot;&gt;<br>            {{item.name}}<br>        &lt;li&gt;<br>    &lt;/ul&gt;`<br>})<br>export class AppComponent implements OnInit {<br>  <br>  constructor(private http: <a href="https://angular.io/api/common/http/HttpClient">HttpClient</a>)){ }</pre><pre>  ngOnInit() {<br>    this.fetchItems();<br>  }</pre><pre>  getItems() {<br>     return this.http.get&lt;Item[]&gt;(&#39;api/items&#39;)<br>  }</pre><pre>}</pre><p>Utilizando este pipe ya no necesitamos guardar la respuesta del fetch en una variable local, sino que nos referenciamos directamene al Observable.</p><pre>&lt;li *ngFor=&quot;let item of (getItems() | async)&quot;&gt;<br>   {{item.name}}<br>&lt;li&gt;</pre><h4>Promise</h4><pre>import { Component, OnInit } from &#39;@angular/core&#39;;</pre><pre>import { Item } from &#39;types/item&#39;;</pre><pre>@Component({<br>  selector: &#39;my-list&#39;,<br>  template: `<br>    &lt;ul&gt;<br>        &lt;li *ngFor=&quot;let item of (getItems() | async)&quot;&gt;<br>            {{item.name}}<br>        &lt;li&gt;<br>    &lt;/ul&gt;`<br>})<br>export class AppComponent implements OnInit {</pre><pre>  ngOnInit() {<br>    this.fetchItems();<br>  }</pre><pre>  getItems() {<br>     return fetch(&#39;api/items&#39;)<br>  }</pre><pre>}</pre><p>De esta forma también podemos utilizar AsyncPipe con una <strong>Promise</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1954f3b481ba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[React Beginners: Anatomía de un Componente.]]></title>
            <link>https://medium.com/@polbac/react-beginners-qu%C3%A9-elementos-componen-un-componente-react-anatom%C3%ADa-y-funcionamiento-282065377dfe?source=rss-a7a647ae29f5------2</link>
            <guid isPermaLink="false">https://medium.com/p/282065377dfe</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[components]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[polbac]]></dc:creator>
            <pubDate>Wed, 22 Aug 2018 20:05:16 GMT</pubDate>
            <atom:updated>2018-08-27T19:21:43.246Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Lo mejor de React es que es súper fácil de aprender. Hacer un ‘Hola mundo’ y familiarizarse con la onda React lleva muy poco tiempo.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*AL_YmH7gjFZbQLRElqaKew.jpeg" /></figure><h3>Import</h3><p>Para poder generar un componente de React necesitamos importarlo, lo hacemos de la siguiente manera</p><pre>import React, { Component } from &#39;react&#39;;</pre><h3>Declaración</h3><p>Aquí definimos el tipo de componente, puede ser <strong>Component.React</strong> o <strong>Component.PureComponent</strong>, más abajo está la descripción del segundo.</p><pre>export class HelloWorldComponent extends Component.React {<br>  ...<br>}</pre><h3>Implementación</h3><p>Una vez declarado el componente vamos a poder utilizarlo en cualquier otro componente, siempre y cuando lo importemos</p><pre>import { HelloWorldComponent } from &#39;./components/hello-world&#39;;</pre><pre>...</pre><pre>&lt;HelloWorldComponent /&gt;</pre><h3>State</h3><p>Básicamente es un contenedor de datos donde se almacenará el <em>estado</em> de un componente. El estado de un componente es la configuración del mismo en un momento determinado. La idea es que los componentes vayan mutando dependiendo de factores externos o internos al mismo. Con un poco de imaginación podríamos pensar en que podríamos viajar en el tiempo y ver como un componente iría variando. Posee propiedades de lectura y escritura y es inmutable.</p><pre>this.setState({<br>     title: &#39;This is the best article in the world&#39;,<br>     price: 99.99,<br>     ...<br>});</pre><p>Cuando un componente no tiene <em>state</em> (stateless) podemos definirlo como <strong>PureComponent</strong>. En el universo React cuantos más componentes de este tipo tengamos en nuestra aplicación, mejor estamos haciendo bien las cosas.</p><h3>Props</h3><p>La idea es que los componentes se comuniquen, hereden estados, atributos, comportamientos. El canal por el cual un componente recibe estados de un componente superior, es a través de las props (propiedades).</p><pre>&lt;TheBestComponentInTheWorld color=&quot;#666&quot; image=&quot;i-am-the-devil.jpg&quot; /&gt;</pre><p>Las props son de solo lectura y la idea es que configuren nuestro componente. Dentro del scope de un componente es tan simple como leerlas desde el atributo <em>props</em>.</p><pre>const { color, image } = this.props;</pre><h3>Render (jsx)</h3><p>Y aquí es donde la magia sucede, donde se justifica React.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FreDuckpHdUNX2%2Ftwitter%2Fiframe&amp;url=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2FreDuckpHdUNX2%2Fgiphy.gif&amp;image=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2FreDuckpHdUNX2%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="283" frameborder="0" scrolling="no"><a href="https://medium.com/media/28d8e8c08f7b1936573e4e430c77eef0/href">https://medium.com/media/28d8e8c08f7b1936573e4e430c77eef0/href</a></iframe><p>El método <strong>render()</strong> es equivalente al concepto de<em> template engine</em> de Angular/VUE/Handlebars/Mustache/etc.</p><p>Este método debe retornar un elemento del tipo <strong>JSX</strong>, siendo una mezcla entre Javascript y XML. En esta sintaxis podemos dentro del contexto de Javascript incluir etiquetas:</p><pre>const button = &lt;button&gt;Click me bitch!&lt;/button&gt;;</pre><p>Y dentro de HTML también agregar Javascript, de esta manera tenemos una agradable libertad y una poderosa potencialidad para poder crear nuestros templates de manera inteligente y ordenada.</p><pre>render() {<br>     const { title, news } = this.props;</pre><pre>     return (<br>           &lt;div class=&#39;the-nice-component&#39;&gt;</pre><pre>             &lt;h2&gt;{title}&lt;/h2&gt;<br>             <br>             {news.map(n =&gt; &lt;News data={n} /&gt;}</pre><pre>          &lt;/div&gt;<br>     );<br>}</pre><h3>LifeCycle</h3><p>Son un conjunto de métodos que poseen los componentes React que se ejecutan en un determinado momento. Corresponden al ciclo de vida de un componente, desde que se genera, muta y se destruye. Estos métodos fueron cambiando en las distintas versiones de React y algunos fuero deprecándose.</p><p>Los más importantes a utilizar son:</p><ul><li><strong>componentDidMount()</strong> se dispara cuando un componente está montado en el DOM / flow aplicación.</li><li><strong>componentWillUnmount()</strong> cuando se desmonta / elimina de la aplicación.</li><li><strong>componentDidUpdate()</strong> cada vez que se actualiza.</li><li><strong>shouldComponentUpdate(</strong>nextProps, nextState<strong>)</strong> este método debe retornar un booleano y de esta manera evaluar si debería actualizarse o no a partir de las props/ state.</li><li><strong>componentDidCatch()</strong> a partir de la versión 16 se agregó este método y es súper útil para poder detectar cuando un componente falla.</li></ul><h3><strong>The End</strong></h3><p>Bueno asta acá llegamos. Cómo dice al principio este artículo React es súper fácil: los elementos que contiene un componente de React no son muchos, los conceptos no son para nada difíciles de aprender / utilizar.</p><p>Ahora… hay algo que decir: cuando empezás a utilizar React para una aplicación que salga de una simple landing, o un formulario de pocos campos y necesitas implementarlo en una aplicación con un flow más complejo, todo cambia. Todo se vuelve confuso y oscuro. Ahí es cuando necesitas aprender Redux, MobX o cualquier otro state manager.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=282065377dfe" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>