What is destructuring assignment and its uses?

Solution for What is destructuring assignment and its uses?
is Given Below:

I have been reading about Destructuring assignment introduced in ES6.

What is the purpose of this syntax, why was it introduced, and what are some examples of how it might be used in practice?

What is destructuring assignment ?

The destructuring assignment syntax is a JavaScript expression that makes it possible to unpack values from arrays, or properties from objects, into distinct variables.



A. Makes code concise and more readable.

B. We can easily avoid repeated destructing expression.

Some use cases

1. To get values in variable from Objects,array

let obj = { 'a': 1,'b': {'b1': '1.1'}}
let {a,b,b:{b1}} = obj
console.log('a--> ' + a, 'nb--> ', b, 'nb1---> ', b1)

let obj2 = { foo: 'foo' };
let { foo: newVarName } = obj2;

let arr = [1, 2, 3, 4, 5]
let [first, second, ...rest] = arr
console.log(first, 'n', second, 'n', rest)

// Nested extraction is possible too:
let obj3 = { foo: { bar: 'bar' } };
let { foo: { bar } } = obj3;

2. To combine an array at any place with another array.

let arr = [2,3,4,5]
let newArr = [0,1,...arr,6,7]

3. To change only desired property in an object

let arr = [{a:1, b:2, c:3},{a:4, b:5, c:6},{a:7, b:8, c:9}]

let op = arr.map( ( {a,...rest}, index) => ({...rest,a:index+10}))


4. To create a shallow copy of objects

let obj = {a:1,b:2,c:3}
let newObj = {...obj}
newObj.a="new Obj a"

console.log('Original Object', obj)
console.log('Shallow copied Object', newObj)

5. To extract values from parameters into standalone variables

// Object destructuring:
const fn = ({ prop }) => {
fn({ prop: 'foo' });


// Array destructuring:
const fn2 = ([item1, item2]) => {
fn2(['bar', 'baz']);


// Assigning default values to destructured properties:

const fn3 = ({ foo="defaultFooVal", bar }) => {
  console.log(foo, bar);
fn3({ bar: 'bar' });

6. To get dynamic keys value from object

let obj = {a:1,b:2,c:3}
let key = 'c'
let {[key]:value} = obj


7. To build an object from other object with some default values

let obj = {a:1,b:2,c:3}
let newObj = (({d=4,...rest} = obj), {d,...rest})

8. To swap values

const b = [1, 2, 3, 4];
[b[0], b[2]] = [b[2], b[0]]; // swap index 0 and 2


9. To get a subset of an object

  • 9.1 subset of an object:

    const obj = {a:1, b:2, c:3},
    subset = (({a, c}) => ({a, c}))(obj); // credit to Ivan N for this function
  • 9.2 To get a subset of an object using comma operator and destructuring:

    const object = { a: 5, b: 6, c: 7  };
    const picked = ({a,c}=object, {a,c})
    console.log(picked); // { a: 5, c: 7 }

10. To do array to object conversion:

const arr = ["2019", "09", "02"],
date = (([year, day, month]) => ({year, month, day}))(arr);


11. To set default values in function. (Read this answer for more info )

function someName(element, input,settings={i:"#1d252c", i2:"#fff",...input}){

someName('hello', {i:'#123'})
someName('hello', {i2:'#123'})

12. To get properties such as length from an array, function name, number of arguments etc.

let arr = [1,2,3,4,5];

let {length} = arr;


let func = function dummyFunc(a,b,c) {
  return 'A B and C';

let {name, length:funcLen} = func;

console.log(name, funcLen);

It is something like what you have can be extracted with the same variable name

The destructuring assignment is a JavaScript expression that makes it possible to unpack values from arrays or properties from objects into distinct variables. Let’s get the month values from an array using destructuring assignment

var [one, two, three] = ['orange', 'mango', 'banana'];

console.log(one); // "orange"
console.log(two); // "mango"
console.log(three); // "banana"

and you can get user properties of an object using destructuring assignment,

var {name, age} = {name: 'John', age: 32};

console.log(name); // John
console.log(age); // 32

The De-structured assignment of Javascript is probably an inspiration drawn from Perl language.

This facilitates reuse by avoid writing getter methods or wrapper functions.

One best example that I found very helpful in particular was on reusing functions that return more data than what is required.

If there is a function that returns a list or an array or a json, and we are interested in only the first item of the list or array or json,
then we can simply use the de-structured assignment instead of writing a new wrapper function to extract the interesting data item.