What About These Fat Arrow Functions?
Tags: javascript
Published: 2020-10-16 00:48:13

When I first started learning JavaScript a couple years ago, I was taught to write the classic arrow expressions:

```javascript
function myMessage( ) {
   console.log(“Hello, World!”)
}

```

Then I started using the new-fangled ***arrow function*** ES2015 way of
writing the same thing:

```javascript

const myMessage = ( ) => {
   console.log(“Hello, World!”)
}

```

The new syntax seems cool to me, but then I found out there were some important differences between the new and the old syntax. Sometimes those differences made arrow functions really amazing and other times, they caused unforeseen problems.

First, let’s go over some basics:

###Omitting Parentheses.

Normally, we use parentheses to define the parameters our arrow function:

```javascript

const addTwoNumbers = ( x, y ) => {
   return x + y
}

```

Above, we’ve put parentheses around our two parameters, x and y.

We also must use parentheses if we have zero parameters:

```javascript

const mySecretMessage = ( ) => {
   console.log(“This is fun”)
}

```

However, if we have just one parameter, we can optionally omit the parenthesis:

```javascript

const sayMyName = (string) => {
   console.log (string)
}

// we could have eliminated the parenthesis since there
// is only one parameter in our arrow function. 

// Let’s rewrite it:

const sayMyName = string => {
   console.log (string)
}

```

To summarize:  you can only omit parentheses around the parameters of an arrow function if you have one parameter.  If you have zero, two, three or more parameters, you must use parentheses.

###Omit the Curly Braces

When we have just one statement in our function body, we can simplify the statement by vomiting the curly braces:


This function with only one statement in the function body:

```javascript

//Example A

const addTwoNumbers = ( x, y ) => {
   return x + y
}

```

Becomes this:

```javascript
//Example B

const addTwoNumbers = ( x, y ) =>   return x + y
}

```


Cool!  In the re-written statement, we 1) removed the curly braces, 2) removed the keyword “return” and 3) put the function body statement on the same line as the function definition.
Note the use of a couple of new vocabulary words.  in Example A above, when we use the return keyword it is known as an **explicit return**.  In contract, when we omit the return keyword as in Example B, it is called an **implicit return**.


***An Outlier Occassion Where Parentheses Are A Must:

If you’re going to return an object literal, then you must wrap that object in parentheses:

```javascript

const greetings = name =>({ message: `Hello, ${ name }!`})

//now call “greetings”

greetings(‘Timmy’)    // -> { message: Hello, Timmy! }

```

If we don’t wrap the object literal in parentheses, then JavaScript will confuse the curly braces with those that define the function body.


###The Famous “This”

The “this” keyword is a well-known bugaboo for many a JavaScript programmer.  And to make it more fun, the “this” keyword acts differently in a classic function call vs. an arrow function call.

Let’s look at how “this” works in a method of an object.

See the method below:

```javascript
const car = {
  model: 'Fiesta',
  manufacturer: 'Ford',
  fullName: function() {
    return `${this.manufacturer} ${this.model}`
  }
}
```

Above you see the object “car”.  Look at the key “fullName”.  The value corresponding to “fullName” is a classic anonymous function.

In this case, when we call the fullName function like this:

```javascript
car.fullName( )
```

because we’re using a classic function,  JavaScript knows to look for the meaning of “this” in the object it’s being called in.  In our case, the “this” is being called in the object named “car”.  Good, now JS will know how to parse the literals “this.manufacturer” and “this.model”.  We just said the “this” must refer to the “car” object, so we we have “manufacturer” and a “model” property in our “car” object?  Yes, we do!  So JS can return:

```javascript
car.fullName( )  // returns: “Ford Fiesta”
```

Now let see what would happen if we turn our car.fullName method into an arrow function like this:

```javascript
const car = {
  model: 'Fiesta',
  manufacturer: 'Ford',
  fullName: () => {
    return `${this.manufacturer} ${this.model}`
  }
}
```
What happens now when we try to call “car.fullName( )” ?
The difference lies in the fact how the arrow function will interpret the “this” keyword.  We already saw how the classic function knew that “this” referred to the object itself and therefore all the object’s key/value pairs were made available to that function.

However, our arrow function interprets the “this” keyword differently.

Our arrow function will only look for a meaning of “this” in its **lexical scope** meaning the context where that function is executed.

In other words, this is the only thing our arrow function “sees”:

```javascript
fullName: ( ) => {
  return `${ this.manufacturer} ${ this.model }`
```
Our arrow function only sees the parts of the object that directly concern its own execution.  It does not see the “model” property nor does it see the “manufacturer” property.

Therefore, when our fat arrow method function tries to interpret “this.manufacturer” and “this.model” it finds no references to anything like that.  Both values will be returned as undefined.

```javascript
car.fullName(  )  // “undefined undefined”
```

The upshot of all “this” is: when constructing a method in an object, you have to use the classic function keyword.