Using destructuring for function arguments

Dmitry Soshnikov dmitry.soshnikov at gmail.com
Sat May 31 13:24:41 PDT 2014


On Sat, May 31, 2014 at 11:59 AM, Nicholas C. Zakas <
standards at nczconsulting.com> wrote:

> I've been playing around with using destructuring as function arguments
> and have come across some odd behaviors that I'm not sure are intentional
> (or perhaps, not to spec). For context, consider the following function:
>
> ```
> function setCookie(name, value, { secure, path, domain, expires }) {
>     console.log(secure);
>     // ...
> }
>
> // called as
> setCookie("type", "js", {
>     secure: true
> });
> ```
>
> What happens here:
> * `secure === true`
> * `path === undefined`
> * `domain === undefined`
> * `expires === undefined`
>
> I'd say all of that behavior is as expected. However, if I omit the third
> argument completely, things get a bit strange:
>
> ```
> setCookie("type", "js");   // throws error at console.log
> ```
>
> What happens here is that none of `secure`, `path`, `domain`, `expires`
> are defined. I can use `typeof` on them to protect against this, but then I
> end up with some lousy looking code:
>
> ```
> function setCookie(name, value, { secure, path, domain, expires }) {
>
>     if (typeof secure !== "undefined") {
>         // use it
>     }
>
>     if (typeof path !== "undefined") {
>         // use it
>     }
>
>     if (typeof domain !== "undefined") {
>         // use it
>     }
>
>     if (typeof expires !== "undefined") {
>         // use it
>     }
>
>     // ...
> }
> ```
>
>
Strange, it seems should fail at trying to start destructuring process:
when ToObject coercion fails with the `undefined` value set to the value of
the parameter.


> My first thought was that this behavior made sense, since no destructuring
> can happen on undefined. However, the workaround for dealing with that
> behavior seems a bit heavy-handed.
>
> I thought perhaps I could assign a default value, and that would solve the
> problem:
>
> ```
> function setCookie(name, value, { secure, path, domain, expires } = {}) {
>     console.log(secure);
>     // ...
> }
> ```
>
> Unfortunately, that resulted in a syntax error in Firefox. Traceur seems
> to have no problem with it.
>
> So I really have two questions:
>
> 1. Who is right about assigning a default value to a destructured
> parameter, Firefox or Traceur?
>

Well, the the `FormalParameter` is the `BindingElement`, and the later may
be the `BindingPattern Initializer`, where the `Initializer` is your
default value. From which chain Traceur is correct.


> 2. Is the behavior of not having any bindings for destructured parameter
> properties correct? And if so, is it desirable?
>

Where do you test this? It seems it should fail at destructuring, and not
set any binding pattern properties in this case.

I.e.

```
setCookie('type', 'js'); // throws right away, since no ToObject coercion
is made
setCookie('type', 'js', {}); // sets all binding props to undefined
```

With the default value of the pattern, the first call sets all binding
props to `undefined` as well.

Dmitry
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20140531/f8d63ceb/attachment.html>


More information about the es-discuss mailing list