Desestructuración en ES6, consejos para obtener un código limpio
Tags: javascript, es6, cleancode
Published: 2023-03-15 08:33:53

# Introducción

¿Estás cansado de escribir código extendido y difícil de leer? ¿Quiere mejorar sus habilidades de codificación y hacer que su código sea más legible y conciso? ¡No busque más! En este artículo, me sumergiré en el mundo de la desestructuración de ES6 y le mostraré cómo usarlo para escribir código más limpio y eficiente.

Desde la desestructuración de objetos y matrices hasta el uso de valores predeterminados y el operador de propagación, lo cubriremos todo. Prepárate para dominar el arte de la codificación limpia y concisa 🚀.

# Desestructurando objetos 🔧

Una de las formas más comunes de usar la desestructuración es asignar propiedades de un objeto a las variables. Por ejemplo, en lugar de escribir:

```jsx
const person = { name: 'John', age: 30 };
const name = person.name;
const age = person.age;
```

Puede usar la desestructuración para hacer que el código sea más conciso:

```jsx
const person = { name: 'John', age: 30 };
const { name, age } = person;
```

# Desestructurando Arrays 🔳

Al igual que con los objetos, también puede usar la **desestructuración para asignar elementos de una matriz a las variables**. Por ejemplo, en lugar de escribir:

```jsx
const numbers = [1, 2, 3];
const first = numbers[0];
const second = numbers[1];
const third = numbers[2];
```

Puede usar la desestructuración para hacer que el código sea más conciso:

```jsx
const numbers = [1, 2, 3];
const [first, second, third] = numbers;
```

# Valores por defecto 📈

La desestructuración también le permite asignar valores predeterminados a las variables en caso de que el valor no esté definido. Por ejemplo, en lugar de escribir:

```jsx
const person = { name: 'John' };
let age = person.age || 25;
```

Puede usar la desestructuración para hacer que el código sea más conciso:

```jsx
const person = { name: 'John' };
const { age = 25 } = person;
```

# Renombrar las variables 🔀

A veces, los nombres de propiedades o variables que está desestructurando no coinciden con los nombres que desea usar en su código. En estos casos, **puede utilizar los dos puntos (:) para cambiar el nombre de la variable**. Por ejemplo, en lugar de escribir:

```jsx
const person = { firstName: 'John', lastName: 'Doe' };
const first = person.firstName;
const last = person.lastName;
```

Puede usar la desestructuración para hacer que el código sea más conciso y semántico:

```jsx
const person = { firstName: 'John', lastName: 'Doe' };
const { firstName: first, lastName: last } = person;
```

# Desestructuración anidada 🕸️

La desestructuración también se puede utilizar en matrices y objetos anidados. Por ejemplo, en lugar de escribir:

```jsx
const data = {
    results: [
        {
            title: 'Article 1',
            author: {
                name: 'John',
                age: 30
            }
        },
        {
            title: 'Article 2',
            author: {
                name: 'Jane',
                age: 25
            }
        }
    ]
};
const firstResultTitle = data.results[0].title;
const firstAuthorName = data.results[0].author.name;
const firstAuthorAge = data.results[0].author.age;
```

Puede usar la desestructuración anidada para que el código sea más conciso:

```jsx
const data = {
  results: [
    {
      title: 'Article 1',
      author: {
        name: 'John',
        age: 30
      }
    },
    {
      title: 'Article 2',
      author: {
        name: 'Jane',
        age: 25
      }
    }
  ]
};

const {
	results: [{ 
						title: firstResultTitle, 
						author: { 
							name: firstAuthorName, 
							age: firstAuthorAge } 
						}]
} = data;
```

# Parámetros de funciones de desestructuración 🔥

La desestructuración también se puede utilizar en parámetros de función. Por ejemplo, en lugar de escribir:

```jsx
function createPerson(options) {
const name = options.name;
const age = options.age;
// ...
}

createPerson({ name: 'John', age: 30 });
```

Puede usar la desestructuración para hacer que el código sea más conciso y semántico:

```jsx
function createPerson({ name, age }) {
// ...
}

createPerson({ name: 'John', age: 30 });
```

Otro ejemplo que utilizaremos desde un listener en los eventos, 

```jsx
// El Objeto que llega es 

/*
event : {
    detail: { 
        value: 'clave a mostrar'
    }
}
*/

// En este caso definimos valores por defecto pero por
// lo general los eventos si son escuchado por una acción
// seguramente tengan datos y no haga falta declarar los
// valores por defecto.

function _setValue({ detail: { value = "" } = {} } = {}){
    this.clave = value;
};
```

# Operador de desestructuración y propagación 🌀

También puede usar el operador de propagación `(...)` en combinación con la desestructuración **para asignar los elementos restantes de una matriz o las propiedades restantes de un objeto a una variable**. Por ejemplo, en lugar de escribir:

```jsx
const numbers = [1, 2, 3, 4, 5];
const [first, second, ...others] = numbers;
console.log(others); // [3, 4, 5]
```

Puede usar el operador de propagación y la desestructuración juntos para hacer que el código sea más conciso:

```jsx
const numbers = [1, 2, 3, 4, 5];
const [first, second, ...others] = numbers;
console.log(others); // [3, 4, 5]
```

# Conclusión

En conclusión, la **desestructuración de ES6** es una herramienta poderosa que puede ayudarlo a escribir un código más limpio y legible. Con los trucos y técnicas descritos en este artículo, podrá desestructurar objetos y matrices, usar valores predeterminados, cambiar el nombre de las variables e incluso combinar la desestructuración con el operador de propagación.

Recuerde, la clave para escribir código limpio y conciso es esforzarse siempre por la simplicidad y la legibilidad. Entonces, la próxima vez que esté escribiendo JavaScript, ¡pruebe estos trucos de desestructuración y vea cómo pueden mejorar su código! 💻🚀