Vertical Scaling

• Vertical Scaling is also referred to as scale up. In this, we add more resources to the existing machine like adding more RAM, faster CPU, etc.

• It's good for simple architecture because there is a limit, we can't add unlimit amount of RAM or CPU to a single machine.

• It does not have a failover if it does down our complete application goes down.

Horizontal Scaling

• Horizontal scaling is also referred to as scale out. In this, we add more machines to spread the load across multiple machines.

• It's considered effective for large-scale systems.

• It does have a failover if a single machine goes down, It will not affect our application much because it can be distributed across other machines.

• We will be required to add a load balancer to distribute the load across different machines.

Choosing between vertical and horizontal scaling depends on the needs of your application. Vertical scaling is easy but limited, while horizontal scaling offers more flexibility and resilience for large-scale systems.

Compilation to Bytecode

• When we execute a Python script, the Python interpreter compiles the source code into bytecode.

• Bytecode is a lower-level representation of the code, stored in a .pyc file within the __pycache__ directory.

• During this process, all syntax errors are checked.

• Bytecode instructions are platform-independent and remain the same across different operating systems.

• We can manually generate the bytecode of file Python file using this command. python3 -m py_compile main.py

• We can also execute the generated bytecode.`python3 __pycache__/main.cpython-310.pyc`

Execution by Python Virtual Machine (PVM)

• Once the source code is compiled into bytecode, the Python Virtual Machine (PVM) interprets these bytecode instructions and performs the corresponding actions.

• PVM is a part of Python Interpreter.

authenticate()

The authenticate method is used to verify the user's credentials against the authentication backends defined in the project. it takes the user's credentials as arguments and returns user object if the credentials are valid and if the credentials are invalid then it returns None

login()

The login() function is used to create user sessions and log them in. It takes a HttpRequest object and a User object saves the user's ID in the session using Django’s session framework and sets a session cookie in the user's browser, allowing them to remain authenticated across different pages and requests.

Example to create a login_view using both methods

from django.contrib.auth import authenticate, login
from django.http import HttpResponse
from django.shortcuts import render
from django.contrib.auth.models import User

def login_view(request):
    if request.method == 'POST':
        username = request.POST['username']
        password = request.POST['password']
        user = authenticate(request, username=username, password=password)
        if user is not None:
            login(request, user)
            return HttpResponse("Logged in successfully")
        else:
            return HttpResponse("Authentication failed. Please try again.")

    return render(request, 'login.html')

Creating Dictionary

Using Curly Braces {}:

To create a dictionary in Python we use a pair of curly brackets {} and store comma-separated key-value pairs in it.

# empty dictionary
my_dict = {}
print(type(my_dict)) # <class 'dict'>

# storing value in dictionary
my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
print(my_dict) # my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

Note:

Dictionaries in Python must have unique keys. When the same key is provided multiple times, the last one overwrites the previous one.

user = {
    'name': 'John',
    'age': 25,
    'email': 'john.doe@example.com',
    "name": "James" # using the same key
}
print(user) # {'name': 'James', 'age': 25, 'email': 'john.doe@example.com'}

Using dict() Constructor:

We can also use dict() constructor to create a dictionary, and to store some data in it. We can pass key-value pairs as arguments or as a list of tuples. Take a look at the examples below.

my_dict = dict()
print(type(my_dict)) # <class 'dict'>

# stroing data as arguments
my_dict = dict(key1='value1', key2='value2', key3='value3')
print(my_dict) # {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

# stroring data as list of tuples
my_dict = dict([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3')])
print(my_dict) # {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

Accessing Data from Dictionary

Using Square Brackets:

We can use square brackets with keys to access its corresponding values. If the key is not present in the dictionary a KeyError will be raised.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

print(user['name']) # John Doe
print(user['age']) # 25
print(user['email']) # john.doe@example.com

print(user['phone']) # KeyError

Using get() method:

The get() method allows us to retrieve the value associated with the key, if the key is not present in the dictionary then it returns None or the default_value if it is specified.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

print(user.get('name')) # John Doe
print(user.get('age')) # 25
print(user.get('email')) # john.doe@example.com

print(user.get('phone')) # None
print(user.get('phone','No Phone Number')) # No Phone Number

Accessing keys of the dictionary:

To get all the keys of a dictionary we use dict.keys() method. It returns a view object that contains all the keys of the dictionary. This view object is a dynamic view, meaning it reflects any changes made to the dictionary, If we add or remove an item to the dictionary, the view will automatically update. we can also use dict.keys() method to iterate over the keys of a dictionary using a for loop or we can use it to test the membership of any key in the dictionary. Take a look at the example below to learn about different actions we can perform using the dict.keys() method.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}
print(user.keys()) # dict_keys(['name', 'age', 'email'])

# adding a new key to the dictionary
user['phone'] = '9898989898'
print(user.keys())  # dict_keys(['name', 'age', 'email', 'phone'])

# Iterating over the keys of a dictionary
for i in user.keys():
  print(i)

# Testing membership
if 'phone' in user.keys():
  print("True")
else:
  print("False")

# converting the view object to a static list
static_list = list(user.keys())
print(static_list)  # ['name', 'age', 'email', 'phone']

Accessing Values of the dictionary.

To access all the values of the dictionary we use the dict.values() method. It returns a view object that contains all the values of the dictionary. This view object is a dynamic view, meaning it reflects any changes made to the dictionary, If we add or remove an item to the dictionary, the view will automatically update. The view object can be iterated and it also supports membership testing, which means we can use dict.values() the method to iterate over the values of the dictionary or to test the membership of some value in the dictionary. Take a look at the example below.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}
print(user.values())  # dict_values(['John Doe', 25, 'john.doe@example.com'])

# adding a new item to the dictionary
user['phone'] = '9898989898'
print(user.values())  # dict_values(['John Doe', 25, 'john.doe@example.com', '9898989898'])

# Iterating over the keys of a dictionary
for i in user.values():
  print(i)

# Testing membership
if 25 in user.values():
  print("True")
else:
  print("False")

# converting the view object to a static list
static_list = list(user.values())
print(static_list)  # ['name', 'age', 'email', 'phone']

Accessing items from the dictionary

we use dict.items method to access all the items from the dictionary. It returns a view object that contains a list of tuples with key-value pairs of the dictionary. The view object is the same as we learned in dict.keys() or dict.values() methods. Take a look at the example below.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}
print(user.items())  # dict_items([('name', 'John Doe'), ('age', 25), ('email', 'john.doe@example.com')])

# adding a new item to the dictionary
user['phone'] = '9898989898'
print(user.items())  # dict_items([('name', 'John Doe'), ('age', 25), ('email', 'john.doe@example.com'), ('phone', '9898989898')])

# Iterating over the keys of a dictionary
for key, value in user.items():
  print(key, value)

# Testing membership
if ('age', 25) in user.items():
  print("True")
else:
  print("False")

# conveting the object view to static list
static_list = list(user.items())
print(static_list)  # [('name', 'John Doe'), ('age', 25), ('email', 'john.doe@example.com'), ('phone', '9898989898')]

Modifying Dictionary

While working with a dictionary, we will need to add new data, delete existing data, or update the existing data from the dictionary, in this section of the article we will learn about this.

Adding new data

We can add new key-value pairs to the dictionary either by using square brackets or by using dict.update() method let's take a look at them one by one. Any new key:value pair added to the dictionary will be added at the end of the dictionary since the dictionary maintains the order of its items.

Using Square Brackets:

Syntax :-

dict[key] = value

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

# adding new key value pair
user['phone'] ='9898989898'
user['username'] = 'john'

print(user) # {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com', 'phone': '9898989898', 'username': 'john'}

Using the update method:

The update() method is used to update a dictionary with elements from another dictionary or from an iterable of key-value pairs (as tuples or other iterable of length two) or keyword arguments. This method modifies the dictionary in place, adding new key-value pairs or if the key already exits it updates the value of it.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

# updating with another dictionary 
extra_data = {"phone": "989898989", "username": "john"}
user.update(extra_data)
print(user)  # {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com', 'phone': '989898989', 'username': 'john'}

# updating with list of tuples
extra_data = [("phone", "989898989"), ("username", "john")]
user.update(extra_data)
print(user)  # {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com', 'phone': '989898989', 'username': 'john'}

# updating with keyword arguments
user.update(phone="989898989", username="john")
print(user)  # {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com', 'phone': '989898989', 'username': 'john'}

# updating values of a key 
user.update(phone="989898989", username="john",age=30)
print(user)  # {'name': 'John Doe', 'age': 30, 'email': 'john.doe@example.com', 'phone': '989898989', 'username': 'john'}

Removing data from the dictionary

Using del statement

del statement is used to remove key-value pairs from the dictionary. It takes a key and removes the key and its corresponding value from the list. if the key is not present in the dictionary it raises KeyError. We can even delete the complete dictionary using the del statement.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

# removing item with del statement
del user['name']
print(user) # {'age': 25, 'email': 'john.doe@example.com'}

# trying to delete item that doesn't exists in the dictionary
del user['phone'] # KeyError: 'phone'

# removing the complete dictionary
del user

Using the pop() method:

pop() methods accept a key and optional default value, it removes the specified key from the dictionary and returns its value. If the key is not in the dictionary it returns the default value if it is specified else it raises a key error.

Syntax:

dict.pop(key,default_value)

• key: The key whose associated value is to be retrieved and removed.

• default (optional): If the key is not found, the default value is returned (if provided). If not provided and the key is not found, a KeyError is raised.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

# using pop method to remove item from the list
returned_value = user.pop('name')
print(returned_value) # John Doe

# using default value
returned_value = user.pop('phone',"Invalid key")
print(returned_value) # invalid key

# using invalid key without default value
returned_value = user.pop('username')
print(returned_value) # KeyError

print(user) # {'age': 25, 'email': 'john.doe@example.com'}

Using dict.clear() method:

dict.clear() method is used to remove all the key-value pairs from the dictionary and returns None.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

# using clear method
returned_value = user.clear()
print(returned_value) # None
print(user) # {}

Using Loops with Dictionary

Note:

The dictionary preserves the insertion order, which means the order in which items are added to a dictionary will be maintained, when we iterate through the items of a dictionary, they will be in the same order in which they were inserted. However, we can't access the items in the dictionary using their position because items in the dictionary are key-indexed not position-indexed.

Using for loop with dictionary:

When we loop over the dictionary it implicitly loops over its keys.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

for val in user:
  print(val)

# Output
'''
name
age
email
'''

but we can use these keys to access their corresponding values.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

for val in user:
  print(user[val])

# Output
'''
John Doe
25
john.doe@example.com
'''

Looping through keys or values.

As we have seen in this article earlier we can user dict.values() to get values of the list and dict.keys() to get list of keys.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

# looping through keys
for key in user.keys():
  print(key)

# looping through values
for val in user.values():
  print(val)

Looping through key-value pairs

We can use dict.items() to loop through the key-value pairs of the dictionary. dict.items() method returns tuples of key-value pairs of a dictionary.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

# looping through key-value pairs
for key,value in user.items():
  print(f"Key: {key}, Value: {value}")

Dictionary Comprehension

Comprehensions:

Comprehension in Python is syntactic sugar, it allows us compact and shorter syntax to create new sequences (set, list, dictionary). Take a look at a simple example below.

Syntax:

dict = {key: value for i in iterable}

# Create a dictionary with squares of numbers from 1 to 5
my_dict = {num: num**2 for num in range(1, 6)}
print(my_dict) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Choosing the correct key

We know that keys in the dictionary must be unique, but what are the possible candidates for keys?

Any immutable type can serve as a key, such as a number, string, or tuple. If you use a tuple as a key, it must only contain immutable types such as a number, string, or another tuple.

As another way to put it, keys need to be hashable to be used in dictionaries. Hashable means that the value should have a fixed hash value that doesn't change during its lifetime.

# Using numbers as keys
number_dict = {1: 'One', 2: 'Two', 3: 'Three'}

# Using strings as keys
string_dict = {'apple': 1, 'banana': 2, 'orange': 3}

# Using a tuple with immutable elements as a key
tuple_dict = {('John', 25): 'Student', ('Alice', 30): 'Teacher', ('Bob', 22): 'Engineer'}

Dictionary methods

Summary:-

• Python dictionaries are collections that store data in key-value pairs, enclosed in curly braces {}.

• Keys in a dictionary must be unique, and dictionaries are mutable (modifiable).

• Creating dictionaries can be done using curly braces {} or the dict() constructor.

• Accessing data in a dictionary is possible through square brackets or the get() method.

• Modifying dictionaries involves adding, removing, or updating key-value pairs.

• Keys in dictionaries must be hashable, and any immutable type can be used as a key.

• Loops can be used with dictionaries, implicitly iterating over keys or explicitly using methods like keys(), values(), or items().

• Dictionary comprehension provides a concise syntax for creating dictionaries in a single line.

• The dictionary preserves the insertion order, which means the order in which items are added to a dictionary will be maintained, when we iterate through the items of a dictionary, they will be in the same order in which they were inserted. However, we can't access the items in the dictionary using their position because items in the dictionary are key-indexed not position-indexed.

• using len(dict) function with a dictionary will return the number of key:value pairs in the dictionary.

• using sorted(dict) function will return a sorted list of keys.

• using max(dict) function will return the maximum key in the dictionary.

• using min(dict) function will return the minimum key in the dictionary.

• using sum(dict) function will return the sum of all the keys if the keys are numbers.

• NodeJs -

  • To verify whether nodejs is installed or not, open your terminal and run the command node -v and npm -v this should give any version number.

• Vscode

• postman

Step 1: Basic Setup

First, we will create a project folder, we can do that using the GUI, but let's try to create that by using the terminal.

• mkdir helloExpress - mkdir command is used to create a new directory. so this command will create a new directory helloExpress

• cd helloExpress/ - cd is used to change the directory. So this command will change the current directory to the helloExpress directory.

• code . this command will open vscode in the current directory.

Now the next step is to create our package.json file. package.json file is a simple JSON file located in the project root directory. This file contains important information about the project like name, version, dependencies, and other configuration options. Every nodejs project contains a package.json file.

To create the package.json file open the in-built terminal of vs code, you can use ctrl + ` . Now we are going to write the command npm init . This will initialize a new node js project and ask you to fill in a bunch of information about the project. You can give that information or keep pressing enter to either keep them empty or default, and if you don't want to keep pressing enter then you can use npm init -y this will skip all the question prompts and set them to default.

This is how our package.json file looks currently.

{
  "name": "helloexpress",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

Now the next step is to create an entry point for our application, we will create a new index.js file in the project root directory.

// index.js file
console.log("Hello Express");

Currently, We only have a simple console message in our index.js file.

Now we will add script in our package.json file.

{
  "name": "helloexpress",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "author": "",
  "license": "ISC"
}

Now when we run the command npm start then it should display Hello Express message in the console.

Step 2: Express and nodemon Installation.

In this section of the article, we are going to install Express and nodemon and do a basic setup of express and nodemon.

installing Express

Express is a popular and widely-used web application framework for Node.js. It provides a set of features and tools for building web applications and APIs.

To install Express run command npm install express in the vscode in-built terminal.

Installing nodemon

Nodemon is a command-line tool that monitosr for any changes in your source and automatically restart your server.

To install nodemon run the command npm i nodemon -D . nodemon is used for development and testing purposes, that's why we install it as devDependencies for installing any package as devDependencies we use -D flag.

Now nodemon is installed, let's modify the script in package.json file.

{
  "name": "helloexpress",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "nodemon index.js"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "express": "^4.18.2"
  },
  "devDependencies": {
    "nodemon": "^2.0.22"
  }
}

Now try doing any changes in index.js file and save it, and your server will start automatically.

Step 3: Express Setup

Let's move to index.js file and start setting up our app. Let's add the following code to your index.js file and then I will try to explain you each and every line.

const express = require("express");
const app = express();
const port = 3000;

app.get("/", (req, res) => {
  res.send("Hello Express");
});

app.listen(port, () => {
  console.log(`listening on port ${port}`);
});

const express = require("express");

This line imports the Express module and assigns it to express variable. This allows us to use the functionality provided by the Express framework.

const app = express();

This creates an instance of the Express application and assigns it to app variable. This is the main object that we will use to configure and interact with our application.

const port = 3000;

This line sets our port to 3000, our server will listen for any incoming request on this port only.

app.get("/", (req, res) => {
  res.send("Hello Express");
});

The above line sets up a GET route on the root URL ("/") of our server. It accepts two arguments PATH and a Handler function. When a user makes a request to the root URL, the function passed as the second argument will be executed. In this case, the function sends the string "Hello World!" as the response.

app.listen(port, () => {
  console.log(`listening on port ${port}`);
});

This line starts the server and listens for incoming requests on the specified port. When the server starts listening for any incoming request, the function passed as the second argument will be executed, which logs a message to the console indicating that the server is listening on the specified port.

Now if you open localhost:3000 in your browser, it will show you Hello Express message.

While working with Express we usually don't send this type of one-line message usually we send JSON data which might be coming from the database, but currently, we don't have that type of knowledge so let's create some static JSON data and try to send that as a response. This is the data we are going to send as response.

const data = [
  {
    id: 1,
    first_name: "Leonid",
    last_name: "Bardsley",
    email: "lbardsley0@yahoo.co.jp",
    gender: "Male",
  },
  {
    id: 2,
    first_name: "Tybalt",
    last_name: "Antushev",
    email: "tantushev1@storify.com",
    gender: "Male",
  },
  {
    id: 3,
    first_name: "Bethena",
    last_name: "Worgen",
    email: "bworgen2@virginia.edu",
    gender: "Female",
  },
  {
    id: 4,
    first_name: "Bartram",
    last_name: "Matts",
    email: "bmatts3@myspace.com",
    gender: "Non-binary",
  },
  {
    id: 5,
    first_name: "Marice",
    last_name: "Pavlenkov",
    email: "mpavlenkov4@tmall.com",
    gender: "Bigender",
  },
];

Next, we need to add a new GET Route and add the following line.

app.get("/users", (req, res) => {
  res.status(200).json(data);
});

The above line sets up a new GET route on the root URL ("/users") of our server. It accepts two arguments PATH and a Handler function. When a user makes a request to the URL, the function passed as the second argument will be executed. In this case, the function sends a JSON string as the response. The status() method sets the HTTP status code to 200, indicating that the request was successful, and the json() method converts the data variable into a JSON string and sends it as the response body.

Now if you go to `localhost:3000/users` in your browser or postman you can see the data as result and in postman, you can also see the status code.

That's it you have successfully created your first express app.

Github Repo

In Short:

When a script is loaded a Global Execution Context is created and every time a function is invoked a Function Execution Context is created and it's deleted after the function is executed. When we run the any program, javascript will create a new execution context. In the memory-creation phase, it will start allocating memory to variables and functions. In the case of variables a special value undefined will be stored and for the function, the whole function code will be stored.

Hoisting of Variables.

Take a look at the example below.

var name = "Ankit";
console.log(name);

We all know how the above program is going to execute, in line 1 value Ankit will be assigned to a variable name and in line 2 the value stored in the variable name will be displayed in the console. But what if we change the order of the line, take a look at the example below.

console.log(name);
var name = "Ankit";

// output in the console
undefined

This time it logs undefined to the console, but why?

As I have talked about in this article or above, javascript allocates memory to variables and functions before executing them, when it allocates memory to variables it stores the special keyword undefined to it. That's why it showing undefined.

Take a look at the below example

console.log(name);
// var name = "Ankit";

In the above example, we are trying to console.log the name without declaring it, this will give an error. Notice the name is not defined error, name is not defined error and undefined error is two different things. We get this error because the name variable has not been declared, and no memory has been allocated to the name variable.

Please note that the variable declared with only var keyword is hoisted, a variable declared with let and const are not hoisted.

Hoisting of Functions

Take a look at the below code example.

function sayHello(name) {
  console.log(`Hello ${name}`);
}
sayHello("Rahul"); // Hello Rahul

This is how we declare a function in any programming language when we call the sayHello function with a name argument it's going to display the Hello message, what if we call the function before declaring it? Let's see

sayHello("Rahul");

function sayHello(name) {
  console.log(`Hello ${name}`);
}

When we execute the above code it also displays the Hello Rahul message in the console, but why and How? Let's understand this.

As we have talked javascript allocates memory to variables and functions before executing them, in the case of variables it stores the special keyword undefined , and in the case of functions, it stores a copy of the function. so the function is already in the memory that's why we can invoke the function before declaring it. This doesn't mean that you can invoke a function without declaring it.

Please note that only the function declaration is hoisted, not the function expression.

In Javascript we can also define functions as values and store them in a variable, this is known as a function expression.

Arrow functions are also not hoisted.

Conclusion 🙋‍♀️🙋‍♂️

Thanks for taking the time to read this tutorial. I hope you found it helpful and informative. Please share it with your friends and followers on social media if you enjoyed reading it.

Always keep this two line in mind.

• function declaration are scanned and made available

• variable declaration are scanned and made undefined.

Read this before reading this article.

var name = "Ankit";

function displayMessage(name) {
  var message = "Hello " + name;
  return message;
}

var message1 = displayMessage(name);
var message2 = displayMessage("Rahul");

console.log(message1);
console.log(message2);

Take a look at the above code, we all know the working of the above code, we call the displayMessage function with an argument and it will return a message and later the message will be displayed in the console, but let's try to understand how JavaScript will execute this code.

Execution Context.

You might be thinking what the heck is Execution Context? let me tell you one thing everything in javascript happens inside the execution context. Execution context refers to an environment in which javascript code is executed. There are two types of Execution Context in javascript.

• Global Execution Context:- It is the default execution context When a script file is loaded in the javascript engine then the Global Execution Context is created.

• Function Execution Context:- Whenever a function is invoked in javascript a new function execution context is created.

Execution Context is created in two phases.

• Memory Creation Phase:- in this phase memory is allocated variables and functions.

• Code Execution Phase:- In this phase, the JavaScript engine starts executing the code from top to bottom. Variables and functions declared in the creation phase are now accessible and can be used to execute the code.

How code is Executed in JavaScript.

Now we know about the execution context, Take a look at the below code and try to understand how the code will be executed by javascript.

var name = "Ankit";

function displayMessage(name) {
  var message = "Hello " + name;
  return message;
}

var message1 = displayMessage(name);
var message2 = displayMessage("Rahul");

console.log(message1);
console.log(message2);

Phase1: Memory Creation Phase

When we run the above program, javascript will create a new execution context. In the memory-creation phase, it will start allocating memory to variables and functions. In the case of variables a special value undefined will be stored and for the function, the whole function code will be stored.

This is how the execution context will look in the memory creation phase.

Phase2: Code Execution Phase

In the code Execution phase, javascript will again go through the code line by line and start executing. So it starts executing and it encounters name="Ankit" now it replaces undefined with Ankit and moves to the next line. The next line is the function definition, a function is only executed when it is invoked, so nothing to execute here. Moving to the next line we have var message1 = displayMessage(name); a function is being invoked, so a new function execution context will be created. In this new execution context, there will be two phases. The first one of memory creation phase and the second is the code execution phase, In the memory execution phase memory will be allocated to variables and functions.

Notice that in the displayMessage function we have a name parameter, this parameter will also be treated as a variable. so in the memory creation phase, this is how our execution context looks.

Code Execution Phase

Again in the code execution phase undefined in name will be replaced with the argument passed and undefined in the message will be replaced by Hello Ankit. After that, it encounters return keyword, and when js encounters return message it moves the control back to the place where the function was invoked with the returned value. In our case, the control will move back to message the variable and this function execution contested will be deleted, and undefined in the message1 will be replaced by the returned value.

Representing Deletion of the function execution context.

Now our control will move to the next line i.e message2 here also displayMessage function is being invoked so the same process will be repeated again, and a new function execution context will be created, and the memory creation phase and code execution phase will be repeated.

Memory Creation Phase

Code Execution Phase

After the code execution phase, the control is moved to the message2 execution context is also deleted. undefined in message2 is replaced by returned value. After that js encounters console.log statements and it displays both messages to the console.

Once the whole program is executed the global execution context is also deleted.

Call Stack

As you might have noticed that there are lots of execution contexts need to be created and deleted, so to keep track of execution contexts javascript uses Call Stack. It operates on the Last In First Out (LIFO) principle, meaning that the last function called is the first one to be executed. When Ever a new execution context is created it is pushed into the call stack and when the execution context is deleted it's popped out of the stack. It also maintains the order of execution contexts. It is also known as an 'Execution Context Stack', 'Runtime Stack', or 'Machine Stack'.

Conclusion 🙋‍♀️🙋‍♂️

Thanks for taking the time to read this tutorial. I hope you found it helpful and informative. Please share it with your friends and followers on social media if you enjoyed reading it.

// function as values
const var1 = function sayHello() {
  console.log("Hello There");
};

var1(); // -> Hello There

// returning function from function
function returnFunction() {
  return function () {
    console.log("I am being return as function");
  };
}

let var2 = returnFunction(); //stores the returned function
var2(); // I am being return as function

// function as argument
function square(num, callback) {
  var result = num * num;
  callback(result);
}

function IAmCallback(result) {
  console.log(result); // 25
}

// passing function as an argument
square(5, IAmCallback); // -> 25

You might be thinking this article is about higher-order functions then why are we reading this, here is the answer.

Higher-order functions are function which takes function as an argument or returns a function. It is called "higher-order" because it operates on functions, rather than just values. This allows for greater flexibility and abstraction in coding.

Example 1:

Let's under the Higher-order function with an Example. Take a look at the code example below.

const numbers = [2, 4, 5, 6, 7, 8, 9, 10];

function square(numbers) {
  let squaredNumbers = [];
  for (let i = 0; i < numbers.length; i++) {
    squaredNumbers.push(numbers[i] * numbers[i]);
  }
  return squaredNumbers;
}

function cube(numbers) {
  let cubedNumbers = [];
  for (let i = 0; i < numbers.length; i++) {
    cubedNumbers.push(numbers[i] * numbers[i] * numbers[i]);
  }
  return cubedNumbers;
}

console.log(square(numbers)); // -> [4, 16, 25, 36, 49, 64, 81, 100];

console.log(cube(numbers)); // -> [ 8,   64, 125, 216,  343, 512, 729, 1000 8,   64, 125, 216,  343, 512, 729, 1000 ]

In the above example, there are two functions square and cube which accepts a list of numbers and returns a new array with squared and cubed values. as you can see in the above example we are repeating code a lot. let's fix this with a higher-order function.

const numbers = [2, 4, 5, 6, 7, 8, 9, 10];

function square(number) {
  return number * number;
}

function cube(number) {
  return number * number;
}

function calculate(numbers, operation) {
  const output = [];
  for (let i = 0; i < numbers.length; i++) {
    output.push(operation(numbers[i]));
  }
  return output;
}
// calling the calculate function with square operation
let squaredNumbers = calculate(numbers, square);
console.log(squaredNumbers); // -> [4, 16, 25, 36, 49, 64, 81, 100];

// calling the calcualte function with cube operation
let cubedNumbers = calculate(numbers, cube);
console.log(cubedNumbers); // -> [ 8,   64, 125, 216,  343, 512, 729, 1000 8,   64, 125, 216,  343, 512, 729, 1000 ]

In the above example, we have three different function square cube and calculate the square and cube the function accepts a number as an argument and returns the square and cube of that number respectively. Things to notice here are the calculate function, which is the higher order function, which accepts a list of numbers, and a function as arguments. It performs the operation we pass as a function on every element of the array. Now we can also create any number of new operations and pass them to calculate functions. Take a look at the example below.

function doubles(number) {
  return 2 * number;
}

let doubledNumbers = calculate(numbers, doubles);
console.log(doubledNumbers); //  [4, 8, 10, 12, 14, 16, 18, 20];

Example 2:

function multiplyBy(factor) {
  return function(number) {
    return number * factor;
  };
}

const double = multiplyBy(2);
console.log(double(5)); // 10

In this example, multiplyBy is a higher-order function that takes a factor and returns a new function. The returned function takes a number and returns the result of multiplying that number by the factor. We can then use the double constant, which is the result of calling multiplyBy(2), to quickly double any number we pass to it.

Examples of Higher-Order Function.

There are lots of in-built higher-order functions in Javascript, like Array.map(), Array.filter(), Array.reduce() setTimeout() etc. We will learn more about them later, but let's look at the example of Array.map(). This function takes a callback function as an argument and returns a new array containing the results of calling the callback function on each element of the original array.

const numbers = [2, 4, 5, 6, 7, 8, 9, 10];
let squaredNumbers = numbers.map(square);
console.log(squaredNumbers);  // ->  [4, 8, 10, 12, 14, 16, 18, 20];

Conclusion 🙋‍♂️🙋‍♀️

In conclusion, higher-order functions are a powerful and flexible tool in JavaScript that allows for greater abstraction and code reusability. They operate on functions, either by taking them as arguments or returning them as results and allow for dynamic and flexible behavior in code. Their use can lead to more concise and readable code, making them a valuable tool in any JavaScript programmer's toolkit.

Why do we use the callback function?

we use the callback function because it allows for the execution of another function after the result of a previous function call has been received.

For example, consider a simple function that takes two arguments, a number and a callback function. The function calculates the square of the number, and then calls the callback function, passing the result as an argument.

// normal function
function square(num, callback) {
  var result = num * num;
  callback(result);
}

// callback function
function iAmCallback(result) {
  console.log(result); // 25
}

// passing function as an argument
square(5, iAmCallback);

In the above example, there are two functions first one is square and the second is iAmCallback The square functions accept two arguments a number and a callback function, it calculates the square of the number and stores it in the result variable after that it calls another function and passes the result as an argument.

next, we have defined another function iAmCallback it accepts one argument and displays it in the console. and at last, we are calling the square function and passing number and iAmCallback function as an argument, here iAmCallback is a callback function that is being passed as an argument to another function that is square once the square finishes its execution it calls the callback function i.e iAmCallback. and the result gets displayed in the console.

Example:

function displayMessage() {
  console.log("How are You?");
}

function sayHello(name) {
  console.log(`Hello ${name}`);
}

setTimeout(displayMessage, 2000);
sayHello("Ankit");

In the above example, we have two function displayMessage and sayHello and later we are calling both the function, but we are delaying the execution of displayMessage function with 2sec using setTimeout. so normally displayMessage should be executed first and then the sayHello should be executed, but here displayMessage is called after 2sec and in this meantime sayHello is executed, so Hello Ankit is displayed first in the console and after that How are You the message is displayed in the console. The sayHello the function does not wait for the displayMessage function to execute, but we can make sayHello to wait for displayMessage to execute using the callback function, let's look at the example below.

 function displayMessage(name, callbackFunction) {
  console.log("How are You?");
  callbackFunction(name);
}

function sayHello(name) {
  console.log(`Hello ${name}`);
}

setTimeout(displayMessage, 2000, "Ankit", sayHello);

Now in the above example the sayHello function waits for the displayMessage function to finish its execution. So the message is displayed first in the console and then the Hello Ankit is displayed in the console.

Conclusion 🙋‍♀️🙋‍♂️

Callback functions are also often used in asynchronous programming, where a function is called, and the program continues to execute other code before the function has been completed. The callback function is then called when the function has finished executing, to handle the results.

Here are a few examples where the callback function is used.

• In JavaScript, callbacks are commonly used in event handling, such as when a button is clicked or a page finishes loading.

• They can also be used in AJAX (Asynchronous JavaScript and XML) requests to handle the response from the server.

• In database operations such as MongoDB driver for nodejs uses callback for handling the query results.

Function Declaration

In JavaScript function is defined using function keyword followed by the function name.

Syntax:

function sayHello(){

// code to be executed

}

function sayHello() {
  console.log("Hello");
}

in the above example, we have declared a sayHello function, for any function to be executed we need to call that function.

This is how we can call that sayHello function*.*

// when we call the sayHello function Hello message will be displayed on the screen.
sayHello(); // -> Hello

Declaring another function with a parameter

We can also declare functions with parameters. A parameter in a function is a variable that is used to accept an argument when the function is called. It stores the arguments passed to the function so that its value can be used later. This is how we can declare a function in javascript with parameters.

// function declaration with parameter
function sayHello(name) {
  console.log(`Hello ${name}`);
}

// calling the function with an argument.
sayHello("Ankit"); // -> Hello Ankit

In the above example, we have used the same sayHello function, but this time it is declared with name parameter. When we call this function we need to pass an argument and the value of the argument will be stored inside the name and we can use it later. Here we are displaying a Hello message with the name passed as an argument.

parameter and arugment.

A parameter is a variable that is declared in the function definition. It acts as a placeholder for the arguments that will be passed to the function when it is called. The parameter is used to receive the value of the argument within the function.

An argument, on the other hand, is the actual value passed to the function when it is called. The argument provides the input to the function, which is then stored in the corresponding parameter.

In the above example, while declaring the function name is the parameter and while calling the function we passed "Ankit" that is the arguments.

A function can be declared with any number of parameters.

Returning a value from a function.

functions can also be used to return some values, return keyword is used to return some values from a function. when a function encounters the return statement then the execution of the function is stopped, and any code after return statement is not executed. Take a look at the example below.

function square(number) {
  return number * number;
}

// calling the sqare function with 5 as argument and value function will return will be stored in the output variable.
const output = square(5);
console.log(output);

In the above example, we have declared a square function that accepts a number as an argument and returns the square of the number. next, we are calling the square function with 5 as an argument, and the value the function will return will be stored in the output variable later we are displaying the output in the console.

Note:

Function in javascript is hoisted, in short, it means that we can call a function before declaring them.

Function Expression

In Javascript we can also define functions as values and store them in a variable, this is known as a function expression. remember that function expression is not hoisted which means you can't use function expression before you create them.

const square = function (number) {
  return number * number;
};

const output = square(5);
console.log(output);

Arrow function

Arrow functions were introduced in ES6. The Arrow function allows us to declare functions with shorter syntax. This is how we declare the arrow function.

const square = (number) => {
  return number * number;
};

const output = square(5);
console.log(output);

Conclusion 🙋‍♀️🙋‍♂️

That's all for this article, functions are a very important concept of any programming language, and knowledge about functions is definitely going to help you to become a better developer.

For Loop

for is one of the most used loops, for loop repeats until the specified condition evaluates to false.

Syntax:-

for (initialization; condition; incrementExpression) {

// code to be executed

} Initialization: The starting value for the loop counter is set.

Condition: The loop will continue to run as long as the condition is true.

incrementExpression: The counter is updated after each iteration of the loop.

Code: The code inside the loop will be executed as long as the condition is true.

for (let i = 0; i < 5; i++) {
  console.log("Hello world");
}

In the above example, we have initialized i=0 and our condition is i<5 and our increment expression i++ it means i = i+1. Here loop will keep displaying Hello World message to the console until the value of i is less than 5 and each time it displays Hello World message to the console value of i is incremented by 1.

While Loop

Syntax:-

while (condition) {

// code to be executed

}

while loop executes the statement as long as the condition evaluates to true. It stops the execution of the code if the condition evaluates to true.

i = 0;
while (i < 5) {
  console.log("Hello World");
  i++;
}

In the above example, the loop will keep displaying Hello World message to the console, until the value of I, is less than 5, and each time it displays Hello World to the console the i++ statement increases the value of I by 1.

do-while

Syntax:-

do {

// code to be executed

} while (condition);

do...while loop also executes the statement as long as the condition evaluates to true. It stops the execution of the code if the condition evaluates to true. The main difference between while loop and do...while loop is that in do... while loop statement is executed once before checking the condition.

let i = 0;
do {
  console.log("Hello World");
  i++;
} while (i < 5);

for in

for (variable in object) {

// code to be executed for each property

}

The "for in" loop in JavaScript is used to iterate over the properties of an object. Each iteration returns a key and we can use that key to access the values of the object.

let person = {
  name: "John Kumar",
  age: 32,
  occupation: "Full Stack Developer",
  skills: ["Python", "Django", "JavaScript"],
};

for (const key in person) {
  console.log(key); // name age occupation skills
  console.log(person[key]); // ->  John Kumar 32 Full Stack Developer ['Python', 'Django', 'JavaScript' ]
}

in the case of an array, it returns the index of the element.

let fruits = ["apple", "banana", "cherry"];

for (const key in fruits) {
  console.log(key);// 0 1 2
  console.log(fruits[key]); // -> apple banana cherry
}

for of

for (varaible of iterable) {

// code to be executed for each value

}

The "for of" loop in JavaScript is used to iterate over the values of an iterable object such as an array or a string.

let fruits = ["apple", "banana", "cherry"];

for (const value of fruits) {
  console.log(value); // -> apple banana cherry
}

In this example, the fruits array is iterated over using a "for of" loop. The loop variable fruit holds the value of each element in turn. The result is a list of all the elements in the fruits array.

break and continue

The break and continue statements are used in JavaScript to control loop flow.

break

The break statement terminates the loop and moves the control to the next iteration.

for (let i = 0; i < 10; i++) {
  if (i === 5) {
    break;
  }
  console.log(`count is ${i}`);
}

/*
count is 0
count is 1
count is 2
count is 3
count is 4
*/

continue

continue is used to skip the current iteration of a loop and continue with the next iteration. When a continue statement is encountered inside a loop, the current iteration is skipped and the program continues with the next iteration of the loop.

for (let i = 0; i < 10; i++) {
  if (i === 5) {
    continue;
  }
  console.log(`count is ${i}`);
}
/*
count is 0
count is 1
count is 2
count is 3
count is 4
count is 6
count is 7
count is 8
count is 9
*/

In this example, the continue statement causes the program to skip 5, and moves the flow to the next iteration.

Conclusion 🙋‍♂️🙋‍♀️

That's it for this article.

if... else

// Syntax

if (condition) {
  // code to be executed when the condition is evaluated to truthy value
} else {
  // code to be executed when the condition is falsy value
}

if...else statement is used when we want to execute different codes based on truthy and falsy values. If the condition is a truthy value then the if block code will be executed and if the condition is a falsy value the else block code will be executed.

Let's take a look at an example

let age = 18;

if (age >= 18) {
  console.log("You can vote");
} else {
  console.log("You can't vote right now.");
}

// Output
// You can vote

In the above code example the condition i.e age >= 18 evaluates to truthy value so the if block code is executed and it displays You can vote message in the console.

Let's take a look at another example

let age = 16;

if (age >= 18) {
  console.log("You can vote");
} else {
  console.log("You can't vote right now.");
}

// Output
// You can't vote right now.

In the above example, I have changed the age value from 18 to 16 so the condition i.e age >= 18 evaluates to false, so the else block of code is executed and it displays the You can't vote right now message to the console.

Truthy and falsy value

In JavaScript, a truthy value is a value that is considered true when evaluated in a Boolean context. Examples of truthy values include any non-zero number, any non-empty string, and any object.

A falsy value, on the other hand, is a value that is considered false when evaluated in a Boolean context. Examples of falsy values include 0, the empty string, null, undefined, NaN, and the special keyword 'false'.

It's important to note that the only falsy values in javascript are: false, 0, "", null, undefined, and NaN. All other values are truthy.

else if

else if statement is used when we want to test for multiple conditions. Let's take a look at the example below to understand it better.

let age = 16;

if (age >= 18) {
  console.log("You can vote");
} else if (age >= 16) {
  console.log("You are eligible for Driving License");
} else {
  console.log("You can't vote right now.");
}

In the above example the condition next to the if statement evaluates to a falsy value, so the if block code is not executed, then the compiler moves to else if the condition next to else if evaluates to true, so the else if block of code is executed.

Switch Statement

When we have multiple if checks in our code, then we can use the Switch statement to replace multiple if checks.

// Syntax

switch (x) {
  case "value1":
    //   code to be executed
    break;
  case "value2": // if (x === 'value2')
    //   code to be executed
    break;

  default:
    //   code to be executed
    break;
}

In the above example, the value of x is checked with the value of different cases, once the value of x is strictly equal to any one of the different cases, the code block of that case is executed until it encounters the next break statement. If none of the cases is matched then the default block of code is Exected. Notice the break keyword, break keyword is used so that code execution stops and no new cases are checked, the compiler moves on and starts executing any code that appears after the switch statement.

Example.

let color = "green";

switch (color) {
  case "red":
    console.log("The color is red.");
    break;
  case "green":
    console.log("The color is green.");
    break;
  case "blue":
    console.log("The color is blue.");
    break;
  default:
    console.log("The color is not red, green, or blue.");
}

// Output

// The color is green.

Ternary Operator

Ternary Operator takes three operands and returns values based on the condition.

Syntax:

condition ? expression 1 : expression2

• if the condition is true then it returns expression1 and if the expression if false it returns expression2

const var1 = 10;
const var2 = 20;

console.log(var2 > var1 ? "true" : "false"); // true
console.log(var1 > var2 ? "true" : "false"); // false

Conclusion 🙋‍♂️🙋‍♂️

That's it for this article for exploring more about conditionals refer to the recourses mentioned below.

• mdn docs

let student = {
  name: "John Kumar",
  age: 20,
  subjects: ["Maths", "Science", "Computer Science"],
  isPresent: true,
};

In the above example student is an object, and it has four properties. name ,age subjects isPresent are key or we can call it property name and John Kumar 20 ["Maths", "Science", "Computer Science"] isPresent are values of different types. Anything left to the colon : is key and the right to the colon is value.

Creating Objects

For creating objects in javascript there are many different syntaxes, but in this article, we are going to talk about two, object literal and object constructor.

Object Literal

We can create an empty object with just a pair of curly brackets {} , this syntax of creating an object is known as Object Literal.

// object literal syntax
const student = {} // an empty object

Object Constructor

We can also create a new object with the help of the constructor function and new keyword, this method of creating an object is known as an Object constructor.

// object constructor syntax
const teacher= new Object(); // an empty object

Adding Properties to an Object

We have created two objects student and teacher let's now add some properties to these objects. The properties of an object are the same as the variable except that they are linked to objects rather than being confined to a specific scope. The properties of an object define its characteristics.

let Student= {}; // empty object with Object literal syntax

// Adding properties to student object

Student.name = "John Kumar";
Student.age = 20;
Student.subjects = ["Maths", "Science", "Computer Science"];
Student.isPresent = true;
// another syntax to add properties
Student["class"] = "VII";
Student["phone number"] = 9898989898;

// displaying the Student Object
console.log(Student);
// Output
/*
{
  name: 'John Kumar',
  age: 20,
  subjects: [ 'Maths', 'Science', 'Computer Science' ],
  isPresent: true,
  class: 'VII',
  'phone number': 9898989898
}
*/

// teacher Object

const Teacher= new Object(); // empty object with Object Constructor syntax
//Adding properties to teacher Object
Teacher.name = "Tony Prasad";
Teacher.age = 50;
Teacher.teachers = ["Algorithms", "Maths"];
Teacher.isPresent = true;
// another syntax
Teacher["department"] = "Computer Science";
Teacher["phone number"] = 9898989898;
console.log(Teacher);
// Output
/* 
{
  name: 'Tony Prasad',
  age: 50,
  teachers: [ 'Algorithms', 'Maths' ],
  isPresent: true,
  department: 'Computer Science',
  'phone number': 9898989898
}
*/

Accessing Properties from an Object

We can access the properties of an Object using their properties name, there are two syntaxes to do that, let's talk about them one by one.

Dot Notation

This is the most used syntax.

objectName.propertyName

// Display student name from student object 
console.log(Student.name);
// Display student subjects from student object
console.log(Student.subjects);
// Display student phone number from student object

// We can't do that using dot notation, when we are using
// multi word property name we can't use dot notation syntax to do that.
// that's why multi word property name is not recommended use camelCase or 
// sanke_case property name

Bracket Notation

objectName["propertyName"]

// Display student name from student object 
console.log(Student["name"]);

// Display student subjects from student object
console.log(Student["subjects"]);

// Display student phone number from student object
console.log(Student["phone number"]);

Object Methods

What are the methods? - Nothing to worry about methods are functions defined inside an object, yes we can define a function inside an object, let's do that. Let's define some methods inside an Object, but first, let's talk about this keyword.

this is a special keyword in Javascirpt, It refers to an Object but depends on where it's being used. If this keyword is being used in an object's methods then this refers to the current object, if this keyword is being used alone then it refers to global object.

I know this small introduction will not clear your confusion about this, I will talk more about this in the below example which would make more sense, also I will leave some link to resources at the end of this article so that you can understand it better.

Syntax 1

// We can define Methods directly inside an Object
const Student = {
  name: "John Kumar",
  age: 20,
  subjects: ["Maths", "Science", "Computer Science"],
  isPresent: true,
  class: "VII",
  "phone number": 9898989898,
  sayHi: function () {
    console.log(`Hello ${this.name}`); // here this refers to the Student Object
  },
};

// Calling the sayHi Method
Student.sayHi(); // sayHi is a function so we need to call it using ()

Syntax 2

let Student = {}; // empty object

// Adding different properties to it
Student.name = "John Kumar";
Student.age = 20;
Student.subjects = ["Maths", "Science", "Computer Science"];
Student.isPresent = true;
Student["class"] = "VII";
Student["phone number"] = 9898989898;

// Adding sayHi method to Student Object
Student.sayHi = function () {
  console.log(`Hello ${this.name}`); // here this refer to Student Object
};

// Calling the sayHi Method
Student.sayHi(); // sayHi is a function so we need to call it using ()

Syntax 3

// We can declare an independent function
function displayAge() {
  console.log(`${this.name} is ${this.age} years old`); // 

}

// Assigning it to different Object

// Assigning displayAge method to Student Object we defined earlier
Student.displayAge = displayAge;

// Assigning displayAge method to Teacher Object we defined earlier
Teacher.displayAge = displayAge;

// Calling the displayAge method from Student Object
Student.displayAge();

// Calling the displayAge  method from Teacher Object
Teacher.displayAge();

take a look at the displayAge function from the above example, here this will refer to object with which function displayAge will be used, if displayAge function will be used with Student object then this will refer to Student object and if displayAge function will be used with Teacher object then this will refer to Teacher object.

Deleting Object Property

To remove a property from the object we use delete operator.

delete Student.name; // will delete name property from the student object.

Conclusion

That's it for this article we will learn more about objects when we talk about Prototypes.

Resources to Explore More:

• Read more about this on mdn

• YouTube Video on this keyword

• Assignment Operator

• Arithmetic Operator

• Comparison Operator

• Logical Operator

• Ternary Operator

An operand is a value or variable on which an operator performs an operation.

Assignment Operator

The assignment operator = is used to assign value to a variable. The value of the right operand is assigned to the left operand.

let age = 36 // here 36 will be assigned to variable age.
let fruits = ['Banana',"grapes","guava"]

Arithmetic Operator

We can perform standard arithmetic operations on numbers using the arithmetic operators in JavaScript. Following are some of the many arithmetic operators in JavaScript.

• Addition +

• Subtraction -

• Multiplication *

• Division /

• Modulus % (also known as remainder)

• Increment ++

• Decrement --

Addition

The addition operator is used when we want to find the sum of two or more numbers.

console.log(5 + 5); // 10

We can also use the Addition operator to join two or more strings together, This is known as string concatenation.

let firstName = "John ";
let lastName = "Kumar";
console.log(firstName + lastName); // John Kumar

Subtraction

The subtraction operator is used to find the difference between numbers.

console.log(55 - 2); //53
console.log(55.235 - 23.87); //31.365
console.log(10 - 2 + 5); // 13 This is definitely wrong answer according to bodmas rule.

In the above example, line 3 is giving us the wrong answer because of the order of precedence. Both addition and subtraction have the same order of precedence so they are evaluated Right to the left that's why subtraction is being evaluated first. Here is how we can correct that.

console.log(10 - (2 + 5)); // 3

Now the expression inside the parenthesis will be evaluated first because of the order of precedence.

Division (/)

The division operator is used to find the quotient.

console.log(55 / 5);  // 11

Modulus(%)

The modulus operator is used to find the remainder.

console.log(56 % 5); // 1

Increment (++)

The JavaScript increment operator (++) is used to increment (add 1 to) a variable's value. It can be used in both postfix and prefix notation. In postfix notation (i++), the current value of the variable is returned, and then the value is incremented. In prefix notation (++i), the value is incremented first, and then the new value is returned. It's important to note that the increment operator (++) only works on numbers and will result in a NaN if used on a non-numeric value.

let x = 5;
console.log(x++); // Output: 5
console.log(x); // Output: 6

let y = 5;
console.log(++y); // Output: 6
console.log(y); // Output: 6

Decrement (--)

The JavaScript decrement operator (--) is used to decrement (subtract 1 from) a variable's value. It can be used in both postfix and prefix notation. In postfix notation (i--), the current value of the variable is returned, and then the value is decremented. In prefix notation (--i), the value is decremented first, and then the new value is returned.

let x = 5;
console.log(x--); // Output: 5
console.log(x); // Output: 4

let y = 5;
console.log(--y); // Output: 4
console.log(y); // Output: 4

Comparison Operator

A comparison Operator is used to compare two or more operands. These are the different types of comparison operators.

Equal (==)

The equal operator returns ture if both the operands are the same, it does not check the type of the operands.

const var1 = 10;
const var2 = 20;
const var3 = "10";
const var4 = 10;
console.log(var1 == var2); // false
console.log(var1 == var3); // true both variable have same value but they are of different type
console.log(var1 == var4); //true

Strict equal (===)

This operator is the same as the equal operator, but it also checks the type of operands.

const var1 = 10;
const var2 = 20;
const var3 = "10";
const var4 = 10;
console.log(var1 === var2); // false --different value
console.log(var1 === var3); // false --because both value is of different type
console.log(var1 === var4); //true --same value same type

Not Equal (!=)

This operator returns true if the operands are not equal and return false if they are equal.

const var1 = 10;
const var2 = 20;
const var3 = "10";
const var4 = 10;
console.log(var1 != var2); // true -- different value
console.log(var1 != var3); // false -- same value
console.log(var1 != var4); //false -- same value

Strict Not Equal (!==)

This operator returns true if the operands are not equal and of the same type, else it returns false.

const var1 = 10;
const var2 = 20;
const var3 = "10";
const var4 = 10;
console.log(var1 !== var2); // true -- different values
console.log(var1 !== var3); // true -- same value, different type
console.log(var1 !== var4); // false -- same value, same type

Few More (>,>=,<,<=)

const var1 = 10;
const var2 = 20;
const var3 = 10;

// Greater than
console.log(var1 > var2); // false
console.log(var2 > var1); //true

// Less than
console.log(var1 < var2); // true
console.log(var2 < var1); // false

// Greater than or equal 
console.log(var1 >= var2); // false
console.log(var2 >= var1); // true
console.log(var1 >= var3); // true

// Less than or equal
console.log(var1 <= var2); // true
console.log(var2 <= var1); // false
console.log(var1 <= var3); // true

Logical Operator

A logical operator evaluates expressions and returns a boolean value indicating whether a specific condition is true or false. When used with boolean operands, these operators will return a boolean result; when used with non-boolean values, they will produce a non-boolean result. There are three different types of logical operators in JavaScript.

• OR (||)

• AND (&&)

• NOT(!)

OR

The OR the operator is represented by a double vertical line || . OR The operator returns true if any of its expressions evaluates to true otherwise, it returns false. If the OR operator is used with non-boolean values then it returns non-boolean values.

Syntax:

expression1 || expression2

• if expression 1 is evaluated to true then it returns expession 1 otherwise exprssion2

• logical OR expression is evaluated left to right, so if the first expression is evaluated to true, then it doesnot check the next expression.

• if all the expression evaluates to false then it reaturn false.

const var1 = 10;
const var2 = 20;
const var3 = 10;

console.log(var1 > var2 || var2 > var1);// true
console.log(true || true); // true
console.log(false || true); // true
console.log(true || false); // true
console.log(false || false); // false

AND (&&)

The AND operator is represented by two ampersands && sign. The AND operator return true if all of its conditions evaluates to true if any of its conditions evaluates to false it returns false.

Syntax:

expression 1 && expression 2

• returns true if both the conditions if true otherwise it returns false

• AND operator is evaluated from left to right, so if any expression evaluates to false it doesn't evaluates any expression after that.

• it returns last last operand if all the expression evalutes to 'true`

const var1 = 10;
const var2 = 20;
const var3 = 10;

console.log(var1 > var2 && var2 > var1); // false && true
console.log(true && true); // true
console.log(false && true); // false
console.log(true && false); // false
console.log(false && false); // false

NOT (!)

The NOT the operator is represented by an explanation ! sign. The ! operator can be applied to boolean and non-boolean values. When used with a boolean value, it returns the opposite of that value, i.e. if the value is false it returns true, and if the value is true it returns false.

console.log(!true); //false
console.log(!false); //true
console.log(!0); //true
console.log(!"Hello"); // false

Ternary Operator

Ternary Operator takes three operands and returns values based on the condition.

Syntax:

condition ? expression 1 : expression2

• if the condition is true then it returns expression1 and if the expression if false it returns expression2

const var1 = 10;
const var2 = 20;

console.log(var2 > var1 ? "true" : "false"); // true
console.log(var1 > var2 ? "true" : "false"); // false

Conclusion

In this article I have only talked about the operators which are used most, there are a few more operators, and if you want to explore more then you can read about them here.

Click Here

Python is a high-level object-oriented programming language. It was developed by Guido Van Rossum in 1991. Python is a very easy-to-use, interpreted, expressive language. It is one of the most popular programming languages and has many different use cases.

Python is an interpreted language, which means that it executes code line by line and if there is any error, the program execution stops at that line. It can only continue after the error has been corrected.

Why you should learn Python.

• Python is very easy to use and due to its very simple syntax, it is very beginners friendly.
• Python is a cross-platform, open-source language, it is free to use python and you can use it on almost any operating system.
• Python is being used in many different fields like machine learning, data science, web development, scripting, game development, GUI programs, etc.
• Python is an interpreted language, so it makes it easy to debug compared to compiled languages.

Using Python on Your System

• The first thing you need to do is download and install python on your system, You can download python from its official website. python.org
• Next, you need to use some kind of code editor like vscode and set it up for python, here is the official guide or you can use PyCharm ide download it from here
• If you don't want to install it on your system, you can also use an online code editor like Replit

Writing Your First Python Program

Whenever we learn any new programming language, the first thing we do is that we write a hello world program that displays a “Hello World” message, and in this section of the article we are going to do the same.

In Python when we have to display any message or output on the screen we use print function.

print("Hello World")

when we use print function anything inside the parenthesis is displayed on the screen. Here are the few more examples.

print("Hello There")
print('My name is Ankit')
print(23)
print(45 + 34)

Comments in Python.

In the world of programming, comments are the lines of code that are not executed by the interpreter or compiler, these lines are simply ignored by the interpreter or compiler. Every programming language has a different syntax to write comments, but in python, we use the # symbol to write comments.

For writing comments in python, you just need to add the # symbol at the start of the line, and the python interpreter will just ignore that line during program execution.

# This line is commented
# print("Hello There")

Conclusion

That's it for this article, I hope you enjoyed it, in the next article we are going to talk about Variables, keywords, character sets, values, etc.

Number

In JavaScript, every numeric value is a floating-point number, there is no separate integer type. Values like 23, and 23.534 are all considered as one value i.e number. We can perform arithmetic operations using numbers in JavaScript.

console.log(5 + 3);
console.log(234.23 - 230);
console.log(55 / 5);
console.log(55 % 5);

String

Everything Inside single quotes, double quotes, or backticks is considered a string in JavaScript. The string is used to represent text or a sequence of characters. Make sure you are using the same quotes at the beginning and end of the string.

// Valid String in javaSCript
"Hello World"
'Hello World'
`Hello World` // backticks are below your esc key

// Invalid Strings in JavaScript
"Hello World'
"Hello World'
`Hello World"

Boolean

Boolean has only two values true and false. Either it's going to be true or false.

console.log(89 > 23);
console.log(103 < 23);

Empty Values

There are two special values, null and undefined, that are used to represent the absence of a meaningful value. Although they are values, they do not carry any information or content. null represents the absence of any value, whereas "Undefined" refers to a value that has not been assigned or defined by the compiler. It represents the absence of a defined value.

let name; // the value has not been defined
console.log(name); // -> undefined
let name2 = null;
console.log(name); // -> null

Arrays

Arrays in JavaScript are written using square brackets. The array starts with an opening square bracket[ and array ends with a closing square bracket ] . In an array, we store multiple values separating them with , . In an array, we can store values of any type we talked till now. Let's see some examples of an array.

Each element inside an array is given a unique position known as an index. The index starts from 0 and goes up to a length of the array -1. In the given example "hello" is at index 0 and true is at index 4. We use this index to get elements at specific positions, we will learn more about this in coming articles.

["hello", "there", 3, 3.4, true]

Objects

Objects are written using {} curly braces. JavaScript object mimics the behavior of a physical object, Just like a physical object has some properties JavScript objects also have properties, these properties are written in key-value pair separated by a comma. Here is an example of a person object.

const person = {
  name: "Rahul",
  age: 34,
  address: "Delhi",
  designation: "Full Stack Developer",
};

Now we have learned about different types of values we can use in JavaScript, now let's learn how we can store these values in variables.

Variables.

A Variable is a named label for a memory location where some values are stored. In other words, a Variable is like a container where we can store some values. There are three different ways to declare a variable in JavaScript. var let and const . This would be too early to talk about differences between them so just keep this in mind.

• var - don't use this

• let - value can be changed later

• const - once defined value can't be changed

We use the assignment operator = to assign value to a variable, a variable is only created once you assign value to it. Let's create a value to store a message.

let message = "Hello World!";

console.log(message);

in the above example, we use let to declare the variable, so we can change the message, let's do that.

in the above example in line 4 I have used the same message variable to assign a new value. console.log function from line 2 is displaying the old message and console.log function from line 5 is displaying the new message. Now let's see an example of const.

In the above example, I have replaced let with const , Notice in the console console.log function from line 2 is displaying the message, but when I tried to assign a new message in line 4 it's giving me an error in the console.

Rules for naming a variable.

• The first character of a variable must be a letter

• JavaScript is a case-sensitive language so Uppercase letters and lowercase letters are different. E.g variable age and Age will be treated as two different variables.

• JavaScript reserved keywords can not be used as a variable name.

In the next article, we are going to talk about Operators in JavaScript.

In an Array, all the items of an array are known as elements, and elements in an Array are given a unique position known as an index we will talk more about the index later, so in the above example, the names of fruit are elements of the fruit array. In JavaScript Array, we can store values of any type, values can be anything e.g string, boolean, number, etc we can even store an array inside an array. Here are a few more examples of JavaScript Array.

let arr1 = []
let fruits = ['apple', 'grapes', 'banana', 'orange', 'guava'] // array of strings
let even_numbers = [2,4,6,8,10] // array of numbers
let vowels = ['a','e','i','o','u'] // array of characters
let arr2 = ['hello', "2", 76, 8.23] // array of mixed values
let arr3 = ["How are You", ["hi", 4.5, 9], 98] // array of mixed values

How to create an Array in JavaScript

We can create an array by just assigning a pair of square brackets to a variable let's look at this example let fruits = []; This fruit array has no element inside it, so it is known as an empty array. There is also another way to create an array in JavaScript but it's not used much.let fruits = new Array(); this is also an empty array. take a look at the below code and you will know how we add elements to this Array.

let fruits = []; // empty array
let fruits = ['apple', 'grapes', 'banana', 'orange', 'guava']

let fruits = new Array(); .// not used much
let fruits = new Array("apple", "grapes", "banana", "orange", "guava");

More on Index

An Array is an ordered collection of elements and an element in an array is given a unique position known as an Index, we use this index to access individual elements from the array. The index starts from 0 and goes up the length of the array - 1. The length of the array is the number of elements in the array. let's look at our fruits array let fruits = ['apple', 'grapes', 'banana', 'orange', 'guava'] in this fruits array, there are five elements so the length of the array is 5. So the index of the array of fruits starts from 0 and goes up to 4, apple is at an index of 0, and guava is at the index of 4. Take a look at the below picture you will get a more clear picture of how the index works.

Access Element of an Array Using Index.

We have already learned that we can access an individual element using the index, to access individual elements from an array we use this syntax.

arrayName[index]

Take a look at the example below it will make more sense.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// get first element from the fruits array
console.log(fruits[0]); // first element is always at index 0

// get second element from the fruits array
console.log(fruits[1]);

// get third element from the array
console.log(fruits[2]);

// get last element from the fruits array
console.log(fruits[4]); // not recommended

Getting the Last element of an Array

Getting the last element from an array is the same as getting the element at any other position in an array, take a look at the example below.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// get last element from the fruits array
console.log(fruits[4]); // not recommended

In the above example, you can see that guava at index 4 is the last element from the fruits array and we are able to access it just like any other element on any position, yes but think of a situation when you don't have any idea about the length of the array, you don't know at what index the last element of the array is going to be, this method works only when the array is short. Let's learn about the other method.

Remember I mentioned that the index starts from 0 and goes up to the length of the array -1, so if the length of the array is 10 then the index will start from 0 and will go up to 9, if we can somehow find the length of the array then it will be easy to find the last index of the array.

length of the array:-

lenght of the array is number of elemement in the array. I f there are 5 elements in the array then lenght of the array is 5.

JavaScript comes with inbuilt property to find length of the array, this is the syntax we use to find the lenght of the array.

arrayName.length

this return us the lenght of the array.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

console.log(fruits.length); // output -> 5

Now we know how to find the length of the array so to access the last element of the array we can use fruits.length - 1 it will give us the last index of the array.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// just for example gives us last index of any array
console.log(fruits.length - 1); // output -> 4

// get the last element from the fruits array
console.log(fruits[fruits.length - 1]); // output -> 4

Modifying Element of An Array Using Index.

We can access elements of an array using the index, we can also use the index to modify an array, take a look at the below syntax.

arrayName[index] = "value"

Here are a few more examples.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// Remove banana from index 2 and add Papaya at index 2
fruits[2] = "Papaya"; // this will replace banana with papaya
console.log(fruits); // o/p->[ 'apple', 'grapes', 'Papaya', 'orange', 'guava' ]

let newList = [];

// Add element to the newList

newList[0] = "Pear";
newList[1] = "Strawberry";
newList[2] = "Watermelon";
console.log(newList); // o/p -> [ 'Pear', 'Strawberry', 'Watermelon' ]

Array Methods

JavaScript comes with lots of array methods, we can use this method to make perform different tasks and make our work easy. In this section of the article, we will talk about some of the most used array methods.

push()

push() method is to add one or more elements at the end of the array, it also returns us the new length of the array after adding new elements.

arrayName.push("element") when adding single element

arrayName.push("element","element2") adding multiple element

let fruits = ["apple", "grapes", "banana", "orange", "guava"];
let newArrayLength = fruits.push("Pear"); // this will return new array length 
console.log(fruits); // o/p -> [ 'apple', 'grapes', 'banana', 'orange', 'guava', 'Pear' ]

pop()

pop() method removes the last element from the array and also returns the removed element. We use this method when we want to remove the last element from the array and use the returned element later.

Syntax:

arrayName.pop()

let fruits = ["apple", "grapes", "banana", "orange", "guava"];
let poppedElement = fruits.pop(); // last element removed from the fruits array will be stored in poppedElement Variable
console.log(poppedElement); // o/p -> guava
console.log(fruits); // o/p [ 'apple', 'grapes', 'banana', 'orange' ]

shift()

shift() method removes the first element i.e element at index 0, from the array and returns the removed element.

Syntax:

arrayName.shit()

let fruits = ["apple", "grapes", "banana", "orange", "guava"];
// fruits.shift(); // use this when you don't want to store the removed element
let removedElement = fruits.shift(); // removes the first element from the fruits array and store the removed element
// fruits.shift();
console.log(removedElement); // o/p -> apple i.e first element of fruits array
console.log(fruits); // o/p -> [ 'grapes', 'banana', 'orange', 'guava' ]

unshift()

unshift() method is used to add one or more elements at the start of the array, it also returns the new length of the array after adding the element.

Syntax:

arrayName.unshift("element") // single element

arrayName.unshift("element1","element2") // multilple element

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// Add "Pear" at the start of the array
fruits.unshift("Pear"); // adding one element
console.log(fruits); // o/p -> [ 'Pear', 'apple', 'grapes', 'banana', 'orange', 'guava' ]

// Add "Strawberry" and "Papaya" at the beginning  of the array
fruits.unshift("Strawberry", "Papaya"); // adding multiple element at the beginning of the array
console.log(fruits); // o/p [ 'Strawberry',  'Papaya','Pear', 'apple', 'grapes', 'banana', 'orange', 'guava' ]

// Add "PineApple at the start of the array  and store the new length of the array in  newLength variable"
let newLength = fruits.unshift("PineApple");
console.log(newLength); // o/p ->    9

sort()

sort() method is used to sort the elements of the array. It sorts the strings in alphabetical order and numbers in ascending order. sort() the method doesn't use any extra space or use another array for sorting, it overwrites the original array and returns it.

Syntax:

arrayName.sort()

let fruits = ["apple", "grapes", "banana", "orange", "guava"];
fruits.sort();
console.log(fruits); // o/p -> [ 'apple', 'banana', 'grapes', 'guava', 'orange' ]

let marks = [23, 66, 22, 96.4, 84.3];
// displaying the returned array
console.log(marks.sort()); // o/p -> [ 22, 23, 66, 84.3, 96.4 ]

reverse()

reverse() method is used when we want to reverse the original order of the array. reverse() method also doesn't use any extra space or use another array for sorting, it overwrites the original array and returns it.

Syntax:

arrayName.reverse()

let fruits = ["apple", "grapes", "banana", "orange", "guava"];
fruits.reverse();
console.log(fruits); // o/p -> [ 'guava', 'orange', 'banana', 'grapes', 'apple' ]

let marks = [23, 66, 22, 96.4, 84.3];

// displaying the returned value.
console.log(marks.reverse()); // o/p -> [ 84.3, 96.4, 22, 66, 23 ]

splice()

splice() method is used to remove, replace or add elements to the array. It returns an array of removed items.

Syntax:

arrayName.splice(startIndex,deleteCount, item1, item2, n_item)

startIndex-> The index from where you want to modify the array

deleteCount(optional) -> It is the number of element you want to delete.

item1,item2,n_item(optional) ->Elements you want to add to the start index. if this is not specfied,splice() wll only remove elements from the array.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// Add PineApple at index 1
fruits.splice(1, 0, "PineApple"); // no items is being removed so it will remove empty array.
console.log(removedFruits); // o/p ->[]
console.log(fruits); // o/p -> [ 'apple', 'PineApple', 'grapes', 'banana', 'orange', 'guava' ]

// now our fruits array contains following elements [ 'apple', 'PineApple', 'grapes', 'banana', 'orange', 'guava' ]

// Add 2 Elements "Watermelon" and "Strawberry"  starting at index 2
fruits.splice(2, 0, "Watermelon", "Strawberry");
console.log(fruits);

// Remove all the newly added elements from the array and store the removed element in a variable.
let removedFruits = fruits.splice(1, 3);
console.log(removedFruits); // 0/p -> [ 'PineApple', 'Watermelon', 'Strawberry' ]
console.log(fruits);  // o/p ->[ 'apple', 'grapes', 'banana', 'orange', 'guava' ]

slice()

slice() method is used when we want a copy of an array's portion. It returns a copy of a small portion of the array from the original array without modifying the original array.

Syntax:-

arrayName.slice(startIndex,stopIndex)

startIndex(optional) -> Index from where you want to start the slicing.

stopIndex(optional) -> Index at where you want to stop slicing. Rembember stopIndex is always exclusive element at this index is not included in the returned array.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// get a new array of "grapes", "banana" and "orange"
let newSlicedList = fruits.slice(1, 4); // stop index is 4 instead of 3 because stop index is exclusive.
console.log(newSlicedList); // o/p ->[ 'grapes', 'banana', 'orange' ]
console.log(fruits); // o/p -> [ 'apple', 'grapes', 'banana', 'orange', 'guava' ]

console.log(fruits.slice()); // if no parameter is passed it slice the array from start to end

concat()

concat() method is used to join two or more arrays or values. It does not modify the original array instead it returns a new array with the values from both the array.

Syntax:

arrayName.concat(array/value,array/value)

array/value: can be a single value or an array.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];
let anotherFruitsArray = ["PineApple", "Watermelon", "Strawberry"];

// create a new array which has all the elements from both the array.
let newJoinedArray = fruits.concat(anotherFruitsArray);
console.log(newJoinedArray); // ["apple","grapes", "banana", "orange","guava", "PineApple","Watermelon","Strawberry",];

join()

join() method returns a new string by concatenating all of the elements of an array, separated by a comma or by the specified separator.

Syntax:

arrayName.join(seprator)

seprator(optional) :- optional seprator string

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

console.log(fruits.join()); // apple,grapes,banana,orange,guava
console.log(fruits.join("-")); // apple-grapes-banana-orange-guava

includes()

includes() method is used to check whether an element is in the array or not. It returns true if the element is in the array else it returns false.

Syntax:

arrayName.includes(element)

element :- element you want to check for

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// check if grapes is in the fruits array
console.log(fruits.includes("grapes")); // o/p-> true

// check if "PineApple" in in the fruits array
console.log(fruits.includes("PineApple")); // o/p -> false

fill()

fill() method fills the array with the specified value and returns the new modified array. It modifies the original array.

Syntax:-

arrayName.fill(value,startIndex,stopIndex)

value -> value you want to fill with

startIndex(optional) -> strarting index from where you want to start filling the value. The default value for this is 0.

stopIndex(optional) -> index where you want to stop the filling.rembember stopIndex is always exclusive. the default value for this is the length of the array.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// fill "PineApple" from index 1 to index 3
let returnedArray = fruits.fill("PineApple", 1, 4);
console.log(returnedArray); // [ 'apple', 'PineApple', 'PineApple', 'PineApple', 'guava' ]
console.log(fruits); //[ 'apple', 'PineApple', 'PineApple', 'PineApple', 'guava' ]

// fill fruits array with "Watermelon"
let returnedArray2 = fruits.fill("Watermelon");
console.log(returnedArray); // ["Watermelon", "Watermelon", "Watermelon", "Watermelon", "Watermelon"];
console.log(fruits); // ["Watermelon", "Watermelon", "Watermelon", "Watermelon", "Watermelon"];

indexOf()

indexOf method returns the index of the given element, if there are duplicate elements in the array then it returns the index of elements that occur first and if the element is not present in the array then it returns -1.

Syntax:-

arrayName.indexOf(element)

let fruits = ["apple", "grapes", "banana", "orange", "guava", "apple"];
// find the index of "grapes"
console.log(fruits.indexOf("grapes")); // 1

// find the index of "apple"

// apple can be found at index 0 and at index 5, but this method only return index of element which occur first.
console.log(fruits.indexOf("apple")); // 0

// find the index of "PineApple"
console.log(fruits.indexOf("PineApple")); // -1 because "PineApple is not present in the array."

isArray()

isArray() method checks if the object is an array. We know that everything in JavaScript is an object. If the object is an array then it returns true and if not then it returns false.

Syntax:-

Array.isArray(arrayName)

let fruits = ["apple", "grapes", "banana", "orange", "guava", "apple"];

console.log(Array.isArray(fruits)); // true

keys()

The keys() method returns an Array Iterator object that contains the keys for each index in the array.

Syntax:-

arrayName.keys()

let fruits = ["apple", "grapes", "banana", "orange", "guava", "apple"];

let KeyIterator = fruits.keys();

for (let key of iterator) {
  console.log(key);
}

// output
/*
0
1
2
3
4
5
*/

values()

The values() method creates a new iterator object that allows you to access the values of each index in the array. This iterator can be used to iterate through the values of the array in a loop.

Syntax :-

arrayName.values()

let fruits = ["apple", "grapes", "banana", "orange", "guava", "apple"];

let valueIterator = fruits.values();

for (let value of valueIterator) {
  console.log(value);
}

// Output
/*
apple
grapes
banana
orange
guava
apple
*/

Not the End ^😒

That's it, for now, there are many more array methods that are left to cover in this article, I will be updating this article as I learn and explore more. Write your feedback in the comment section.

Why JavaScript?

As I have already mentioned that JavaScript is one of the most popular programming languages. In today's internet, almost more than 90% of website uses JavaScript, so there are always requirements for JavaScript Developers. In the early days, JavaScript was used on the client-side only but with help of runtime environments like node we can now run JavaScript also on the server-side.

• client-side:code is downloaded as plain text and is executed on the user's computer only.

• server-side: code is executed on the server, and only results are downloaded and displayed on the screen.

Now JavaScript has evolved so much that with help of JavaScript only you can develop webpages, Single Page Applications, mobile apps, desktop apps, backend applications, Game development and even now you can do machine learning with JavaScript, you can say that possibilities are endless.

A pinch of history.

During the browser war between Microsoft (Internet Explorer) and Netscape (Netscape Navigator). In 1995 Netscape's engineer named Brendan Eich developed a new lightweight scripting language called Mocha , and later it was renamed to JavaScript. Soon after that in 1996 Microsoft also developed its own version of JavaScript and this brought compatibility issues to the website. To develop JavaScript, Netscape and Brendan Eich took it to the ECMA international standards organization in 1996. In 1997 the language specification called ECMAScript as a ECMA-262 standard was published. This specification could be used by other browser vendors to prepare their implementations.

Getting Started

Now, let's get started and write our first program in JavaScript, but where, we can run JavaScript directly in the browser console but we are not going to do that. For executing the JavaScript code we are going to use nodejs which is a runtime environment based on the chrome v8 engine, we will learn about the runtime environment and engine later and for writing the codes we are going to use vs code. Download these tools from their official website and install them in your system.

Hello World

Create a directory and open that directory in vs code, and create a new file in that directory hello.js notice the .js extension all JavaScript code files have .js extension. Write the following line in that file.

console.log("Hello World!"); 
// console.log is used to dislplay message in the console

Open vs code inbuilt terminal by pressing cltl + ` together, and writenode hello.js and press enter. This will display Hello World! message in your terminal. That's it we have written our first program in JavaScript. In the next article, we are going to learn about the values we can use in JavaScript.

It is a way of applying styles or running other code based on specific characteristics, features, and browser preferences. It allows us to conditionally use styles based on different media types like print, screen etc. media queries are mostly used to apply styles based on the viewport so that web developers can develop responsive websites across different screen sizes. In this article, we are going to discuss the same.

Syntax

@media

Media queries use the @media rule to apply different styles to different types of media and devices based on the type of media.

screen

the screen is the media type we are using here, it matches devices with a screen, and we can also use different media types like print to the printer.

and

The media query supports logical operators, which enable us to match media types based on certain conditions.

max-width

max-width is the media feature we are defining here, and we can apply some styles when the features match. The max-width specifies a width less or equal to the specified width. All the styles will apply when the width is less than the specified width.

min-width

This is another media feature we can define instead of max-width, min-width specifies a width greater or equal to the specified width. All the styles will apply when the width is greater than the specified width.

Example 1 min-width

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Media Queries</title>
  </head>
  <style>
    @media screen and (min-width: 768px) {
      body {
        background-color: #3944f7;
      }
      h1 {
        font-size: 50px;
      }
    }
  </style>
  <body>
    <h1>Media Queries</h1>
  </body>
</html>

Notice that in the above gif when I increase the window size to greater than 768 px our styles get applied, the background color changes, and the font size of the heading becomes 50px. Try running the code on your system and check the output.

Example 2 max-width

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Media Queries</title>
  </head>
  <style>
    @media screen and (max-width: 768px) {
      body {
        background-color: #3944f7;
      }
      h1 {
        font-size: 50px;
      }
    }
  </style>
  <body>
    <h1>Media Queries</h1>
  </body>
</html>

Notice that in the above example styles only apply when the window width is less than and or equal to 768px.

Using and operator

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Media Queries</title>
  </head>
  <style>
    @media screen and (min-width: 768px) and (max-width: 1200px) {
      body {
        background-color: #3944f7;
      }
      h1 {
        font-size: 50px;
      }
    }
  </style>
  <body>
    <h1>Media Queries</h1>
  </body>
</html>

Notice in the above example that styles only apply when the window width is greater than or equal to 768px and less than or equal to 1200px.

Using print media-type

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Media Queries</title>
  </head>
  <style>
    body {
      background-color: #3944f7;
    }
    h1 {
      font-size: 100px;
      color: #b4161b;
    }
    @media print {
      body {
        background-color: #ffffff;
      }
      h1 {
        font-size: 20px;
        color: #000000;
      }
    }
  </style>
  <body>
    <h1>Media Queries</h1>
  </body>
</html>

The print media type matches the document type viewed in the print preview

webpage with normal styles

styles applied on print preview

CSS Flexbox allows items to be laid out in a single dimension. With Flexbox's properties, we can control the dimensions, spaces, and positions of items. Flexbox is used for designing the one-dimensional layout, at a time you can either design your layout in columns or rows. Everything in flexbox depends on these two terms main axis and cross-axis they are perpendicular to each other. The main axis is determined by the flex-direction property.

Flexbox works with the concept of containers and items, every element which is to be layout needs to be inside a container, this container is known as a flex container and the element is known as a flex-items. Let’s try to understand this with an example.

This is the HTML file we are going to use for this article, in this HTML document we have a div element with the class as container and it has five div child elements.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Positioning</title>
  </head>
  <style>
    .container {
      width: 90vw;
      height: 80vh;
      border: 2px solid #242b2e;
      padding: 10px;

      /* changes below this*/
    }
    .box {
      background-color: #242b2e;
      height: 100px;
      width: 100px;
            margin: 10px;
      font-size: 40px;
      text-align: center;
      color: #ffffff;
    }
  </style>
  <body>
    <div class="container">
      <div class="box box-1">1</div>
      <div class="box box-2">2</div>
      <div class="box box-3">3</div>
      <div class="box box-4">4</div>
      <div class="box box-5">5</div>
    </div>
  </body>
</html>

As you can see all five boxes are stacked one after another, let’s add display: flex to the container.

.container {
      width: 600px;
      height: 500px;
      border: 2px solid #242b2e;
      padding: 10px;

      /* changes below this*/
      display: flex;
    }
    .box {
      background-color: #242b2e;
      height: 100px;
      width: 100px;
      margin: 10px;
      font-size: 40px;
      text-align: center;
      color: #ffffff;
    }

Adding display: flex to the container element will define it as a flex container and all the flex items will be layout according to their main axis depending on the flex-direction by default the flex: direction is set to row so horizontal is our main axis, so the item will layout in a row. Now let’s change the flex-direction to a column and see the changes.

.container {
      width: 600px;
      height: 500px;
      border: 2px solid #242b2e;
      padding: 10px;

      /* changes below this*/
      display: flex;
      flex-direction: column;
    }
    .box {
      background-color: #242b2e;
      height: 100px;
      width: 100px;
      margin: 10px;
      font-size: 40px;
      text-align: center;
      color: #ffffff;
    }

As you can see when we change the flex-direction to the column, the column becomes the main axis and the horizontal becomes the cross axis.

Flex direction

The flex-direction property is used to establish the main axis. flex-direction takes 4 values row column row-reverse and column-reverse. On webpages, the default value of `flex-direction is set to row.

flex-direction: column

This property set’s the column as the main axis, so items are arranged from top to bottom.

flex-direction:row-reverse

This property reverses the items from left to right to right to left and moves the element toward the end of the container.

flex-direction: column-reverse

This property reverses the items from top to bottom to bottom to top and moves the item toward the end of the container.

flex-wrap

Flexbox is a one-dimensional layout system, so by default, all the items will try to fit in one line, but we can allow items to wrap and move to the next line, just like word wrap in vs code. We can pass three values to flex-wrap nowrap wrap wrap-reverse By default, flex-wrap is set to no-wrap flex-wrap: nowrap.

flex-wrap: wrap

When we change the size of the container items move to the next line.

flex-wrap:wrap-reverse

Applying wrap-reverse will wrap items to the next line but from bottom to top.

justify-content

justify-content is used to align the items along the main axis. This is generally used to distribute the space between the items. justify-content takes many values but we are going to discuss the values that are used most.

justify-content: center

the justify-content center is used to move the items to the center of the main axis.

justify-content: flex-start

This is used to move the items to the start of the main axis. This is also the default value.

justify-content: flex-end

This property is used to move the items to the end of the main axis.

justify-content:space-between

This property moves the first item to the start of the main axis and the last item to the last of the main axis and leftover space is event distributed between the items.

justify-content: space-around

This property is used to evenly distributes the items, with equal space around them.

justify-content: space-evenly

This property is used to distribute equal space around the items.

align-items

align-items is used to control the alignment of items along the cross-axis. align-items takes the following values flex-start flex-end center stretch baseline.

align-items: center

This property is used to align items to the center along the cross-axis.

align-items: flex-start

This property is used to align and move the items to the start of the container along the cross-axis.

align-items: flex-end

This property is used to align and move the items to the end of the container along the cross-axis.

align-items:stretch

This property is used to stretch and fill the items along the cross-axis.

align-content

align-content is very similar to justify-content property. This is also used to distribute the space between the items but along the cross-axis. align-content takes the following values. flex-start flex-end center stretch space-between and space-around

Now let’s discuss some properties which can be applied only to the items themselves.

order

order property is used to control the order of the items. By default, all the flex items have an order value of 0. The order of items is controlled by the order property.

.container {
      width: 50%;
      height: 500px;
      border: 2px solid #242b2e;
      padding: 10px;

      /* changes below this*/
      display: flex;
    }
    .box {
      background-color: #242b2e;
      height: 100px;
      width: 100px;
      margin: 10px;
      font-size: 40px;
      text-align: center;
      color: #ffffff;
    }

    .box-1 {
      order: 3;
    }
    .box-4 {
      order: -1;
    }

flex-grow

It specifies the amount by which an item will grow relative to the rest of the flexible items in the same container.

Conclusion

The article only discusses the most commonly used flexbox properties. If you want to learn more about flexbox, CSS Tricks has a great article on it. That's all for this article, let me know what you think in the comments.