What Do Curly Braces Inside of Function Parameter Lists Do in Es6

What do curly braces inside of function parameter lists do in es6?

It is destructuring, but contained within the parameters. The equivalent without the destructuring would be:

const func = o => {
    var param1 = o.param1;
    var param2 = o.param2;
    //do stuff
}

JS: What do the curly braces inside function parameter declarations mean?

It looks like destructuring syntax, but I didn't know javascript had destructuring.

If that's what it is, the function is expecting an object with a tracks field (but can default to an empty list if the object doesn't have one), and an onAuth field, which will default to undefined. It's basically a neater way of accessing the fields of the passed object.

Curly braces inside JavaScript arguments for functions

The curly braces denote an object literal. It is a way of sending key/value pairs of data.

So this:

var obj = {name: "testing"};

Is used like this to access the data.

obj.name; // gives you "testing"

You can give the object several comma separated key/value pairs, as long as the keys are unique.

var obj = {name: "testing",
           another: "some other value",
           "a-key": "needed quotes because of the hyphen"
          };

You can also use square brackets to access the properties of the object.

This would be required in the case of the "a-key".

obj["a-key"] // gives you "needed quotes because of the hyphen"

Using the square brackets, you can access a value using a property name stored in a variable.

var some_variable = "name";

obj[ some_variable ] // gives you "testing"

Meaning of curly braces in array.map()

That’s the behavior of arrow function. Arrow function syntax is designed to be terse.

(arg) => [single expression]

If what follows the arrow is one single expression without curly braces, it implies returning the value of that expression. The return keyword is omitted.

If wrapping curly braces follows the arrow, then what goes inside the braces are treated as normal function body, and return keyword must be used if you mean to return a value.

So (x) => x + 1 is translated to:

function (x) {
  return x + 1;
}

And (x) => { x + 1 } is translated to:

function (x) {
  x + 1;
}

I must also add that (x) => ({ x }) is translated to:

function (x) {
  return { x: x };
}

Curly brace {...} can mean an object literal, a function body or a code block.

In order to disambiguate, you need to put parenthesis around the braces to tell the parser to interpret {...} as an “object literal expression”.

What do curly braces around a variable in a function parameter mean

This is destructuring assignment syntax.

As another example, the following two lines of code are equal:

const { items } = args

const items = args.items

Simply put, it is a simplified way of accessing specific field of a given variable for further use in that scope.

In your original example, it is declaring a variable items for use in the function body that is the items field of that first argument.

const SortableList = SortableContainer(({items}) => {
    // do stuff with items here

is equal to

const SortableList = SortableContainer((input) => {
    const items = input.items
    // do stuff with items here

JavaScript Curly braces argument as function parameter

This is an ES2015 (also called ES6) shorthand to create objects.

{ product } is equivalent to { product: product }.

Basically, you end up with an object with a property called "product" that has the value of the product variable.

const prop = "prop value";const obj = { prop, anotherProp: "something else" }console.log("obj: ", obj);

Why are there curly brackets in the parameters when declaring this javascript function? (Node, MongoDB in model.js)

It's an ES6 destructuring assignment.

This syntax declares a function with two parameters.

The values of the username, password, name and weight properties of the object passed as the first argument will be available through the variables username, password, name and weight in the function body.

The second argument will be available through the variable f.

For example:

(function ({a,b}, c) {
  return [a,b,c];
})({a:1, b:2, d:"ignored"}, 3); // [1,2,3]

JavaScript ES6 curly braces in arguments to old-style JavaScript

push_back_button and pop_back_button expects first parameter to be an object.

({ commit }) deconstructs object parameter to get it's property commit

actions: {
  push_back_button:       function (object, callback)       { object.commit('push_back_button', callback)          },
  pop_back_button:        function (object)                 { object.commit('pop_back_button')                     },
}

function fn(parent) { console.log("called from", parent);}
function es5_fn(object) { object.fn("es5_fn");}
function es6_fn({fn}) { fn("es6_fn");}
es5_fn({fn});es6_fn({fn});

Why is the parameter of then() handler function wrapped in curly braces in this POST request?

Your response is an object with an atribute quote. { quote } will get that object and assign to quote the content of the property quote.

See this example:

let foo = {
  bar: 5
}

function printbar({bar}) {
  console.log(bar)
}

printbar(foo)

---

Related Topics