This year I’ve been feeling an urge to really learn a programming language. There are lots of languages I know well enough to write automation code in- C#, Java, Javascript, and so on- but I decided I wanted to really dive into one language and learn to really understand it.
I decided to go deep with Node.js. Node is essentially Javascript with a server-side runtime environment. It’s possible to write complete applications in Node, because you can code both the front-end and the back-end of the application. And I was fortunate enough to find this awesome course by Andrew Mead. Andrew does a great job of making complicated concepts really simple, so as I am taking the course, I’m finding that things that used to confuse me about Node finally make sense! And because I like sharing things I’ve learned, I’ll be periodically sharing my new-found understanding in my blog posts.
I’ll start with arrow functions. Arrow functions have been around for a few years now, but I’ve always been confused by them, because they weren’t around when I was first learning to write code. You may have seen these functions, which use the symbol =>. They seem so mysterious, but they are actually quite simple! Arrow functions are simply a way to notate a function to save space and make code easier to read. I’ll walk you through an example. We’ll start with a simple traditional function:
const double = function(x) {
return x + x
}
double is the name of the function. When x is passed into the function, x + x is returned. So if I called the double function with the number 3, I’d get 6 in response.
Now we’re going to replace the function with an arrow:
const double = (x) => {
return x + x
}
Note that the arrow comes after the (x), rather than before. Even though the order is different, function(x) and (x) => mean the same thing.
Now we’re going to replace the body of the function { return x + x } with something simpler:
const double = (x) => x + x
When arrow functions are used, it’s assumed that what comes after the arrow is what will be returned. So in this case, x + x means the same thing as { return x + x }. This is only used if the body of the response is relatively simple.
See? It’s simple! You can try running these three functions for yourself if you have node installed. Simply create an app.js file with the first version of the function, and add a logging command:
console.log(double(3))
Run the file with node app.js, and the number 6 will be returned in the console.
Then replace version 1 of the function with version 2, run the file, and you should get a 6 again. Finally, replace version 2 with version 3, and run the file; you should get a 6 once again.
It’s even possible to nest arrow functions! Here’s an example:
const doublePlusTen = (x) => {
const double = (x) => x + x
return double(x) + 10
}
The const double = (x) => x + x is our original function. It’s nested inside a doublePlusTen function. The doublePlusTen is using curly braces and a return command, because there’s more than one line inside the function (including the double function). If we were going to translate this nested function into plain English, it would look something like this:
“We have a function called doublePlusTen. When we pass a number into that function, first we pass it into a nested function called double, which takes the number and doubles it. Then we take the result of that function, add 10 to it, and return that number.”
You can try out this function by calling it with console.log(doublePlusTen(3)), and you should get 16 as the response.
Hopefully this information will help you understand what an arrow function is doing the next time you encounter it in code. You may want to start including arrow functions in your own automation code as well. Stay tuned in the coming weeks for more Adventures in Node posts!