DEV Community: Sadra Isapanah Amlashi

Mastering in Javascript Closures, Grandma Style + Tips & Tricks

Sadra Isapanah Amlashi — Fri, 14 Apr 2023 07:52:01 +0000

Closures are a powerful feature in JavaScript that allows a function to retain access to its lexical environment, even after the function has returned. They are used extensively in modern JavaScript programming and can be a bit tricky to understand and use effectively.

In this post, we’ll dive deep into closures and explore some tips, tricks, and best practices for mastering them in JavaScript.

Explain it to Grandma

Imagine you have a box with some things inside. This box represents a function in JavaScript. When you call that function, you can use the things inside the box.

But what if there’s something outside the box that the function needs to use? Usually, the function wouldn’t be able to see it.

This is where closures come in. A closure is like a little bubble that forms around the function, including anything outside the box that the function needs to use. So even though the function can’t see it directly, the closure allows it to access those things and use them as if they were inside the box.

In short, a Closure is a way for a function to remember and access its outer scope even after it has been called and executed.

Example

Let’s say we have a function called greet that takes a name as an argument and returns a function that will greet that person. The returned function will also remember the original name even after greet has finished running. Here's what the code might look like:

function greet(name) {
  return function() {
    console.log(`Hello, ${name}!`);
  }
}

const greeting = greet('Grandma');

greeting(); // logs "Hello, Grandma!"

In this example, greet is a function that takes an name argument and returns a function that logs a greeting to the console. When we call greet('Grandma'), it returns a new function that greets "Grandma". We store this returned function in a variable called greeting.

When we call greeting() later on, it logs "Hello, Grandma!" to the console. But how does it remember the name "Grandma" even though greet has already finished running?

This is where the closure comes in. The returned function has a closure that includes the name variable from the outer greet function. So even though greet has finished running and the name variable should no longer be accessible, the closure allows the returned function to remember and use it.

Using Closures Effectively

Now that we have a basic understanding of closures, let’s look at some tips and tricks for using them effectively in JavaScript.

Tip 1: Avoid Creating Unnecessary Closures

Creating a closure can have performance implications, especially if it is done unnecessarily. In some cases, you can avoid creating closures by passing variables as function arguments, rather than accessing them through a Closure.

Tip 2: Use Closures for Data Privacy

One of the most powerful uses of closures is for data privacy. By creating a closure around a function, you can ensure that the variables and parameters within the closure are only accessible to that function. This can be useful for creating modules and other encapsulated components.

Tip 3: Be Careful with Shared Variables

When using closures, it’s important to be careful with shared variables. If multiple closures reference the same variable, changes made to that variable in one closure will be visible in all other closures that reference it. This can lead to unexpected behaviour if you’re not careful.

Tip 4: Use Closures for Memoization

Another powerful use of closures is for memoization. Memoization is a technique for caching the results of expensive function calls so that they can be returned quickly on subsequent calls. By using a closure to store the cached results, you can avoid the need to recalculate the results each time the function is called.

Best Practices for Using Closures

Finally, let’s look at some best practices for using closures in JavaScript.

Best Practice 1: Keep Closures Simple

Closures can be complex and difficult to understand, especially if they are nested or used in complex ways. As a best practice, it’s a good idea to keep closures as simple as possible, with a clear and understandable purpose.

Best Practice 2: Use Descriptive Variable Names

When using closures, it’s important to use descriptive variable names. This can make it easier to understand what the closure is doing and how it’s being used.

Best Practice 3: Avoid Memory Leaks

Finally, it’s important to be careful with closures to avoid memory leaks. Because closures can retain references to variables and objects, they can also prevent those variables and objects from being garbage collected. To avoid this, make sure to clean up any unnecessary closures when they are no longer needed.

Conclusion

Closures are a powerful feature in JavaScript that can be used in a variety of ways. By understanding how they work and following some best practices, you can master closures and use them effectively in your JavaScript programs. Remember to keep closures simple, use descriptive variable names, and be careful with shared variables to avoid unexpected behaviour. With these tips, tricks, and best practices, you’ll be well on your way to mastering closures in JavaScript.

Let’s Connect

Thanks for reading my article. If you like my content, please consider buying me a slice of Pizza 🍕 .

Connect to me on Linkedin and Twitter.

What is the best comment service for a hosted website?

Sadra Isapanah Amlashi — Wed, 02 May 2018 22:42:11 +0000

These days I'm looking for a suitable online comment service. I've tried out many services like Disqus & just-comments. But both of theme has their own problems & I can't feel comfortable with them!
I've made a blog on GitHub pages with Jekyll, so I need an online comment service for my static website. Can you tell me what you use? or do you know any other free online comment service?

How to see top posts in a category?

Sadra Isapanah Amlashi — Fri, 19 Jan 2018 19:08:37 +0000

I want to see the top post (measured by viewed and liked) of day, week, month & year in a specific category (e.g. Nodejs or Android). but I can't find any tool for that.

How can I do it in dev.to ?

How to detect when app moves to background or foreground

Sadra Isapanah Amlashi — Thu, 24 Aug 2017 10:07:55 +0000

As we know, there is implemented some methods for triggering an application's lifecycle:

There is an issue. These methods didn't help us when the app moves to background or foreground! it just shows us the one-time creation of UIViewControl or process of destroying.

But as the guides in docs there is more information about application lifecycle.

When your app goes to background, The Cocoa broadcasts a notification with the message of the app is moving to the background. So, if your app or your UIViewController registered for this notification, you can be aware when your app moves to background:

As the same, for Moving to Foreground, we have a notification too:

So, you have two ways to detect when your app moves to background or foreground:

In AppDelegate

That implemented by default in app delegation, and you can use these default methods for the issue:

func applicationDidEnterBackground(_ application: UIApplication) {
    print("applicationDidEnterBackground")
}

func applicationWillEnterForeground(_ application: UIApplication) {
    print("applicationWillEnterForeground")
}

In UIViewController

If you want to detect it in a UIViewController manually, you should register for the UIApplicationWillEnterForeground or UIApplicationDidEnterBackground notification anywhere in your app. That it's triggered when the user pressed the home button and it moves to the background, and then pressed double and choose app so it moves to the foreground.

foreground

override func viewDidLoad() {
    super.viewDidLoad()

    let notificationCenter = NotificationCenter.default
    notificationCenter.addObserver(self, selector: #selector(appMovedToBackground), name: Notification.Name.UIApplicationWillEnterForeground, object: nil)
}

func appMovedToForeground() {
    print("App moved to ForeGround!")
}

Background

override func viewDidLoad() {
    super.viewDidLoad()

    let notificationCenter = NotificationCenter.default
    notificationCenter.addObserver(self, selector: #selector(appMovedToBackground), name: Notification.Name.UIApplicationDidEnterBackground, object: nil)
}

func appMovedToBackground() {
    print("App moved to Background!")
}

Did this solution work for you? Please pass it on! Tweet