add new notes

Author: famsameerkhan1342

notes/Hindi/13-string.md

@@ -0,0 +1,352 @@
+### What is loop
+
+Loop ek programming construct hai jo ek block of code ko baar-baar execute karne ki permission deta hai. Ye ek aisa mechanism hai jiska use hum repetitive tasks ko asaani se solve karne ke liye karte hai.
+
+Javascript mein 3 types ke loops hote hai: for loop, while loop, aur do-while loop.
+
+For loop ka use jab karna hota hai jab humein ek list ya array ko iterate karna hota hai. For loop ke andar hum ek counter variable ka use karte hai jo humein bata hai ki loop kitni baar repeat hona hai. Yeh loop syntax ke andar 3 expressions hoti hai: initialization, condition, and update.
+
+Example:
+
+```
+for (var i = 0; i < 5; i++) {
+  console.log("Hello " + i);
+}
+```
+
+Iss example mein, hum for loop ka use kar rahe hai jisse "Hello" string 0 se 4 tak print ho raha hai. Loop ke andar, humne ek counter variable "i" initialize kiya hai jiska starting value 0 hai, aur humne yeh bhi decide kiya hai ki yeh loop tab tak chalega jab tak "i" ki value 5 se kam hai, iske baad humne "i" ko increment kiya hai.
+
+While loop ka use jab karna hota hai jab humein kisi task ko perform karte waqt ek condition ko check karna hota hai. While loop ke andar hum sirf ek condition statement dete hai jisse hum yeh decide karte hai ki loop continue hoga ya nahi.
+
+Example:
+
+```
+var num = 0;
+while (num < 5) {
+  console.log("World " + num);
+  num++;
+}
+```
+
+Iss example mein, hum while loop ka use kar rahe hai jisse "World" string 0 se 4 tak print ho raha hai. Humne "num" variable ko initialize kiya hai, aur uski value zero rakhi hai. While loop ke andar, humne yeh decide kiya hai ki jab tak "num" ki value 5 se kam hai, tab tak loop continue kare. Har baar loop execute hone par hum "num" ko increment karte hai.
+
+Do-while loop bhi while loop ki tarah hi hota hai, bas ek chhota sa difference hai ki do-while loop mei pehle code block execute hota hai phir condition check ki jaati hai. Iska matlab hai ki do-while loop ke andar ke code block atleast ek baar to execute hoga.
+
+Example:
+
+```
+var i = 0;
+do {
+  console.log("Welcome " + i);
+  i++;
+} while (i < 3);
+```
+
+Iss example mein, hum do-while loop ka use kar rahe hai jisse "Welcome" string 0 se 2 tak print ho raha hai. Do-while loop ke andar, hum pehle "Welcome" string ko print karte hai, aur phir "i" variable ki value ko increment karte hai. Fir humne condition check ki hai ki kya "i" ki value 3 se kam hai ya nahi. Agar humara answer "true" hai to loop wapas se start hoga aur agar "false" hai to loop stop ho jayega.
+
+Is tarah se loops ka use karke hum repetitive programming tasks ko asaani se solve kar sakte hai.
+
+### What is for loop
+
+For loop JavaScript mein ek tarah ka loop hai jiske dwara hum kisi array ya object ke andar ke har element ko access kar sakte hain. For loop ke ander ek counter variable hoti hai jo ki shuruat se lekar loop ke ant tak badhti rahti hai aur uske dwara hum har ek element ko access kar sakte hain.
+
+For loop ka syntax yeh hai:
+
+```
+for (let i = 0; i < array.length; i++) {
+  // code block to be executed
+}
+```
+
+Yahan `let i = 0` ek counter variable hai jiska initial value 0 hai, `array.length` array ke length se compare kiya jaata hai aur `i++` loop ke har iteration ke baad counter ko increment karta hai.
+
+Ab ek example lete hain jismein hum ek array ke saare elements ko console par print karenge:
+
+```
+const fruits = ["Apple", "Banana", "Orange"];
+
+for (let i = 0; i < fruits.length; i++) {
+  console.log(fruits[i]);
+}
+```
+
+Yahan `fruits` ek array hai jismein hum 3 strings store kar rahe hain. For loop ke ander counter variable `i` hai jo 0 se shuruat karta hai aur `fruits.length` (yani 3) tak chalta hai. Har iteration ke baad hum `console.log(fruits[i])` ka use karke current index ki value console par print karte hain.
+
+Iska output niche diya gaya hai:
+
+```
+Apple
+Banana
+Orange
+```
+
+### What is for...of loop
+
+"for...of" loop in JavaScript is a way to iterate over iterable objects like Arrays, Strings, Maps, Sets, etc. It is similar to the "for...in" loop, but it provides more concise and readable syntax for looping through elements in an array or other iterable objects.
+
+To use the "for...of" loop, we first declare a variable to hold each element in the iterable object. Then, we use the "of" keyword followed by the iterable object to loop through its elements.
+
+Here's an example of using "for...of" loop to loop through an array of numbers:
+
+```javascript
+const numbers = [1, 2, 3, 4];
+
+for (const num of numbers) {
+  console.log(num); // Output: 1, 2, 3, 4
+}
+```
+
+In this example, we declared a constant variable "numbers" that holds an array of numbers. We then used "for...of" loop to iterate over each element of the "numbers" array, assigning each element to the variable "num", and logging it to the console.
+
+Another example is to loop through a string:
+
+```javascript
+const str = "Hello World";
+
+for (const char of str) {
+  console.log(char); // Output: H, e, l, l, o, , W, o, r, l, d
+}
+```
+
+In this example, we declared a constant variable "str" that holds a string value. We then used "for...of" loop to iterate over each character of the string, assigning each character to the variable "char", and logging it to the console.
+
+In summary, "for...of" loop is a convenient way to iterate over the elements of an iterable object in JavaScript.
+
+### What is for...in loop
+
+"for...in" loop is a type of loop in JavaScript that allows you to iterate over the properties of an object. In simple terms, it helps you to loop through each key-value pair of an object and perform some action on them.
+
+Here's an example in Hinglish:
+
+Suppose you have a dictionary (object) with multiple words and their meanings. You want to loop through every word and print its meaning. Here's how you can use "for...in" loop to achieve this:
+
+```
+// Define the dictionary object
+var dictionary = {
+  "apple": "seb",
+  "banana": "kela",
+  "orange": "santara"
+};
+
+// Loop through each word in the dictionary object
+for (var word in dictionary) {
+
+  // Print the word and its meaning
+  console.log(word + " ka arth hai " + dictionary[word]);
+}
+```
+
+In this example, we define an object called "dictionary" with three key-value pairs. We then use a "for...in" loop to loop through each key-value pair in the object. Inside the loop, we print the word and its meaning using the "console.log()" function. The output of this program will be:
+
+```
+apple ka arth hai seb
+banana ka arth hai kela
+orange ka arth hai santara
+```
+
+So, the "for...in" loop is a very useful construct in JavaScript for iterating over the properties of an object. It is particularly helpful when you need to work with data stored in objects.
+
+### What is while loop
+
+While loop JavaScript mein ek aisa loop hai jo ek shart ko check karta hai aur jab tak wo shart true rahe, tab tak loop chalta rehta hai.
+
+Is loop ke andar code block ko ek baar bhi nahi chalaya jata hai agar shart hi false hoti hai. While loop ka syntax neeche diya gaya hai:
+
+```
+while (shart) {
+  // Code Block
+}
+```
+
+Yahan "shart" ek boolean expression hai, jo true ya false ho sakta hai. Aur "Code Block" ek set of statements hai jo execute hote rahtey hai jab tak shart true rahti hai.
+
+Example:
+
+```
+let i = 1;
+while (i <= 5) {
+  console.log(i);
+  i++;
+}
+```
+
+Iss example mein humne ek variable "i" create kiya aur ek while loop ka use kiya jo "i" ki value 5 se kam hone tak chalta rehta hai. Har baar "i" ki value print hoti hai aur phir "i" ki value 1 se badhaya jaata hai. Jab "i" ki value 6 ho jaati hai to loop khatam ho jaata hai.
+
+Iska output hoga:
+
+```
+1
+2
+3
+4
+5
+```
+
+Ummid hai ki ab aapko while loop ke baare mein achi tarah se samajh aa gaya hoga!
+
+### What is do...while loop
+
+Do...while loop ek aisa loop hai jo kisi bhi code block ko baar-baar execute karta hai jab tak ki uske condition ka result true na ho. Yeh loop pehle code block ko execute karta hai aur phir condition check karta hai. Agar condition true hoti hai to loop continue rahta hai, lekin agar condition false hoti hai tab bhi code block ko kam se kam ek baar execute kar diya jaata hai.
+
+Ek example ke through samajhte hain:
+
+```
+var i = 1;
+do {
+  console.log(i);
+  i++;
+} while (i <= 5);
+```
+
+Is code mein `i` ki value 1 se start hogi aur do..while loop ke andar code block ko execute karne ke baad `i` ki value 1 se 2 ho jayegi. Phir condition check hoti hai ki kya `i` ki value 5 se choti ya barabar hai? Kyunki yeh condition abhi true hai, isliye loop 2nd iteration ke liye chalta rahega aur `i` ki value 3 ho jayegi. Iss tarah se loop ke har iteration mein `i` ki value badhti rahegi jab tak ki `i` ki value 5 na ho jaye. Jab `i` ki value 6 ho jati hai, to condition false ho jati hai aur loop se bahar nikal jata hai.
+
+Iss tarah se do..while loop ek baar to code block ko execute karta hi hai chahe condition true ho ya false ho.
+
+### What is Switch Statment
+
+Switch statement in JavaScript is a conditional statement that allows you to evaluate an expression and execute different code blocks based on the value of that expression. It's a way to simplify writing multiple if/else statements.
+
+For example, let's say you have a variable called "dayOfWeek" that contains a string representing the day of the week. You want to perform different actions depending on the value of "dayOfWeek". Instead of using multiple if/else statements, you can use a switch statement:
+
+```
+var dayOfWeek = "Monday";
+
+switch (dayOfWeek) {
+  case "Monday":
+    console.log("It's Monday, time to start the week!");
+    break;
+  case "Tuesday":
+    console.log("It's Tuesday, still a long way to go...");
+    break;
+  case "Wednesday":
+    console.log("It's Wednesday, halfway there!");
+    break;
+  case "Thursday":
+    console.log("It's Thursday, almost done!");
+    break;
+  case "Friday":
+    console.log("It's Friday, yay weekend!");
+    break;
+  default:
+    console.log("Invalid day of the week.");
+}
+```
+
+In this example, the switch statement evaluates the value of the "dayOfWeek" variable and executes the code block corresponding to the matching case label. If there is no match, the default case is executed.
+
+So, if "dayOfWeek" is "Monday", the output will be "It's Monday, time to start the week!". If "dayOfWeek" is "Saturday", the output will be "Invalid day of the week." because there is no matching case label.
+
+Switch statements are useful when you have a large number of conditions to check and want to avoid writing nested if/else statements.
+
+### What is case clause
+
+"Case clause" (केस क्लॉज) जावास्क्रिप्ट में एक संरचना है जो switch ब्लॉक के अंदर इस्तेमाल की जाती है। यह एक conditional statement है, जो switch block में निर्दिष्ट value को evaluate करती है और शर्तों के आधार पर उपयुक्त code block को execute करती है।
+
+जब switch block की expression की value किसी एक case के value से match करती है, तो उस case के अंदर का code block execute होता है। अगर कोई case match नहीं होता है, तो default case का code block execute होता है।
+
+इसका syntax निम्नलिखित है:
+
+```
+switch (expression) {
+  case value1:
+    //code block
+    break;
+  case value2:
+    //code block
+    break;
+  case value3:
+    //code block
+    break;
+  default:
+    //code block
+}
+```
+
+यहाँ expression value को evaluate करने के लिए है जो case के values से match करती हैं। अगर expression किसी bhi case value से match करता है, तो उस case का code block execute होता है। इसके बाद break statement से execution control switch block से बाहर निकल जाता है।
+
+यहाँ एक उदाहरण है:
+
+```
+let day = "Monday";
+switch (day) {
+  case "Sunday":
+    console.log("Today is Sunday");
+    break;
+  case "Monday":
+    console.log("Today is Monday");
+    break;
+  case "Tuesday":
+    console.log("Today is Tuesday");
+    break;
+  default:
+    console.log("Today is some other day");
+}
+```
+
+इस example में, variable 'day' की value "Monday" है, इसलिए switch block में वह "Monday" case से match होती है। इसलिए उस case के अंदर का code block execute होता है और निम्न output print होता है:
+
+```
+Today is Monday
+```
+
+### What is break
+
+Break ka matlab hai ek code block se bahar nikalna. Jab tak hum break na use karein, tab tak loop ya switch statement continue hote rahenge.
+
+Ek example ke through samjhate hain:
+
+```
+for (let i = 1; i <= 5; i++) {
+  console.log(i);
+  if (i === 3) {
+    break;
+  }
+}
+```
+
+Iss code mein, hum for loop ka use karke 1 se 5 tak ke numbers ko print kar rahe hai. Lekin jab `i` ki value 3 ho jaati hai toh humne `break` ka use kiya hai, jisse ki loop uss point pe hi stop ho jaata hai aur aage nahi chalta.
+
+Agar hum issi code ke bina break ka use karte toh output yeh hota:
+
+```
+1
+2
+3
+4
+5
+```
+
+Lekin humne break ka use kiya hai jab `i` ki value 3 ho jaati hai, isliye output yeh hoga:
+
+```
+1
+2
+3
+```
+
+Iss tarah, break ka use karke hum loop ya switch statement ko jald se jald exit kar sakte hai.
+
+### What is default case in a Switch Statement ?
+
+Switch Statements are used in programming languages to execute different blocks of code based on the value of an expression.
+
+The default case is a branch in a switch statement that is executed when no other case matches the value of the expression. It is like a catch-all clause in a try-catch block.
+
+For example, let's say we have a variable called "dayOfWeek" which represents the day of the week (1 for Sunday, 2 for Monday, and so on) and we want to print a message depending on the day of the week:
+
+```
+int dayOfWeek = 3;
+switch(dayOfWeek){
+    case 1:
+        System.out.println("Today is Sunday");
+        break;
+    case 2:
+        System.out.println("Today is Monday");
+        break;
+    //... cases for other days of the week
+    default:
+        System.out.println("Invalid day of the week");
+}
+```
+
+we could say that the default case is like a "baki sab" option in a switch statement. It is executed when none of the other options match the given value.

notes/Hindi/12-typeconversion.md renamed to notes/Hindi/13-typeconversion.md

@@ -0,0 +1,210 @@
+### What is String
+
+Javascript mein, String ek primitive data type hai jo text ko represent karta hai. Har string ek sequence of characters hoti hai aur ek quotation mark (' ' aur " ") ke beech mein define ki jati hai.
+
+Jaise ki,
+
+```
+var naam = 'Amit'; // single quotes mein string ko define kiya gaya hai
+var message = "Main aaj khush hoon."; // double quotes mein string ko define kiya gaya hai
+```
+
+Ismein, `naam` aur `message` variables string values store kar rahe hai.
+
+String mein characters indexes ke dwara access kiye ja sakte hai. Index 0 se start hota hai aur string.length - 1 tak chalta hai. Iske alawa, hum strings ko concatenate (combine) kar sakte hai `+` operator se.
+
+Jaise ki,
+
+```
+var firstName = 'Amit';
+var lastName = 'Kumar';
+var fullName = firstName + ' ' + lastName; // Concatenate karne ke liye '+'' operator ka use kiya gaya hai.
+console.log(fullName); // Output: Amit Kumar
+```
+
+Yahan, `fullName` variable `firstName` aur `lastName` strings se combined hai. Hum yeh bhi dekh sakte hai ki space `" "` concatenate karne ke liye bhi use kiya gaya hai.
+
+In summary, String ek primitive data type hai jo text ko represent karta hai. Har string ek sequence of characters hoti hai aur quotation marks ke beech mein define ki jaati hai. Strings ko index ke dwara access kiya ja sakta hai aur concatenate karne ke liye `+` operator ka use kiya jaa sakta hai.
+
+### How to create String
+
+JavaScript mein ek string banane ke liye hum " " ya fir ' ' (single quotes) ka use karte hain. Jaise ki:
+
+```
+var str1 = "Hello";
+var str2 = 'world';
+```
+
+Yahan humne do variables `str1` aur `str2` banaye hain jo ek-ek string hai. `str1` mein "Hello" string hai aur `str2` mein "world".
+
+Agar aapko kuch bhi double quote (" ") ke andar likhna hai jaisa ki `"I'm a string"` toh aap use single quote (' ') ke andar wrap kar sakte hain. Jaise ki:
+
+```
+var str3 = 'I\'m a string';
+```
+
+Yahan humne `\` ka use kiya hai taaki string mein single quote ka use kar sakein.
+
+Hum multiple strings ko concatenate bhi kar sakte hain, jisse ek naya string banega. Jaise ki:
+
+```
+var greeting = str1 + ', ' + str2 + '!'; // Output: Hello, world!
+```
+
+Yahan `+` operator ka use kiya gaya hai do strings ko concatenate karne ke liye. `greeting` variable mein ab "Hello, world!" string hai.
+
+Is tarah se hum JavaScript mein strings create kar sakte hain.
+
+### String Literal vs String Object ?
+
+String Literal aur String Object dono tarah ke string hote hai, lekin unke banane ka tarika alag hota hai.
+
+String Literal ek aisa string hai jo code mein directly declare kiya jata hai, aur use double quotes (" ") ya single quotes (' ') ke beech mein likha jata hai. Jab hum isse banate hai to iska ek reference bhi ban jata hai. Jaise:
+
+```
+String literal = "Hello World!";
+```
+
+String Object ek aisa string hai jo hum new keyword se create karte hai. Ismein humein ek object banaana padta hai jo ki String class ka object hota hai. Jaise:
+
+```
+String object = new String("Hello World!");
+```
+
+Dono hi tareeke se banaye gaye string mein same value hai, lekin inki memory allocation aur usage mein antar hota hai. Jab hum string literal banate hai to uska reference pool me store ho jaata hai (jise String Constant Pool kehte hai) aur jab hum dusri jagah se usi literal ko use karte hai to woh phele se stored reference ko point karta hai. Lekin jab hum string object banate hai to har baar naya object ban jata hai aur alag-alag memory allocation hoti hai.
+
+Upar diye gaye examples ko hinglish mein likhenge to yeh aise dikhega:
+
+```
+// String Literal
+String literal = "Hello World!";
+
+//String Object
+String object = new String("Hello World!");
+```
+
+Ummid hai yeh samjhane mein madad milegi.
+
+### String length property
+
+"String length property" refers to the number of characters in a string. It is a built-in property of the String object in JavaScript and can be accessed using the ".length" syntax.
+
+For example, consider the following code:
+
+```
+var name = "ChatGPT";
+console.log(name.length); // Output: 7
+```
+
+In this code, we have defined a variable "name" with the value "ChatGPT". We then use the ".length" property to find out the length of the string "name", which is 7.
+
+Similarly, we can use the ".length" property to find out the length of any string, as shown below:
+
+```
+var message = "Namaste dosto!";
+console.log(message.length); // Output: 14
+```
+
+Here, we have defined a variable "message" with the value "Namaste dosto!". We then use the ".length" property to find out the length of the string "message", which is 14.
+
+इसका मतलब होता है कि "String length property" एक स्ट्रिंग में उपलब्ध वर्णों की संख्या को दर्शाता है। यह JavaScript में String ऑब्जेक्ट की बिल्ट-इन property होती है और ".length" का syntax उपयोग करके इसे एक्सेस किया जा सकता है।
+
+एक उदाहरण के रूप में, निम्नलिखित कोड का विवरण दिया गया है:
+
+```
+var name = "ChatGPT";
+console.log(name.length); // Output: 7
+```
+
+इस कोड में, हमने एक वेरिएबल "name" को "ChatGPT" के साथ परिभाषित किया है। फिर हम ".length" property का उपयोग करके "name" स्ट्रिंग की लंबाई पता लगाते हैं, जो 7 है।
+
+इसी तरह, हम किसी भी स्ट्रिंग की लंबाई का पता लगाने के लिए ".length" property का उपयोग कर सकते हैं, जैसा कि निम्नलिखित में दिखाया गया है:
+
+```
+var message = "Namaste dosto!";
+console.log(message.length); // Output: 14
+```
+
+यहाँ, हमने "message" वेरिएबल को "Namaste dosto!" के साथ परिभाषित किया है। फिर हम ".length" property का उपयोग करके "message" स्ट्रिंग की लंबाई पता लगाते हैं, जो 14 है।
+
+### String functions
+
+String functions in JavaScript are built-in functions that allow you to manipulate and modify strings. Here's a list of commonly used string functions in JavaScript:
+
+1. length(): This function returns the length of the string.
+
+Example:
+var str = "Hello World";
+console.log(str.length); // Output: 11
+
+2. toUpperCase(): This function converts all characters in a string to uppercase.
+
+Example:
+var str = "hello world";
+console.log(str.toUpperCase()); // Output: HELLO WORLD
+
+3. toLowerCase(): This function converts all characters in a string to lowercase.
+
+Example:
+var str = "HELLO WORLD";
+console.log(str.toLowerCase()); // Output: hello world
+
+4. indexOf(): This function returns the index of the first occurrence of a specified substring in a string.
+
+Example:
+var str = "Hello World";
+console.log(str.indexOf("o")); // Output: 4
+
+5. slice(): This function extracts a part of a string and returns a new string.
+
+Example:
+var str = "Hello World";
+console.log(str.slice(0, 5)); // Output: Hello
+
+6. replace(): This function replaces the first occurrence of a specified substring with another substring.
+
+Example:
+var str = "Hello World";
+console.log(str.replace("Hello", "Hi")); // Output: Hi World
+
+7. trim(): This function removes whitespace from both ends of a string.
+
+Example:
+var str = " Hello World ";
+console.log(str.trim()); // Output: Hello World
+
+8. concat(): This function joins two or more strings and returns a new string.
+
+Example:
+var str1 = "Hello";
+var str2 = "World";
+console.log(str1.concat(" ", str2)); // Output: Hello World
+
+In Hindi (Devanagari script):
+JavaScript में स्ट्रिंग फंक्शंस वह बिल्ट इन फंक्शंस हैं जो आपको स्ट्रिंग को मैनिपुलेट और मॉडिफाई करने की अनुमति देते हैं। यहाँ जावास्क्रिप्ट में उपयोग में आने वाले स्ट्रिंग फंक्शंस की सूची है:
+
+1. length(): यह फंक्शन स्ट्रिंग की लंबाई लौटाता है।
+
+उदाहरण:
+var str = "Hello World";
+console.log(str.length); // आउटपुट: 11
+
+2. toUpperCase(): यह फंक्शन स्ट्रिंग के सभी अक्षरों को अपरकेस में रूपांतरित करता है।
+
+उदाहरण:
+var str = "hello world";
+console.log(str.toUpperCase()); // आउटपुट: HELLO WORLD
+
+3. toLowerCase(): यह फंक्शन स्ट्रिंग के सभी अक्षरों को लोअरकेस में रूपांतरित करता है।
+
+उदाहरण:
+var str = "HELLO WORLD";
+console.log(str.toLowerCase()); // आउटपुट: hello world
+
+4. indexOf(): यह फंक्शन स्ट्रिंग में एक निर्दिष्ट उपस्थिति से पहले उपस्थिती के आधार पर एक सबस्ट्रिंग का इंडेक्स लौटाता है।
+
+उदाहरण:
+var str = "Hello World";
+console.log(str.indexOf("o")); // आउटपुट: 4
+
+5. slice(): यह फंक

notes/Hindi/15-loopand_switch.md

@@ -0,0 +1,311 @@
+### What is default parameter ?
+
+Default parameter ek programming concept hai jismein ek function ka argument deafult value se initialize kiya jaata hai. Jaise ki, agar hum kisi function mein ek argument ko default value assign karte hain toh jab bhi uss function ko call kiya jaata hai aur uss argument ka value nahi diya jaata hai, toh woh argument default value ke saath initialize ho jaata hai.
+
+For example, agar hum ek function define karte hain jiska naam hai print_name aur usmein ek argument hai name, toh hum uska default value "Guest" rakh sakte hain. Iska matlab hai ki agar hum print_name function ko call karte hain aur usmein koi Name nahi dete hain toh "Guest" as a default value use ho kar print ho jayega.
+
+Yehi concept Hinglish mein samjhaya jaaye toh - agar tumhein koi party mein invite kiya gaya hai aur invitation mein likha hai ki RSVP pe apna naam dena zaruri hai, lekin agar tumne RSVP mein naam nahi diya toh tum automatically "Guest" ke roop mein count kiye jaoge.
+
+### What is passing arguments: value vs reference in JavaScript ?
+
+JavaScript mein, argument pass karna do tariko se kiya jata hai - value aur reference ke dwara. Value-based argument mein, argument ka copy function ke andar banaya jata hai aur ismein koi bhi changes function se bahar visible nahi hote hain. Jabki reference-based argument mein, original object ya array ko function ke through modify kiya ja sakta hai aur yeh changes function ke bahar bhi visible hote hain.
+
+Value-based argument ka ek example hai:
+
+```
+function addOne(num) {
+  num = num + 1;
+  console.log(num); // output: 6
+}
+
+let myNum = 5;
+addOne(myNum);
+console.log(myNum); // output: 5
+```
+
+Is example mein, `addOne` function ko `myNum` variable ke value ke sath call kiya jata hai, jo ki initially 5 hai. Function mein, `num` variable ko `myNum` ki value se assign kiya jata hai. Iske baad, `num` variable mein 1 add kar diya jata hai. Lekin `myNum` variable ki value function ke bahar waise hi rehti hai jaise pahle thi, yaani 5.
+
+Reference-based argument ka ek example hai:
+
+```
+function addToArr(arr, val) {
+  arr.push(val);
+  console.log(arr); // output: [1, 2, 3, 4]
+}
+
+let myArr = [1, 2, 3];
+addToArr(myArr, 4);
+console.log(myArr); // output: [1, 2, 3, 4]
+```
+
+Is example mein, `addToArr` function ko `myArr` variable ke sath call kiya jata hai, jo `[1, 2, 3]` hai. Function mein, `arr` variable ko `myArr` ki reference se assign kiya jata hai. Iske baad, `val` variable ko 4 se assign kiya jata hai. Fir, `push()` method ka use karke `arr` array mein `val` value add kiya jata hai. Ab, `myArr` variable ki value bhi `addToArr` function ke through modify ho jati hai aur ismein `[1, 2, 3, 4]` ho jata hai.
+
+Is tarah se, value-based argument mein original variable/function ke copy banaya jata hai aur modifications us copy pe kiye jate hain. Jabki reference-based arguments mein original variable ko hi modify kiya jata hai aur changes function ke bahar bhi visible hote hain.
+
+### What is First Class function/Citizen ?
+
+First Class functions (FCF) refer to the ability of a programming language to treat functions as variables or first-class citizens. This means that functions can be assigned to variables, passed as arguments to other functions, and returned as values from functions.
+
+For example, let's consider the following Python code:
+
+```
+def add(x, y):
+    return x + y
+
+result = add(3, 4)
+print(result)
+```
+
+In this code, `add` is a function that takes two arguments `x` and `y`, and returns their sum. We then assign the value returned by `add(3, 4)` to the variable `result`, which is then printed to the console.
+
+Now, let's see an example of treating a function as a first-class citizen:
+
+```
+def add(x, y):
+    return x + y
+
+def apply(func, x, y):
+    return func(x, y)
+
+result = apply(add, 3, 4)
+print(result)
+```
+
+In this code, we have defined a new function `apply` that takes three arguments: a function `func`, and two arguments `x` and `y`. The `apply` function then applies the function `func` to the arguments `x` and `y`.
+
+We then call the `apply` function with the `add` function as the `func` argument, and `3` and `4` as the `x` and `y` arguments. The result of calling `apply` is the same as calling `add(3, 4)`, which is `7`.
+
+So, in summary, first-class functions allow us to treat functions as data, which gives us more flexibility and power when writing code.
+
+### What is High Order function ?
+
+High order function ek aisa function hota hai jo doosre functions ko argument ke roop mein le sakta hai, ya fir ek function ko return kar sakta hai. Iss tarah ke functions ka upyog kisi specific kaam ke liye kaafi flexible aur powerful hota hai.
+
+Ek udaharan ke roop mein, hum ek high order function likh sakte hain jo kisi list ke har item pe apply ho sakta hai aur use double kar sake. Is function ko hum "map" kehte hain:
+
+```python
+def double(x):
+    return x * 2
+
+my_list = [1, 2, 3, 4, 5]
+
+new_list = map(double, my_list)
+
+print(list(new_list)) # Output: [2, 4, 6, 8, 10]
+```
+
+Yahaan, `double` function ko `map` function ke argument ke roop mein pass kiya gaya hai. `Map` function ne phir `my_list` ke har item pe `double` function ko apply kiya aur ek naye list mein un values ko store kar diya jismein har value original list ke corresponding value ka double tha.
+
+Iss example mein, `map` function ek high order function hai kyunki usne ek doosre function (`double`) ko apna argument ke roop mein liya hai.
+
+### What is Callback function ?
+
+Callback function ek programming concept hai jisme ek function ko dusre function mein argument ke taur par pass kiya jaata hai aur yeh function baad mein call kiya jaata hai. Yeh kaam karke asynchronous programming mein kaafi help karta hai.
+
+Let's take an example: Suppose humare paas ek function hai jo do numbers ka sum calculate karta hai:
+
+```python
+def add_numbers(a, b):
+    return a + b
+```
+
+Ab humein ek aur function banana hai jo kisi bhi do numbers ka product calculate karega, lekin ismein hum chaahte hai ki agar iska calculation complete hua toh humare paas ek message aa jaaye. Iske liye hum callback function ka use karenge:
+
+```python
+def multiply_numbers(a, b, callback):
+    result = a * b
+    callback(result)
+
+# Ab hum apna callback function bana sakte hain
+def print_result(result):
+    print("Product is:", result)
+
+multiply_numbers(5, 6, print_result)
+```
+
+Yahaan humne `multiply_numbers` mein `callback` parameter add kiya jisse hum uss function mein bhejte hain. Fir `multiply_numbers` function mein hum result ko calculate karte hain aur `callback` function ko call kar dete hain jisse wo message print kar sake.
+
+Upar diye gaye example mein humne Python ka use kiya hai, lekin callback functions ka concept kisi bhi programming language mein istemaal kiya ja sakta hai.
+
+### What is setTimeOut ?
+
+setTimeOut ek JavaScript function hai jiske through hum apne code ko delay kar sakte hai. Iske liye, setTimeOut function ko call kiya jata hai aur ismein pehle argument mein ek function define kiya jata hai jo hum delay karna chahte hai, aur dusre argument mein delay time (milliseconds) specify kiya jata hai.
+
+For example:
+
+```
+setTimeout(function() {
+  console.log("Hello, world!");
+}, 3000);
+```
+
+Is code mein, setTimeout function ko call kiya gaya hai jismein pehla argument ek anonymous function hai jo "Hello, World!" console.log statement print karega, aur dusra argument hai 3000 milliseconds ka delay time hai.
+
+Iss code ko Hinglish mein explain karte hai:
+"setTimeout" ek JavaScript function hai jisse hum code mein delay laga sakte hain. Jaise ki agar humein 3 second ke baad "Hello, World!" console mein print karna hai to hum "setTimeout" function use karenge. Ismein hum pehle argument mein "Hello, World!" print karne wali function ko define karenge aur dusre argument mein 3000ms (3 seconds) ka time specify karenge."
+
+### What is setInterval ?
+
+setInterval ek JavaScript function hai jo humein time-based actions ko perform karne mein help karta hai. Iske through, hum ek function ko specific interval ke baad repeatedly call kar sakte hain.
+
+Iske liye sabse pehle hum setInterval() function ko call karte hain aur usmein do parameters pass karte hain:
+
+1. Ek function jo humein har interval ke baad call karna hai.
+2. Interval ka duration milliseconds mein kitna hona chahiye.
+
+Jab hum is function ko call karte hain, woh turant ek ID return karta hai jo humare setInterval loop ko stop karne ke liye use kar sakte hain.
+
+Example:
+
+Agar humein 1 second ke interval ke baad "Hello World" print karna hai, to hum is tarah ka code likh sakte hain:
+
+```javascript
+let count = 0;
+const intervalId = setInterval(() => {
+  console.log("Hello World");
+  count++;
+  if (count === 5) {
+    clearInterval(intervalId);
+  }
+}, 1000);
+```
+
+Iss code mein, humne `count` variable ki madad se 5 iterations ke baad setInterval loop ko stop karne ka condition set kiya hai. Humne `setInterval()` function ko call kiya aur usmein ek anonymous function pass kiya jo 1 second ke interval ke baad "Hello World" print karega.
+
+### what is Function returning a function ?
+
+Function returning a function is when a function returns another function as its output instead of a regular value. The returned function can be stored in a variable and called later.
+
+For example, let's say we want to create a function that adds a given number to any input. We can define this function like this:
+
+```
+def add_number(number):
+    def add_to_input(input_num):
+        return input_num + number
+    return add_to_input
+```
+
+this would be something like "function jo ek aur function return karta hai". Iska matlab hai ki hum ek aisi function bana sakte hain jismein hum ek number ko diya hai aur ye function ek aur function return karta hai. Ye returned function input number ko liya aur usmein diye hue number ko add karke output dega.
+
+In the above example, `add_number` function takes in a `number` argument and defines an inner function `add_to_input` that takes a single input `input_num`. This inner function adds the `number` passed to it to the `input_num` and returns the result.
+
+The `add_number` function then returns the `add_to_input` function as its output. Now, we can store the returned function in a variable and call it with different inputs like this:
+
+```
+add_five = add_number(5)
+add_ten = add_number(10)
+
+print(add_five(3))  # Output: 8
+print(add_ten(3))   # Output: 13
+```
+
+Here, we created two new functions, `add_five` and `add_ten`, by calling the `add_number` function with arguments 5 and 10 respectively. These new functions add 5 and 10 to their inputs, respectively. Calling these new functions with different inputs gives us the desired output.
+
+I hope this helps!
+
+### What are the call and apply methods ?
+
+Call and Apply methods are functions in JavaScript that allow you to invoke a function with a specific context (or "this" value) and arguments.
+
+The difference between the two is that call takes individual arguments separated by commas, while apply takes arguments as an array.
+
+For example, let's say we have a function named "printFullName" which takes two arguments: firstName and lastName. We also have an object named "person" with properties "firstName" and "lastName". We can use the Call method to invoke the "printFullName" function with the "person" object as the context:
+
+```
+function printFullName(firstName, lastName) {
+  console.log(this.firstName + " " + this.lastName);
+}
+
+var person = {
+  firstName: "John",
+  lastName: "Doe"
+}
+
+printFullName.call(person); // Output: John Doe
+```
+
+In this example, we used the Call method to invoke the printFullName function with the "person" object as the context. The "this" keyword inside the function now refers to the "person" object, and we get the output "John Doe".
+
+Similarly, to use the Apply method, we can pass the arguments as an array:
+
+```
+printFullName.apply(person, ["Jane", "Doe"]); // Output: Jane Doe
+```
+
+Here, we passed an array containing two values - "Jane" and "Doe" - as the arguments for the function. The Apply method allows us to pass arguments as an array instead of individual arguments.
+
+So, in summary, Call and Apply methods are used to invoke a function with a specific context (or "this" value) and arguments.
+
+### What is the bind method ?
+
+Bind method ek JavaScript function ka method hai jo humein ek naya function return karta hai. Bind method se hum apne original function ko ek naya "this" value aur arguments ke saath connect kar sakte hai.
+
+Bind method ka syntax aisa hota hai: `function.bind(thisArg, arg1, arg2, ...)`
+
+Ismein `thisArg` ek object hota hai jise hum bind karna chahte hai aur `arg1`, `arg2`, ... baki ke arguments hote hai jo humare original function mein pass kiye jaate hai.
+
+Ek example dekh lete hai:
+
+```
+const person = {
+  firstName: "John",
+  lastName: "Doe",
+  fullName: function() {
+    return this.firstName + " " + this.lastName;
+  }
+}
+
+const printName = person.fullName.bind(person);
+
+console.log(printName()); // Output: John Doe
+```
+
+Is example mein humne `person` object ka `fullName` method banaya hai jo `this.firstName` aur `this.lastName` ki madad se full name return karta hai. Fir humne `bind()` method ka use karke `printName` variable mein `person.fullName` ko bind kiya hai. Ab hum `printName()` ko call karte hai toh yeh `person.fullName()` ko call karega lekin `this` ka value `person` hi hoga.
+
+Mujhe ummeed hai ki ab aapko bind method samajh mein aa gaya hoga!
+
+### What is Immediately invoked function expression ?
+
+Immediately Invoked Function Expression (IIFE) is a JavaScript function that is executed as soon as it's defined. In simple terms, it's a function that runs right away.
+
+Example in JavaScript:
+
+(function(){
+// Code to be executed immediately
+})();
+
+In Hinglish language:
+
+Immediately invoked function expression (IIFE) ek JavaScript function hai jo ki define hote hi execute ho jata hai. Saral bhasha me samjhe to ye ek function hai jo turant chal jata hai.
+
+Udaharan JavaScript me:
+
+(function(){
+// Code jo immediate taur par execute hoga
+})();
+
+### What is Closure in javascript ?
+
+Closure in JavaScript refers to the ability of a function to access variables from its outer lexical scope, even after the outer function has returned.
+
+Ek closure tab hota hai jab ek function bahar ke variables aur functions ke references ko lekar apne andar use karta hai, aur phir wo function ussi state mein rehta hai jis mein usko define kiya gaya tha. Yeh bahar ke variables aur functions ke liye private scope create karta hai.
+
+For example:
+
+```
+function counter() {
+  let count = 0;
+  return function increment() {
+    count++;
+    console.log(count);
+  }
+}
+
+const c = counter();
+c(); // logs 1
+c(); // logs 2
+```
+
+Iss code mein, `counter` function ek function `increment` ko return karta hai. `increment` function `count` variable ko access kar sakta hai, jo `counter` function ke lexical scope mein define kiya gaya hai. Jab `c` ko `counter` se invoke kiya jata hai, wo `increment` function ko return karta hai jismein `count` variable ki value increment ho jaati hai. Har baar jab `increment` function call kiya jata hai, wo `count` variable ki updated value ko print karta hai.
+
+Iss tarah se, closure ka upyog karke hum private variables aur functions ko create kar sakte hai, jinka access sirf unhi functions ke through possible hai jismein wo define kiye gaye hai.