right side of assignment cannot be destructured angular

• Skip to main content
• Skip to search
• Skip to select language
• Sign up for free
• Português (do Brasil)

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.

Description

The object and array literal expressions provide an easy way to create ad hoc packages of data.

The destructuring assignment uses similar syntax but uses it on the left-hand side of the assignment instead. It defines which values to unpack from the sourced variable.

Similarly, you can destructure objects on the left-hand side of the assignment.

This capability is similar to features present in languages such as Perl and Python.

For features specific to array or object destructuring, refer to the individual examples below.

Binding and assignment

For both object and array destructuring, there are two kinds of destructuring patterns: binding pattern and assignment pattern , with slightly different syntaxes.

In binding patterns, the pattern starts with a declaration keyword ( var , let , or const ). Then, each individual property must either be bound to a variable or further destructured.

All variables share the same declaration, so if you want some variables to be re-assignable but others to be read-only, you may have to destructure twice — once with let , once with const .

In many other syntaxes where the language binds a variable for you, you can use a binding destructuring pattern. These include:

• The looping variable of for...in for...of , and for await...of loops;
• Function parameters;
• The catch binding variable.

In assignment patterns, the pattern does not start with a keyword. Each destructured property is assigned to a target of assignment — which may either be declared beforehand with var or let , or is a property of another object — in general, anything that can appear on the left-hand side of an assignment expression.

Note: The parentheses ( ... ) around the assignment statement are required when using object literal destructuring assignment without a declaration.

{ a, b } = { a: 1, b: 2 } is not valid stand-alone syntax, as the { a, b } on the left-hand side is considered a block and not an object literal according to the rules of expression statements . However, ({ a, b } = { a: 1, b: 2 }) is valid, as is const { a, b } = { a: 1, b: 2 } .

If your coding style does not include trailing semicolons, the ( ... ) expression needs to be preceded by a semicolon, or it may be used to execute a function on the previous line.

Note that the equivalent binding pattern of the code above is not valid syntax:

You can only use assignment patterns as the left-hand side of the assignment operator. You cannot use them with compound assignment operators such as += or *= .

Default value

Each destructured property can have a default value . The default value is used when the property is not present, or has value undefined . It is not used if the property has value null .

The default value can be any expression. It will only be evaluated when necessary.

Rest property

You can end a destructuring pattern with a rest property ...rest . This pattern will store all remaining properties of the object or array into a new object or array.

The rest property must be the last in the pattern, and must not have a trailing comma.

Array destructuring

Basic variable assignment, destructuring with more elements than the source.

In an array destructuring from an array of length N specified on the right-hand side of the assignment, if the number of variables specified on the left-hand side of the assignment is greater than N , only the first N variables are assigned values. The values of the remaining variables will be undefined.

Swapping variables

Two variables values can be swapped in one destructuring expression.

Without destructuring assignment, swapping two values requires a temporary variable (or, in some low-level languages, the XOR-swap trick ).

Parsing an array returned from a function

It's always been possible to return an array from a function. Destructuring can make working with an array return value more concise.

In this example, f() returns the values [1, 2] as its output, which can be parsed in a single line with destructuring.

Ignoring some returned values

You can ignore return values that you're not interested in:

You can also ignore all returned values:

Using a binding pattern as the rest property

The rest property of array destructuring assignment can be another array or object binding pattern. The inner destructuring destructures from the array created after collecting the rest elements, so you cannot access any properties present on the original iterable in this way.

These binding patterns can even be nested, as long as each rest property is the last in the list.

On the other hand, object destructuring can only have an identifier as the rest property.

Unpacking values from a regular expression match

When the regular expression exec() method finds a match, it returns an array containing first the entire matched portion of the string and then the portions of the string that matched each parenthesized group in the regular expression. Destructuring assignment allows you to unpack the parts out of this array easily, ignoring the full match if it is not needed.

Using array destructuring on any iterable

Array destructuring calls the iterable protocol of the right-hand side. Therefore, any iterable, not necessarily arrays, can be destructured.

Non-iterables cannot be destructured as arrays.

Iterables are only iterated until all bindings are assigned.

The rest binding is eagerly evaluated and creates a new array, instead of using the old iterable.

Object destructuring

Basic assignment, assigning to new variable names.

A property can be unpacked from an object and assigned to a variable with a different name than the object property.

Here, for example, const { p: foo } = o takes from the object o the property named p and assigns it to a local variable named foo .

Assigning to new variable names and providing default values

A property can be both

• Unpacked from an object and assigned to a variable with a different name.
• Assigned a default value in case the unpacked value is undefined .

Unpacking properties from objects passed as a function parameter

Objects passed into function parameters can also be unpacked into variables, which may then be accessed within the function body. As for object assignment, the destructuring syntax allows for the new variable to have the same name or a different name than the original property, and to assign default values for the case when the original object does not define the property.

Consider this object, which contains information about a user.

Here we show how to unpack a property of the passed object into a variable with the same name. The parameter value { id } indicates that the id property of the object passed to the function should be unpacked into a variable with the same name, which can then be used within the function.

You can define the name of the unpacked variable. Here we unpack the property named displayName , and rename it to dname for use within the function body.

Nested objects can also be unpacked. The example below shows the property fullname.firstName being unpacked into a variable called name .

Setting a function parameter's default value

Default values can be specified using = , and will be used as variable values if a specified property does not exist in the passed object.

Below we show a function where the default size is 'big' , default co-ordinates are x: 0, y: 0 and default radius is 25.

In the function signature for drawChart above, the destructured left-hand side has a default value of an empty object = {} .

You could have also written the function without that default. However, if you leave out that default value, the function will look for at least one argument to be supplied when invoked, whereas in its current form, you can call drawChart() without supplying any parameters. Otherwise, you need to at least supply an empty object literal.

For more information, see Default parameters > Destructured parameter with default value assignment .

Nested object and array destructuring

For of iteration and destructuring, computed object property names and destructuring.

Computed property names, like on object literals , can be used with destructuring.

Invalid JavaScript identifier as a property name

Destructuring can be used with property names that are not valid JavaScript identifiers by providing an alternative identifier that is valid.

Destructuring primitive values

Object destructuring is almost equivalent to property accessing . This means if you try to destruct a primitive value, the value will get wrapped into the corresponding wrapper object and the property is accessed on the wrapper object.

Same as accessing properties, destructuring null or undefined throws a TypeError .

This happens even when the pattern is empty.

Combined array and object destructuring

Array and object destructuring can be combined. Say you want the third element in the array props below, and then you want the name property in the object, you can do the following:

The prototype chain is looked up when the object is deconstructed

When deconstructing an object, if a property is not accessed in itself, it will continue to look up along the prototype chain.

Specifications

Browser compatibility.

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

• Assignment operators
• ES6 in Depth: Destructuring on hacks.mozilla.org (2015)

You're signed out

Sign in to ask questions, follow content, and engage with the Community

• Canvas Developers Group

Cannot destruct right side of assignment

• Subscribe to RSS Feed
• Mark Topic as New
• Mark Topic as Read
• Float this Topic for Current User
• Printer Friendly Page

• Mark as New
• Report Inappropriate Content

Solved! Go to Solution.

View solution in original post

• All forum topics
• Previous Topic

Destructuring assignment

The two most used data structures in JavaScript are Object and Array .

• Objects allow us to create a single entity that stores data items by key.
• Arrays allow us to gather data items into an ordered list.

However, when we pass these to a function, we may not need all of it. The function might only require certain elements or properties.

Destructuring assignment is a special syntax that allows us to “unpack” arrays or objects into a bunch of variables, as sometimes that’s more convenient.

Destructuring also works well with complex functions that have a lot of parameters, default values, and so on. Soon we’ll see that.

Array destructuring

Here’s an example of how an array is destructured into variables:

Now we can work with variables instead of array members.

It looks great when combined with split or other array-returning methods:

As you can see, the syntax is simple. There are several peculiar details though. Let’s see more examples to understand it better.

It’s called “destructuring assignment,” because it “destructurizes” by copying items into variables. However, the array itself is not modified.

It’s just a shorter way to write:

Unwanted elements of the array can also be thrown away via an extra comma:

In the code above, the second element of the array is skipped, the third one is assigned to title , and the rest of the array items are also skipped (as there are no variables for them).

…Actually, we can use it with any iterable, not only arrays:

That works, because internally a destructuring assignment works by iterating over the right value. It’s a kind of syntax sugar for calling for..of over the value to the right of = and assigning the values.

We can use any “assignables” on the left side.

For instance, an object property:

In the previous chapter, we saw the Object.entries(obj) method.

We can use it with destructuring to loop over the keys-and-values of an object:

The similar code for a Map is simpler, as it’s iterable:

There’s a well-known trick for swapping values of two variables using a destructuring assignment:

Here we create a temporary array of two variables and immediately destructure it in swapped order.

We can swap more than two variables this way.

The rest ‘…’

Usually, if the array is longer than the list at the left, the “extra” items are omitted.

For example, here only two items are taken, and the rest is just ignored:

If we’d like also to gather all that follows – we can add one more parameter that gets “the rest” using three dots "..." :

The value of rest is the array of the remaining array elements.

We can use any other variable name in place of rest , just make sure it has three dots before it and goes last in the destructuring assignment.

Default values

If the array is shorter than the list of variables on the left, there will be no errors. Absent values are considered undefined:

If we want a “default” value to replace the missing one, we can provide it using = :

Default values can be more complex expressions or even function calls. They are evaluated only if the value is not provided.

For instance, here we use the prompt function for two defaults:

Please note: the prompt will run only for the missing value ( surname ).

Object destructuring

The destructuring assignment also works with objects.

The basic syntax is:

We should have an existing object on the right side, that we want to split into variables. The left side contains an object-like “pattern” for corresponding properties. In the simplest case, that’s a list of variable names in {...} .

For instance:

Properties options.title , options.width and options.height are assigned to the corresponding variables.

The order does not matter. This works too:

The pattern on the left side may be more complex and specify the mapping between properties and variables.

If we want to assign a property to a variable with another name, for instance, make options.width go into the variable named w , then we can set the variable name using a colon:

The colon shows “what : goes where”. In the example above the property width goes to w , property height goes to h , and title is assigned to the same name.

For potentially missing properties we can set default values using "=" , like this:

Just like with arrays or function parameters, default values can be any expressions or even function calls. They will be evaluated if the value is not provided.

In the code below prompt asks for width , but not for title :

We also can combine both the colon and equality:

If we have a complex object with many properties, we can extract only what we need:

The rest pattern “…”

What if the object has more properties than we have variables? Can we take some and then assign the “rest” somewhere?

We can use the rest pattern, just like we did with arrays. It’s not supported by some older browsers (IE, use Babel to polyfill it), but works in modern ones.

It looks like this:

In the examples above variables were declared right in the assignment: let {…} = {…} . Of course, we could use existing variables too, without let . But there’s a catch.

This won’t work:

The problem is that JavaScript treats {...} in the main code flow (not inside another expression) as a code block. Such code blocks can be used to group statements, like this:

So here JavaScript assumes that we have a code block, that’s why there’s an error. We want destructuring instead.

To show JavaScript that it’s not a code block, we can wrap the expression in parentheses (...) :

Nested destructuring

If an object or an array contains other nested objects and arrays, we can use more complex left-side patterns to extract deeper portions.

In the code below options has another object in the property size and an array in the property items . The pattern on the left side of the assignment has the same structure to extract values from them:

All properties of options object except extra which is absent in the left part, are assigned to corresponding variables:

Finally, we have width , height , item1 , item2 and title from the default value.

Note that there are no variables for size and items , as we take their content instead.

Smart function parameters

There are times when a function has many parameters, most of which are optional. That’s especially true for user interfaces. Imagine a function that creates a menu. It may have a width, a height, a title, an item list and so on.

Here’s a bad way to write such a function:

In real-life, the problem is how to remember the order of arguments. Usually, IDEs try to help us, especially if the code is well-documented, but still… Another problem is how to call a function when most parameters are ok by default.

That’s ugly. And becomes unreadable when we deal with more parameters.

Destructuring comes to the rescue!

We can pass parameters as an object, and the function immediately destructurizes them into variables:

We can also use more complex destructuring with nested objects and colon mappings:

The full syntax is the same as for a destructuring assignment:

Then, for an object of parameters, there will be a variable varName for the property incomingProperty , with defaultValue by default.

Please note that such destructuring assumes that showMenu() does have an argument. If we want all values by default, then we should specify an empty object:

We can fix this by making {} the default value for the whole object of parameters:

In the code above, the whole arguments object is {} by default, so there’s always something to destructurize.

Destructuring assignment allows for instantly mapping an object or array onto many variables.

The full object syntax:

This means that property prop should go into the variable varName and, if no such property exists, then the default value should be used.

Object properties that have no mapping are copied to the rest object.

The full array syntax:

The first item goes to item1 ; the second goes into item2 , and all the rest makes the array rest .

It’s possible to extract data from nested arrays/objects, for that the left side must have the same structure as the right one.

We have an object:

Write the destructuring assignment that reads:

• name property into the variable name .
• years property into the variable age .
• isAdmin property into the variable isAdmin (false, if no such property)

Here’s an example of the values after your assignment:

The maximal salary

There is a salaries object:

Create the function topSalary(salaries) that returns the name of the top-paid person.

• If salaries is empty, it should return null .
• If there are multiple top-paid persons, return any of them.

P.S. Use Object.entries and destructuring to iterate over key/value pairs.

Open a sandbox with tests.

Open the solution with tests in a sandbox.

• If you have suggestions what to improve - please submit a GitHub issue or a pull request instead of commenting.
• If you can't understand something in the article – please elaborate.
• To insert few words of code, use the <code> tag, for several lines – wrap them in <pre> tag, for more than 10 lines – use a sandbox ( plnkr , jsbin , codepen …)

Lesson navigation

• © 2007—2024  Ilya Kantor
• about the project
• terms of usage
• privacy policy

• DSA with JS - Self Paced
• JS Tutorial
• JS Exercise
• JS Interview Questions
• JS Operator
• JS Projects
• JS Examples
• JS Free JS Course
• JS A to Z Guide
• JS Formatter

Destructuring Assignment in JavaScript

• How to swap variables using destructuring assignment in JavaScript ?
• Division Assignment(/=) Operator in JavaScript
• Exponentiation Assignment(**=) Operator in JavaScript
• What is a Destructuring assignment and explain it in brief in JavaScript ?
• Describe closure concept in JavaScript
• Copy Constructor in JavaScript
• Classes In JavaScript
• JavaScript Function() Constructor
• Multiple Class Constructors in JavaScript
• Implementation of Array class in JavaScript
• Functions in JavaScript
• JavaScript TypeError - Invalid assignment to const "X"
• Scoping & Hoisting in JavaScript
• How to set default values when destructuring an object in JavaScript ?
• What is Parameter Destructuring in TypeScript ?
• JavaScript Hoisting
• Addition Assignment (+=) Operator in Javascript
• Array of functions in JavaScript
• Enums in JavaScript

Destructuring Assignment is a JavaScript expression that allows to unpack values from arrays, or properties from objects, into distinct variables data can be extracted from arrays, objects, nested objects and assigning to variables . In Destructuring Assignment on the left-hand side defined that which value should be unpacked from the sourced variable. In general way implementation of the extraction of the array is as shown below:  Example:  

• Array destructuring:

Object destructuring:

Array destructuring: Using the Destructuring Assignment in JavaScript array possible situations, all the examples are listed below:

• Example 1: When using destructuring assignment the same extraction can be done using below implementations. 
• Example 2: The array elements can be skipped as well using a comma separator. A single comma can be used to skip a single array element. One key difference between the spread operator and array destructuring is that the spread operator unpacks all array elements into a comma-separated list which does not allow us to pick or choose which elements we want to assign to variables. To skip the whole array it can be done using the number of commas as there is a number of array elements. 
• Example 3: In order to assign some array elements to variable and rest of the array elements to only a single variable can be achieved by using rest operator (…) as in below implementation. But one limitation of rest operator is that it works correctly only with the last elements implying a subarray cannot be obtained leaving the last element in the array. 
• Example 4: Values can also be swapped using destructuring assignment as below: 
• Example 5: Data can also be extracted from an array returned from a function. One advantage of using a destructuring assignment is that there is no need to manipulate an entire object in a function but just the fields that are required can be copied inside the function. 
• Example 6: In ES5 to assign variables from objects its implementation is 
• Example 7: The above implementation in ES6 using destructuring assignment is. 
• Example1: The Nested objects can also be destructured using destructuring syntax. 
• Example2: Nested objects can also be destructuring

Please Login to comment...

Similar reads.

• JavaScript-Questions
• Web Technologies

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Destructuring and parameter handling in ECMAScript 6

ECMAScript 6 (ES6) supports destructuring , a convenient way to extract values from data stored in (possibly nested) objects and arrays. This blog post describes how it works and gives examples of its usefulness. Additionally, parameter handling receives a significant upgrade in ES6: it becomes similar to and supports destructuring, which is why it is explained here, too.

Destructuring   #

In locations that receive data (such as the left-hand side of an assignment), destructuring lets you use patterns to extract parts of that data. In the following example, we use destructuring in a variable declaration (line (A)). It declares the variables f and l and assigns them the values 'Jane' and 'Doe' .

Destructuring can be used in the following locations. Each time, x is set to 'a' .

Constructing versus extracting   #

To fully understand what destructuring is, let’s first examine its broader context. JavaScript has operations for constructing data:

And it has operations for extracting data:

Note that we are using the same syntax that we have used for constructing.

There is nicer syntax for constructing – an object literal :

Destructuring in ECMAScript 6 enables the same syntax for extracting data, where it is called an object pattern :

Just as the object literal lets us create multiple properties at the same time, the object pattern lets us extract multiple properties at the same time.

You can also destructure arrays via patterns:

We distinguish:

• Destructuring source: the data to be destructured. For example, the right-hand side of a destructuring assignment.
• Destructuring target: the pattern used for destructuring. For example, the left-hand side of a destructuring assignment.

Being selective with parts   #

If you destructure an object, you are free to mention only those properties that you are interested in:

If you destructure an array, you can choose to only extract a prefix:

If a part has no match   #

Similarly to how JavaScript handles non-existent properties and array elements, destructuring silently fails if the target mentions a part that doesn’t exist in the source: the interior of the part is matched against undefined . If the interior is a variable that means that the variable is set to undefined :

Nesting   #

You can nest patterns arbitrarily deeply:

How do patterns access the innards of values?   #

In an assignment pattern = someValue , how does the pattern acess what’s inside someValue ?

Object patterns coerce values to objects   #

The object pattern coerces destructuring sources to objects before accessing properties. That means that it works with primitive values:

Failing to object-destructure a value   #

The coercion to object is not performed via Object() , but via the internal operation ToObject() . Object() never fails:

ToObject() throws a TypeError if it encounters undefined or null . Therefore, the following destructurings fail, even before destructuring accesses any properties:

As a consequence, you can use the empty object pattern {} to check whether a value is coercible to an object. As we have seen, only undefined and null aren’t:

The parentheses around the object patterns are necessary because statements must not begin with curly braces in JavaScript.

Array patterns work with iterables   #

Array destructuring uses an iterator to get to the elements of a source. Therefore, you can array-destructure any value that is iterable. Let’s look at examples of iterable values.

Strings are iterable:

Don’t forget that the iterator over strings returns code points (“Unicode characters”, 21 bits), not code units (“JavaScript characters”, 16 bits). (For more information on Unicode, consult the chapter “ Chapter 24. Unicode and JavaScript ” in “Speaking JavaScript”.) For example:

You can’t access the elements of a set [1] via indices, but you can do so via an iterator. Therefore, array destructuring works for sets:

The Set iterator always returns elements in the order in which they were inserted, which is why the result of the previous destructuring is always the same.

Infinite sequences. Destructuring also works for iterators over infinite sequences. The generator function allNaturalNumbers() returns an iterator that yields 0, 1, 2, etc.

The following destructuring extracts the first three elements of that infinite sequence.

Failing to array-destructure a value   #

A value is iterable if it has a method whose key is Symbol.iterator that returns an object. Array-destructuring throws a TypeError if the value to be destructured isn’t iterable:

The TypeError is thrown even before accessing elements of the iterable, which means that you can use the empty array pattern [] to check whether a value is iterable:

Default values   #

Default values are a feature of patterns:

• Each part of a pattern can optionally specify a default value.
• If the part has no match in the source, destructuring continues with the default value (if one exists) or undefined .

Let’s look at an example. In the following destructuring, the element at index 0 has no match on the right-hand side. Therefore, destructuring continues by matching x against 3, which leads to x being set to 3.

You can also use default values in object patterns:

Default values are also used if a part does have a match and that match is undefined :

The rationale for this behavior is explained later, in the section on parameter default values.

Default values are computed on demand   #

The default values themselves are only computed when they are needed. That is, this destructuring:

is equivalent to:

You can observe that if you use console.log() :

In the second destructuring, the default value is not needed and log() is not called.

Default values can refer to other variables in the pattern   #

A default value can refer to any variable, including another variable in the same pattern:

However, order matters: the variables x and y are declared from left to right and produce a ReferenceError if they are accessed before their declaration.

Default values for patterns   #

So far we have only seen default values for variables, but you can also associate them with patterns:

What does this mean? Recall the rule for default values:

If the part has no match in the source, destructuring continues with the default value […].

The element at index 0 has no match, which is why destructuring continues with:

You can more easily see why things work this way if you replace the pattern { prop: x } with the variable pattern :

More complex default values. Let’s further explore default values for patterns. In the following example, we assign a value to x via the default value { prop: 123 } :

Because the array element at index 0 has no match on the right-hand side, destructuring continues as follows and x is set to 123.

However, x is not assigned a value in this manner if the right-hand side has an element at index 0, because then the default value isn’t triggered.

In this case, destructuring continues with:

Thus, if you want x to be 123 if either the object or the property is missing, you need to specify a default value for x itself:

Here, destructuring continues as follows, independently of whether the right-hand side is [{}] or [] .

More object destructuring features   #

Property value shorthands   #.

Property value shorthands [2] are a feature of object literals: If the value of a property is provided via a variable whose name is the same as the key, you can omit the key. This works for destructuring, too:

This declaration is equivalent to:

You can also combine property value shorthands with default values:

Computed property keys   #

Computed property keys [2:1] are another object literal feature that also works for destructuring: You can specify the key of a property via an expression, if you put it in square brackets:

Computed property keys allow you to destructure properties whose keys are symbols [3] :

More array destructuring features   #

Elision   #.

Elision lets you use the syntax of array “holes” to skip elements during destructuring:

Rest operator   #

The rest operator ( ... ) lets you extract the remaining elements of an array into an array. You can only use the operator as the last part inside an array pattern:

[Note: This operator extracts data. The same syntax ( ... ) is used by the spread operator , which constructs and is explained later.]

If the operator can’t find any elements, it matches its operand against the empty array. That is, it never produces undefined or null . For example:

The operand of the rest operator doesn’t have to be a variable, you can use patterns, too:

The rest operator triggers the following destructuring:

You can assign to more than just variables   #

If you assign via destructuring, each variable part can be everything that is allowed on the left-hand side of a normal assignment, including a reference to a property ( obj.prop ) and a reference to an array element ( arr[0] ).

You can also assign to object properties and array elements via the rest operator ( ... ):

If you declare variables via destructuring then you must use simple identifiers, you can’t refer to object properties and array elements.

Pitfalls of destructuring   #

There are two things to be mindful of when using destructuring.

Don’t start a statement with a curly brace   #

Because code blocks begin with a curly brace, statements must not begin with one. This is unfortunate when using object destructuring in an assignment:

The work-around is to either put the pattern in parentheses or the complete expression:

You can’t mix declaring and assigning to existing variables   #

Within a destructuring variable declaration, every variable in the source is declared. In the following example, we are trying to declare the variable b and refer to the existing variable f , which doesn’t work.

The fix is to use a destructuring assignment and to declare b beforehand:

Examples of destructuring   #

Let’s start with a few smaller examples.

The for-of loop [4] supports destructuring:

You can use destructuring to swap values. That is something that engines could optimize, so that no array would be created.

You can use destructuring to split an array:

Destructuring return values   #

Some built-in JavaScript operations return arrays. Destructuring helps with processing them:

exec() returns null if the regular expression doesn’t match. Unfortunately, you can’t handle null via default values, which is why you must use the Or operator ( || ) in this case:

Multiple return values   #

To see the usefulness of multiple return values, let’s implement a function findElement(a, p) that searches for the first element in the array a for which the function p returns true . The question is: what should that function return? Sometimes one is interested in the element itself, sometimes in its index, sometimes in both. The following implementation does both.

In line (A), the array method entries() returns an iterable over [index,element] pairs. We destructure one pair per iteration. In line (B), we use property value shorthands to return the object { element: element, index: index } .

In the following example, we use several ECMAScript features to write more concise code: An arrow functions helps us with defining the callback, destructuring and property value shorthands help us with handling the return value.

Due to index and element also referring to property keys, the order in which we mention them doesn’t matter:

We have successfully handled the case of needing both index and element. What if we are only interested in one of them? It turns out that, thanks to ECMAScript 6, our implementation can take care of that, too. And the syntactic overhead compared to functions that support only elements or only indices is minimal.

Each time, we only extract the value of the one property that we need.

Parameter handling   #

Parameter handling has been significantly upgraded in ECMAScript 6. It now supports parameter default values, rest parameters (varags) and destructuring. The new way of handling parameters is equivalent to destructuring the actual parameters via the formal parameters. That is, the following function call:

Let’s look at specific features next.

Parameter default values   #

ECMAScript 6 lets you specify default values for parameters:

Omitting the second parameter triggers the default value:

Watch out – undefined triggers the default value, too:

The default value is computed on demand, only when it is actually needed:

Why does undefined trigger default values?   #

It isn’t immediately obvious why undefined should be interpreted as a missing parameter or a missing part of an object or array. The rationale for doing so is that it enables you to delegate the definition of default values. Let’s look at two examples.

In the first example (source: Rick Waldron’s TC39 meeting notes from 2012-07-24 ), we don’t have to define a default value in setOptions() , we can delegate that task to setLevel() .

In the second example, square() doesn’t have to define a default for x , it can delegate that task to multiply() :

Default values further entrench the role of undefined as indicating that something doesn’t exist, versus null indicating emptiness.

Referring to other variables in default values   #

Within a parameter default value, you can refer to any variable, including other parameters:

However, order matters: parameters are declared from left to right and within a default value, you get a ReferenceError if you access a parameter that hasn’t been declared, yet.

Default values exist in their own scope, which is between the “outer” scope surrounding the function and the “inner” scope of the function body. Therefore, you can’t access inner variables from the default values:

If there were no outer x in the previous example, the default value x would produce a ReferenceError .

Rest parameters   #

Putting the rest operator ( ... ) in front of the last formal parameter means that it will receive all remaining actual parameters in an array.

If there are no remaining parameters, the rest parameter will be set to the empty array:

No more arguments !   #

Rest parameters can completely replace JavaScript’s infamous special variable arguments . They have the advantage of always being arrays:

One interesting feature of arguments is that you can have normal parameters and an array of all parameters at the same time:

You can avoid arguments in such cases if you combine a rest parameter with array destructuring. The resulting code is longer, but more explicit:

Note that arguments is iterable [4:1] in ECMAScript 6, which means that you can use for-of and the spread operator:

Simulating named parameters   #

When calling a function (or method) in a programming language, you must map the actual parameters (specified by the caller) to the formal parameters (of a function definition). There are two common ways to do so:

Positional parameters are mapped by position. The first actual parameter is mapped to the first formal parameter, the second actual to the second formal, and so on.

Named parameters use names (labels) to perform the mapping. Names are associated with formal parameters in a function definition and label actual parameters in a function call. It does not matter in which order named parameters appear, as long as they are correctly labeled.

Named parameters have two main benefits: they provide descriptions for arguments in function calls and they work well for optional parameters. I’ll first explain the benefits and then show you how to simulate named parameters in JavaScript via object literals.

Named Parameters as Descriptions   #

As soon as a function has more than one parameter, you might get confused about what each parameter is used for. For example, let’s say you have a function, selectEntries() , that returns entries from a database. Given the function call:

what do these two numbers mean? Python supports named parameters, and they make it easy to figure out what is going on:

Optional Named Parameters   #

Optional positional parameters work well only if they are omitted at the end. Anywhere else, you have to insert placeholders such as null so that the remaining parameters have correct positions.

With optional named parameters, that is not an issue. You can easily omit any of them. Here are some examples:

Simulating Named Parameters in JavaScript   #

JavaScript does not have native support for named parameters like Python and many other languages. But there is a reasonably elegant simulation: name parameters via an object literal, passed as a single actual parameter. When you use this technique, an invocation of selectEntries() looks like:

The function receives an object with the properties start , end , and step . You can omit any of them:

In ECMAScript 5, you’d implement selectEntries() as follows:

In ECMAScript 6, you can use destructuring, which looks like this:

If you call selectEntries() with zero arguments, the destructuring fails, because you can’t match an object pattern against undefined . That can be fixed via a default value. In the following code, the object pattern is matched against {} if there isn’t at least one argument.

You can also combine positional parameters with named parameters. It is customary for the latter to come last:

In principle, JavaScript engines could optimize this pattern so that no intermediate object is created, because both the object literals at the call sites and the object patterns in the function definitions are static.

Note: In JavaScript, the pattern for named parameters shown here is sometimes called options or option object (e.g., by the jQuery documentation).

Pitfall: destructuring a single arrow function parameter   #

Arrow functions have a special single-parameter version where no parentheses are needed:

The single-parameter version does not support destructuring:

Examples of parameter handling   #

Foreach() and destructuring   #.

You will probably mostly use the for-of loop in ECMAScript 6, but the array method forEach() also profits from destructuring. Or rather, its callback does.

First example: destructuring the arrays in an array.

Second example: destructuring the objects in an array.

Transforming maps   #

An ECMAScript 6 Map [1:1] doesn’t have a method map() (like arrays). Therefore, one has to:

• Convert it to an array of [key,value] pairs.
• map() the array.
• Convert the result back to a map.

This looks as follows.

Handling an array returned via a Promise   #

The tool method Promise.all() [5] works as follows:

• Input: an array of Promises.
• Output: a Promise that resolves to an array as soon as the last input Promise is resolved. The array contains the resolutions of the input Promises.

Destructuring helps with handling the array that the result of Promise.all() resolves to:

fetch() is a Promise-based version of XMLHttpRequest . It is part of the Fetch standard .

Required parameters   #

In ECMAScript 5, you have a few options for ensuring that a required parameter has been provided, which are all quite clumsy:

In ECMAScript 6, you can (ab)use default parameter values to achieve more concise code (credit: idea by Allen Wirfs-Brock):

Interaction:

Enforcing a maximum arity   #

This section presents three approaches to enforcing a maximum arity. The running example is a function f whose maximum arity is 2 – if a caller provides more than 2 parameters, an error should be thrown.

The first approach collects all actual parameters in the formal rest parameter args and checks its length.

The second approach relies on unwanted actual parameters appearing in the formal rest parameter extra .

The third approach uses a sentinel value that is gone if there is a third parameter. One caveat is that the default value OK is also triggered if there is a third parameter whose value is undefined .

Sadly, each one of these approaches introduces significant visual and conceptual clutter. I’m tempted to recommend checking arguments.length , but I also want arguments to go away.

The spread operator ( ... )   #

The spread operator ( ... ) is the opposite of the rest operator: Where the rest operator extracts arrays, the spread operator turns the elements of an array into the arguments of a function call or into elements of another array.

Spreading into function and method calls   #

Math.max() is a good example for demonstrating how the spread operator works in method calls. Math.max(x1, x2, ···) returns the argument whose value is greatest. It accepts an arbitrary number of arguments, but can’t be applied to arrays. The spread operator fixes that:

In contrast to the rest operator, you can use the spread operator anywhere in a sequence of parts:

Another example is JavaScript not having a way to destructively append the elements of one array to another one. However, arrays do have the method push(x1, x2, ···) , which appends all of its arguments to its receiver. The following code shows how you can use push() to append the elements of arr2 to arr1 .

Spreading into constructors   #

In addition to function and method calls, the spread operator also works for constructor calls:

That is something that is difficult to achieve in ECMAScript 5 .

Spreading into arrays   #

The spread operator can also be used inside arrays:

That gives you a convenient way to concatenate arrays:

Converting iterable or array-like objects to arrays   #

The spread operator lets you convert any iterable object to an array:

Let’s convert a set [1:2] to an array:

Your own iterable objects [4:2] can be converted to arrays in the same manner:

Note that, just like the for-of loop, the spread operator only works for iterable objects. Most important objects are iterable: arrays, maps, sets and arguments . Most DOM data structures will also eventually be iterable.

Should you ever encounter something that is not iterable, but array-like (indexed elements plus a property length ), you can use Array.from() [6] to convert it to an array:

Further reading:   #

ECMAScript 6: maps and sets ↩︎ ↩︎ ↩︎

ECMAScript 6: new OOP features besides classes ↩︎ ↩︎

Symbols in ECMAScript 6 ↩︎

Iterators and generators in ECMAScript 6 ↩︎ ↩︎ ↩︎

ECMAScript 6 promises (2/2): the API ↩︎

ECMAScript 6’s new array methods ↩︎

• recommendations

• Async/Await
• @code_barbarian
• TCB Facebook

Most Popular Articles

• Common Async/Await Design Patterns in Node.js
• Unhandled Promise Rejections in Node.js
• Using Async/Await with Mocha, Express, and Mongoose
• Write Your Own Node.js Promise Library from Scratch
• The 80/20 Guide to Express Error Handling

The 80/20 Guide to ES2015 Generators

An Overview of Destructuring Assignments in Node.js

JavaScript introduced destructuring assignments as part of the 2015 edition of the JavaScript language spec . Destructuring assignments let you assign multiple variables in a single statement, making it much easier to pull values out of arrays and objects. Below are examples of the two types of destructuring assignment: array destructuring and object destructuring .

Destructuring assignments are powerful, but they also come with several syntactic quirks. Plus, you can get some truly baffling error messages if you do destructuring assignments incorrectly. In this article, I'll provide an overview of what you need to know to successfully use destructuring assignments in Node.js.

Array Destructuring and Iterators

The right hand side of an array destructuring assignment must be an iterable . JavaScript arrays are iterables, and you will almost always see an array on the right hand side, but there's nothing stopping you from using array destructuring with a generator , a set , or any other iterable.

Array Destructuring Error Cases

Here's a fun exercise: what happens if you try to use array destructuring where the right hand side isn't an array or iterable?

In Node.js 10.x you get a nice sane error: TypeError: {} is not iterable . But in Node.js 6.x and 8.x you get a baffling "undefined is not a function" error.

If you see this error, don't panic, it is a bug in V8 . The issue is that the right hand side of an array destructuring assignment must be an iterable , which means it must have a Symbol.iterator function. V8 throws this error because it tries to call the non-existent Symbol.iterator function on an empty object.

Another edge case with destructuring assignments might make you throw out standard and run for the safety of semi-colons. What does the below script print?

It will not print '1, 2, 3', you'll instead get an error Cannot read property 'forEach' of undefined . That's because the above code is equivalent to:

You need a semicolon ; before destructuring assignment unless you use let or const .

If you use semicolons, it isn't a problem. If you use a linter like standard that doesn't require semicolons, your linter will give you a ["Unexpected newline between object and of property access" error .

Object Destructuring

Object destructuring is different from array destructuring. It doesn't use iterables, object destructuring is just a shorthand for multiple property accesses.

By default, the variable name must match the property name, but you can change that. This is handy if you're working with an API that prefers snake case property names and your linter only accepts camel case variable names .

Things get messy when you use object destructuring without let or const . That's because if you do { name } = obj; , the JavaScript interpretter interprets { name } as a block . If you use object destructuring without let , const , or var , you must wrap your assignment in parenthesis () as shown below.

This becomes cumbersome when you're not using semi-colons, because JavaScript interprets () as a function call unless it is preceded by a semicolon ; . The below is perfectly valid.

If you're not using semicolons, you need to be careful to use both a semicolon ; and parenthesis () when using object destructuring.

If you choose to write JavaScript without semicolons, make sure you use a linter. The alternative is to be well versed in all the exceptions to automatic semicolon insertion (ASI) and be committed to keeping up with all future changes in the JavaScript language that may change the list of ASI exceptions .

Destructuring assignments are one of the slickest new features from ES2015, they can make your code a lot more concise and make working with CSVs much easier. But destructuring assignments come with several quirks that you need to be aware of, particularly when you aren't using semicolons. Make sure you use semicolons or a linter, and take advantage of destructuring assignments to save yourself from repetitive code.

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.

Description

The object and array literal expressions provide an easy way to create ad hoc packages of data.

The destructuring assignment uses similar syntax but uses it on the left-hand side of the assignment instead. It defines which values to unpack from the sourced variable.

Similarly, you can destructure objects on the left-hand side of the assignment.

This capability is similar to features present in languages such as Perl and Python.

For features specific to array or object destructuring, refer to the individual examples below.

Binding and assignment

For both object and array destructuring, there are two kinds of destructuring patterns: binding pattern and assignment pattern , with slightly different syntaxes.

In binding patterns, the pattern starts with a declaration keyword ( var , let , or const ). Then, each individual property must either be bound to a variable or further destructured.

All variables share the same declaration, so if you want some variables to be re-assignable but others to be read-only, you may have to destructure twice — once with let , once with const .

In many other syntaxes where the language binds a variable for you, you can use a binding destructuring pattern. These include:

• The looping variable of for...in for...of , and for await...of loops;
• Function parameters;
• The catch binding variable.

In assignment patterns, the pattern does not start with a keyword. Each destructured property is assigned to a target of assignment — which may either be declared beforehand with var or let , or is a property of another object — in general, anything that can appear on the left-hand side of an assignment expression.

Note: The parentheses ( ... ) around the assignment statement are required when using object literal destructuring assignment without a declaration.

{ a, b } = { a: 1, b: 2 } is not valid stand-alone syntax, as the { a, b } on the left-hand side is considered a block and not an object literal according to the rules of expression statements . However, ({ a, b } = { a: 1, b: 2 }) is valid, as is const { a, b } = { a: 1, b: 2 } .

If your coding style does not include trailing semicolons, the ( ... ) expression needs to be preceded by a semicolon, or it may be used to execute a function on the previous line.

Note that the equivalent binding pattern of the code above is not valid syntax:

You can only use assignment patterns as the left-hand side of the assignment operator. You cannot use them with compound assignment operators such as += or *= .

Default value

Each destructured property can have a default value . The default value is used when the property is not present, or has value undefined . It is not used if the property has value null .

The default value can be any expression. It will only be evaluated when necessary.

Rest property

You can end a destructuring pattern with a rest property ...rest . This pattern will store all remaining properties of the object or array into a new object or array.

The rest property must be the last in the pattern, and must not have a trailing comma.

Array destructuring

Basic variable assignment, destructuring with more elements than the source.

In an array destructuring from an array of length N specified on the right-hand side of the assignment, if the number of variables specified on the left-hand side of the assignment is greater than N , only the first N variables are assigned values. The values of the remaining variables will be undefined.

Swapping variables

Two variables values can be swapped in one destructuring expression.

Without destructuring assignment, swapping two values requires a temporary variable (or, in some low-level languages, the XOR-swap trick ).

Parsing an array returned from a function

It's always been possible to return an array from a function. Destructuring can make working with an array return value more concise.

In this example, f() returns the values [1, 2] as its output, which can be parsed in a single line with destructuring.

Ignoring some returned values

You can ignore return values that you're not interested in:

You can also ignore all returned values:

Using a binding pattern as the rest property

The rest property of array destructuring assignment can be another array or object binding pattern. The inner destructuring destructures from the array created after collecting the rest elements, so you cannot access any properties present on the original iterable in this way.

These binding patterns can even be nested, as long as each rest property is the last in the list.

On the other hand, object destructuring can only have an identifier as the rest property.

Unpacking values from a regular expression match

When the regular expression exec() method finds a match, it returns an array containing first the entire matched portion of the string and then the portions of the string that matched each parenthesized group in the regular expression. Destructuring assignment allows you to unpack the parts out of this array easily, ignoring the full match if it is not needed.

Using array destructuring on any iterable

Array destructuring calls the iterable protocol of the right-hand side. Therefore, any iterable, not necessarily arrays, can be destructured.

Non-iterables cannot be destructured as arrays.

Iterables are only iterated until all bindings are assigned.

The rest binding is eagerly evaluated and creates a new array, instead of using the old iterable.

Object destructuring

Basic assignment, assigning to new variable names.

A property can be unpacked from an object and assigned to a variable with a different name than the object property.

Here, for example, const { p: foo } = o takes from the object o the property named p and assigns it to a local variable named foo .

Assigning to new variable names and providing default values

A property can be both

• Unpacked from an object and assigned to a variable with a different name.
• Assigned a default value in case the unpacked value is undefined .

Unpacking properties from objects passed as a function parameter

Objects passed into function parameters can also be unpacked into variables, which may then be accessed within the function body. As for object assignment, the destructuring syntax allows for the new variable to have the same name or a different name than the original property, and to assign default values for the case when the original object does not define the property.

Consider this object, which contains information about a user.

Here we show how to unpack a property of the passed object into a variable with the same name. The parameter value { id } indicates that the id property of the object passed to the function should be unpacked into a variable with the same name, which can then be used within the function.

You can define the name of the unpacked variable. Here we unpack the property named displayName , and rename it to dname for use within the function body.

Nested objects can also be unpacked. The example below shows the property fullname.firstName being unpacked into a variable called name .

Setting a function parameter's default value

Default values can be specified using = , and will be used as variable values if a specified property does not exist in the passed object.

Below we show a function where the default size is 'big' , default co-ordinates are x: 0, y: 0 and default radius is 25.

In the function signature for drawChart above, the destructured left-hand side has a default value of an empty object = {} .

You could have also written the function without that default. However, if you leave out that default value, the function will look for at least one argument to be supplied when invoked, whereas in its current form, you can call drawChart() without supplying any parameters. Otherwise, you need to at least supply an empty object literal.

For more information, see Default parameters > Destructured parameter with default value assignment .

Nested object and array destructuring

For of iteration and destructuring, computed object property names and destructuring.

Computed property names, like on object literals , can be used with destructuring.

Invalid JavaScript identifier as a property name

Destructuring can be used with property names that are not valid JavaScript identifiers by providing an alternative identifier that is valid.

Destructuring primitive values

Object destructuring is almost equivalent to property accessing . This means if you try to destruct a primitive value, the value will get wrapped into the corresponding wrapper object and the property is accessed on the wrapper object.

Same as accessing properties, destructuring null or undefined throws a TypeError .

This happens even when the pattern is empty.

Combined array and object destructuring

Array and object destructuring can be combined. Say you want the third element in the array props below, and then you want the name property in the object, you can do the following:

The prototype chain is looked up when the object is deconstructed

When deconstructing an object, if a property is not accessed in itself, it will continue to look up along the prototype chain.

Specifications

Browser compatibility.

• Assignment operators
• ES6 in Depth: Destructuring on hacks.mozilla.org (2015)

© 2005–2023 MDN contributors. Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement . We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

TypeError: Right side of assignment cannot be destructured #435

nervusdm commented Sep 24, 2021 • edited

iamhosseindhv commented Sep 25, 2021

Sorry, something went wrong.

No branches or pull requests

• Search forums

Follow along with the video below to see how to install our site as a web app on your home screen.

Note: This feature currently requires accessing the site using the built-in Safari browser.

• If you are still using CentOS 7.9, it's time to convert to Alma 8 with the free centos2alma tool by Plesk or Plesk Migrator. Please let us know your experiences or concerns in this thread: CentOS2Alma discussion
• Plesk Discussion
• Plesk Obsidian for Linux

Resolved   Right side of assignment cannot be destructured

• Thread starter Raymond_Davelaar
• Start date Dec 4, 2023
• Raymond_Davelaar

Basic Pleskian

• Dec 4, 2023

After update to Plesk Versie 18.0.57 Update #2, laatste update op 2023-12-4 21:33 I receive this error when trying to view domain. Reloading page does nothing.. Plesk repair shows no errors.. Right side of assignment cannot be destructured  

Just a nobody

Hmm... usually that's a cache problem with your browser cache iirc. Did you tried clearing your browser's cache and cookies and tried loading the page again?  

I have the same problem. The message varies depending on the browser you use. The same error message is displayed on the JavaScript console, so it seems to be a JavaScript problem, but the result does not change even after a forced reload. - Safari Right side of assignment cannot be destructured - Firefox data.site is null - Chrome Cannot destructure property 'screenshotUrl' of 'data.site' as it is null.  

We are discussing the same issue here. TypeError data.site is null  

wget https://ext.plesk.com/packages/80591d56-628c-4d24-a685-b805d4d1c589-monitoring/download?2.9.2-433 -O monitoring.zip plesk bin extension -i monitoring.zip Click to expand...

• Dec 5, 2023

can confirm that my problem is solved. probably by clearing browser cache..  

Similar threads

• Dec 7, 2023
• Nov 21, 2023

• Dec 30, 2023
• Mar 7, 2023