Not only should you know the mechanics of what a closure is, you should know why it matters, and be able to easily answer several possible use-cases for closures.
If you can’t answer this question, you’re a junior developer. I don’t care how long you’ve been coding.
That may sound mean, but it’s not. What I mean is that most competent interviewers will ask you what a closure is, and most of the time, getting the answer wrong will cost you the job. Or if you’re lucky enough to get an offer anyway, it will cost you potentially tens of thousands of dollars per year in pay because you’ll be hired as a junior instead of a senior level developer, regardless of how long you’ve been coding.
Be prepared for a quick follow-up: “Can you name two common uses for closures?”
What is a Closure?
To use a closure, simply define a function inside another function and expose it. To expose a function, return it or pass it to another function.
The inner function will have access to the variables in the outer function scope, even after the outer function has returned.
Using Closures (Examples)
Among other things, closures are commonly used to give objects data privacy. Data privacy is an essential property that helps us program to an interface, not an implementation. This is an important concept that helps us build more robust software because implementation details are more likely to change in breaking ways than interface contracts.
“Program to an interface, not an implementation.”
Design Patterns: Elements of Reusable Object Oriented Software
In the example above, the `.get()` method is defined inside the scope of `getSecret()`, which gives it access to any variables from `getSecret()`, and makes it a privileged method. In this case, the parameter, `secret`.
Objects are not the only way to produce data privacy. Closures can also be used to create stateful functions whose return values may be influenced by their internal state, e.g.:
const secret = msg => () => msg;
In functional programming, closures are frequently used for partial application & currying. This requires some definitions:
Application: The process of applying a function to its arguments in order to produce a return value.
Partial Application: The process of applying a function to some of its arguments. The partially applied function gets returned for later use. In other words, a function that takes a function with multiple parameters and returns a function with fewer parameters. Partial application fixes (partially applies the function to) one or more arguments inside the returned function, and the returned function takes the remaining parameters as arguments in order to complete the function application.
Partial application takes advantage of closure scope in order to fix parameters. You can write a generic function that will partially apply arguments to the target function. It will have the following signature:
partialApply(targetFunction: Function, ...fixedArgs: Any) =>
If you need help reading the signature above, check out Rtype: Reading Function Signatures.
It will take a function that takes any number of arguments, followed by arguments we want to partially apply to the function, and returns a function that will take the remaining arguments.
An example will help. Say you have a function that adds two numbers:
const add = (a, b) => a + b;
Now you want a function that adds 10 to any number. We’ll call it `add10()`. The result of `add10(5)` should be `15`. Our `partialApply()` function can make that happen:
const add10 = partialApply(add, 10);
In this example, the argument, `10` becomes a fixed parameter remembered inside the `add10()` closure scope.
Let’s look at a possible `partialApply()` implementation:
As you can see, it simply returns a function which retains access to the `fixedArgs` arguments that were passed into the `partialApply()` function.
What do you use closures for? Send me a response with your favorite use-case, examples, etc…
He spends most of his time in the San Francisco Bay Area with the most beautiful woman in the world.