These days I assumed I would take you thru one of the most examples from
my es6 workshop.

Believe the next code:

serve as getCandy(type, measurement, upperKind, callback) {
  if (!type) {
    requiredParam('type')
  }
  if (!measurement) {
    requiredParam('measurement')
  }
  upperKind = upperKind || type.toUpperCase()
  callback = callback || serve as noop() {}

  const consequence = {type, measurement, upperKind}
  callback(consequence)
  go back consequence
}

serve as requiredParam(argName) {
  throw new Error(`${argName} is needed`)
}

It is quite easy, however there are doable insects (examine
Falsy
on MDN) and a few
irritating boilerplate. Thankfully for us, ES6 presented new syntax into JavaScript
that we will use to simplify issues a little bit. Specifically:
default parameters.
Let’s checkout what the above could be like when the use of this selection.

serve as getCandy(
  type = requiredParam('type'),
  measurement = requiredParam('measurement'),
  upperKind = type.toUpperCase(),
  callback = serve as noop() {},
) {
  const consequence = {type, measurement, upperKind}
  callback(consequence)
  go back consequence
}

serve as requiredParam(argName) {
  throw new Error(`${argName} is needed`)
}

Realize that we are in a position to take every expression and put it at the proper aspect of
the equals signal. If the parameter is undefinedthen the expression at the proper
aspect will likely be evaluated. This permits us to simply name the requiredParam serve as
if type or measurement is undefined. It is also imaginable to make use of the worth of
different parameters in our expression like we do within the default param for
upperKind which I to find to be a ridiculously cool characteristic and I take advantage of this all
the time in choices configuration for a few of my equipment
(as an example).

I will upload that the similar forms of semantics would follow for object destructuring
(whether or not as a parameter or now not) as smartly. As an example, if we modify the arguments
to be an choices object:

serve as getCandy(choices = {}) {
  const {
    type = requiredParam('type'),
    measurement = requiredParam('measurement'),
    upperKind = type.toUpperCase(),
    callback = serve as noop() {},
  } = choices
  // and so forth...
}

Or, if we wish to destructure the choices object at once within the parameter listing:

serve as getCandy({
  type = requiredParam('type'),
  measurement = requiredParam('measurement'),
  upperKind = type.toUpperCase(),
  callback = serve as noop() {},
} = {}) {
  // and so forth...
}

A laugh stuff!

Conclusion

I am hoping you to find this beneficial! If you need to look at me speak about this a little bit,
you’ll be able to take a look at this phase of my ES6 workshop I gave and recorded at PayPal
some time again:
ES6 and Past Workshop Phase 1 at PayPal (Jan 2017).
Just right success!