JavaScript control flow statements help you manage the sequence in which code executes. They include conditional statemets loops, and exception handling. Here’s a comprehensive breakdown of each type with examples.

1. if statement: Use the if statement to specify a block of code to be executed if a condition is true. if statement is used to execute code based on a condition. If the specified condition evaluates to true, the code inside the if block runs. If it’s false, the code is skipped.

let age = 23;

if (age >= 18) {
    console.log("You are an adult.");  
}
//you are an adult

2. else if: Use else statements to specify a block of code is executed the wrong statement. In else if is used to handle multiple conditions in an if statement. It allows you to check additional conditions if the previous if or else if condition was false and evaluate them one by one until a true condition is found, at which point the corresponding block of code runs.

let age = 10;

if (age >= 7) {
    console.log("You can have the candy");  //if true condition pass then it will go it true statment
}
else{
console.log("Sorry you are too adult");
}   
//You can have the candy

3. if_else if_else: The if...else if...else structure is used to control the flow of code by evaluating multiple conditions in a sequence, and the structure allows the program to choose different paths based on different conditions, and else if uses for multiple conditions only.

let num = -2;

if (num > 0) {
  console.log("Positive");
} else if (num < 0) {
  console.log("Negative");
} else {
  console.log("Zero"); 
}
// Negative

4. Nested if-else: In nested if...else structure, one if...else statement is placed inside another if or else block.

let age = 23;

if(age >= 18){
    console.log("You are an adult");
    if (age >= 21) {
        console.log("You are eligible for job")
    }
    else{
        console.log("You are not eligivle for job")
    }
}
else{
    console.log("You are a minor");
}
//You are an adult
//You are eligible for job

In JavaScript, implicit and explicit refer to different ways in which certain behaviors, especially type conversions, can occur within your code. These terms are commonly used when discussing type coercion, function calls, and code clarity.

List of DataType that can convert

1. String => Number, Boolean, null, undefined
2. Number => String, Boolean, null, undefiend
3. Boolean => String, Number, null, undefiend
4. null => String, Number, Boolean, undefiend
5. undefined => String, Number, Boolean, undefiend

1.1 Any Datatype to String (using + operator)

let marks = 2 + "3";
console.log(marks,typeof marks);  //23 string

marks = '3' + true;
console.log(marks,typeof marks);  //3true string

marks = '3' + undefined
console.log(marks,typeof marks);  //3undefined string

marks = "5" + null;
console.log(marks,typeof marks);  //5null string

marks = false + "10";
console.log(marks, typeof marks);  //false10 string

let number = 5 + "5";
console.log(number,typeof number); //55 string

let numbers = "7" + 8;
console.log(numbers,typeof number); //78 string

2.1 Any datatype to a number (-, /, *)

let results;
results = "4" -2;                //2 number
results = "4" + "4";  44 string
results = 4 + 6;                //10 numbers
results = "0" - "1";            //-1 number
results = "hello" - "hii";      //NaN number
results = "5" * 3;              //15 number
results = "5" - "hi";          //NaN number
results = "5" - true;          // true is 1 and false is 2 
console.log(results, typeof results);

3.1 Any Datatype of Boolean

let check;
 check = "5" + true;     //5true
 check = "10" - false;  //10
 check = 4 - true;      //3
console.log(check)

4.1 Any Datatype to Null

 // null = 0

 let test;
 test = 4 - null;   //4 number
 test = 4 + null;   //4 number
 console.log(test, typeof test);

5.1 Any Datatype to Undefined

 let final;

 final = undefined + "Test";    //undefinedTest string
 final = 4 - "0";               //4 number
 console.log(final, typeof final);

Explicit conversion :

In JavaScript, explicit conversions mean changing a value from one type to another on purpose, using specific functions. This way, you control the conversion and avoid any surprises caused by JavaScript’s automatic type changes.

1. Convert to Number: Change something into a number.

let results;
results = Number("60");         // 60 number
results = Number("hello");      //NaN number
results = Number(true);         //NaN number
results = Number(null);         //0 number
results = Number(undefined);    //NaN number

console.log(results,typeof results);

2. Convert to String: Change something into text.

let results;
results = String(60);       //60 String
results = String("hello");  //hello string
results = String(false);    //false string
results = String('80');     //80 string
results = String(null);     //null string
console.log(results,typeof results);

3. Convert to Boolean: Change something into true or false.

let results;
results = Boolean("");       //false boolean
results = Boolean(" ");      //true boolean
results = Boolean('hello');  // true booean
results = Boolean(true);     // true boolean
results = Boolean('20');     // true boolean
results = Boolean(null);     //false boolean
console.log(results,typeof results);

1. Logical Operators : They are used to determine the logic between variables or values. Given that x = 6 and y = 3, the table below explain the logical operator.

let a = true;
let b = false;

console.log(a && b);  // false
console.log(a || b);  // true
console.log(!a);      // false 

2. Bitwise Operators: A bitwise operator in programming is used to perform operations on the binary (0s and 1s) representation of numbers. Instead of dealing with whole numbers directly, bitwise operators manipulate the individual bits (binary digits) within the numbers.

2.1 AND (&): Compares each bit of two numbers and returns 1 only if both bits are 1; otherwise, it returns 0.
2.2 OR (|): Compares each bit and returns 1 if either bit is 1; otherwise, it returns 0.
2.3 XOR (^): Compares each bit and returns 1 if only one of the bits is 1; otherwise, it returns 0.

console.log(5 & 1); //1
console.log(5 | 1); //5
console.log(5 ^ 1); //4

3. Ternary Operator : The ternary operator in JavaScript provides a shorthand way of writing an if-else statement in a single line. It’s represented by the ? and : symbols and takes form

let exam = 60;
let result = exam >= 100 ? "You are qualified." : "Better luck next time."
console.log(result) //Better luck next time

Here are step that how its works:

condition — an expression that is evaluated as true or false.
expressionIfTrue— the code that runs if the condition is true.
expressionIfFalse—the code that runs if the condition is false.

4. typeof: Check or manipulate the type of a variable

console.log(typeof "hello"); //string
console.log(typeof 35);  //number
console.log(typeof true); //boolean
console.log(typeof false); //boolean

console.log(typeof {}); //object
console.log(typeof []); //object // array is also an object
console.log(typeof null) // object
//! there was a bug in javascript which says typeof array and null is an oblects

Note: by default in a javascript array, and objects of the data type are objects. The bug was null is an object.

5. Strings: string operators are primarily used to work with and manipulate strings.

let fname = "Suhail";
let lname = "Roushan";
console.log(fname + lname); //SuhailRoushan
----------------------------------------------------
let name = "Syed" + " " + " samid";
console.log(name);  // Syed samid

1. Arithmetic Operators:

These operators perform basic mathematical operations

1. Addition (+): Adds two values.

let result = 5 + 3; // 8

Subtraction (-): Subtracts one value from another.

let result = 5 - 3; // 2

Multiplication (*): Multiplies two values.

let result = 5 * 3; // 15

Division (/): Divides one value by another.

let result = 6 / 3; // 2

Modulus (%): Finds the remainder of division

let result = 7 % 3; // 1

Exponentiation (**): Raises a value to the power of another

let result = 2 ** 3; // 8

2. Assignment Operators:

1. Initial Assignment: Here, we assign the value 10 to x and log it. So, x is initially 10.

let x = 10;
console.log(x); // 10

2. Addition Assignment (+=): x = x + 5
We have added 5 to the current value of x, which is 10, so x will be 15.

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

3. Subtraction Assignment (-=): x = x—3.
We subtract 3 from the current value of x (which is 15), so x will be 12.

x -= 3;
console.log(x); // 12

4. Multiplication Assignment (*=): x = x * 2.
We multiply the current value of x (which is 12) by 2, so x will be 24.

x *= 2;
console.log(x); // 24

5. Division Assignment (/=): x = x / 4.
We divide the current value of x (which is 24) by 4, so x will be 6.

x /= 4;
console.log(x); // 6

6. Modulus Assignment (%=): x = x % 2.
We take the remainder when the current value of x (which is 6) is divided by 2. Since 6 is evenly divisible by 2, the remainder is 0, so x will be 0.

x %= 2;
console.log(x); // 0

x %= 2;
console.log(x)

Objects:

1. An object is a collection of key-value pairs, where each key (also called a “property”) has a corresponding value.
2. Objects are ideal for storing related data and more complex structures.
3. Each key is unique and is usually a string, though ES6 symbols can also be used.
4. Object syntax is enclosed in curly braces {person} with key-value pairs inside, separated by commas.
5. Objects are unordered and store data in key-value pairs, which are ideal for descriptive or structured data.

Here is an example of an objects…

let myAmazonUser = {
    firstName: "syed samid",
    phone: "898384794",
    age: "23",
    address: 'hydreadbad',
    gender: "Male",
    active: true,
    cart: null,
    totalShopping: ["iphone", "samsung"],
};

This will update the data into main object.

myAmazonUser.active = false;
console.log(myAmazonUser)

myAmazonUser.gender = "female";
console.log(myAmazonUser);

This will add value to object.

myAmazonUser.id ="AMZ89887";
console.log(myAmazonUser);

To delete a particular key.

delete myAmazonUser.cart;
console.log(myAmazonUser);

Array:

1. An array is an ordered list of values. This values can be of any type, and an array can store multiple types at once.
2. Arrays are commonly used to store collections of data, especially when the data items share a similar nature.
3. Each element in an array has a unique index, starting from 0.
4. Array syntax is enclosed in square brackets [], with elements separated by commas.
5. Arrays are ordered lists, where each element is accessed by its index, making them better for ordered data or lists of items.

Example:

let number = [1, 2, 3, 4, 5];
// let mixedArray = [1, "Hello", true, {id : 1}, [10, 20]];             
console.log(number,mixedArray)
 console.log(number[3]);
 console.log(mixedArray[4][0]);

output:
[ 1, 2, 3, 4, 5 ] [ 1, 'Hello', true, { id: 1 }, [ 10, 20 ] ]
4
10

Adding or Removing Elements

1. push(): It add an element to the end of the array.

let arr = [1, 2];
arr.push(3); // arr is now [1, 2, 3]

2. pop(): Removes the last element from the array.

let arr = [1, 2, 3];
arr.pop(); // arr is now [1, 2]

3. unshift( ): It will add an element to the beginning of the array.

let arr = [2, 3];
arr.unshift(1); // arr is now [1, 2, 3]

4. shift(): It will Removes the first element from the array.

let arr = [1, 2, 3];
arr.shift(); // arr is now [2, 3]

In JavaScript, data types are broadly categorized into two categories — primitive types and non-primitive types.

Primitive data types are basic data types that represent a single value, whereas non-primitive data types are complex data types that represent a collection of values.

Primitive data types are further classified into 6 types:

1. Numbers
2. String
3. Boolean
4. Undefined
5. Null

Number: The number data type represents numerical values, which can be integers, decimals or floating-point numbers. Numbers can be manipulated using various mathematical operations.

let num = 10;
let pi = 3.14;

String: A string is a sequence of characters enclosed in single or double quotes. It represents text values and can be manipulated using various string methods.

let name = 'Hello World';
console.log(name);

Boolean: A boolean represents a logical entity that can have only two values — true or false. Booleans are often used for conditional testing and are typically the result of a comparison operation.

let isTrue = true;
let isFalse = false;

Undefined: When a variable is declared but not assigned a value, its value is undefined. Undefined is also a data type in JavaScript that represents the absence of a value.

let x;
console.log(x); // Output: undefined

Null: The null data type represents the intentional absence of any object value. It is often used to signify that a variable has no value assigned to variables.

Conclusion: In JavaScript’s primitive data types are essential, providing the basis for all data handling in the language. Their immutability, storage-by-value behavior, and unique characteristics shape how JavaScript operates and interacts with data, making a strong understanding of primitives foundational for JavaScript development.

1. let: The let keyword in JavaScript is a modern way to declare variables, introduced with ES6 (ECMAScript 2015). It addresses some of the issues associated with the older var keyword, such as scoping behavior and redeclaration quirks.

eg: Redeclare: You can’t redeclare a let variable within the same scope. Attempting to do so will result in an error.

let name = "samid";
let name = "syed"; // Error: Identifier 'name' has already been declared
console.log(name);

e.g., Reassign: While let doesn’t allow redeclaration, it does allow reassignment of values within its scope.

let age = 25;
age = 26; // This is allowed
console.log(age); // Output: 26

2. var: The var keyword in JavaScript is the original way to declare variables. While still used, it’s generally recommended to use let and const for new JavaScript code, as var has some quirks that can lead to unintended behavior.

e.g., Redeclare: Variables declared with var can be redeclared within the same scope without any error

var name= 5;
var name= 10;

var z = x + y;
console.log(z); //15

eg: Reassign: This can sometimes lead to accidental overwrites if a variable name is used multiple times.

var name = "syed";
var name = "samid"; // Allowed: name is redeclared with "samid"
console.log(name); // Output: samid

3. const: The const keyword in JavaScript is used to declare variables that are meant to remain constant, meaning their values cannot be reassigned after they are set.

eg: Redeclare: Variables declared with const cannot be redeclared in the same scope, and they cannot be reassigned to a new value after their initial assignment.

const a = 10;
const a = 20;

console.log(a);

eg: Reassigne: This is because const prevents reassignment of the variable itself but does not prevent modifications to the data the variable points to

const a = 10;
a = 20;
console.log(a)

When to use let and when to use const:

Feature:          let                                     const

Reassignment:     Allowed                                 Not allowed
        
Scope:            Block-scoped                            Block-scoped

Best Use Case    Variables that need to change            Immutable or Reference Values

Conclusion: Understanding when to use var, let, or const can save you from unexpected behavior in your code. As a rule of thumb, lean towards const and let, and reserve var for legacy code if necessary.

History of javascript

javaScript also known as ECMA script, was created by Brendan Eich while working at Netscape Communication. Originally named ‘Mocha,’ it was quickly renamed ‘LiveScript’ and eventually to ‘JavaScript’ to capitalize on Java’s popularity. Despite the name, JavaScript is distinct from Java, with a syntax loosely based on C, but it’s a lightweight, dynamically-typed scripting language designed to make web pages interactive.

In the mid-1990s, JavaScript was gaining traction as a popular language for web interactivity, but differences in implementations were creating challenges for developers. Netscape (the original creator of JavaScript) and Microsoft (which created its own version called JScript) worked with the European Computer Manufacturers Association (ECMA) to standardize the language, creating ECMAScript 1 (ES1) in 1997. This standard defines core syntax, functions, and language structure.

Versions of ESL was launched in 1997, they are:
ES5 : 2009
ES6 : 2015 (Biggest Update of JS in History)
ES7 : 2016
ES8 : 2017w

ECMAScript’s is predominantly used for making web pages interactive, such as form validation and animations, but known as ECMA Scrip is also used in other areas. Such as server-side development, mobile app developers, and many more. Desktop app development. Because of its wide range of applicaitions you can run JavaScript in several ways

The JavaScript Engine and Runtime

JavaScript Engines: A JavaScript engine is a program that executes JavaScript code. Examples include Google Chrome’s V8, Firefox’s SpiderMonkey, and Microsoft’s Chakra. These engines convert JavaScript into optimized machine code, allowing high performance.
Runtime Environments: JavaScript’s primary runtime environment is the web browser, where engines interpret JavaScript code. Node.js provides an additional runtime, allowing JavaScript to run on servers and interact with the file system, network, and databases.

History of NodeJS

Node.js is an open-source, cross-platform runtime environment that enables JavaScript to be used on the server side. It is a free, open source, cross-platform javascript runtime environment that lets developers write command line tools and server-side script outside of the browsers

The latest version of Node is v23.1.0 (current)

LTS is v20.18.0

Developed by Ryan Dahl in 2009, Node.js has grown into one of the most popular tools for backend development. It’s built on Google Chrome’s V8 JavaScript engine, which compiles JavaScript directly into machine code, allowing Node.js to deliver high performance.

NPM (Node Package Manager):

Node.js comes with NPM, the largest software registry globally, which hosts over a million packages. These packages provide pre-built solutions for various functionalities, such as database connection, authentication, and file handling, significantly speeding up development.

Cross-platform compatibility:

Node.js can run on major operating systems, including Windows, macOS, and Linux. Additionally, Node.js applications can be developed on one platform and deployed on another with minimal adjustments.

If you’ve ever delved into the world of computer science or digital electronics, you’ve probably come across the terms “1’s complement” and “2’s complement.” These terms may sound intimidating, but they are essential concepts used in representing signed numbers in binary systems. In this blog, we’ll break down these concepts, explain how they work, and why they matter.

1. 1’s complement

The binary numbers can be easily converted into the 1’s complement with the help of a simple algorithm. According to this algorithm, if we toggle or invert all bits of a binary number, the generated binary number will become the 1’s complement of that binary number. That means we have to transform 1 bit into the 0 bit and 0 bit into the 1 bit in the 1’s complement. N’ is used to indicate the 1’s complement of a number.
Example: Here, we will assume that the number is stored with the help of 4 bits.

Let numbers be stored using 4 bits

2's complement of 7 (0111) is 9 (1001)
2's complement of 12 (1100) is 4 (0100) 

2. 2’s complement

Understanding 2’s complement after understanding unsigned binary representation is very easy. 2’s complement is just a method to represent negative numbers in addition to positive numbers.

2's complement of "0111" is "1001"
2's complement of "1100" is "0100" 

In 2’s complement representation, we look at the first digit of the binary number to determine if it is positive or negative. If the number is position, the number will start with 0. If the number is negative, the number will start with 1.

However, there IS a specific procedure to convert the numbers. For example, 11111 in 2’s complement is -1 (decimal), not -15 or -31. This is to make addition, subtraction, and even multiplication possible with 2’s complement.

Note that while 2’s complement can hold the same amount of numbers as ordinary binary representation (2ⁿ numbers with n digits), the numbers stored are always smaller than normal binary representation. Recall that using 5 digits, you can represent 00000 to 11111 (0 to 31). Using 2’s complement and 5 digits, you can only represent 10000 to 01111 (-16 to 15).

2’s Complement to Decimal
To convert a 2’s complement representation into a readable number format, follow these steps:

1. If the number is positive (the most significant bit is 0), convert the number into decimal format normally.
2. If the number is negative, flip all the digits in the number. In other words, change all the 1’s to 0’s and all the 0’s to 1's.
3. Add 1 to the flipped number.
4. To see the number in decimal format, just convert it to a decimal number like in regular binary representation.

For example, let’s convert 10110110.

1. Since the most significant bit is 1, we need to flip the digits in the number.
2. 10110110 → 01001001.
3. Add 1 to the number. 01001001+1=01001010.
4. 01001010 (binary) = 74 (decimal).
5. So, 10110110 (2’s complement)=-74 (decimal).

Decimal to 2’s Complement
If we implement the steps from the previous part but in reverse, we can convert a decimal number into a 2’s complement representation.

1. If the number is positive, convert the number to binary representation normally. Make sure the binary number’s most significant digit is 0, because the number is positive.
2. If the number is negative, convert the number to a binary representation as if it were a positive number.
3. Subtract the number by 1.
4. Flip all the digits in the number.

When it comes to downloading files from the web, two command-line tools dominate the landscape wget and curl. Both are immensely powerful, versatile, and highly useful for automating downloads, retrieving content, and interacting with web servers. Though they are often used interchangeably, they each have unique features and capabilities that suit different use cases. In this blog post, we’ll explore the differences between wget and curl, along with their most common options, variations, and when you might want to use one over the other. So, if you just want to download a file, wget is a good choice. But if you need to do something more complicated, curl might be better. Both tools are very helpful for downloading things from the internet!

Common Usage Examples of Wget

1. Simple File Download:
wget URL
Downloads a file from the provided URL.

2. Download to a Specific File Name:
wget -O custom_name.zip URL
Saves the downloaded file as custom_name.zip.

3. Resume Interrupted Download:
wget -c URL
It continues the downloading of the file from where it was left off if the connection was interrupted.

4. Download Entire Website:
wget — mirror -p — convert-links -P ./local-dir URL
This command will mirrors an entire website for offline viewing:

— mirror: Enables options for mirroring.
-p: Downloads all necessary files for proper display.
 — convert-links: Converts links so that the mirrored website can be viewed offline.
-P ./local-dir: Saves the downloaded site to local-dir.

5. Download in Background:
wget -b URL
Downloads the file in the background, writing progress to a log file.

6. Limit Download Speed:
wget — limit-rate=100k URL
Limits the download speed to 100 KB/s.

7. Recursive Download (multiple levels of pages):
wget -r URL
Downloads the entire directory structure recursively.

8. Download Files via FTP:
wget ftp://username:password@ftp.example.com/file.zip
Allows downloading files from an FTP server, optionally using a username and password.

9. Download All Files of a Certain Type:
wget -r -A ‘*.jpg’ URL
Recursively download all files with the .jpg extension from the specified directory.

10. Set Number of Retries for Download

wget — tries=10 URL
Retries up to 10 times before giving up on the download.

11. Continue Downloading Even After a 404 Error:
wget — ignore-errors URL
Ignores 404 errors and continues downloading the remaining files.

Popular wget Options:

• V, — version: Display the version of wget
• -h, — help: Print a help message listing available options.
• -O file: Save the downloaded content to the specified file (instead of the default filename).
• -o logfile: Write the output messages to the specified file (log).
• -q, — quiet: Run in quiet mode (no output).
• -nv: Show fewer output messages (non-verbose).
• — no-check-certificate: Skip certificate validation when downloading over HTTPS.
• -c, — continue: Continue downloading a partially downloaded file
• -b, — background: Run wget in the background after starting.
• --limit-rate=amount: Limit download speed (e.g., — limit-rate=100k)
• -r, — recursive: Download recursively (useful for downloading entire websites).
• -l depth, — level=depth: Set the recursion depth level (works with -r).
• -np: Same as — no-parent.
• — random-wait: Wait for a random amount of time between downloads to avoid being throttled.
• — wait=seconds: Wait for the specified number of seconds between retrievals.
• -t number, — tries=number: Set the number of retries for failed downloads.
• — header=header: Send a custom HTTP header with the request.
• — user=username — password=password: Provide HTTP authentication credentials.
• — post-data=data: Send data using HTTP POST method.
• -method=method: Use a custom HTTP method (like PUT, DELETE, etc.).
• — ftp-user=user — ftp-password=password: Provide FTP authentication credentials.
• — no-remove-listing: Do not remove .listing files generated by FTP downloads

What Is CURL

curl allows you to interact with URLs and send requests to servers directly from the command line. It retrieves or uploads data using supported protocols, making it a versatile tool for automation, testing APIs, or simply downloading web content.

Common curl Options:

1. Downloading Files
1.1 To save it to a file, you can use the -o option:
curl -o URL
1.2 If you want to keep the original filename, use -O (uppercase):
curl -O URL

2. Custom Headers
2.1 You can use custom headers with the -H option, which is useful for API requests:
curl -H “Authorization: Bearer <token>” URL

3. HTTP Methods
3.1 POST request with data:
curl -X POST -d “name=John&age=30” URL
3.2 You can send JSON data using the -d flag and specifying the content type:
curl -X POST -H “Content-Type: application/json” -d ‘{“name”:”John”, “age”:30}’ URL
3.3 PUT and DELETE work similarly:
curl -X PUT -d ‘{“name”:”Jane”}’ URL
curl -X DELETE URL

4. Authentication
4.1 If you need to authenticate with a username and password, you can use -u:
curl -u username:password URL

5. Follow Redirects
By default, cURL won’t follow HTTP redirects. To enable this, use the -L option:
curl -L short_URL

6. Verbose Mode
For debugging purposes, you can use -v to see detailed information about the request and response:
curl -v URL
For even more information (including headers), use — trace:
curl — trace trace.log URL

7. Timeouts
If you need to limit the time cURL waits for a response, you can set a timeout:
curl — max-time 10 URL

8. Resume Downloads
If a download was interrupted, you can use the -C option to resume it:
curl -C — -O URL