# FAQ: Functions - Concise Body Arrow Functions

This community-built FAQ covers the "Concise Body Arrow Functions " exercise from the lesson “Functions”.

Paths and Courses
This exercise can be found in the following Codecademy content:

## FAQs on the exercise _Concise Body Arrow Functions _

There are currently no frequently asked questions associated with this exercise – that’s where you come in! You can contribute to this section by offering your own questions, answers, or clarifications on this exercise. Ask or answer a question by clicking reply () below.

If you’ve had an “aha” moment about the concepts, formatting, syntax, or anything else with this exercise, consider sharing those insights! Teaching others and answering their questions is one of the best ways to learn and stay sharp.

## Join the Discussion. Help a fellow learner on their journey.

Agree with a comment or answer? Like () to up-vote the contribution!

Found a bug? Report it!

Have a question about your account or billing? Reach out to our customer support team!

None of the above? Find out where to ask other questions here!

A post was split to a new topic: I don’t get this lesson

Even more concise code:

const plantNeedsWater = day => day === ‘Wednesday’;

console.log(plantNeedsWater(‘Wednesday’));

2 Likes

And we can write it this consisely, why?

The solution to this exercise confused me a tad…

How are we able to use the concise body function when the correct answer is too long and still results in a multi-line block?

1 Like

When there are multiple lines of code in the block, write it like a regular function expression (with curly braces and a return).

``````const foo = (baz, bar) => {
// code
// code
// code
return "some value"
};``````
1 Like

I struggled with this exercise too.
Whilst concise functions sound useful - I prefer the more readable form of multi-line functions personally.
Still it’s useful to know!

13 Likes

I was good until the last page (review functions):

When I played around with the code I noticed:

``````const plantNeedsWater = day => day === 'Wednesday' ? 'Water me' : "Don't water me";

``````

can also be on two lines

``````const plantNeedsWater = day => day === 'Wednesday'
? 'Water me' : "Don't water me";
``````

… without having to use the ‘return’ statement, or additional code. I was considering this if the true/false answers were a longer statement; to allow for better readability. Is this doable, or should I be considering a better way to keep the code ‘clean’?

I am trying to print the answer:

``````const plantNeedsWater = day => day === 'Wednesday' ? console.log('water') : console.log('no water');
``````

Did you call `plantNeedsWater`?

1 Like

I dind’t, thanks

``````const plantNeedsWater = day => day === 'Wednesday' ? console.log('water') : console.log('no water');
plantNeedsWater('Wednesday'); // returns water
``````
2 Likes

At this point in my learning, I vastly prefer the longhand way of writing functions.

2 Likes

Preference is subjective. Programming is not about subjectivity, but objectivity. By having a preference we end up closing the book on possible ways to simplify a program and better manage memory and resources.

6 Likes

You’re both correct and infuriating.

6 Likes

Concise arow function seems to work for IF functions.
Example:
userInput2.toLowerCase() === ‘rock’? userInput2+“answer” : “Try again”;
How about when function has 2 more else if parameters ?

Hey @dev0403120509!

Here’s how:

``````1 == 2 ? 2+2 : 3
-> 3
``````

That’s just a simple if/else conditional. To make it longer, you do this:

``````1 == 2 ? 2+12 : 2==2 ? 2+21 : 3+5
^       ^      ^      ^      ^
If     do this  if  do this  else
-> 23
``````
2 Likes

We need to clarify that this is not a function, but a ternary expression.

``````condition ? value/action if true : default
``````

As Steven has shown above, nested conditions are written into the default slot.

We should also note that if a value is being assigned then we need a variable to receive it.

``````a = Math.floor(Math.random() * 10 + 1);
b = a < 5 ? -1 : a > 5 ? 1 : 0;
---         --- ---   => values
-----        -----            => conditions
const f = x => x + 5;
const g = x => x - 5;

console.log(a < 5 ? f(a) : a > 5 ? g(a) : a);
----           ----   => action returns value``````
1 Like

Here’s where it gets interesting…

``````const f = x => x + 5;
const g = x => x - 5;
const h = x => x;

console.log((a < 5 ? f : a > 5 ? g : h)(a));
___         ___ ___       => reference
---    => invocation
``````

``````console.log(a * b)  // `b` from above
``````

There is some fun to be had running this sequence repeatedly. Haven’t done it, yet, myself, but that is in the offing.

Okay, I’m a bit confused right now. I started this exercise by writing this exact code:

`const plantNeedsWater = day => day === 'Wednesday' ? true : false;`

But it wasn’t correct apparently since it kept telling me to remove parentheses around the word day.

`const plantNeedsWater = day => day === 'Wednesday' ? true : false;`