Use Destructuring Assignment to Pass an Object as a Function's Parameters

JavaScript
1

Tell us what’s happening:
Not sure why this is not passing? Any advice would be helpful. TY!

Your code so far


const stats = {
  max: 56.78,
  standard_deviation: 4.34,
  median: 34.54,
  mode: 23.87,
  min: -0.75,
  average: 35.85
};
const half = (function() {
  "use strict"; // do not change this line

  return function half(stats) {
    const{max, standard_deviation, median, mode, min, average} = stats;
    // use function argument destructuring
    return (max + min) /2;
};
  // change code above this line

})();
console.log(stats); // should be object
console.log(half(stats)); // should be 28.015

Your browser information:

User Agent is: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.139 Safari/537.36.

Link to the challenge:
https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-pass-an-object-as-a-functions-parameters

2

Try this

const half = (function() {
  "use strict"; // do not change this line

  // change code below this line
  return function half({max,min}) {
    // use function argument destructuring
    return (max + min) / 2.0;
  };
  // change code above this line

})();
1 Like
3

Hi,

Could you explain a bit more this solution?
I am lost a bit.
Why we need to wrap the whole function creating an IIFE.
It seems a closure to me as well.

I have this solution but it is not accepted although I can understand this one.

const half = (function() {
  "use strict"; // do not change this line

  // change code below this line
  return function half(stats) {
    // use function argument destructuring
    const{min, max} = stats;
    return (max + min) / 2.0;
  };
  // change code above this line

})();
4

Same problem here.
I do not understand, why the code from @pradesh-kumar is a solution and the one from @Lacika1981 ist not?

And if pradesh-kumar’s solution is the correct one, how does the exercise description help finding the solution? This is really an issue with the new ES6 exercises (not sure if they are new, but before the update of the curriculum I hadn’t seen them). The examples in the exercises don’t help a lot in finding the solution.

2 Likes
5

In this challenge, there’s no particular reason (that I’m aware of) to use an IIFE. You can replace the entire IIFE with the code below, and FCC will accept the answer:

function half({min,max}){
  return (min + max) /2
}

IIFEs are sometimes used as a way to apply strict mode to all the code contained within the IIFE, without requiring the entire external script to be in strict mode. However, since the IIFE in this example is returning a single function rather than a whole API, you could just as easily add ‘use strict’ into the half function declaration.

Your solution returns the correct answer, but in order to pass the FCC tests you need to

Use destructuring assignment within the argument to the function half to send only max and min inside the function.

Your solution destructures inside the function, rather than in its arguments, so it’s being rejected

3 Likes
6

This is because you need to

Use destructuring assignment within the argument to the function half to send only max and min inside the function.

2 Likes
7

The key to understanding this challenge is to understand that the object being passed as a parameter to the inner function half() can be destructered right up front.

Consider this object;
const waterLevels1 = {high: 20.0, normal: 12.00, low: 10.0}

The call to the function is made here:
console.log( third( waterLevels1 )); // should be the sum of (high + low) / 3.0

Understand that waterLevels1 is an object with several properties.

What we’ve always done before is accept the whole object as a parameter which is what challenge starts out with.
return function third( todaysWaterLevels )) { etc…
Note: the parameter “todaysWaterLevels” accepts the object “waterLevels1”.

(Part of the confusion of the challenge is name of the parameter of the inner function is the same as the object it receives; if the parm name had been different from the object name, it might have made more sense. Example:
return function half( anyObjectWithMinAndMaxProperties ) {…etc…
)

So, what the challenge is asking us to understand is that the inner function can receive JUST specifically chosen properties so long as the passed object has those properties)

So, instead of a function that receives an object like this:
return function third(todaysWaterLevels) {…etc…

… the function can receive just the specific properties that are wanted without caring about the name of the object coming in
return function third( {high, low} ) {…etc…
return (high + low) / 3.0;

Does that make sense?

8

That makes so much sense, I don’t know how I didn’t stumble upon this. Thanks for sharing.

1 Like