Los grupos se usan con frecuencia para permitir que ciertos usuarios modifiquen un archivo o directorio.

Los dos tipos de grupos principales son grupos primarios y grupos secundarios. El grupo primario de un usuario es el grupo por defecto con el que se asocia la cuenta, generalmente comparte el mismo nombre que el usuario. Los directorios y los archivos que el usuario crea tendrán asignados este grupo. Un grupo secundario es cualquier grupo adicional del que un usuario sea parte.

Creación de grupos

Creemos dos grupos llamados "writers" y "editors". Usa el comando groupadd (es posible que necesites usar el comando sudo al inicio para tener el permiso adecuado para crear el grupo):

groupadd writers
groupadd editors

Creación de usuarios

Puede que ya tengas usuarios para agregar a tu grupo. Si no, aquí está la sintaxis básica para crear un usuario con el comando useradd:

useradd [options] username

Aquí está para crear un usuario llamado "quincy". El argumento -m le dice al comando que cree el directorio principal del usuario con el mismo nombre que el usuario. El argumento con su valor -p p4ssw0rd crea la contraseña "p4ssw0rd" para el usuario.

useradd -m quincy -p password

Los usuarios serán capaces de cambiar su contraseña con el comando passwd. Para ello, tendrán que ingresar su contraseña actual en ese momento y luego definir una nueva.

Agregar un usuario a un grupo

Puedes usar el comando usermod para agregar un usuario a un grupo. Así es cómo agregaríamos el usuario "quincy" al grupo "writers". El argumento -a significa "añadir" (append) y el argumento -G agrega un grupo como un grupo secundario.

usermod -a -G writers quincy

Cuando un usuario es creado con el comando adduser, este es automáticamente asignado a un grupo primario con el mismo nombre que el usuario. En nuestro ejemplo, actualmente el usuario "quincy" es parte de un grupo primario "quincy" y de un grupo secundario "writers".

También puedes agregar un usuario a muchos grupos a la vez al separar por comas los nombres de los grupos, así -G group1,group2,group3.

El siguiente comando cambia el grupo primario del usuario "quincy" de "quincy" a "editors":

usermod -g editors quincy

Remover un usuario de un grupo secundario

Para remover un usuario de un grupo secundario necesitas sobreescribir los grupos a los que actualmente este usuario pertenece, por una nueva lista de grupos dónde no esté el grupo que se quiere remover.

Primero, usa el comando id para verificar a cuáles grupos secundarios pertenece un usuario:

id -nG quincy

Digamos que este comando nos devuelve editors writers, esto indica que el usuario "quincy" es parte de los grupos "editors" y "writers". Si quieres remover al usuario del grupo "writers", usa el comando:

usermod -G editors quincy

Ese comando establece como grupo secundario del usuario "quincy" como "editors". Ya que el argumento -a no fue usado, los grupos previos fueron sobreescritos.

Conclusión

Deberías ahora estar listo para manejar usuarios y grupos en Linux. El siguiente paso es determinar qué privilegios debería tener cada grupo.

Traducido del artículo de Beau Carnes - Linux User Groups Explained: How to add a new group, a new group member, and change groups

Recientemente pregunté en Hashnode, "¿Cuál convención de mensaje usas en tus commits en el trabajo?" recibí muchas respuestas de usuarios quejándose de las convenciones que usan en el trabajo y proyectos personales.

En este artículo explicaré cómo escribir un buen mensaje de commit y por qué tú deberías darle importancia.

PS: Este artículo fue publicado primero aquí.

Introducción al control de versiones con Git

El software de control de versiones es una parte esencial de las prácticas de desarrollo de software modernas.

Por mucho, Git es el controlador de versiones más ampliamente utilizado en el mundo. Es un proyecto de código abierto, distribuido y activamente en desarrollo. Fue originalmente desarrollado en 2005 por Linus Torvalds, el famoso creador del kernel Linux.

¿Qué es un commit?

El comando commit se usa para confirmar los cambios en el área de preparación y guardarlos en el repositorio local en Git. Sin embargo, antes de guardar algún cambio, tienes que decirle a Git cuáles cambios quieres incluir de los muchísimos que puedes haber hecho. Una excelente manera de hacerlo es agregar un mensaje en el commit para identificar tus cambios.

Opciones de comando commit

• -m

Esta opción establece el mensaje del commit.

git add static/admin/config.yml
git commit -m "Configurar múltiples roles para netlify-cms git gateway"

• -a ó --all

Esta opción confirma todos los archivos en el área de trabajo (esos nuevos, con modificaciones, o incluso eliminados) automáticamente..

git commit -a -m "Agregar un nuevo rol para netlify-cms git gateway"

• --amend

Esta opción reescribe el último commit con cualquier cambio que esté en el área de preparación o un nuevo mensaje, y solo debería ser incluido en commits que no han sido aún sincronizados con el repositorio remoto.

git add .
git commit --amend -m "Actualizar roles para netlify-cms git gateway"

¿Por qué debería escribir un buen mensaje de commit?

Puede que digas: "Es solo un proyecto personal". Sí, puede que estés trabajando solo ahora, pero, ¿Qué pasa cuando trabajas con un equipo o contribuyes al código abierto?

Un mensaje de commit bien elaborado es la mejor manera de comunicar el contexto del cambio realizado a otros desarrolladores trabajando en el proyecto y también al futuro tú.

¿Haz alguna vez intentando ejecutar el comando git log en uno de tus proyectos viejos para ver los mensajes de commit "raros" que has usado desde su creación? Quizá sea difícil entender por qué hiciste algunos cambios en el pasado y es probable que desees haber leído este artículo antes.

Los mensajes de commit pueden comunicar adecuadamente el porqué un cambio fue hecho y de este modo entenderlo fácilmente. Haciendo más eficiente la colaboración y el desarrollo.

Cómo escribir mensajes de commit con Git

Hasta hoy, solamente usaba git commit -m "Arregle X para permitir que Y use Z" en mis proyectos personales especificando solo un título sin ninguna descripción extra. Esto es perfecto para parches pequeños y claros de código como, git commit -m "Corregi error tipográfico en README.md" pero en casos donde hay cambios más extensos necesitamos agregar más detalles.

Método editor

Ejecuta git commit sin un mensaje u opción y se abrirá tu editor de texto predeterminado para escribir el mensaje de commit.

Para configurar tu editor "predeterminado":

git config --global core.editor nano

Esto configurará Git para usar nano como editor predeterminado. Reemplaza "nano" con "emacs", "vim" o cualquiera de tu preferencia.

En el editor que se abrió, usa la primera línea para el título (corta descripción), deja una línea en blanco y todo lo de más es para la descripción extendida (cuerpo del mensaje).

<Resumir los cambio(s) en alrededor de 50 caracteres o menos>

<Descripción explicativa más detallada del cambio envuelto en aproximadamente 72 caracteres>

Método de línea de comando

git commit -m "Sujeto" -m "Descripción..."

El primer argumento -m es para el título (corta descripción), y el siguiente es para la descripción extendida (cuerpo del mensaje).

Cómo escribir buenos mensajes de commit

Existen muchas convenciones que son usadas por diferentes equipos y desarrolladores para escribir bien mensajes de commit. Aquí solo mostraré algunas reglas generales y consejos para escribir buenos mensajes de commit – puedes escoger cuál de estas reglas quieres seguir. Y si trabajas para una compañía o contribuyes al código abierto, tienes que aceptar y adaptarte a su convención.

Por consistencia, puedes usar una convención para el trabajo y otra para proyectos personales. Cuando cambies de trabajo, puede que la convención sea diferente en el nuevo lugar.

Esta es una gran plantilla de un buen mensaje de commit escrito originalmente por Tim Pope:

Aprovechar, Resumen breve (50 caracteres o menos)

Texto explicativo más detallado, si es necesario. Envuélvalo a unos 72 personajes más o menos. En algunos contextos, la primera línea se trata como asunto de un correo electrónico y el resto del texto como cuerpo. El espacio en blanco línea que separa el resumen del cuerpo es fundamental (a menos que omita todo el cuerpo); herramientas como rebase pueden confundirse si ejecuta el dos juntos.


Escriba su mensaje de confirmación en imperativo: "Corregir error" y no "Corregido error" o "Corrige error". Esta convención coincide con los mensajes de confirmación generados mediante comandos como git merge y git revert.

Los párrafos adicionales vienen después de las líneas en blanco.

- Las viñetas también están bien

- Normalmente se utiliza un guión o asterisco para la viñeta, seguido de un espacio único, con líneas en blanco en el medio, pero las convenciones varían aquí

- Usar una sangría colgante

Si utiliza un rastreador de problemas, agregue una referencia a ellos en la parte inferior, como tal:

Soluciona: #123

¿Se ve bien, no? Así es cómo tú puedes hacer el tuyo genial también:

1. Especifica el tipo de commit:
   feat: La nueva característica que agregas a una aplicación en particular
   fix: Un parche para un error
   style: Características o actualizaciones relacionadas con estilos
   refactor: Refactorizar una sección específica de la base de código
   test: Todo lo relacionado con pruebas
   docs: Todo lo relacionado con documentación
   chore: Mantenimiento de código regular.
2. Separa el título del cuerpo del mensaje con una línea en blanco.
3. Tu mensaje de commit no debería contener ningún mensaje de espacios en blanco.
4. Quita signos de puntuación innecesarios.
5. No termines el título con un punto.
6. Usa mayúsculas al inicio del título y por cada párrafo del cuerpo del mensaje.
7. Usa el modo imperativo en el título.
8. Usa el cuerpo del mensaje para explicar cuáles cambios has hecho y por qué los hiciste.
9. No asumas que las personas que revisará el código entiende cuál era el problema original, asegúrate de agregar la información necesaria.
10. No piense que tu código se explica solo.
11. Sigue la convención del mensaje de commit definida por tu equipo.

Conclusión

La parte más importante de un mensaje de commit es que sea claro y entendible. A final de cuentas, escribir buenos mensajes de commit demuestra que tan buen colaborador eres. Los beneficios de escribir un buen mensaje de commit no se limitan a tu equipo, de hecho, se expanden a ti y tus futuros colaboradores.

Traducido del artículo de Bolaji Ayodeji - How to Write Good Commit Messages: A Practical Git Guide

Aquí hay un corto vídeo dónde se muestra cómo hacer una función de rebote (en inglés):

Y aquí está el código fuente que se muestra en el vídeo:

Ahora veamos el código con más detalles.

Asume que tienes un botón definido de la siguiente manera:

<button id="myBtn">Click me</button>

Y en tu archivo JavaScript tienes algo parecido a esto:

document.getElementById('myBtn').addEventListener('click', () => {
  console.log('clicked');
})

Cada vez que hagas clic en el botón, verás el mensaje "click" en tu consola.

Agreguemos ahora una función de rebote a nuestro manejador de evento click:

document.getElementById('myBtn').addEventListener('click', debounce(() => {
  console.log('click');
}, 2000))

La función de rebote recibe dos párametros: callback y wait. El primero recibe la función que deseas ejecutar después de un periodo de tiempo, mientras que el segundo recibe el tiempo a esperar antes de ejecutar la función callback.

En el ejemplo de arriba, nuestra función callback simplemente es una función que ejecuta un console.log('click'); y wait representa 2000 milisegundos de espera.

Dado este escenario, definamos debounce:

function debounce(callback, wait) {
  let timerId;
  return (...args) => {
    clearTimeout(timerId);
    timerId = setTimeout(() => {
      callback(...args);
    }, wait);
  };
}

La función debounce recibe dos parámetros: el callback (la función que queremos ejecutar luego de un periodo predeterminado) y el periodo de espera wait (después del cuál callback será ejecutado).

Dentro de la función debounce, simplemente retornamos otra función, así:

let timerId;
return (...args) => {
  clearTimeout(timerId);
  timerId = setTimeout(() => {
    callback(...args);
  }, wait);
};

El próposito de esta función es invocar a la función callback después de cierto período de tiempo. Si durante el periodo de espera la misma función es ejecutada nuevamente, la ejecución previa es cancelada y el temporizador es reiniciado para empezar de nuevo.

¡Eso es todo! Todo lo que necesitas saber sobre qué es una función de debounce.

Aquí hay un video extra que habla sobre closures, ya que en este ejemplo usé un closure dentro de mi función debounce.

Avísame en Twitter si pudiste encontrar el uso de closure dentro de la función debounce.

¡Feliz programación, a todos!

Traducido del artículo de Adeel Imran - Debounce JavaScript – How to Make your JS Wait Up

Hay una razón por la qué puede ser difícil entender los closures: por lo general, se enseña al revés. Puede que te hayan enseñado qué es un closure, pero es posible que no hayas entendido el porqué son útiles para el desarrollador promedio, o dentro de tu propio código.

Entonces, ¿Por qué los closures importan en nuestro código JavaScript del día a día?

En lugar de ver a los closures como un tema a memorizar para algún tipo de examen, veamos que pasos nos pueden llevar a ver un closure en primer lugar. Una vez veamos lo qué son, descubriremos porqué los closures valen la pena en tu código JavaScript.

¿Haz visto un closure en la vida real?

Dígamos que estamos haciendo un clon del sitio de blogging Medium y queremos que cada usuario sea capaz de dar me gusta a diferentes posts.

Cada vez que un usuario haga click en el botón me gusta, su valor será incrementado por cada vez.

Piensa en el botón aplaudir de Medium:

La función handleLikePost manejará el incremento del contador, cada vez que se le de clic al botón, y la variable likeCount mantendrá el número de me gusta registrados:

// global scope
let likeCount = 0;

function handleLikePost() {
  // function scope
  likeCount = likeCount + 1;
}

handleLikePost();
console.log("like count:", likeCount); // like count: 1

Cuando un usuario haga clic en me gusta en un post, llamaremos a la función handleLikePost y esto incrementará nuestra variable likeCount en 1.

Esto funciona porque sabemos que esa función puede acceder a las variables fuera de sí mismas.

En otras palabras, las funciones pueden acceder cualquier variable definida en cualquier ámbito (scope) superior.

Sin embargo, hay un problema con este código. Ya que likeCount está en el ámbito global, y no en alguna función, likeCount es una variable global. Las variables globales pueden ser usadas (y actualizadas) por cualquier otra pieza de código o función en nuestra aplicación.

Por ejemplo, ¿Qué pasa si, erróneamente, después de nuestra función fijamos nuestra variable likeCount a cero?

let likeCount = 0;

function handleLikePost() {
  likeCount = likeCount + 1;
}

handleLikePost();
likeCount = 0;
console.log("like count:", likeCount); // like count: 0

Naturalmente, likeCount será siempre cero.

Cuando únicamente una función necesita una pieza de datos, ese dato solo necesita existir locamente, esto es, dentro de esa función.

Ahora traigamos likeCount dentro de nuestra función:

function handleLikePost() {
  // likeCount moved from global scope to function scope
  let likeCount = 0;
  likeCount = likeCount + 1;
}

Fíjate que hay una manera más corta de escribir la línea donde incrementamos likeCount. En lugar de decir que likeCount es igual al valor actual (en ese momento) de likeCount y agregar 1, podemos simplemente usar el operador +=, así:

function handleLikePost() {
  let likeCount = 0;
  likeCount += 1;
}

Y para que obtengamos el mismo resultado en consola, debemos también traernos nuestro console.log dentro de la función.

function handleLikePost() {
  let likeCount = 0;
  likeCount += 1;
  console.log("like count:", likeCount);
}

handleLikePost(); // like count: 1

Ahora vemos lo mismo que antes.

Ahora los usuarios deberían ser capaces de darle me gusta a un post las veces que ellos quieran, llamemos a la función handleLikePost unas cuantas veces más:

handleLikePost(); // like count: 1
handleLikePost(); // like count: 1
handleLikePost(); // like count: 1

Sin embargo, cuando ejecutamos este código, hay un problema.

Esperaríamos ver a la variable likeCount seguir incrementando, pero solo vemos un 1 cada vez. ¿Por qué pasa esto?

Detente un momento, mira nuestro código e intenta explicar porqué nuestra variable likeCount no se está incrementado cómo antes.

Veamos al código de la función handleLikePost:

function handleLikePost() {
  let likeCount = 0;
  likeCount += 1;
  console.log("like count:", likeCount);
}

Cada vez que lo usamos, estamos recreando la variable likeCount, la cual es inicializada a cero.

¡No hay duda del porqué no podemos mantener la cuenta entre cada llamada a la función! La variable es constantemente inicializada a cero, luego se incrementa en 1, y después la función finaliza su ejecución.

Estamos atorados. Nuestra variable necesita vivir dentro de la función handleLikePost, pero no podemos mantener la cuenta.

Necesitamos algo que nos permita preservar o recordar el valor de la variable likeCount entre las llamadas a la función.

Qué tal si probamos algo que puede parecer un poco extraño a primera vista: qué tal si intentamos poner una función dentro de nuestra función:

function handleLikePost() {
  let likeCount = 0;
  likeCount += 1;
  function() {

  }
}

handleLikePost();

Vamos a nombrar esta función addLike. ¿La razón? Porque ahora será responsable de incrementa la variable likeCount.

En la mayoría de casos, nuestra nueva función no necesitaría un nombre. Podría ser anónima. La estamos nombrando con el próposito de referinos a ella más fácilmente en nuestra explicación.

La función addLike ahora será responsable de incrementar nuestra variable likeCount, entonces moveremos la línea donde incrementamos la variable en 1 dentro de esta función interna.

function handleLikePost() {
  let likeCount = 0;
  function addLike() {
    likeCount += 1;
  }
}

¿Qué pasa si llamamos a la función addLike dentro de la función handleLikePost?

Lo qué pasará es que la función addLike incrementará la variable likeCount, pero aún así la variable likeCount será destruida. Así que, otra vez, perdemos la cuenta y nuestro resultado es cero.

Pero si en lugar de llamar a la función addLike dentro de su función padre, ¿Qué pasaría si la llamamos por fuera? Esto puede parecer aún más extraño. ¿Y cómo haríamos eso?

A este punto, sabemos que las funciones retornan valores. Por ejemplo, podríamos retornar el valor de la variable likeCount al final de la función handleLikePost para pasarlo a otras partes de nuestro programa:

function handleLikePost() {
  let likeCount = 0;
  function addLike() {
    likeCount += 1;
  }
  addLike();
  return likeCount;
}

Pero en lugar de hacer eso, retornemos la variable likeCount dentro de la función addLike y luego retornemos a la función addLike misma:

function handleLikePost() {
  let likeCount = 0;
  return function addLike() {
    likeCount += 1;
    return likeCount;
  };
  // addLike();
}

handleLikePost();

Esto puede verse bizarro, pero es permitido en JavaScript. Podemos tratar a las funciones como variables. Esto significa que una función puede ser retornada por otra función. Al retornar la función interna, podemos llamarla desde afuera de su función padre.

¿Pero cómo hacemos eso? Piensa en esto por un minuto e intenta averiguarlo por tu cuenta...

Primero, para ver mejor lo qué está pasando, vamos a imprimir la llamada a la función handleLikePost con un console.log, asi: console.log(handleLikePost()). Mira que pasa cuando lo ejecutamos:

function handleLikePost() {
  let likeCount = 0;
  return function addLike() {
    likeCount += 1;
    return likeCount;
  };
}

console.log(handleLikePost()); // ƒ addLike()

Como era de esperarse, vemos a la función addLike. ¿Por qué? Porque la estamos retornado después de todo.

Para llamarla, ¿Podríamos solo recibirla en otra variable? Como acabamos de decir, las funciones pueden ser tratadas como cualquier otra variable en JavaScript. Si podemos retornar una función desde otra, podemos recibirla en una variable también. Recibamosla en una variable con nombre like:

function handleLikePost() {
  let likeCount = 0;
  return function addLike() {
    likeCount += 1;
    return likeCount;
  };
}

const like = handleLikePost();

Y finalmente, llamemos like. Hagámoslo unas cuantas veces e imprimamos cada resultado con un console.log:

function handleLikePost() {
  let likeCount = 0;
  return function addLike() {
    likeCount += 1;
    return likeCount;
  };
}

const like = handleLikePost();

console.log(like()); // 1
console.log(like()); // 2
console.log(like()); // 3

¡Nuestra variablelikeCount finalmente mantiene el conteo! Cada vez que nosotros llamamos a la función like, la variable likeCount es incrementada a partir de su valor previo.

¿Pero qué fue lo que paso aquí? Bien, averiguamos cómo llamar a la función addLike desde fuera del ámbito en el cuál fue declarada. Hicimos esto al retornar la función interna desde la función padre y, de esta manera, preservamos el acceso al ámbito de la función padre, la recibimos en la variable like, y al final, la ejecutamos.

¿Cómo funciona un closure, línea por línea?

Sí, esa fue nuestra implementación, claro, ¿Pero cómo hicimos para preservar el valor de la variable likeCount entre cada llamada a la función?

function handleLikePost() {
  let likeCount = 0;
  return function addLike() {
    likeCount += 1;
    return likeCount;
  };
}

const like = handleLikePost();

console.log(like()); // 1

1. Cuando la función padre handleLikePost es ejecutada, crea una instancia de la función interna addLike; esa función tiene acceso directo a la variable likeCount, la cuál está un ámbito más arriba.
2. Llamamos a la función addLike desde afuera del ámbito en el cuál fue declarada. Hicimos eso al retornar la función interna desde la función padre, así preservamos una referencia a su ámbito, la recibimos en la variables like, y la ejecutamos.
3. Cuando la función like finaliza su ejecución, normalmente, todas sus variables serían removidas de la memoria por el garbage collector (esto es un proceso automático que el compilador de JavaScript hace). Esperaríamos que cada valor de likeCount se elimine cuando la función termina, pero no pasa esto.

¿Cuál es la razón? El closure.

Ya que las instancias de la función interna aún viven (la función que recibimos en la variable like), el closure aún preserva el valor y el acceso a la variable countLike.

Es normal pensar que declarar una función dentro de otra es como declarar una función en el ámbito global, pero no.

Es por esto que los closures dan a las funciones súper poderes, porque es una propiedad especial que no está presente en en ninguna otra parte del lenguaje.

La vida útil de una variable

Para apreciar mejor a los closures, tenemos que entender cómo JavaScript trata a las variables que son creadas. Puedes haberte preguntado qué le pasa a las variables cuando cierro una página web o abro otra página dentro de la aplicación. ¿Cuánto viven las variables?

Las variables globales viven hasta que el programa es descartado, por ejemplo cuando cierras la ventana. Viven lo que viva la ejecución del programa.

Sin embargo, las variables locales tienen vidas cortas. Son creadas cuando una función es invocada, y eliminadas cuando la función termina su ejecución.

Así que antes, cuando la variable likeCount era solo una variables local, solo vivia mientras la función corría. La variable likeCount era creada al inicio de la ejecución y destruida al final.

Los closures no son capturas instantáneas: mantienen a las variable locales vivas

A veces se dice que los closures en JavaScript son similares a capturas instantáneas, una foto del programa en cierto periodo de tiempo. Esta es una idea equivocada que podemos disipar agregando otra característica a la funcionalidad de nuestro botón me gusta.

Dígamos que en raras ocaciones, queremos permitir a los usuarios que al hacer doble clic en el botón este incremente el valor de la variable likeCount por 2 en lugar de por 1.

¿Cómo agregamos esta característica?

Otra forma de pasar valores a una función es a través de argumentos, los cuales operan justo como variables locales.

Vamos a pasar un argumento nombrado step a la función, el cuál nos permitirá proveer un valor dinámico e intercambiable para incrementar nuestro contador en lugar de un valor fijo 1.

function handleLikePost(step) {
  let likeCount = 0;
  return function addLike() {
    likeCount += step;
    // likeCount += 1;
    return likeCount;
  };
}

Ahora, intentemos hacer una función especial que nos permitirá hacer doble clic a nuestros posts, doubleLike. Pasaremos un 2 como valor al argumento step y luego intentaremos llama a nuestras dos funciones, like and doubleLike:

function handleLikePost(step) {
  let likeCount = 0;
  return function addLike() {
    likeCount += step;
    return likeCount;
  };
}

const like = handleLikePost(1);
const doubleLike = handleLikePost(2);

like(); // 1
like(); // 2

doubleLike(); // 2 (the count is still being preserved!)
doubleLike(); // 4

Vemos que el valor de la variable likeCount se mantiene también para la función doubleLike.

¿Qué está pasando aquí?

Cada instancia de la función interna addLike preserva el acceso a las variables likeCount and step del ámbito de su función padre handleLikePost. La variable step se mantiene viva, y su valor es actualizado por cada invocación a la función interna. Ya qué el acceso al ámbito (el closure) es sobre las variables y no solo una instántanea de sus valores, estas actualizaciones son preservadas entre cada llamada a la función.

Entonces, ¿Todo lo que este código nos muestra es el hecho de que podemos pasar valores dinámicos para cambiar el resultado de nuestra función? No, no es todo. ¡Nos muestra qué las variables locales aún están vivas! Los closures mantienen a las variables locales vivas aún cuando estas debieron ser destruidas tiempo atrás.

En otras palabras, los closures no son estáticos y fijos, como una captura instantánea de los valores de las variables en cierto periodo del tiempo, sino que mantienen a las variables locales vivas y proveen acceso a ellas. Como resultado, podemos usar closures para observar o hacer actualizaciones a estas variables a lo largo del tiempo.

¿Qué es exactamente un closure?

Ya que viste porque los closures son útiles, hay dos condiciones para que exista un closure:

1. Los closures son una propiedad exclusiva de las funciones.
2. Para crear un closure, primero debes ejecutar una función en un ámbito diferente a ese en el cuál se definió.

¿Por qué deberíamos saber de closures?

Respondamos a la pregunta original que nos dimos a la tarea de responder. Basado en todo lo que has visto, detente un momento e intenta responderla tu mismo. ¿Por qué nos deberían importan los closures siendo desarrolladores JavaScript?

Los closures son importantes para ti y tu código porque nos permiten recordar valores, lo cuál es una muy poderosa y única característica en el lenguaje que solo las funciones poseen.

Lo vimos justo en este ejemplo. Después de todo, ¿Qué uso tiene una variable contador que no recuerda el número de me gusta? Te encontraras con eso frecuentemente en tu carrera al trabajar con JavaScript. Necesita mantener el valor de una variable pero a la vez separada del resto de variables. ¿Qué usas? Una función. ¿Por qué? Para mantener un valor a través del tiempo en un closure.

Y con eso, estas un paso adelante de otros desarrolladores.

¿Quieres convertirte en un maestro en JavaScript? Únete al JS Bootcamp 2020? (en inglés)

Follow + Say Hi! ? Twitter • Instagram • codeartistry.io

Traducido del artículo de Reed Barger - Why You Should Know JavaScript Closures