<?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[Entendiendo JavaScript - Medium]]></title>
        <description><![CDATA[Artículos semanales sobre JavaScript, aprende no solo las buenas partes, también las partes raras y poderosas del lenguaje. Articulo nuevo cada viernes. - Medium]]></description>
        <link>https://medium.com/entendiendo-javascript?source=rss----a55affbbd35e---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Entendiendo JavaScript - Medium</title>
            <link>https://medium.com/entendiendo-javascript?source=rss----a55affbbd35e---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 04:18:23 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/entendiendo-javascript" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Hindley-Milner en JavaScript]]></title>
            <link>https://medium.com/entendiendo-javascript/hindley-milner-en-javascript-7ef0b0370818?source=rss----a55affbbd35e---4</link>
            <guid isPermaLink="false">https://medium.com/p/7ef0b0370818</guid>
            <category><![CDATA[funciones]]></category>
            <category><![CDATA[hindley-milner]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Yeison Daza ]]></dc:creator>
            <pubDate>Wed, 10 Aug 2016 15:39:39 GMT</pubDate>
            <atom:updated>2018-06-30T15:05:48.555Z</atom:updated>
            <content:encoded><![CDATA[<p>Una parte fundamental de programar es la manera en que documentamos el código que escribimos, hoy veremos una manera de documentar funciones en JavaScript.</p><p><strong><em>Nota: Este contenido lo publiqué primero en </em></strong><a href="https://tinyletter.com/yeion7"><strong><em>mi newsletter</em></strong></a><strong><em>, la semana después de publicar el newsletter publico en mi blog, si quieres ser el primero en leer </em></strong><a href="https://tinyletter.com/yeion7"><strong><em>suscríbete</em></strong></a><strong><em>.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OhNaGDOKAt5D0VSda-Vjfg.jpeg" /></figure><p>La semana pasada vimos como <a href="https://medium.com/entendiendo-javascript/componiendo-funciones-en-javascript-6fd956bc7f71#.wxxggjozw">componer funciones en JavaScript</a>, como dijimos después de crear un función nos interesa cómo se relacionan con otras funciones y no tanto su implementación.</p><p>Para entender esta relación debemos pensar en los tipos de datos que recibe y retornan las funciones.</p><blockquote>En JavaScript los valores son los que tienen tipos, no las variables —<a href="https://medium.com/entendiendo-javascript/entendiendo-los-tipos-en-javascript-4c1c718e8e2a"> Tipos en JavaScript</a></blockquote><p>JavaScript no tiene un sistema fuerte de pitado de sus variables, para comprobar estos podríamos usar una librería como <a href="https://flowtype.org/">Flow</a>.</p><p>Hoy veremos una manera de documentar las funciones siguiendo un sistema utilizado en programación funcional, bastante simple y que resulta útil cuando leamos código.</p><h4>Hindley-Milner</h4><p>Este es un sistema de tipos creado para el <a href="https://medium.com/entendiendo-javascript/calculo-lambda-en-javascript-57ea69b427b1#.q9h2dta1y">calculo Lambda</a>, es usado en lenguajes funcionales, principalmente <a href="http://dev.stephendiehl.com/fun/006_hindley_milner.html">Haskell</a>.</p><p>Veamos como podemos documentar nuestras funciones usando este sistema.</p><blockquote>Hindley-Milner es una notación bastante sencilla que nos va a dar claridad de como se comporta la función respecto a sus tipos.</blockquote><p>Recordemos que los tipos básicamente son una colección de valores, por ejemplo si nos referimos al tipo <em>Booleano</em>, es una colección de dos valores (True, False).</p><p>Comencemos viendo como se escriben los tipos básicos.</p><h4>Tipos básicos</h4><pre><strong>Bool</strong>    —  booleanos<br><strong>Char</strong>    —  Caracter sencillo<br><strong>String</strong>  —  Cadena de caracteres<br><strong>Integer</strong> —  Números enteros <br><strong>Float</strong>   —  Números con punto flotante</pre><h4>Tipos de lista</h4><p>Las listas son secuencias de valores, estos son fundamentales en cualquier lenguaje funciones (JavaScript no es un lenguaje puramente funcional, así que las listas son un tipo especial de objetos)</p><p><strong>Arrays</strong></p><p>Los arrays son colecciones de un mismo tipo, para escribirlas podemos usar el tipo que las compone sin importar la longitud.</p><pre>// xs :: [Bool]</pre><pre>const xs = [False, True, False, True]</pre><pre>// ns :: [Char]]</pre><pre>const ns = [&#39;a&#39;, &#39;b&#39;, &#39;c&#39;]</pre><p>También podemos escribir listas de listas</p><pre>xss :: [[Char]]</pre><pre>const xss = [[‘a’], [‘a’,’c’]]</pre><blockquote>Los arrays normalmente se escriben con los nombres como <strong>xs, ns, xss</strong></blockquote><h4>Tipos tupla</h4><p>En JavaScript no existe un tipo tupla, pero es un tipo de dato importante.</p><p>Tupla es una secuencia de valores de diferente tipo, estas podemos usarla para escribir los tipos de datos que acepta una función.</p><pre>// (Bool, Bool)<br>(False, True)</pre><pre>// (Bool, Char, Integer)<br>(False, &#39;a&#39;, 12)</pre><p>Con esto ya vimos los tipos de datos que normalmente se usan en las funciones ahora veamos como documentar estas.</p><h4>Documentando nuestras funciones</h4><p>Como ya sabemos una función es un <strong>mapa de valores</strong> de un tipo a valores de otro tipo o el mismo, esta relación la podemos escribir usando una flecha (→) que representa la función.</p><pre>// not :: Bool → Bool<br>const not = (a) =&gt; !(a) ;</pre><pre>// isDigit :: a → Bool<br>const isDigit = (x) =&gt; typeof(x) === &#39;number&#39;</pre><pre>// add :: (Int, Int) → Int<br>const add = (x,y) =&gt; x + y</pre><pre>// take :: ([a], Int) → a<br>const take = (xs, i) =&gt; xs[i]</pre><pre>// length :: String → Number<br>const length = (a) =&gt;  return a.length</pre><p>Cómo vemos documentar una función es bastante sencillo y nos da información sobre que tipos acepta y entrega la función.</p><p>Por ejemplo la función <em>add</em>, recibe una tupla de dos números y retorna un número.</p><p>Pero si vemos la función <em>isDigit</em> vemos algo interesante, su tipo de entrada lo escribimos con una <em>a</em>, esto es porque esta función no recibe un tipo especifico, puede recibir varios tipos.</p><p>Veamos un poco esto.</p><h4>Funciones polimorficas</h4><p>Existen funciones donde los datos que recibe o entrega pueden ser de varios tipos, cuando contiene uno o más tipos variables se llaman funciones polimorficas.</p><pre>// length :: [a] → Int<br>const length = (xs) =&gt; xs.length();</pre><pre>length([true, false, true]); // 3<br>length([1,2,3,4,5]); // 5</pre><pre>// id :: a → a<br>const id = (x) =&gt; x</pre><pre>id(&#39;a&#39;); //a<br>id(12); //12</pre><p>En la función id esta puede recibir valores de cualquier tipo, asi que podemos escribir este tipo con <em>a, </em>los tipos variables se escriben con letras como a, b, c, etc.</p><blockquote>Un tipo variable debe iniciar con minúscula, mientras que los tipos fijos comienzan con mayúscula</blockquote><h4>Funciones currificadas</h4><p>Como ya sabemos podemos escribir <a href="https://medium.com/entendiendo-javascript/currying-en-javascript-funciones-con-superpoderes-1c8760c728a">funciones currificadas</a>, así que podemos documentar estas de la siguiente forma.</p><pre>// add :: Int → Int → Int <br>const add = x =&gt; y =&gt; x + y</pre><pre>// map :: (a → b) → [a] → [b]<br>const map = curry(function(f, xs) {<br>  return xs.map(f);<br>});</pre><pre>// reduce :: (b -&gt; a -&gt; b) -&gt; b -&gt; [a] -&gt; b<br>const reduce = curry(function(f, x, xs) {<br>  return xs.reduce(f, x);<br>});</pre><p>El valor que retorna la función es el último, y las funciones las podemos agrupar de derecha a izquierda.</p><p>Las funciones <em>map</em> y <em>reduce</em> son un poco más complejas que las anteriores, pero con esta documentación se entiende su proposito.</p><h4>Sobrecargar una función</h4><p>Una función polimorfica es llamada sobrecargada (overloaded) si tipo contiene una o más restricciones.</p><p>Por ejemplo</p><pre>sum :: Num a =&gt; (a, a) → a</pre><p>En esta función sum, antes de la flecha (=&gt;) estamos aclarando que el tipo a, es un tipo que debe ser numérico.</p><p>Así estamos colocando una condición del tipo que se puede utilizar.</p><pre>sum [1,2,3]</pre><pre>sum [‘a’,’b’,’c’] -&gt; error</pre><p>Algunas de las restricciones que se pueden utilizar son.</p><pre><strong>Num</strong>, tipo numérico<br><strong>Eq</strong> , tipo que pueda comparar igualdad<br><strong>Ord</strong>, tipo que pueda ser ordenado</pre><h4>Conclusión</h4><p>Este sistema de documentación es usado en la comunidad de programación funcional, si lees la <a href="http://ramdajs.com/0.21.0/docs/">documentación de Ramda</a> veras que usa esta notación para documentar los métodos que contiene.</p><p>Aunque esta notación no tiene una implementación en JavaScript, si podemos utilizarla como documentación que nos dará información importante al momento de componer funciones.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*OvyjlZ4boegoaGUWGgQ5OQ.gif" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7ef0b0370818" width="1" height="1" alt=""><hr><p><a href="https://medium.com/entendiendo-javascript/hindley-milner-en-javascript-7ef0b0370818">Hindley-Milner en JavaScript</a> was originally published in <a href="https://medium.com/entendiendo-javascript">Entendiendo JavaScript</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Componiendo funciones en JavaScript]]></title>
            <link>https://medium.com/entendiendo-javascript/componiendo-funciones-en-javascript-6fd956bc7f71?source=rss----a55affbbd35e---4</link>
            <guid isPermaLink="false">https://medium.com/p/6fd956bc7f71</guid>
            <category><![CDATA[funciones]]></category>
            <category><![CDATA[composition]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Yeison Daza ]]></dc:creator>
            <pubDate>Sat, 16 Jul 2016 15:34:56 GMT</pubDate>
            <atom:updated>2018-01-09T18:02:29.437Z</atom:updated>
            <content:encoded><![CDATA[<p>Para crear aplicaciones que resuelvan problemas complejos, debemos dividir estos en problemas pequeños que podamos resolver e implementar, luego componemos estas soluciones. Esto es lo que hacemos cada día como programadores y hoy veremos como hacer esto usando funciones en JavaScript.</p><p><strong><em>Nota: Este contenido lo publiqué primero en </em></strong><a href="https://tinyletter.com/yeion7"><strong><em>mi newsletter</em></strong></a><strong><em>, la semana después de publicar el newsletter publico en mi blog, si quieres ser el primero en leer </em></strong><a href="http://suscribete/"><strong><em>suscríbete</em></strong></a><strong><em>.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JWw9P6iXIkHs8bg0-nSVqw.jpeg" /></figure><p>Desde que se inventaron las sub-rutinas o la programación estructural usamos este concepto de crear bloques de código que podamos componer, en programación orientada a objetos todo es <a href="https://medium.com/entendiendo-javascript/entendiendo-la-composici%C3%B3n-en-javascript-ac7f0c384b8c#.bwf9598p5">componer objetos.</a></p><blockquote><em>Composición es la esencia de la programación.</em></blockquote><p>En lenguajes funcionales se compone usando funciones, las ideas teorías que sirven como base para esto también las podemos implementar en JavaScript.</p><h3>Componiendo en JavaScript</h3><p>Componer funciones se basa en combinar funciones simples para construir funciones más complicadas, para hacer esto el resultado de cada función es pasado como argumento de la siguiente.</p><blockquote><em>“La composición de funciones es el acto de dirigir el resultado de una función, a la entrada de otra, creando una nueva función” </em><a href="https://wiki.haskell.org/Function_composition"><em>Haskell Wiki</em></a></blockquote><p>JavaScript al implementar <a href="https://medium.com/entendiendo-javascript/funciones-de-alto-orden-en-javascript-42d04769d9b5">funciones de alto orden</a> y <a href="https://medium.com/entendiendo-javascript/entendiendo-closures-en-javascript-8fb9a284964e">closures</a> hace que esto sea bastante sencillo de lograr, podemos escribir esto como:</p><pre><strong>const</strong> compose = (f, g) =&gt; (x) =&gt; f(g(x));</pre><p>Con la función anterior podemos componer una función con dos funciones, para hacerlo con más funciones podemos reescribir esta función o usar una librería como <a href="http://ramdajs.com/0.21.0/docs/#compose">Ramda</a>, que tienen un método <strong>compose, </strong>este nos permite componer una función con <em>X</em> cantidad de funciones.</p><blockquote><em>En matemáticas, la composición de una función es definida como:</em></blockquote><blockquote><em>(f ◦ g)(x) = f (g(x)).</em></blockquote><p>Debemos tener claro:</p><ul><li>Las funciones se ejecutan de derecha a izquierda según se pasen a la función compone.</li><li>El tipo de dato que resulta de una función, debe ser el mismo que acepta como entrada la siguiente función.</li></ul><p>La idea principal es que cada función resuelva un pequeño problema y luego componemos una función que resuelva lo que deseamos hacer.</p><p>Veamos como funciona con código.</p><p>Para las siguientes funciones vamos a usar una lista de datos que puedes ver en este <a href="https://gist.github.com/yeion7/6c26b8bf1ad39f840f8741165ce12ed5">link</a>.</p><p><strong>Caso 1</strong></p><pre>/*<br> * Calcular el promedio de ingresos de todos los usuarios.<br> */</pre><pre><strong>import</strong> { prop, map, reduce, add, compose } <strong>from</strong> &#39;ramda&#39;;</pre><pre><strong>const</strong> average = (xs) =&gt; reduce(add, 0, xs) / xs.length;</pre><pre><strong>const</strong> incomesAverage = compose(average, map(prop(&#39;incomes&#39;)));</pre><pre>incomesAverage(USERS) <em>// 8333.333</em></pre><ul><li>Las funciones que reciben más de un argumento deben estar <a href="https://medium.com/entendiendo-javascript/currying-en-javascript-funciones-con-superpoderes-1c8760c728a#.99exgpptp">currificadas</a>.</li><li>Es una buena idea separar las <a href="https://medium.com/entendiendo-javascript/funciones-puras-en-javascript-crea-funciones-libres-c2b9b3785418#.z9oztzkva">funciones puras</a> de las que tienen efectos secundarios.</li></ul><p><strong>Caso 2.</strong></p><pre><em>/*<br> * Retornar el nombre del usuario con mejores ingresos<br> */</em></pre><pre><strong>import</strong> { compose, sortBy, prop, last } <strong>from</strong> &#39;ramda&#39;;</pre><pre><strong>const</strong> bestIncomes = compose(<br>                    prop(&#39;name&#39;),<br>                    last,<br>                    sortBy(prop(&#39;incomes&#39;))    <br>                );</pre><pre>bestIncomes(USERS); <em>// Laura Mantilla</em></pre><ul><li>Los datos fluyen de derecha a izquierda en las funciones, cada función procesan los datos que recibe.</li></ul><p><strong>Caso 3.</strong></p><pre><em>/*<br> * Retornar los nombre en minúscula y<br> * reemplazando espacios por underscores(_)<br> */</em></pre><pre><strong>import</strong> { compose, replace, toLower, prop, map } <strong>from</strong> &#39;ramda&#39;;</pre><pre><strong>const</strong> underscore = replace(/\s/g, &#39;_&#39;)</pre><pre><strong>const</strong> nameToLower = compose(toLower, prop(&#39;name&#39;))</pre><pre><strong>const</strong> toCamelCase = map(compose(underscore,namesToLower))<br></pre><pre>toCamelCase(USERS) <br><em>// [&#39;yeison_daza&#39;, &#39;camilo_suarez&#39;, &#39;laura_mantilla&#39;]</em></pre><ul><li>Una clave de la composición es que podemos agrupar las funciones como deseemos y ir componiendo funciones cada vez más complejas.</li></ul><p><strong>Caso 4.</strong></p><pre><em>/*<br> * Comprobar si alguien es un usuario<br> */</em></pre><pre>import { contains, map, prop, compose } from &#39;ramda&#39;;</pre><pre><strong>const</strong> toUsers = map(prop(&#39;nick&#39;));</pre><pre><strong>const</strong> isUser = <strong>function</strong>(user, data) { <br>    <strong>return</strong> compose(contains(user), toUsers)(data);<br>}</pre><pre>isUser(&#39;yeion7&#39;, USERS); <em>// true</em><br>isUser(&#39;nata1&#39;, USERS); <em>// false</em></pre><ul><li>Cada función debe esperar solo un argumento y operar sobre el, por esto es importante trabajar con funciones currificadas.</li></ul><h3>Funciones genéricas</h3><p>Para componer funciones es importante pensar en procesar datos abstractos, es decir una función va a procesar un tipo de dato, pero no sabemos que dato sera.</p><p>A este estilo se llama <em>point free</em>, veamos este ejemplo tomado de <a href="https://drboolean.gitbooks.io/mostly-adequate-guide/content/ch5.html">mostly adequate guide</a>.</p><pre><em>// No es point free porque esta especificando que es una palabra lo que espera</em><br><strong>var</strong> snakeCase = <strong>function</strong>(word) {<br>  <strong>return</strong> word.toLowerCase().replace(/\s+/ig, &#39;_&#39;);<br>};</pre><pre><em>// Si es pointfree</em><br><strong>var</strong> snakeCase = compose(replace(/\s+/ig, &#39;_&#39;), toLowerCase);</pre><p>De esta manera tenemos funciones genéricas.</p><p>Lo que buscamos con esto es crear piezas de código que al implementarlas no pensamos en detalles de su funcionamiento, solo nos enfoquemos en que tipos acepta y retorna.</p><p>No con todas las funciones podemos hacer esto, pero es importante buscar crear funciones de este estilo.</p><p><em>La próxima semana hablare sobre como documentar estas funciones.</em></p><h3>Teoría de categorías</h3><p>La composición de funciones esta fundamentada en la <strong>teoría de categorías</strong>, las ideas de estas han sido utilizadas por la comunidad de programación funcional durante mucho tiempo.</p><p>Una categoría se puede representar como:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5oUSKLuzS0xRr9hTNq3UGw.png" /></figure><p>Esta categoría esta compuesta por:</p><ul><li><strong>Objetos,</strong> son datos de cualquier tipo (String, Boolean, Number, etc), en este caso <em>X, Y, Z</em></li><li><strong>Morfismos,</strong> son funciones puras, en este caso <em>f, g</em></li><li><strong>Composición de los morfismos</strong>, en este caso una función compuesta por f y g</li><li><strong>Morfismo llamado identidad</strong>, cada objeto tiene una función que retorna su mismo valor.</li></ul><p><strong>Propiedades:</strong></p><ul><li><strong>La composición es asociativa</strong>: Si tienes tres funciones o más, se pueden agrupar de cualquier manera.</li></ul><blockquote>h∘(g∘f) = (h∘g)∘f = h∘g∘f</blockquote><p>No importa como agrupemos los elementos el resultado siempre va a ser el mismo</p><ul><li><strong>Cada objeto tiene una función identidad</strong>: La identidad es una función que retorna el mismo valor que recibe.</li></ul><pre><strong>const</strong> identity = (x) =&gt; x;</pre><p>En teoría de categorías no es importante ver como funciona cada objeto por dentro, todo lo que nos interesa saber es como se relacionan con otros.</p><p>No todos los objetos pueden ser compuestos, el tipo que produce el morfismo debe ser el mismo que recibe el siguiente morfismo.</p><h3>Conclusiones</h3><p>El saber descomponer un problema en pequeños problemas que podamos resolver es fundamental.</p><p>Creo que la composición es una excelente manera de escribir código elegante y mantenible, creando piezas de código que son del tamaño adecuado con las cuales creamos procesos que podemos entender.</p><p>También nos ayuda a manejar los efectos secundarios, los cuales podemos separar y saber en donde se ejecutan estos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*OvyjlZ4boegoaGUWGgQ5OQ.gif" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6fd956bc7f71" width="1" height="1" alt=""><hr><p><a href="https://medium.com/entendiendo-javascript/componiendo-funciones-en-javascript-6fd956bc7f71">Componiendo funciones en JavaScript</a> was originally published in <a href="https://medium.com/entendiendo-javascript">Entendiendo JavaScript</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[¿Por qué deberías apostar tu futuro profesional a JavaScript?]]></title>
            <link>https://medium.com/entendiendo-javascript/por-qu%C3%A9-deber%C3%ADas-apostar-tu-futuro-profesional-a-javascript-9247b5c8da9b?source=rss----a55affbbd35e---4</link>
            <guid isPermaLink="false">https://medium.com/p/9247b5c8da9b</guid>
            <category><![CDATA[español]]></category>
            <category><![CDATA[fundamentals]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Yeison Daza ]]></dc:creator>
            <pubDate>Wed, 06 Jul 2016 15:10:28 GMT</pubDate>
            <atom:updated>2018-01-09T18:02:40.036Z</atom:updated>
            <content:encoded><![CDATA[<p>Si quieres aprender a programar o aprender un nuevo lenguaje de programación, este es un buen momento para aprender JavaScript, déjame contarte por qué.</p><p><strong><em>Nota: Este contenido lo publiqué primero en </em></strong><a href="https://tinyletter.com/yeion7"><strong><em>mi newsletter</em></strong></a><strong><em>, la semana después de publicar el newsletter publico en mi blog, si quieres ser el primero en leer </em></strong><a href="http://suscribete/"><strong><em>suscríbete</em></strong></a><strong><em>.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FF6eKN77sOJGIxzm2YesGg.jpeg" /></figure><p>Este año JavaScript cumple 21 años, mucho tiempo ha pasado desde que <a href="https://es.wikipedia.org/wiki/Netscape_Navigator">NetScape</a> contrató a <a href="https://es.wikipedia.org/wiki/Brendan_Eich">Brendan Eich</a> con el fin de crear un lenguaje de programación, el cual colocaría a su favor lo que hoy conocemos como <a href="https://es.wikipedia.org/wiki/Guerra_de_navegadores"><strong>la</strong> <strong>guerra de los navegadores</strong></a><strong>.</strong></p><p>Aunque NetScape perdió, afortunadamente JavaScript sobrevivió (gracias a su comunidad) en medio de incompatibilidades entre navegadores siguió siendo el lenguaje de la web.</p><p>Luego de pasar más de una década sin actualizaciones (aun así se crearon cosas increíbles) el lenguaje tuvo una actualización importante en 2015 siendo lanzado ES2015.</p><p>Por eso creo que es un buen momento para pensar porque apostar tu futuro profesional a aprender JavaScript.</p><h4>Apoyo de la industria</h4><p>Cuando Google lanzó gmail y le mostró al mundo el poder de JavaScript utilizando Ajax para no tener que recargar las páginas al hacer nuevos request, la industria cambio completamente.</p><p>Hoy empresas como Netflix, Spotify, Yahoo, Medium, Platzi, Uber e incluso la Nasa lo utilizan para construir sus plataformas tecnológicas.</p><p>Pero más allá de que lo usen, el comité de desarrollo del lenguaje (TC39) esta conformado y representado por ingenieros de grandes empresas tecnológicas, las cuales buscan hacer que el lenguaje avance.</p><p>Esto nos lleva a dos cosas,</p><ul><li>El lenguaje seguirá creciendo cumpliendo requerimientos de la industria en manos de personas que están altamente calificadas.</li><li>Mientras más empresas apuestan por JavaScript, la cantidad de vacantes para JavaScript developers crece cada año y esto increíblemente lleva a que los sueldos de estos suban por la demanda de buenos programadores en la industria.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/625/1*IGI289ZYKz3YImaHlb4pMQ.png" /><figcaption><a href="https://blog.bloc.io/2014-javascript-developer-job-trends-report/">Job Trends Report: The Job Market for JavaScript Developers</a></figcaption></figure><h4>Programa lo que quieras</h4><p>JavaScript en sus inicios era utilizado para crear animaciones e interacciones sencillas en los sitios web, pero en 2009 se lanzo el proyecto <a href="https://nodejs.org/en/">nodeJS</a> el cual llevo a JavaScript al back-end, esto representó grandes posibilidades y un cambio en la industria.</p><p>Hoy podemos utilizar JavaScript en casi cualquier cosa que se nos ocurra, permitiendo algo genial: hacer el código muchas veces reusable y pensar en un solo lenguaje.</p><blockquote>Netflix utiliza JavaScript para construir sus aplicaciones para <strong>todos</strong> los dispositivos que soporta.</blockquote><p>Si quieres ser <a href="https://facebook.github.io/react/">front-end</a>, <a href="http://expressjs.com/">back-end</a>, <a href="https://facebook.github.io/react-native/">crear aplicaciones móviles</a>, <a href="http://www.nodecopter.com/">programar drones</a>, <a href="https://wit.ai/">programar bots</a>, <a href="https://www.mongodb.com/es">manejar bases de datos</a>, etc.</p><p>Puedes aprender un solo lenguaje y usarlo a través de todos.</p><h4>Te da libertad de aprender y crecer</h4><p>Como ya dije el lenguaje tuvo una época donde no se lanzaron nuevas versiones, Aunque si tuvo propuestas y avances dentro de la comunidad, esto debido a que JavaScript integra grandes ideas dentro de un lenguaje de programación.</p><p>JavaScript te da la libertad de programar con el paradigma que desees, puedes:</p><ul><li>Programar orientado a objetos, con un sistema de <a href="https://medium.com/entendiendo-javascript/entendiendo-la-delegaci%C3%B3n-en-javascript-8d99e3bc3826#.1vduj0jlc">delegación</a> y <a href="https://medium.com/entendiendo-javascript/entendiendo-la-composici%C3%B3n-en-javascript-ac7f0c384b8c#.ms7sf3iyl">composición</a> mucho más sencillo que los basados en clases y jerarquías.</li><li>Programar utilizando el paradigma funcional, ya que aplica conceptos de closures y funciones como ciudadanos de primera clase, sin ser tan estricto como lenguajes funcionales puros.</li><li>Puedes utilizar programación reactiva la cual te da la posibilidad de trabajar con grandes cantidades de datos de manera eficiente.</li><li>Puedes trabajar de manera asíncrona, ya que tiene un modelo de concurrencia genial y simple de entender, perfecto para crear plataformas real time.</li></ul><h4>La comunidad no te dejara solo</h4><p>JavaScript es el lenguaje con una de las comunidades de desarrollo más grandes, siendo rankeado por Github en 2015 como el lenguaje de programación más popular.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y9ArANdKox3qGATSUsc1jA.jpeg" /><figcaption><a href="https://github.com/blog/2047-language-trends-on-github">Language Trends on GitHub</a></figcaption></figure><p>Además de esto cuenta con el gestor de paquetes más grande de un lenguaje de programación.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/952/1*WEa8vRMeN88htOU4g3a3Pg.png" /></figure><p>Estas dos cosas son solo una muestra de lo increíble que es su comunidad y no solo por lo activa que es, si no porque es una comunidad que propone y no existen verdades absolutas; siempre busca hacer las cosas mejor y siguiendo conceptos increíbles como: divide y vencerás, o mantener las cosas simples, etc.</p><p>Puedes buscar en tu ciudad <a href="http://www.meetup.com/es/">meetups</a> de JavaScript o grupos que se reúnan y muy posiblemente conseguirás uno o varios.</p><h4>Conclusión</h4><p>Siéndote sincero no vas a aprender JavaScript en una semana, posiblemente te tome más de 6 meses en entender el lenguaje y las herramientas para crear productos increíbles.</p><p>Pero van a valer totalmente la pena y vas a estar en un viaje de aprendizaje increíble, donde conozcas programadores muy talentosos que te reten a ser mejor profesional cada día y ha crear productos que impacten en la vida de cientos o miles de personas.</p><p>Si estas comenzando y no sabes mucho inglés, puedes visitar nuestro repositorio donde recopilamos <a href="https://github.com/sergiodxa/impresionante-javascript">recursos increíbles para aprender JavaScript en español.</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*OvyjlZ4boegoaGUWGgQ5OQ.gif" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9247b5c8da9b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/entendiendo-javascript/por-qu%C3%A9-deber%C3%ADas-apostar-tu-futuro-profesional-a-javascript-9247b5c8da9b">¿Por qué deberías apostar tu futuro profesional a JavaScript?</a> was originally published in <a href="https://medium.com/entendiendo-javascript">Entendiendo JavaScript</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Inmutabilidad en JavaScript]]></title>
            <link>https://medium.com/entendiendo-javascript/wip-immutabilidad-en-javascript-todo-a-cambiado-d3d4dc3f997?source=rss----a55affbbd35e---4</link>
            <guid isPermaLink="false">https://medium.com/p/d3d4dc3f997</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[inmutablidad]]></category>
            <category><![CDATA[objetos]]></category>
            <dc:creator><![CDATA[Yeison Daza ]]></dc:creator>
            <pubDate>Thu, 30 Jun 2016 15:21:45 GMT</pubDate>
            <atom:updated>2018-01-09T18:05:53.079Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>“La inmutabilidad habilita el JavaScript del futuro”</blockquote><p>No podría estar más de acuerdo, esta característica propia de los lenguajes funcionales comienza a tener gran importancia y hoy veremos porque.</p><p><strong><em>Nota: Este contenido lo publiqué primero en </em></strong><a href="https://tinyletter.com/yeion7"><strong><em>mi newsletter</em></strong></a><strong><em>, la semana después de publicar el newsletter publico en mi blog, si quieres ser el primero en leer </em></strong><a href="http://suscribete/"><strong><em>suscríbete</em></strong></a><strong><em>.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1w8Jk_NEcGn3arujgIq8Rw.png" /></figure><p>Una de las características más importantes de los lenguajes funcionales es que sus estructuras de datos son inmutables, las cuales muestran reducir la complejidad del software.</p><blockquote>La verdad es el constante cambio, la mutación oculta los cambios, los cambios se manifiestan en caos, por lo tanto, el sabio abraza la historia. — <a href="https://medium.com/javascript-scene/the-dao-of-immutability-9f91a70c88cd#.b1cayh7g7">The Dao of Immutability</a></blockquote><p>Pero en lenguajes imperativos como JavaScript por defecto son mutables.</p><pre>const objeto = {cosa: ‘casa’};</pre><pre>function cambiarCosa(obj) {<br> return obj.cosa = ‘Carro’;<br>}</pre><pre>cambiarCosa(objeto) //mutación</pre><pre>console.log(objeto) // {cosa: &#39;Carro&#39;}</pre><p>Esto es útil ya que resulta mucho más fácil modelar un personaje de un juego como un objeto mutable que cambia su estado, a modelarlo como un objeto inmutable que va a crear una nueva instancia del personaje con cada cambio de su estado.</p><p>El problema con esto es que no tenemos manera de saber el estado pasado de nuestro personaje, así que tenemos que tener en cuenta el tiempo.</p><p>Entendamos como ayuda a esto la inmutabilidad.</p><h4>Que nos hace inmutables</h4><p><strong>Un valor inmutable es un valor que no se puede cambiar luego de ser definido</strong>, se puede modificar pero debe ser en un objeto diferente.</p><p>Pero esto nos deja una duda, ¿crear un objeto nuevo por cada cambio es costoso? si, ya que se debe instanciar nuevamente en memoria.</p><p>Esto ha sido objeto de investigación durante las ultimas décadas y actualmente tenemos soluciones bastante eficientes para crear estructuras de datos inmutables que nos permitan tener persistencia de nuestros datos y rendimiento para acceder a ellos.</p><blockquote>Cuando creamos estructuras de datos nos preocupamos principalmente de dos cosas, <strong>como se almacenan los datos</strong> y <strong>que tan rápido puedo acceder a mis datos.</strong></blockquote><h4>Cual es el fin</h4><p>Lo que buscamos principalmente al almacenar nuestros datos de manera inmutable es tener <a href="https://es.wikipedia.org/wiki/Persistencia_(inform%C3%A1tica)">persistencia en nuestros datos</a></p><p>Buscamos saber que ha sucedido con nuestros datos a lo largo del tiempo.</p><p>Algunos de los tipos de persistencia que podemos encontrar son:</p><ul><li><strong>Persistencia parcial</strong>: Toda versión de los datos alguna vez creada es accesible y solo la ultima versión es modificable.</li><li><strong>Persistencia total</strong>: Todas las versiones son accesibles y modificables. (<em>por defecto en lenguajes imperativos</em>)</li><li><strong>Persistencia confluente</strong>: Persistencia parcial + las dos ultimas versiones se pueden combinar .</li><li><strong>Persistencia funcional</strong>: No se puede modificar ninguna versión ya creada, solo se pueden crear nuevos versiones de los datos apartir de las ya creadas.</li></ul><p>De estas, la persistencia funcional nos resulta particularmente útil.</p><p>Como almacenamos nuestros datos</p><p>Dos de las más importantes formas de estructurar nuestros datos para tener persistencia funcional, es Array Mapped Trie y <a href="https://en.wikipedia.org/wiki/Hash_array_mapped_trie">Hash Array Mapped Trie</a>.</p><p>Como dije antes es costoso crear un objeto nuevo cada vez que hay un cambio, más en objetos complejos, para esto, estas estructuras de datos trabajan con algo genial: <strong><em>Estructura compartida</em></strong></p><p>Entendamos esto.</p><p>Si tenemos una estructura como esta, una <a href="https://es.wikipedia.org/wiki/Lista_enlazada">lista enlazada</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/693/1*QVkukbkkPmvtkKZ7gY47ng.png" /><figcaption>David Nolen — Immutability, interactivity &amp; JavaScript (FutureJS 2014)</figcaption></figure><p>Si tengo una versión en el <em>estado x</em> y creo una nueva versión con <em>estado y</em>, la estructura sera compartida.</p><p>De esta manera no tenemos que crear un nuevo objeto por cada cambio, s<strong>olo modificamos las referencias que componen el objeto.</strong></p><p>Ahora, una estructura utilizada en persistencia funcional es de esta manera:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*DVTYnM7EkXX0C1LtW_O2sQ.png" /><figcaption>David Nolen — Immutability, interactivity &amp; JavaScript (FutureJS 2014)</figcaption></figure><p>Si realizamos algún cambio, simplemente las referencias son cambiadas</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/757/1*Vt-9IeXtnlG3Avn4o7hWwg.png" /><figcaption>David Nolen — Immutability, interactivity &amp; JavaScript (FutureJS 2014)</figcaption></figure><p>Estas estructuras de datos son extremadamente eficientes, podemos crear 34,359,738,368 objetos con estructuras compartida.</p><h4>Quiero mis datos rápido</h4><p>El acceso a nuestros datos es extremadamente rápido, cuando buscamos un valor este se expresa en su valor binario y se toma en duplas para buscar en el árbol.</p><p>De esta manera solo se requiere máximo 7 búsquedas dentro de los arrays del árbol para encontrar cualquier valor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*unempNOCiGKF50FPmqrhYw.png" /><figcaption>React.js Conf 2015 — Immutable Data and React</figcaption></figure><h4>Esto suena complejo de usar</h4><p>Aunque teóricamente resulta algo complejo, esto esta disponible para nosotros hoy, librerías como <a href="https://facebook.github.io/react/">React</a> ya lo utilizan, pero lo más importante si queremos utilizarlo en nuestros proyectos podemos usar librerías como <a href="https://facebook.github.io/immutable-js/">Immutable</a>.</p><p>Immutable abstrae la complejidad de estas estructuras, dándonos un API el cual nos permite simplemente pensar en <a href="https://facebook.github.io/immutable-js/docs/#/List">List</a>, <a href="https://facebook.github.io/immutable-js/docs/#/Stack">Stack</a>, <a href="https://facebook.github.io/immutable-js/docs/#/Map">Map</a>, <a href="https://facebook.github.io/immutable-js/docs/#/OrderedMap">OrderedMap</a>, <a href="https://facebook.github.io/immutable-js/docs/#/Set">Set</a>, <a href="https://facebook.github.io/immutable-js/docs/#/OrderedSet">OrderedSet</a> y <a href="https://facebook.github.io/immutable-js/docs/#/Record">Record</a>.</p><p>Las cuales resultan estructuras más simples para utilizar.</p><p>Los siguientes son ejemplos tomados de la documentación.</p><p>Podemos pasarle objetos a immutable, luego solo debemos pensar en ellos como valores, la librería nos da varios métodos con los cuales podemos obtener valores, iterar, comparar y mucho más.</p><pre>var map1 = Immutable.Map({a:1, b:2, c:3}); <br>var map2 = map1.set(‘b’, 50); <br>map1.get(‘b’); <em>// 2 <br></em>map2.get(‘b’); <em>// 50</em></pre><p>Podemos comparar valores de maneras simple.</p><pre>var map1 = Immutable.Map({a:1, b:2, c:3});<br>var map2 = map1.set(‘b’, 2); <br>assert(map1.equals(map2) === true); <br>var map3 = map1.set(‘b’, 50); <br>assert(map1.equals(map3) === false);</pre><h4>Ahora que sigue</h4><p>Personalmente creo que la inmutabilidad es una gran característica que podemos utilizar, claro los estados inmutables y mutables tienen ambos pros y contras pero es responsabilidad de los equipos de desarrollo pensar en cual camino reduce la complejidad de los proyectos.</p><p>Recomiendo mucho leer la <a href="https://facebook.github.io/immutable-js/docs/#/">documentación de immutable</a> la cual es bastante completa y si ya trabajas en proyectos que utilizan librerías como <a href="http://redux.js.org/">Redux</a> puedes comenzar a usar <a href="https://medium.com/react-redux/estado-inmutable-con-redux-e-immutable-js-5a3d69ef0451#.32v0trm0t">estados inmutables</a> hoy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*OvyjlZ4boegoaGUWGgQ5OQ.gif" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d3d4dc3f997" width="1" height="1" alt=""><hr><p><a href="https://medium.com/entendiendo-javascript/wip-immutabilidad-en-javascript-todo-a-cambiado-d3d4dc3f997">Inmutabilidad en JavaScript</a> was originally published in <a href="https://medium.com/entendiendo-javascript">Entendiendo JavaScript</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Funciones puras en JavaScript: crea funciones libres]]></title>
            <link>https://medium.com/entendiendo-javascript/funciones-puras-en-javascript-crea-funciones-libres-c2b9b3785418?source=rss----a55affbbd35e---4</link>
            <guid isPermaLink="false">https://medium.com/p/c2b9b3785418</guid>
            <category><![CDATA[advanced-javascript]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[funciones]]></category>
            <dc:creator><![CDATA[Yeison Daza ]]></dc:creator>
            <pubDate>Sat, 25 Jun 2016 14:38:08 GMT</pubDate>
            <atom:updated>2018-01-09T18:04:45.222Z</atom:updated>
            <content:encoded><![CDATA[<p>Uno de los principios más útiles para programar es KISS (Keep It Simple, Stupid), pero mantener las cosas simples no siempre es fácil, por eso hoy veremos como crear funciones que sigan esta filosofía.</p><p><strong><em>Nota: Este contenido lo publiqué primero en </em></strong><a href="https://tinyletter.com/yeion7"><strong><em>mi newsletter</em></strong></a><strong><em>, la semana después de publicar el newsletter publico en mi blog, si quieres ser el primero en leer </em></strong><a href="http://suscribete/"><strong><em>suscríbete</em></strong></a><strong><em>.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fn1aM1qhkSt_KGA80K8Y_Q.png" /></figure><p>En JavaScript las funciones son una parte fundamental del lenguaje, ellas nos permiten cosas como <a href="https://medium.com/entendiendo-javascript/currying-en-javascript-funciones-con-superpoderes-1c8760c728a">currying</a>, <a href="https://medium.com/entendiendo-javascript/herencia-funcional-en-javascript-a3218816cc56">herencia funcional</a>, <a href="https://medium.com/entendiendo-javascript/entendiendo-closures-en-javascript-8fb9a284964e">closures</a>, <a href="https://medium.com/entendiendo-javascript/funciones-de-alto-orden-en-javascript-42d04769d9b5">funciones de alto orden</a>, etc.</p><blockquote>“Funciones son cruciales en computación y matemática, ayudan a procesar datos de maneras útiles.”</blockquote><h4>El problema de lo impuro</h4><p>Una función basicamente acepta entradas, las procesa y produce una salida.</p><p>Tomemos como ejemplo la siguiente función:</p><pre>function sumadorFactory(suma = 0) {</pre><pre>  return function (cantidad) {</pre><pre>     suma = suma + cantidad;<br>     return suma;</pre><pre>  };</pre><pre>}</pre><pre><br>const sumadorA = sumadorFactory();</pre><pre>sumadorA(2); //2<br>sumadorA(2); //4</pre><p>Tenemos una función <a href="https://medium.com/entendiendo-javascript/currying-en-javascript-funciones-con-superpoderes-1c8760c728a">currificada</a> que recibe un número (por defecto 0) y retorna una función que recibe otro numero y retorna la suma.</p><p><em>¿Cual es el problema de esta función?</em></p><p>Como vamos, llamamos dos veces a la misma función con el mismo parametro y nos <strong>retorna un resultado diferente</strong>, esto es debido a que la función cuenta con un <a href="https://es.wikipedia.org/wiki/Objeto_(programaci%C3%B3n)#Estado">estado</a> e <a href="https://es.wikipedia.org/wiki/Objeto_(programaci%C3%B3n)#Identidad">identidad</a>.</p><p>Lo que hace que sea más compleja de lo que deberia ser, ya que para probar o comparar el resultado de la función debemos tener en cuenta el tiempo.</p><p>Esto a su vez añade complejidad para razonar en ella, ya que el programador deberia mantener el seguimiento de como esta relacionado el código y donde se ejecuta.</p><blockquote>“Hay dos formas de diseñar software: la primera es hacerlo tan simple que sea obvio que no tiene deficiencias y la segunda es hacerlo tan complicado que no sea obvio que tiene deficiencias. La primera forma es mucho más difícil.”</blockquote><p>Para esto creamos funciones puras, que nos ayuden a estar libres de estos problemas y sea mucho más simple de testear.</p><h4>El camino de la pureza</h4><p>Para que una función sea pura debe cumplir dos reglas fundamentalmente.</p><blockquote>Dada la mismas entradas, debe retornar el mismo resultado, sin importar cuantas veces se llame.</blockquote><p>volvamos a la función anterior y hagamos que sea pura.</p><pre>function sumadorFactory(suma = 0) {</pre><pre>  return function (cantidad) {</pre><pre>    return suma + cantidad;<br>  }</pre><pre>}</pre><pre>const sumadorA = sumadorFactory();</pre><pre>sumadorA(2); //2<br>sumadorA(2); //2</pre><p>Como vemos libramos a nuestra función de su estado, ahora <strong>cada vez que ejecutemos la función con el mismo parametro obtenemos el mismo resultado.</strong></p><blockquote>Una función es una relación especial entre valores: Cada valor de su entrada devuelve exactamente un valor de salida.</blockquote><blockquote>La función no debe tener efectos secundarios (side-effects)</blockquote><p>Los efectos secundarios son <strong>todo lo que ocurra aparte del calculo denuestro resultado</strong>, principalmente son la interacción con el entorno externo a la función o cambiar estados del sistema.</p><p>veamos un ejemplo</p><pre>//Impuro<br>var minimo = 10;</pre><pre>function comparaMinimo(num) {<br>  return num &lt; minimo;<br>}</pre><p>La función <em>comparaMinimo</em> es impura ya que depende de un estado externo que puede mutar.</p><blockquote>Una función es una relación especial entre valores: Cada valor de su entrada devuelve exactamente un valor de salida.</blockquote><p>Cuando esta comunicación con el exterior existe lo hace de manera invisible, lo que hace que los errores sean más complejos de encontrar. Por eso las funciones puras solo deben depender de los valores que se les pasa como parametros para calcular su resultado.</p><p>Algunos efectos secundarios pueden ser: request http, entradas del usuario, mutaciones, imprimir en pantalla, etc.</p><h4>La magia de la pureza</h4><p>Las funciones puras tienen muchas ventajas entre ellas</p><ul><li><strong>Son más facilmente testeables</strong>, ya que van a retornar el mismo resultado apartir de los mismos parametros.</li><li><strong>Pueden ser cacheadas</strong>, ya que siempre retornan el mismo resultado podemos almacenar estos resultados en cache (<a href="http://ramdajs.com/0.21.0/docs/#memoize">memoizar</a>)</li><li><strong>Más faciles de entender</strong>: Se puede reemplazar la función por su valor de resultado, lo que las hace <a href="https://es.wikipedia.org/wiki/Transparencia_referencial">referencialmente transparentes</a>.</li><li><strong>Se pueden ejecutar en paralelo,</strong> ya que no tienen ninguna dependencia externa.</li><li><strong>Reduce la cantidad de bugs,</strong> ya que no generan alteraciones del estado externo.</li></ul><h4>Este mundo no te deja ser puro</h4><p>Aunque todo suena muy bien, no todo nuestro código puede ser puro, ya que nuestros programas interactúan con un entorno externo así que los efectos secundarios son inherentes.</p><p>Lo que debemos hacer es controlar estos efectos secundarios, esto lo veremos en siguientes posts.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*OvyjlZ4boegoaGUWGgQ5OQ.gif" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c2b9b3785418" width="1" height="1" alt=""><hr><p><a href="https://medium.com/entendiendo-javascript/funciones-puras-en-javascript-crea-funciones-libres-c2b9b3785418">Funciones puras en JavaScript: crea funciones libres</a> was originally published in <a href="https://medium.com/entendiendo-javascript">Entendiendo JavaScript</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Entendiendo la composición en JavaScript]]></title>
            <link>https://medium.com/entendiendo-javascript/entendiendo-la-composici%C3%B3n-en-javascript-ac7f0c384b8c?source=rss----a55affbbd35e---4</link>
            <guid isPermaLink="false">https://medium.com/p/ac7f0c384b8c</guid>
            <category><![CDATA[objetos]]></category>
            <category><![CDATA[spanish]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Yeison Daza ]]></dc:creator>
            <pubDate>Thu, 23 Jun 2016 04:02:54 GMT</pubDate>
            <atom:updated>2018-01-09T18:08:51.107Z</atom:updated>
            <content:encoded><![CDATA[<p>En muchas ocasiones vemos que el sistema de objetos de JavaScript es nombrado como basado ejemplos o prototipos, pero no siempre vemos qué significa esto.</p><p><strong><em>Nota: Este contenido lo publiqué primero en </em></strong><a href="https://tinyletter.com/yeion7"><strong><em>mi newsletter</em></strong></a><strong><em>, la semana después de publicar el newsletter publico en mi blog, si quieres ser el primero en leer </em></strong><a href="http://suscribete/"><strong><em>suscríbete</em></strong></a><strong><em>.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ylQwdExgZccdEI0ooJN4yw.png" /></figure><p>Por esto hoy vamos a entender como funciona la composición en JavaScript</p><p>Una de las formas en que los objetos se relacionan es a través de la <a href="https://medium.com/@yeion7/entendiendo-la-delegaci%C3%B3n-en-javascript-8d99e3bc3826#.wwu3fnl0y">delegación de comportamientos</a>, aunque es un sistema simple y poderoso por sí solo, junto con la composición podremos construir objetos basados en otros, creando un sistema mucho más poderoso.</p><p>Para entender la composición podemos pensar en cada objeto como una <strong>pieza de lego</strong>, que tiene definido comportamientos, y uniendo varios en un objetos destino formamos objetos más complejos.</p><p>Veamos como se implementa la composición en JavaScript</p><h4>Object.assign(..)</h4><p>Desde <em>ES2105</em> el lenguaje implementa el <a href="https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Object/assign">método <em>Object.assign()</em></a>, el cual permite componer objetos o hacer mixins (como algunos lo conocen)</p><blockquote>Aunque antes podíamos hacer uso de esta funcionalidad en librerías como jquery con <a href="https://api.jquery.com/jquery.extend/">$.extend()</a> o en lodash con <a href="https://lodash.com/docs#assign">_.assign()</a></blockquote><p>La sintaxis del método es bastante simple, este recibe la cantidad de argumentos desees, pero <strong>todos deben ser objetos</strong>.</p><p>De estos argumentos el primero, es el objeto sobre el cual se va a construir (el objeto destino), los demás argumentos, son los objetos que se van a usar para construir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3e9e4561be8de43e8a672a6d73fbc799/href">https://medium.com/media/3e9e4561be8de43e8a672a6d73fbc799/href</a></iframe><p>Es importante tener en cuenta, que</p><ul><li>Solo se copian las propiedades enumerables de cada objeto</li><li>La composición usa el método [[put]], por esto se debe tener en cuenta los casos de <a href="https://medium.com/@yeion7/propiedades-internas-en-javascript-717057026516"><em>shadowing</em></a><em> </em>.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/108e2bb7eb12e3692e40d58653cc42fa/href">https://medium.com/media/108e2bb7eb12e3692e40d58653cc42fa/href</a></iframe><h4>Ventajas</h4><ul><li>Como vemos representa un modelo mental más simple, para representar la relación entre objetos.</li><li>Mejora la legibilidad de nuestro código.</li><li>Es más fácil realizar separación de conceptos, pudiendo aislar funcionalidades y reutilizar código (DRY).</li><li>Podemos modularizar nuestro código, partiendo esos grandes y complejos objetos, en unos más pequeños.</li><li>Seguridad, ya que cada objeto es una entidad independiente.</li></ul><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FwfMtDGfHWpA%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DwfMtDGfHWpA&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FwfMtDGfHWpA%2Fhqdefault.jpg&amp;key=d04bfffea46d4aeda930ec88cc64b87c&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/073540706bc03f8ed7045546154c410a/href">https://medium.com/media/073540706bc03f8ed7045546154c410a/href</a></iframe><p>La próxima semana, escribiré sobre herencia funcional, que nos permitirá unir estos conceptos, y ver lo poderoso que resultan juntos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*OvyjlZ4boegoaGUWGgQ5OQ.gif" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ac7f0c384b8c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/entendiendo-javascript/entendiendo-la-composici%C3%B3n-en-javascript-ac7f0c384b8c">Entendiendo la composición en JavaScript</a> was originally published in <a href="https://medium.com/entendiendo-javascript">Entendiendo JavaScript</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Currying en JavaScript: Funciones con superpoderes.]]></title>
            <link>https://medium.com/entendiendo-javascript/currying-en-javascript-funciones-con-superpoderes-1c8760c728a?source=rss----a55affbbd35e---4</link>
            <guid isPermaLink="false">https://medium.com/p/1c8760c728a</guid>
            <category><![CDATA[funciones]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Yeison Daza ]]></dc:creator>
            <pubDate>Thu, 23 Jun 2016 04:01:30 GMT</pubDate>
            <atom:updated>2018-01-09T18:07:52.745Z</atom:updated>
            <content:encoded><![CDATA[<p>Uno de los principios que todo programador busca cumplir es <a href="https://es.wikipedia.org/wiki/No_te_repitas">DRY (Don’t Repeat YourSelf )</a>, con Currying vamos a ver como hacer esto con nuestras funciones es bastante simple y útil.</p><p><strong><em>Nota: Este contenido lo publiqué primero en </em></strong><a href="https://tinyletter.com/yeion7"><strong><em>mi newsletter</em></strong></a><strong><em>, la semana después de publicar el newsletter publico en mi blog, si quieres ser el primero en leer </em></strong><a href="http://suscribete/"><strong><em>suscríbete</em></strong></a><strong><em>.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wf3oKSpDAfw6VClawBMexQ.png" /></figure><p>La manera en que normalmente escribimos nuestra funciones es:</p><pre>//ES2015<br>const divisible = (num, mod) =&gt; num % mod;</pre><pre>//ES5<br>var divisible = function(num, mod) {<br>  return num % mod;<br>}</pre><p>Para poder ejecutar esta función debemos pasar dos argumentos, pero si quisiéramos tener una función que compruebe exclusivamente si un numero es par tendríamos que escribir una nueva función. En este momento resulta útil tener una función currificada.</p><p>Para antes de entender como funciona una función currificada debemos conocer algunos conceptos.</p><blockquote><strong>Las funciones son ciudadanos de primera clase, esto significa que las funciones son objetos, se pueden pasar como argumentos, almacenar en variables y retornar dentro de otras funciones</strong></blockquote><blockquote><a href="https://medium.com/@yeion7/funciones-de-alto-orden-en-javascript-42d04769d9b5#.4cd3sl893"><em>Funciones de alto orden en JavaScript</em></a></blockquote><blockquote><strong><em>Un closure es cuando una función es capaz de recordar y acceder a un lexical scope, incluso cuando la función es ejecutada por fuera del lexical scope.</em></strong></blockquote><blockquote><a href="https://medium.com/@yeion7/entendiendo-closures-en-javascript-8fb9a284964e#.b3okdidlj"><em>Entendiendo los closures en JavaScript</em></a></blockquote><blockquote><strong>Si una función recibe más de un parámetro, se puede reescribir como, una función que toma un parámetro y retorna una función, está a su vez recibe una parámetro y retorna el resultado.</strong></blockquote><blockquote><a href="https://medium.com/@yeion7/calculo-lambda-en-javascript-57ea69b427b1#.vz530hw0s"><em>Calculo lambda en JavaScript</em></a></blockquote><h4>¿Qué es Currying?</h4><p>Curry es poder llamar una función con menos parámetros de los que espera, esta devuelve una función que espera los parámetros restantes y retorna el resultado.</p><p>De esta manera podríamos reescribir la función del comienzo como</p><pre>//ES2015</pre><pre>const divisible = mod =&gt; num =&gt; num % mod;</pre><pre>//ES5</pre><pre>var divisible = function (mod) {<br>  return function (num) {<br>    return num % mod;<br>  }<br>}</pre><p>Para llamar esta función tenemos dos opciones</p><ul><li>Pasar los argumentos ejecutando la funciones</li></ul><pre>divisible(10)(2)</pre><ul><li>Pasar un argumento y recibir una función que recuerde este argumento</li></ul><pre>const divisibleEn3 = divisible(3);</pre><pre>divisibleEn3(10)</pre><p>Como vemos escribir una función currificada no es complicado, pero podríamos hacerlo un poco más natural como escribimos cualquier función.</p><p>Para esto podemos usar <a href="https://lodash.com/docs#curry">Lodash</a> o <a href="http://ramdajs.com/0.21.0/docs/#curry">Ramda</a> quienes tienen un método <em>curry</em>, que nos permite currificar cualquier función de esta manera.</p><pre>import { __, curry, map } from ‘ramda’;</pre><pre>const composeNombre = curry(<br>  (primer, apellido) =&gt; `${primer} ${apellido}`<br>);</pre><pre>const familiaJaimes = composeNombre(__, ‘Jaimes’)</pre><pre>const nombres = [‘Juan’, ‘Camilo’, ‘Miguel’]</pre><pre>console.log(map(familiaJaimes, nombres))</pre><p>Veamos un ejemplo más útil tomado de <a href="http://mostly-adequate-guide/"><em>Mostly adequate guide to functional programming</em></a></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9bca0a1fb3964acff7ebd6d11acedb3f/href">https://medium.com/media/9bca0a1fb3964acff7ebd6d11acedb3f/href</a></iframe><h4>Ventajas de Currying</h4><ul><li>Podemos crear funciones nuevas simplemente pasando nuestras funciones de base con algunos parámetros.</li><li>Podemos transformar cualquier función que trabaje con un solo elemento en una que trabaje con una lista envolviéndola en un map.</li><li>Se pueden escribir pequeñas piezas de código que sean más fácil de reutilizar.</li><li>Es fácil de razonar sobre ellas.</li><li>Escribir funciones currificadas nos permitirá componer funciones.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*OvyjlZ4boegoaGUWGgQ5OQ.gif" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1c8760c728a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/entendiendo-javascript/currying-en-javascript-funciones-con-superpoderes-1c8760c728a">Currying en JavaScript: Funciones con superpoderes.</a> was originally published in <a href="https://medium.com/entendiendo-javascript">Entendiendo JavaScript</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Herencia funcional en JavaScript]]></title>
            <link>https://medium.com/entendiendo-javascript/herencia-funcional-en-javascript-a3218816cc56?source=rss----a55affbbd35e---4</link>
            <guid isPermaLink="false">https://medium.com/p/a3218816cc56</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[spanish]]></category>
            <category><![CDATA[objetos]]></category>
            <dc:creator><![CDATA[Yeison Daza ]]></dc:creator>
            <pubDate>Thu, 23 Jun 2016 04:00:36 GMT</pubDate>
            <atom:updated>2018-01-09T18:08:27.108Z</atom:updated>
            <content:encoded><![CDATA[<p>Si JavaScript no tiene clases, ¿como se implementa la herencia? es tal vez una de las preguntas que todo desarrollador se ha planteado, en este post intentaremos terminar de dar respuesta esto.</p><p><strong><em>Nota: Este contenido lo publiqué primero en </em></strong><a href="https://tinyletter.com/yeion7"><strong><em>mi newsletter</em></strong></a><strong><em>, la semana después de publicar el newsletter publico en mi blog, si quieres ser el primero en leer </em></strong><a href="http://suscribete/"><strong><em>suscríbete</em></strong></a><strong><em>.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8TxkZzlVLG1uw-xOmwNtAQ.png" /></figure><p>En <a href="http://shop.oreilly.com/product/9780596517748.do">JavaScript: The Good Parts</a> escrito por <a href="https://en.wikipedia.org/wiki/Douglas_Crockford">Douglas Crockford</a>, habla sobre <em>factory functions</em>, las cuales son la base para realizar herencia funcional (no confundir con programación funcional)</p><p>Recuerda que existen tres maneras de realizar <a href="https://medium.com/@yeion7/entendiendo-la-herencia-en-javascript-288a578edd5b">herencia en JavaScript</a>:</p><ul><li><a href="https://medium.com/@yeion7/entendiendo-la-delegaci%C3%B3n-en-javascript-8d99e3bc3826#.82z6zlqdf"><strong>Delegación</strong></a>: Delegar comportamientos a objetos vinculados vía <em>[[Prototype]]</em></li><li><a href="https://medium.com/@yeion7/entendiendo-la-composici%C3%B3n-en-javascript-ac7f0c384b8c#.9f6kfzavr"><strong>Composición</strong></a>: Componer objetos basados en ejemplos o prototipos, vía <em>Object.assign()</em></li><li><strong>Funcional</strong>: Componer objetos mediante funciones.</li></ul><p>Hoy hablaremos de la tercera, pero vayamos paso a paso.</p><h4>Herencia funcional</h4><p>Como ya dije, el promotor de esta es Douglas Crockford, quien en gran parte de sus conferencias nos habla de los peligros de la herencia clásica y el uso de <em>this</em> en JS.</p><p>Él promueve un sistema de objetos libre de clases, planteando el uso de <em>factory functions, </em>estas básicamente son funciones que utilizan varios conceptos, como:</p><ul><li>Poder retornar objetos en una <a href="https://medium.com/@yeion7/funciones-de-alto-orden-en-javascript-42d04769d9b5">función</a>.</li><li>Poder crear <a href="https://medium.com/@yeion7/entendiendo-los-objetos-en-javascript-3a6d3a0695e5">objetos literales</a>.</li><li>La <a href="https://medium.com/@yeion7/propiedades-internas-en-javascript-717057026516">naturaleza dinámica</a> de los objetos.</li><li><a href="https://medium.com/@yeion7/entendiendo-closures-en-javascript-8fb9a284964e">Closures</a>.</li></ul><p>Veamos esto en un ejemplo</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/736317cc960ff0cb7b2475c5a70cf9fa/href">https://medium.com/media/736317cc960ff0cb7b2475c5a70cf9fa/href</a></iframe><p>Como vemos, simplemente tenemos funciones que retornan objetos, los cuales pueden ser genéricos (<em>humano</em>) o pueden ser más específicos (<em>mujer</em> y/o <em>hombre</em>), cada función nos va a retornar un objeto independiente.</p><p>Pero el poder de las <em>factory functions</em> no queda en esto, con ellas y utilizando el concepto de closures podemos tener propiedades privadas.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/10e9c41c36bfbd018e4e3a2354502498/href">https://medium.com/media/10e9c41c36bfbd018e4e3a2354502498/href</a></iframe><p>Como vemos, tenemos una propiedad (<em>contador</em>), la cual no puede ser accedida desde los objetos creados por esta <em>factory</em>, pero los métodos en este si pueden hacer gracias a closure.</p><p>Como vemos es bastante simple, por eso se utiliza en gran número de librerías dentro de JavaScript, por ejemplo en</p><ul><li><a href="http://expressjs.com/es/">Express</a> al crear una aplicación, retorna un objeto</li><li><a href="http://jquery.com/">Jquery</a>, al usar $(Selector), retorna un objeto</li><li>etc</li></ul><h4>Ventajas</h4><ul><li><strong>Simplicidad</strong>: Solo se requieren unos cuantos pasos para conseguir realizar herencia.</li><li><strong>Libre de </strong><a href="https://medium.com/@yeion7/entendiendo-this-javascript-cba60c8cec8c"><strong>this</strong></a>: Podemos dejar de preocuparnos de <em>this</em> o como en los ejemplos su uso es bastante sencillo.</li><li><strong>Encapsulación</strong>: Objetos pueden tener miembros privados</li><li><strong>Cada objeto es único: </strong>Cada vez que se llama la función crea un objeto, de esta manera podemos controlar la mutación.</li></ul><p>Para mi la principal ventaja de la herencia funcional es la simplicidad, ya que esta es la que principalmente afecta todo nuestro proyecto, te recomiendo leer este <a href="http://curtclifton.net/papers/MoseleyMarks06a.pdf">paper</a> sobre la complejidad a los proyectos.</p><h4>Desventajas</h4><p>Existen dos grandes “desventajas” que toda persona nombra cuando se trata de herencia funcional o factory functions.</p><ol><li><em>El rendimiento creando objetos es menor.</em></li></ol><p>Esto es cierto, pero veamos que tanto, si realizamos <a href="https://gist.github.com/yeion7/b4613ba0a72d4a8017cae372cce176d2">esta prueba</a> donde medimos cuánto demora en crearse un objeto con objetos literales, factory functions y constructores, obtenemos:</p><pre>Constructor: 0.00002ms</pre><pre>Factory: 0.00004ms</pre><pre>Literal: 0.00001ms</pre><p>Como vemos la velocidad de creación de un objeto es mínima y la diferencia para que llegue a ser significativa seria al crear al menos de diez mil objetos (aun asi sera solo de 2ms)</p><p>Otra consideración es que al usar una función constructora, aunque tiene mejor rendimiento, se debe usar muchas veces <a href="https://medium.com/@yeion7/entendiendo-this-javascript-cba60c8cec8c"><em>bind</em></a> para tener el comportamiento deseado de <em>this</em>, esto también afecta el rendimiento.</p><blockquote>Nota: Estos valores pueden variar dependiendo del engine que uses y varios factores, aun así si decides realizar microbenchmarks como este, te recomiendo ver antes <a href="https://www.youtube.com/watch?v=g0ek4vV7nEA">esta conferencia</a>.</blockquote><p>2. <em>El consumo de memoria es mayor</em></p><p>Esto también es cierto ya que cada objeto creado con una <em>factory function</em> se creará y guardará en memoria como un objeto independiente.</p><p>Pero con el valor actual de memoria, ¿es justificable esta desventaja?</p><h4>Herencia funcional vs herencia clásica</h4><p>Una consideración importante a mi parecer es la simplicidad y la flexibilidad, tomando solo esos dos factores en cuenta considero que las factory functions son una mejor opción.</p><p>Pero si se desea priorizar el rendimiento (micro optimizando) la mejor opción sería usar funciones constructoras (clases), esta <a href="https://www.quora.com/When-should-I-use-JavaScript-prototypes-in-real-world-applications/answer/Mattias-Petter-Johansson?srid=IviF">respuesta en quora</a> te explicara mejor esto.</p><h4>Conclusión</h4><p>JavaScript nos provee de un sistema de herencia increíble, con el cual podemos crear sistemas grandes pero a su vez flexibles y mantenibles.</p><p>En este punto te preguntarás ¿eso es todo?, yo también me hice esa pregunta, la respuesta corta es sí y esto es lo increible de JavaScript, ser muy simple, pero a su vez poderoso.</p><p>Como vimos los tres tipos de herencia son bastante simples, pero se requiere practicar y saber como usarlos, en próximos post, traeré ejemplos sobre su implementación que nos permitan explorar estos más a fondo, por ahora te recomiendo leer este <a href="http://www.nauzethdez.com/javascript-5-herencia-o-composicion/">post</a> es muy bueno y te mostrará la flexibilidad de la herencia en JS, también buscar repositorios de librerías y leer el código es una practica que te ayudará a ser mejor desarrollador.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a3218816cc56" width="1" height="1" alt=""><hr><p><a href="https://medium.com/entendiendo-javascript/herencia-funcional-en-javascript-a3218816cc56">Herencia funcional en JavaScript</a> was originally published in <a href="https://medium.com/entendiendo-javascript">Entendiendo JavaScript</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Entendiendo las comparaciones en JavaScript]]></title>
            <link>https://medium.com/entendiendo-javascript/entendiendo-las-comparaciones-en-javascript-fd9f909f71ec?source=rss----a55affbbd35e---4</link>
            <guid isPermaLink="false">https://medium.com/p/fd9f909f71ec</guid>
            <category><![CDATA[basico]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[spanish]]></category>
            <dc:creator><![CDATA[Yeison Daza ]]></dc:creator>
            <pubDate>Thu, 23 Jun 2016 04:00:25 GMT</pubDate>
            <atom:updated>2018-01-09T18:09:26.628Z</atom:updated>
            <content:encoded><![CDATA[<p>Uno de los procesos que todos realizamos mientras programamos cada día es comparar valores, si estos son iguales, diferentes, mayores, menores, etc, para poder realizar acciones con estos.</p><p><strong><em>Nota: Este contenido lo publiqué primero en </em></strong><a href="https://tinyletter.com/yeion7"><strong><em>mi newsletter</em></strong></a><strong><em>, la semana después de publicar el newsletter publico en mi blog, si quieres ser el primero en leer </em></strong><a href="http://suscribete/"><strong><em>suscríbete</em></strong></a><strong><em>.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WU_TuMm-amzxxkJJ0MqVMg.png" /></figure><p>Muchas veces en JavaScript obtenemos resultados de estas comparaciones que no esperábamos y esto puede conducir a bugs en nuestro código, por esto creo que es importante entender el algoritmo que establece el lenguaje para esto.</p><pre>21 == &#39;21&#39;          // true<br>undefined == null   // true<br>undefined === null  // false<br>{} === {}           // false<br>NaN === NaN         // false<br>[10] == 10          // true<br>21 &lt; &#39;22&#39;           // true<br>[22] &gt; [21]         // true</pre><p>vamos paso a paso y entendamos esto.</p><p>Existen dos tipos principales de comparaciones <strong>igualdades</strong> y <strong>desigualdades</strong>, el resultado de cualquiera de estas es un <strong>booleano</strong> (<em>true</em> o <em>false</em>) reflejando la relación entre los valores evaluados.</p><p>Una de las cosas que hace complejo este mecanismo es la coerción, la cual convierte los tipos de datos según su contexto de uso (si es posible la conversión).</p><p>Si no se entiende este mecanismos se pueden producir algunos resultados inesperados sin saber porque sucede de esta manera.</p><pre>let num = ‘24’;              //String</pre><pre>let explicita = Number(num); //number</pre><pre>let implicita = num * 2;     //num ahora se usa como number</pre><p>Existen valores que son implícitamente convertidos a <em>false</em>, estos son:</p><pre>&#39;&#39; (string vacio)</pre><pre>0, -0, NaN</pre><pre>null, undefined</pre><blockquote><strong>Nota: </strong>Ya que este es un tema algo extenso, se tratará más adelante en un post completo.</blockquote><p>Otro mecanismo que se utiliza en las comparaciones en la <strong>conversión de objetos a primitivos</strong>, cuando se les compara a estos con un valor primitivo.</p><blockquote>Los tipos en JavaScript se dividen en primitivos o por referencia — <a href="https://medium.com/@yeion7/entendiendo-los-tipos-en-javascript-4c1c718e8e2a">Entendiendo los tipos en JavaScript</a></blockquote><p>El mecanismo que se sigue para realizar esta conversión es:</p><ol><li>Si <em>valueOf(..)</em> se puede usar, es llamado y devuelve un valor primitivo.</li><li>Si .<em>toString(..)</em> se puede usar, es llamado y devuelve un valor primitivo.</li><li>En otros casos devuelve un <em>error</em></li></ol><blockquote><strong>Nota</strong>: El mecanismo que normalmente se utiliza es <em>toString()</em>.</blockquote><h3>Tipos de comparaciones</h3><h4>Igualdades</h4><p>Evalúan si dos valores son iguales, se utilizan los siguientes operadores:</p><pre>== , ===  → Igual</pre><pre>!= , !==  → No igual</pre><blockquote><strong>Nota</strong>: se utiliza ! para denotar la negación, refiriéndose a, <em>no es igual</em></blockquote><h4>== vs ===</h4><p>El operador === es muchas veces conocido como igualdad estricta, teniendo un comportamiento más cercano al esperado, pero más allá de esto es bueno conocer el algoritmo de ambos tipos de igualdad.</p><h4>Algoritmo de ==</h4><p>Cuando se evalúan dos valores con este, se sigue la siguiente secuencia para determinar el resultado:</p><ol><li>Si son del mismo tipo, entonces, se prueban con ===</li><li>Si son de diferente tipo:</li></ol><p>2.1 Si uno es <em>null</em> y otro <em>undefined</em>, retorna <em>true.</em></p><p>2.2 Si uno es <em>string</em> y otro <em>number</em>, se convierte el string, y se evalúan como números.</p><p>2.3 Si uno es <em>booleano</em>, se transforma, <em>true</em> en 1 y <em>false</em> en 0, y se evalúan.</p><p>2.4 Si uno es un <em>object</em> y otro un <em>number</em> o <em>string</em>, convierte el objeto a primitivo.</p><p>3. En otros casos, devuelve <em>false.</em></p><p>Puedes revisar este algoritmo en la especificación, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3">sección 11.9.3</a></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e157b597d0aedfda13bc38968a6be31e/href">https://medium.com/media/e157b597d0aedfda13bc38968a6be31e/href</a></iframe><h4>Algoritmo de ===</h4><p>Esta igualdad es más estricta con sus resultados, utilizando secuencia para determinar el resultado.</p><ol><li>Si tienen diferentes tipos, devuelve <em>false</em></li><li>Si ambos son <em>null</em>, devuelve <em>true</em></li><li>Si ambos son <em>undefined</em>, devuelve <em>true</em></li><li>Si uno o ambos son <em>NaN</em>, devuelve <em>false</em></li><li>Si ambos son <em>true</em> o <em>false</em>, devuelve <em>true</em></li><li>Si ambos son <em>number</em> y tienen el mismo valor, devuelve <em>true</em></li><li>Si ambos son <em>string</em> y tienen el mismo valor, devuelve <em>true</em></li><li>En otros casos, devuelve <em>false</em></li></ol><p>Puedes revisar este algoritmo en la especificación, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.6">sección 11.9.6</a></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/059cc7c5892618f5239a7077f33ef572/href">https://medium.com/media/059cc7c5892618f5239a7077f33ef572/href</a></iframe><p>Podrías tener lo siguiente en cuenta para saber cuál operador utilizar.</p><ul><li>Si cualquiera de los valores es boolean, utiliza ===</li><li>Si <strong>no</strong> tienes claro si los valores son convertidos por coerción, usa ===</li><li>En otros casos podrías usar con seguridad ==</li></ul><blockquote><strong>Nota</strong>: Por convención y una buena práctica la comunidad promueve el uso de ===</blockquote><h4>Desigualdades</h4><p>Siempre el resultado de evaluar una desigualdad es un booleano.</p><p>Los siguiente operadores son utilizados para comparar desigualdades,</p><pre>&lt;  → Menor</pre><pre>&gt;  → Mayor</pre><pre>&lt;= → Menor Igual</pre><pre>&gt;= → Mayor Igual</pre><p>Usualmente se utiliza para números, pero también sirve para textos.</p><ol><li>Si alguno es un <em>object</em>, se convierte a primitivo y se evalúa.</li><li>Si ambos son <em>string</em>, se evalúa el orden de los caracteres alfabéticamente.</li><li>Si ambos son <em>number</em>, se evalúa</li><li>En otros casos es <em>false</em></li></ol><p>Puedes revisar este algoritmo en la especificación, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.8.5">sección 11.8.5</a></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/84cc154b5d845d2971afd9bbfe9e91a2/href">https://medium.com/media/84cc154b5d845d2971afd9bbfe9e91a2/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*OvyjlZ4boegoaGUWGgQ5OQ.gif" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fd9f909f71ec" width="1" height="1" alt=""><hr><p><a href="https://medium.com/entendiendo-javascript/entendiendo-las-comparaciones-en-javascript-fd9f909f71ec">Entendiendo las comparaciones en JavaScript</a> was originally published in <a href="https://medium.com/entendiendo-javascript">Entendiendo JavaScript</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Entendiendo la delegación en JavaScript]]></title>
            <link>https://medium.com/entendiendo-javascript/entendiendo-la-delegaci%C3%B3n-en-javascript-8d99e3bc3826?source=rss----a55affbbd35e---4</link>
            <guid isPermaLink="false">https://medium.com/p/8d99e3bc3826</guid>
            <category><![CDATA[objetos]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[spanish]]></category>
            <dc:creator><![CDATA[Yeison Daza ]]></dc:creator>
            <pubDate>Thu, 23 Jun 2016 04:00:16 GMT</pubDate>
            <atom:updated>2018-01-09T18:10:16.706Z</atom:updated>
            <content:encoded><![CDATA[<p>Cuando la mayoría de programadores piensa en programación orientada a objetos (POO), generalmente recuerdan lenguajes como Java o C++ donde una clase es una plantilla estática para crear objetos, heredando estos atributos y métodos dentro del objeto creado.</p><blockquote>“Si estás creando funciones constructoras y heredando de ellas, no has aprendido JavaScript” — <a href="https://medium.com/u/c359511de780">Eric Elliott</a></blockquote><p>Como vimos <a href="https://medium.com/@yeion7/entendiendo-la-herencia-en-javascript-288a578edd5b">antes</a>, JavaScript no tiene clases, pero tiene un sistema de herencia más <strong>simple, flexible y poderoso.</strong></p><p><strong><em>Nota: Este contenido lo publiqué primero en </em></strong><a href="https://tinyletter.com/yeion7"><strong><em>mi newsletter</em></strong></a><strong><em>, la semana después de publicar el newsletter publico en mi blog, si quieres ser el primero en leer </em></strong><a href="http://suscribete/"><strong><em>suscríbete</em></strong></a><strong><em>.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oVVMU8NZpvHfMGa2aUyXiA.png" /></figure><p>La palabra herencia podría llegar a crear confusión, ya que esta hace referencia a que un comportamiento donde se está siendo copiado, lo que no sucede en JavaScript, por esta razón <a href="https://twitter.com/getify?lang=es">Kyle Simpson</a> autor de <a href="https://github.com/getify/You-Dont-Know-JS">You Don’t Know JS</a>, lo define como OLOO (objetos linkeados a otros objetos, por sus siglas en inglés).</p><p>Vamos paso a paso y entendamos el sistema de delegación.</p><h4>Cadena de prototipos</h4><p>Todo objeto tiene una propiedad interna [[Prototype]], esta es un vínculo que hace referencia a otro objeto.</p><blockquote><em>[[Prototype]] crea una referencia a otro objeto, la mayoría de los objetos cuentan con una cadena de prototipo a otro objeto. —</em><a href="https://medium.com/@yeion7/propiedades-internas-en-javascript-717057026516#.em4cy0d6o"><em> Propiedades internas</em></a></blockquote><p>Este mecanismo es utilizado cuando se hace referencia a un propiedad de un objeto y no es encontrada en este, es ahí cuando el método [[get]], continua buscando en el objeto vinculado via [[Prototype]], a esta serie de vínculos entre objetos se le conoce <strong>cadena de prototipos.</strong></p><h4>Object.prototype</h4><p>La parte superior de la cadena de prototipos es <em>Object.prototype</em>, gracias a este objeto tenemos métodos comunes en todos los objetos como:</p><ul><li>toString()</li><li>valueOf()</li><li>hasOwnProperty( .. )</li><li>isPrototypeOf( .. )</li></ul><blockquote>Cuando creamos un objeto literal automáticamente es vinculado a Object.prototype</blockquote><h4>Object.create( .. )</h4><p>Para controlar este vínculo podemos crear objetos con <a href="https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Object/create"><em>Object.create( .. )</em></a>, quien recibe un primer argumento, que es el objeto al cual se vincula por medio de [[Prototype]] y un segundo argumento, con las nuevas propiedades nuevas.</p><p>Veamos un ejemplo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c97363a8c8c946fa3be17ea9e0a98130/href">https://medium.com/media/c97363a8c8c946fa3be17ea9e0a98130/href</a></iframe><p>Una representación de gráfica de esto sería.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/379/1*iVmW3UVprFJ3V7WJ6Kz1zQ.png" /></figure><blockquote>Object.create(null) crea un objeto que tiene un vínculo vacío, así que el objeto no delega nada, no tiene una cadena de prototipos</blockquote><h4>Delegando comportamientos</h4><p>Ya sabemos podemos manejar el vínculo entre los objetos, esta es la clave de la delegación en JavaScript, de esta manera solo debemos preocuparnos de objetos y las propiedades delegadas entre ellos.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/03d94c30fff3338562f8d64880d5c64c/href">https://medium.com/media/03d94c30fff3338562f8d64880d5c64c/href</a></iframe><p>Como vemos podemos crear dos objetos y vincularlos al objeto que usamos como prototipo, y su comportamiento va a ser independiente.</p><h4>Mutación</h4><p>Algo de lo que debemos tener cuidado es de la <strong>mutación</strong>, ya que los objetos en JavaScript son dinámicos.</p><p>Si una propiedad se cambia en un objeto se cambia en todos, claro este comportamiento es esperado si sabemos como funciona los <a href="https://medium.com/@yeion7/entendiendo-los-tipos-en-javascript-4c1c718e8e2a#.k6s9jvnmp">tipos en JavaScript</a>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ab6c89cbd4c174e9ab21f2fc1fe88c02/href">https://medium.com/media/ab6c89cbd4c174e9ab21f2fc1fe88c02/href</a></iframe><p>En el siguiente post veremos <strong>composición</strong>, lo cual nos ayudará a controlar esto y tener un sistema de herencia mucho más poderoso.</p><p>Me gustaría presentarles un ejemplo algo más complejo el cual tomó de <a href="https://github.com/getify/You-Dont-Know-JS">You Don’t Know JS</a>, en su libro dedicado a <a href="https://github.com/getify/You-Dont-Know-JS/blob/master/this%20&amp;%20object%20prototypes/ch6.md">objetos</a>.</p><p>En este ejemplo tenemos dos objetos controladores, que manejan el formulario de login y la autentificación con el servidor.</p><p><strong>Nota</strong>: Antes de leer el ejemplo te recomiendo <a href="https://medium.com/@yeion7/entendiendo-this-javascript-cba60c8cec8c">entender como funciona <em>this</em></a>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1ccc63ee720a7082cc95d224622bb691/href">https://medium.com/media/1ccc63ee720a7082cc95d224622bb691/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/015025b7dfc992a17a3023ac3256c683/href">https://medium.com/media/015025b7dfc992a17a3023ac3256c683/href</a></iframe><p>Con delegación de comportamiento <em>AuthController</em> y <em>LoginController</em> son solo objetos, solo debemos preocuparnos de delegar comportamientos.</p><h4>Conclusión</h4><p>Utilizar delegación de comportamientos puede llevar a arquitecturas de código más simples.</p><p>En este solo debemos pensar en objetos, los cuales delegan comportamientos a otros objetos, lo que lleva a no tener estructuras jerárquicas rígidas.</p><blockquote>“Hay dos clases de programadores JS, los que aprendimos con JS y los que aprendieron con otro lenguaje y tratan de usar JS como ese lenguaje” — <a href="https://medium.com/u/3ab83ddfd089">Sergio Xalambrí</a></blockquote><p>Tal vez al principio después de haber utilizado durante mucho tiempo constructores, jerarquías, poliformismos, etc. entender como funciona el patrón de delegación requiere un poco de costumbre, pero esta es mucho más fácil de entender que la herencia clásica.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8d99e3bc3826" width="1" height="1" alt=""><hr><p><a href="https://medium.com/entendiendo-javascript/entendiendo-la-delegaci%C3%B3n-en-javascript-8d99e3bc3826">Entendiendo la delegación en JavaScript</a> was originally published in <a href="https://medium.com/entendiendo-javascript">Entendiendo JavaScript</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>