Forem: Md Abdur Razzak

Loops in JavaScript !!📚🔄

Md Abdur Razzak — Sat, 10 Aug 2024 15:50:09 +0000

What is Loop in JavaScript ?

Ans: Basically loop use for do repeatedly run a block of code - until a certain condition is met.

Types of Loops

For Loop

When to Use: When you know how many times you want to repeat something.
How It Works: You start with a counter, repeat code as long as the counter is less than a limit, and update the counter each time.
Example:

while Loop

When To use: When you don't know exactly how many times you need to repeat something, but you have a condition to check
*How It Works: *

The condition is checked.
If the condition is true, the code inside the loop is executed.
The condition is checked again.
Steps 2 and 3 repeat until the condition becomes false.

Example:

Do-While Loop

When To use: Similar to a while loop, but the code inside the loop always runs at least once.
*How It Works: *

The code inside the do block is executed once before any condition is checked.
After executing the code block, the while condition is evaluated.
If the condition evaluates to true, the loop executes the code block again. If the condition evaluates to false, the loop terminates, and the program continues with the code that follows the loop.

Example:

For In Loop

When To use: The for...in loop helps you go through each item in an object or an array. It’s like checking each item one by one.
*How It Works: *

The loop starts by creating a variable (often called key) to store the current property name.
The loop checks if the current property exists in the object.
If the property exists, the code inside the loop is executed.
The loop moves to the next property.

Example:

For of Loop

When To use: When you want to loop through values of an array or other iterable.
*How It Works: *

The loop creates a variable to hold the current value.
The loop iterates over each value in the iterable object.
The current value is assigned to the variable.

Example:

Note: If you Know more please share.

Mail: mdabdurrazzakrakib290@gamil.com

JavaScript Functions — Understanding The Basics

Md Abdur Razzak — Mon, 11 Mar 2024 06:28:45 +0000

What is a Function?

A function is a subprogram designed to perform a particular task.
When a function is called, it gets run. We refer to this as calling a function.
Functions can take values as inputs and use them internally.
Functions yield values in all cases. In JavaScript, a function will return undefined if no return value is supplied.
Functions are objects.

Define a Function.
There are a few different ways to define a function in JavaScript:

A named function is defined by a function declaration. The function keyword and the function name are used to generate a function declaration. The function definition is hoisted when function declarations are used, enabling the function to be used prior to definition.

`function name(parameters){
 statements
}`

A named or anonymous function is defined by a function expression. A function without a name is known as an anonymous function. Function expressions cannot be used before they are defined because they are not hoisted. We are assigning a variable value to the anonymous function object in the example below.

`let name = function(parameters){
 statements
}`

A function expression can be written using a simpler syntax called an Arrow Function Expression. This value is not created by arrow functions on its own.

`let name = (parameters) => {
 statements
}`

Parameters vs. Arguments.

If you’re new to JavaScript, you may have heard the terms parameters and arguments used interchangeably. While very similar, there is an important distinction to make between these two keywords.

Parameters are used when defining a function, they are the names created in the function definition. In fact, during a function definition, we can pass in up to 255 parameters! Parameters are separated by commas in the (). Here’s an example with two parameters — param1 & param2:

`const param1 = true;
const param2 = false;
function twoParams(param1, param2){
 console.log(param1, param2);
}`

Contrarily, arguments are the values that each parameter provides to the function during its execution, or when it is called. Our two arguments in the example above are both true and false.

Invoking a Function.

When a function is invoked, it begins to operate. We call this process "invocation." A function can be called by referring to its name, which is followed by an open and closed parenthesis: ().

Let's explore an example.

If you’re using Google Chrome, open up your dev console so you can code along with these examples: [WINDOWS]: Ctrl + Shift + J [MAC]: Cmd + Opt + J

Let's start by defining a function called logIt. The only input required for this function is the name. The function will log that name back to the console when it is executed:

`unction logIt(name){
 console.log(name);
}`

We call our function and pass in the single parameter to make it run. I am referring to this function as Md. Abdur Razzak here:

logIt('Md Abdur Razzak');

You can call your function with an empty set of parenthesis if it doesn't have any parameters:

`function logIt2(){
 console.log('The second one);
}
logIt2();
// The second one`
)

Function Return.

Every function in JavaScript returns undefined unless otherwise specified.

Let’s test this by creating and invoking an empty function:

`function test(){};
test();
// undefined`

Awesome, as expected, undefined is returned.

Now, we can customize what is returned in our function by using the _return _keyword followed by our return value. Take a look at the code below:

`function test(){
 return true;
};
test();
// true`

In this example, we explicitly tell the function to return true. When we invoke the function, that’s exactly what happens.

But why is this important?
It’s important because the value that a function returns, is actually returned to the caller of the function. Take a look at this code:

`let double = function(num) {
  return num * 2;
}`

This is a function expression that creates a function that will return two times the value of our input parameter num. We can then invoke the function and save the return value to a variable:

let test = double(3);
When we log out our test value, we get 6:

console.log(test);
// 6

Awesome! The _return _variable not only returns values from a function, but it assigns them to whatever is called the function!

Another important rule of the return statement is that it stops function execution immediately.

Consider this example where we have two return statements in our test function:

`function test(){
 return true;
 return false;
};
test();
// true`

Our function is immediately stopped from running by the initial return statement, which also makes our function return true. Line three's code, return false; is never run.

Function Objects.

Functions are function objects. In JavaScript, anything that is not a primitive type ( undefined, null, boolean, number, or string) is an object. Objects in JavaScript are extremely versatile. Because of this, we can even pass a function as a parameter into another function.

When a function accepts another function as a parameter or returns a function, it is called a higher-order function. You’ve probably already used a bunch of higher-order functions and don’t even know it: Array. prototype.map and Array.prototype.filter are higher-order functions (Just to name a couple). You can check out some of my previous articles to learn more about objects and higher-order functions in JavaScript

Key Takeaways.
This is a lot of information to digest. Here’s a list of the important stuff:

A function is a portion of a software created to carry out a specific activity.
Expressions are not hoisted; function declarations are.
When a function is called, it gets run. We refer to this as calling a function.
Functions can take values as inputs and use them internally. A parameter is the name given to the value. An argument is the actual value by itself.
Functions invariably yield a value. In JavaScript, a function will return undefined by default if no return value is supplied.
Objects are functions.

What is hoisting in javaScript?

Md Abdur Razzak — Fri, 12 Jan 2024 13:24:04 +0000

Hoisting Basically when we run JavaScript code than it's do every global variable and function go in the top. its called hoisting.
*Variable hoisting: *

console.log(x); // undefined
var x = 5;
console.log(x); // 5

*Functional Hoisting: *
sayHello();

function sayHello() {
console.log("Hello, World!");
}
Note:
var and let/const declarations. let and const are block-scoped and are hoisted but not initialized until their actual declaration in the code, resulting in a "temporal dead zone" if you try to access them before the declaration.

Like
console.log(a);
let a = 10;

Show This error: VM156:1 Uncaught ReferenceError: a is not defined at :1:13