feat: add condition statement

Author: brijeshkumar-chavda

08_string/string_vs_string_object.md

@@ -0,0 +1,34 @@
+// Arrow Function
+
+// SYNTAX
+// const variableName = () => {
+//    code...
+// return
+// }
+
+// Simple arrow function
+const arrowFunction = () => {
+  return console.log("Hello, World!");
+};
+
+// Implicit Return
+
+// Note
+// - If you use {} for function. You need to write the `return` keyword.
+const arrowFunction1 = () => {
+  return console.log("Hello, World!");
+};
+
+// - If you are not using the {}. You don't need to write the `return` keyword.
+const arrowFunction2 = () => console.log("Hello, World!");
+
+// - If you are using object with arrow function without {}. You need to use ().
+const arrowFunction3 = () => ({ key1: "value1" });
+
+// - If you are passing only one parameter. You can remove () around the parameter.
+// const myArrowFunction1 = parameter => console.log(parameter);
+
+// () => {}
+// () =>
+// () => ()
+//    =>

12_object/who_is_object.md

@@ -0,0 +1,13 @@
+// Immediately Invoked Function Expressions (IIFE)
+
+// REMEMBER ME -> ;
+
+// Named IIFE Function
+(function myFunction(parameter) {
+  return console.log(parameter);
+})("I'm IIFE Function");
+
+// Arrow IIFE Function
+((parameter) => {
+  console.log(parameter);
+})("I'm Arrow IIFE Function");

13_function/8ArrowFunction.js

@@ -0,0 +1,62 @@
+// `this` Keyword
+
+// What
+// - In JavaScript, the this keyword refers to an current context.
+
+// Note
+// - The this keyword refers to different objects depending on how it is used:
+// 1. Alone -> Global object
+// 2. In a object method -> object
+// 3. In a function -> Global object
+// 4. In a function with strict mode ("use strict") -> undefined
+// - In an event, this refers to the element that received the event.
+// - Methods like call(), apply(), and bind() can refer this to any object.
+
+// 1. Alone -> Global object
+console.log(this);
+
+// 2. In a object method -> object
+const object = {
+  key1: "Value1",
+  key2: "Value2",
+  key3: function () {
+    console.log(this.key1);
+  },
+};
+console.log(object.key3());
+
+// 3. In a function -> Global object
+function iAmFunction() {
+  return console.log(this);
+}
+
+console.log(iAmFunction());
+
+// 4. Function inside function -> Global object
+function iAmOutsideFunction() {
+  function iAmInsideFunction() {
+    return console.log(this);
+  }
+  console.log(iAmInsideFunction());
+}
+console.log(iAmOutsideFunction());
+
+// 5. Arrow function and this keyword
+// - Arrow functions have a different behavior with this. They inherit the this value from the enclosing scope where they are defined, not from how they are called.
+
+// Defined in the Global Scope -> Global object
+const arrowFunction = () => {
+  return console.log(this);
+};
+console.log(arrowFunction());
+
+// Defined Inside a Function or Object
+const object1 = {
+  key1: "value1",
+  key2: "value2",
+  key3: () => {
+    console.log(this);
+  },
+};
+
+console.log(object1.key3());

13_function/3FunctionConstruction.js 13_function/FunctionConstruction.js

@@ -0,0 +1,24 @@
+// Window VS Global Object
+
+// Global Object
+// - The fundamental object that provides properties and functions accessible throughout your JavaScript code.
+// - In browsers, the global object is typically the window object, but this can vary depending on the environment (e.g., Node.js uses the global object).
+// - It contains built-in functions like console.log(), parseInt(), and properties like document (in browsers).
+
+// Window Object
+// - A special object specific to browser environments that represents the browser window.
+// - It inherits properties and methods from the global object but also has additional properties and methods related to the browser window, such as location (for accessing the URL), alert(), and confirm().
+
+// Key Differences
+// - Scope: The global object exists in all JavaScript environments, while the window object is specific to browsers.
+// - Properties: The window object has additional properties and methods related to the browser window functionality that the global object doesn't have.
+
+// When to Use Which
+// - In most browser code, you can generally use window and global interchangeably since window is the de facto global object in browsers.
+// - However, if you're writing code that might run in different environments (e.g., Node.js), it's safer to use global to explicitly reference the global object across environments.
+
+// In a browser:
+console.log(window === global); // Output: true (usually true in browsers)
+
+// In Node.js:
+console.log(window === global); // Output: false (they are different objects)

13_function/arrow_function.js

@@ -0,0 +1,53 @@
+const age = 20;
+if (age >= 18) {
+  console.log("You can give a vote.");
+} else {
+  console.log("You can't give a vote.");
+}
+
+const userID = true;
+const upiID = true;
+if (userID && upiID) {
+  console.log("Welcome!");
+}
+
+const loggedInFromGoogle = true;
+const loggedInFromEmail = true;
+if (loggedInFromEmail || loggedInFromGoogle) {
+  console.log("Welcome!");
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

13_function/iife.js

@@ -0,0 +1,33 @@
+// Falsy value
+// false
+// 0
+// -0
+// BigInt 0n
+// ""
+// null
+// undefined
+// NaN
+
+// Truthy value
+// - Any value other than falsy.
+// "0"
+// "false"
+// " "
+// []
+// {}
+// function(){}
+
+// For CP and Interview
+// false == 0 -> true
+// false == "" -> true
+// 0 == "" -> true
+
+const emptyArray = [];
+if (emptyArray.length === 0) {
+  console.log("Array is empty");
+}
+
+const emptyObject = {};
+if (Object.keys(emptyObject).length === 0) {
+  console.log("Objet is empty");
+}

15_this_keyword/1_this_keyword.js

@@ -12,7 +12,7 @@
 // - Rest Operator:
 //      - Captures a variable number of arguments passed to a function and handles them as an array within the function body.
 
-// Spread Operator Examples:
+// Examples
 
 // 1. Function Call with Array Elements (avoiding apply or loop)
 function sumNumbers(x, y) {

15_this_keyword/2_window_vs_global_object.js

@@ -8,3 +8,7 @@
 
 let myVariable = null ?? "default value";
 console.log(myVariable);
+
+// It will check for the value. Which ever value it will find first. It will be default value
+const myVariable1 = null ?? "value1" ?? "value2";
+console.log(myVariable1);

this_keyword/3TwoObjectOneFunction.js 15_this_keyword/3TwoObjectOneFunction.js

@@ -1,7 +1,7 @@
 // Ternary or Conditional Operator
 
 // Syntax
-// const variableName = (condition) ? statement1 : statement2;
+// const variableName = (condition) ? true : false;
 
 // Example
 const age = 20;