On Sat, May 31, 2014 at 11:59 AM, Nicholas C. Zakas <
standa...@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
_______________________________________________
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss
