DEV Community: meera123

Understanding Clousers in JavaScript

meera123 — Sun, 13 Aug 2023 15:25:08 +0000

Closures might sound like a complex programming concept, but they're actually quite fascinating and incredibly useful in JavaScript. In this article, we'll break down closures in a way that's easy to understand, using simple language and real-world examples. So, let's dive in and unravel the magic of closures!

What Are Closures?
Imagine you have a function that's like a box, and inside this box are not just the instructions (code) to execute, but also a special power. This power allows the function to "remember" its surroundings even after it's been used. This combination of the function and its remembered surroundings is what we call a closure.

The Basics of Closures
In JavaScript, we have something called "lexical scoping," which means that functions can access variables from their outer environments. If a function can't find a variable in its own "box" (local scope), it goes up to its parent function's box (lexical scope), and this continues until it reaches the global scope.

Here's a simple example to help you grasp this:

function outer() {
  var outerVar = "I'm from outer!";

  function inner() {
    console.log(outerVar);
  }

  return inner;
}

var closureFunc = outer();
closureFunc(); // Outputs: "I'm from outer!"

In this code, the inner function, when returned and assigned to closureFunc, carries its lexical scope along with it. So, when you call closureFunc(), it still remembers the outerVar variable from the outer function, even though outer has already finished executing.

**Real-World Examples

Module Design Pattern** Closures are the backbone of the Module Design Pattern, a way to organize your code and keep variables private. This helps prevent unintended changes to your code's state from outside sources.

var counterModule = (function() {
  var count = 0;

  function increment() {
    count++;
    console.log(count);
  }

  return {
    increment: increment
  };
})();

counterModule.increment(); // Outputs: 1
counterModule.increment(); // Outputs: 2

2. Currying
Currying is a technique where a function with multiple arguments is transformed into a series of functions that each take a single argument. Closures play a vital role in achieving this.

function multiply(x) {
  return function(y) {
    return x * y;
  };
}

var double = multiply(2);
console.log(double(5)); // Outputs: 10

3. Data Hiding and Encapsulation
Closures allow you to create private variables, which are inaccessible from outside the function, achieving data hiding and encapsulation.

function createPerson(name) {
  var privateName = name;

  return {
    getName: function() {
      return privateName;
    }
  };
}

var person = createPerson("Alice");
console.log(person.getName()); // Outputs: "Alice"

Advantages and Disadvantages
Advantages:

Module Design Pattern: Closures enable structuring your code into manageable modules.

Currying: They facilitate creating reusable functions with partially applied arguments.
Data Hiding: Closures help hide implementation details and maintain clean interfaces.

Memoization: Closures are used in techniques like memoization for optimizing function calls.
Disadvantages:

Memory Consumption: Closures can consume memory, especially when they keep references to large objects.
Memory Leaks: Improper use of closures can lead to memory leaks if references aren't properly managed.
Browser Freeze: Misusing closures in certain scenarios, like with event listeners, can cause browser performance issues.

Wrapping Up

Closures might have sounded complex initially, but I hope this article has helped demystify them for you. They are a powerful tool in JavaScript that can make your code more elegant and efficient. Remember, a closure is like a function with a special memory, capable of preserving its surroundings long after its original function has finished running. So go ahead, use closures wisely to create more robust and organized code in your JavaScript projects!

Mastering JavaScript Variable Declarations: A Comprehensive Guide to let, const, and var Usage.

meera123 — Fri, 11 Aug 2023 15:38:40 +0000

If you're embarking on your JavaScript journey, you've likely encountered the terms let, const, and var. While they might initially appear as mere keywords, they hold immense significance for writing clean and reliable JavaScript code. This guide will unravel the mysteries behind these declarations, focusing on the crucial differences between let, const, and the somewhat antiquated var. By the end, you'll grasp why the use of var is discouraged, and when to opt for let or const.

var vs let vs const - A Quick Comparison
Before diving into the nuances, let's outline the fundamental distinctions:

var and let enable you to declare variables that can be reassigned.
const is for creating variables that hold unchanging values.
var usage is discouraged; prefer let or const.
If a variable won't change, use const to signify its immutability.
Now, let's dissect the why, how, and what of these declarations step by step.

Scope of Variables
var:
Variables declared with var can have global or function-level scope. Global variables are accessible throughout your code, while function-level variables are confined to the scope of the function in which they're declared.

var globalVar = 42;

function demoFunction() {
  var localVar = "Local Variable";
  console.log(globalVar); // Accessible
}

console.log(globalVar); // Accessible
console.log(localVar);  // ReferenceError: localVar is not defined

let and const:
Variables declared with let and const possess global, local, and block-level scope. Block-level scope refers to variables declared within curly braces, such as within if statements or loops.

let globalLet = 42;
const globalConst = "Constant Value";

function demoFunction() {
  let localLet = "Local Let";
  const localConst = "Local Const";
  if (true) {
    let blockLet = "Block Let"; // Block scope
    const blockConst = "Block Const"; // Block scope
  }
  console.log(localLet); // Accessible
  console.log(localConst); // Accessible
  console.log(blockLet); // ReferenceError: blockLet is not defined
}

Redeclaration and Reassignment
var:
Variables declared with var can be redeclared and reassigned within the same scope.

var num = 10;
var num = 20; // Redeclaration allowed
num = 30; // Reassignment allowed

let and const:
Variables declared with let and const can be reassigned but not redeclared within the same scope.

let numLet = 10;
numLet = 20; // Reassignment allowed

const numConst = 10;
numConst = 20; // TypeError: Assignment to constant variable

Hoisting and Temporal Dead Zone
Hoisting:
var:
Variables declared with var are hoisted and initialized with undefined.

console.log(hoistedVar); // undefined
var hoistedVar = 42;
console.log(hoistedVar); // 42

let and const:
Variables declared with let and const are hoisted but not initialized. Accessing them before declaration results in a ReferenceError.

console.log(hoistedLet); // ReferenceError: hoistedLet is not defined
let hoistedLet = 42;
console.log(hoistedLet); // 42

Temporal Dead Zone (TDZ):
Variables declared with let and const are inaccessible within the Temporal Dead Zone (TDZ), which is the period between hoisting and actual declaration.

console.log(tdZoneVar); // ReferenceError: Cannot access 'tdZoneVar' before initialization
let tdZoneVar = 42;
console.log(tdZoneVar); // 42

In Conclusion
Comprehending let, const, and var is pivotal for robust JavaScript coding. Remember:

Use var cautiously due to its hoisting quirks; prefer let or const.
Embrace let for reassignment flexibility, but beware of scope and hoisting.
Utilize const for variables meant to remain constant.

As you navigate the JavaScript landscape, make informed decisions based on your code's context. Armed with your newfound understanding of these declarations, your coding journey will be smoother. Happy coding!

Hosting a static website on AWS EC2.

meera123 — Wed, 31 Aug 2022 16:59:23 +0000

Hello everyone.
In this blog, we will be discussing hosting a static website on AWS EC2.

What I will cover
1:Buying a domain and hosting the domain on AWS ROUTE 53
2:Hosting a website
3:How to configure SSL

1:Buying a domain and hosting the domain on AWS ROUTE 53.

There are multiple buying options in the market for domain buying and hosting platforms like
1.GoDaddy
1. Hostinger
2. Bluehost
3. Freenom(free domains) But, I would suggest using GoDaddy. And if you want to buy only for practice purposes then you can go for Freenom. In this blog, I will be using GoDaddy.
After buying a domain from Godaddy. Go to manage DNS.

After clicking u will see the Nameservers as shown below

Then log in to your AWS console and go to ROUTE 53. There we will be hosting our DNS. To do that first create a hosted zone by giving your domain name.

After that, you will be seeing some nameservers on route 53 you have to copy that and paste that on Godaddy nameserver. Then your DNS hosting will shift from GoDaddy to AWS.

2: Hosting a website

Launch an EC2 instance. Here I am using amazon Linux 2. Make sure to allow port 80(HTTP) and port 443(HTTPS) for everyone.

After that connect to the instance using an ssh client.
Connect to the root by following the below commands.

sudo su
cd

After connecting to the root install apache to make a web server by throwing the below commands. yum install httpd Then go to the following directory.

cd var/www/html

Here you need to move your website files.
For that, we will be using winscp
Here is the link to download winscp.

After installing winscp. Open WinSCP and paste your public IP of the ec2 instance in the hostname. Then go to Advance->Authentication. There you need to give your private key.

Then give ec2-user as user-name.

Then move your file to the /var/www/html directory.

Come back to your ssh client and check if the files are available in the/var/www/html directory or not by throwing

ls

If your files are there the throw below commands.
systemctl start httpd
systemctl enable httpd
Your website is ready for hosting. You can copy your IP in chrome and check whether the website is live or not.

Okay, you successfully hosted your domain and deployed your website on your server.

After completing the previous steps you need to register your IP with your domain.
For that go to hosted zone you have created in ROUTE 53 and click on create record there you have to create a record by giving www as a subdomain(Give names by using those you want your customers to come over to your website) and paste your public IP in the value box.

There you go. If your website is successfully deployed you can check by hitting your subdomain and domain name on the browser.

3:How to configure SSL using Let's Encrypt
1.Download the Extra Packages for Enterprise Linux (EPEL) 7
repository packages. These are required to supply dependencies
needed by Certbot.
-Navigate to your home directory (/home/ec2-user). Download
EPEL using the following command.

  sudo wget -r --no-parent -A 'epel-release-*.rpm' 
   https://dl.fedoraproject.org/pub/epel/7/x86_64/Packages/e/

-Install the repository packages as shown in the following
command.

sudo rpm -Uvh dl.fedoraproject.org/pub/epel/7/x86_64/Packages/e/epel-release-*.rpm

-Enable EPEL as shown in the following command.

sudo yum-config-manager --enable epel*

-You can confirm that EPEL is enabled with the following command.

sudo yum repolist all

It should return information similar to the following.

[ec2-user ~]$ 
...
epel/x86_64                          Extra Packages for Enterprise Linux 7 - x86_64                               enabled: 12949+175
epel-debuginfo/x86_64                Extra Packages for Enterprise Linux 7 - x86_64 - Debug                       enabled:      2890
epel-source/x86_64                   Extra Packages for Enterprise Linux 7 - x86_64 - Source                      enabled:         0
epel-testing/x86_64                  Extra Packages for Enterprise Linux 7 - Testing - x86_64                     enabled:    778+12
epel-testing-debuginfo/x86_64        Extra Packages for Enterprise Linux 7 - Testing - x86_64 - Debug             enabled:       107
epel-testing-source/x86_64           Extra Packages for Enterprise Linux 7 - Testing - x86_64 - Source            enabled:         0
...

2.Edit the main Apache configuration file, /etc/httpd/conf/httpd.conf. Locate the "Listen 80" directive and add the following lines after it, replacing the example domain names with the actual Common Name and Subject Alternative Name (SAN).

<VirtualHost *:80>
    DocumentRoot "/var/www/html"
    ServerName "example.com"
    ServerAlias "www.example.com"
</VirtualHost>

Save the file and restart Apache.

sudo systemctl restart httpd

Your website is ready.
I hope you will find this informative.:>

How to connect to a private instance using VPN.

meera123 — Sat, 20 Aug 2022 11:15:00 +0000

In a previous blog, I explained how to connect to an instance with private IP. This blog explains how to connect to the private instance using a VPN.

step 1:
First, create an instance that does not have a public IP.
step 2:
Go to Amazon AMI->Market Place search OpenVPN and click on select->continue.

step 3:
After this configure the instance and make sure to give it a public IP.

step 4:
Then connect to the instance using the ssh client then click yes to agree on agreements and click enter to every option.

step 5:
It won't connect because we have to change the name root to openvpnas. Copy the Admin UI and Client UI to the notepad. Then connect by giving username openvpnas. Because we are trying to connect to the vpn, not the root.

step 6:
After it will get connect give the password to the vpn by providing the following commands.
sudo passwd openvpn

step 7:
After that go to notepad where you pasted the Admin UI and client UI. Again copy the Admin UI then paste it on google search. Then it will ask you for the id and password. Provide the id as OpenVPN and give the password you have created and log into that VPN. There you can manage who can access the server and other permissions.

Step 8:
After that go to openvpn website and install OpenVPN in the client's system so they also can connect to the private server.

Step 9:
After the installation, copy the client UI, paste it into the URL, and give the password you created and on the VPN so that the client can access the private server.

That's it. After these steps, both you and your clients will be able to connect to the private server.

Hope you all find it informative!!

How to connect to a EC2 instance having only private IP using a jump server.

meera123 — Wed, 17 Aug 2022 11:58:45 +0000

The following article explains how to connect to an ECS instance using only a private IP address.
The first thing I would like to do is introduce some key terminologies, where we will first try to understand a few things, and then move on to the implementation.

Key terminologies:

ec2 instances: EC2 instance is like a computer or laptop where you can run your os like Linux, windows, etc.
AMI(Amazon Machine Image): It contains the operating system like windows ,amazonLinux, sushelinux which we use to launch our ec2 instance.
vpc(virtual private cloud): vpc is an isolated network within aws where we deploy our resources so that they can communicate with each other.
Private IP: Using private IP we can not connect to the internet directly.
Public IP: Using public IP we can connect to the internet directly.
Key pair: A key pair has a public key and a private key. So basically this is a set of security credentials that we use to prove our identity while connecting to an ec2 instance.
Bastion host: The ec2 instance which is having a public IP from which we try to connect to an instance present in a private subnet is called a Bastion host.

EC2 Instance Connect allows you to connect to EC2 instances using three different methods:

A browser-based client accessible via the AWS Management Console.
Your own key and SSH client.
EC2 Instance Connect command line interface (CLI).

In this article we only discuss about connecting ec2 instance using key and SSH client.

Step 1:

Start by creating an EC2 instance that has a low configuration. Ensure that this EC2 instance and the instance with the private IP are in the same VPC. And this instance must have a public IP.
Connect the instance by giving key pair to SSH client. And connect to the root.

sudo su
cd

Now try to connect to the private EC2 instance. You will notice it is not connecting because the private key pair is not there.

step 2:

Now login to vi editors with a file name the same name as the private key pair file. In my case, the key name is example.pem.

vi example.pem

Copy-paste the key into the editor. Save and exit to the editor.

Now give permission to the owner by using the following command.

chmod 600 example.pem

You are good to go.

Now trying to connect to the ec2 instance having private IP. It will be connected.

How to create an Elastic IP in AWS.

meera123 — Thu, 11 Aug 2022 13:02:00 +0000

In this post, we will discuss different types of IPs used by AWS. And how to create an Elastic IP in AWS.

AWS offers three types of IP addresses.

Public IP
Private IP
Elastic IP

By using public IP we can access our instance from anywhere on the internet.
By using private IP we can only access our instance within the same VPC.

Public IPs, however, change if an instance is restarted, so we cannot use them. Therefore, the website may be unavailable. Your instance can no longer be accessed using your old IP address.

So to solve that problem we use Elastic IP.
Elastic IPs are public IP addresses you can assign to your AWS account. You can associate this elastic IP with any EC2 instance, disassociate from one instance, then reassociate.

It won't change after you restart the instance because of it's static nature.
So the website won't face downtime.

HOW TO CREATE AN ELASTIC IP IN AWS.

-First create an instance

-Then select Elastic IP in Network & Security

-Now select Allocate IP address and Associate IP.

-Go to Associate IP and select the instance to which you want to allocate the Elastic IP, Leave everything as it is and click on Associate.

-Now you can see the Elastic IP and the public IP of instance are same.

You are done. Now restart the server. You will notice the IP won't change.

Hope you like it:>

HOW TO ATTACH AND MOUNT AN EXTRA AMAZON EBS VOLUME TO AN EXISTING INSTANCE?

meera123 — Sun, 07 Aug 2022 14:20:00 +0000

Creating new EBS volumes can be done in AWS, you can attach them to instances to add additional storage. Mounting an EBS volume to a folder inside the instance is required to use it as
storage inside the instance

MOUNT VOLUME TO THE INSTANCE

Step 1:Create an EC2 instance if you don't have any.
Step 2:Go to the volume section and click on create volume.

Step 3:Select the volume and click on action button, then select attach button.
Note:Make sure the EBS volume and instance are in the same availability zone
Step 4:Select the instance where you want it to attach and click on attach.Your volume has now been attached to the instance.
Now connect to the root by throwing below commands

_sudo su_
_cd_

Step 6:You can now list the disk available on your EC2 instance by firing the below command.

_lsblk_

Step 7:For a detailed description of the volumes throw below commands

_fdisk -l_

Step 8:Now check if the disk is mounted

_df -h_

Step 9:Using the following command, format the volume as ext4 filesystem.

_mkfs.ext4 /dev/xvdf_

Note you can also format it into the xfs filesystem.(Usually used for larger volumes)
Step 10:Create extra directory of your choice to mount out new ext4 volume. I am using the name /extra. You can name it something of your choice.

_mkdir /extra_

Step 11:Mount to the volume to the /extra directory using following command.

_mount /dev/xvdf /extra_

Note: With _df -h_, you can check
whether it is mounted or not.

_cd /extra_

By using the above command you can go into the extra directory and can create fil e
To unmount the volume use the unmount command as shown below

_unmount /dev/xvdf_

Now here is the problem is if you stop and start your instance the data will be gone... So we have to permanently mount the volume..

PERMANENTLY MOUNT THE VOLUME TO THE INSTANCE

Step 1:After mounting your volume click the following command

_blkid_

Step 2:After clicking this you will get a UUID. Copy that UUID of your extra
volume.

Step 3:Then login to vi editor firing below command

_vi /etc/fstab_

** paste the UUID and the path where
you want to mount and the filesystem you
format**

That's it your file is permanently mounted. Now if you stop your instance and start again your data won't be lost.

That's it you can mount and unmount as much as file of your choice by following these steps.

If you have any doubt feel free to comment.