refactor: datatype

Author: brijeshkumar-chavda

11_array/array_method/7_join.js

@@ -1,10 +1,37 @@
 // join()
 
 // What
-// - It return new string that contain all the elements of array in string format which separated by comma
+// - The join() method in JavaScript is used to concatenate all elements of an array into a single string, separated by a specified delimiter.
 
-const myArray = [1, 2, 3, 4, 5];
-const myArray2 = myArray.join();
+// Why
+// - The join() method is useful when you need to convert an array of elements into a formatted string for display, storage, or transmission.
 
-console.log(myArray2);
-console.log(typeof myArray2);
+// How
+// - The join() method takes an optional delimiter as an argument and returns a new string.
+// - If no delimiter is provided, the elements of the array are concatenated without any separation.
+// - If a delimiter is provided, the elements of the array are concatenated with the delimiter between each pair of elements.
+
+// Syntax
+// array.join("delimiter");
+
+// Example
+// Joining an array of strings into a single string
+const fruits = ["apple", "banana", "orange"];
+const fruitString = fruits.join(", ");
+console.log(fruitString); // Output: "apple, banana, orange"
+
+// Joining an array of numbers into a single string
+const numbers = [1, 2, 3, 4, 5];
+const numberString = numbers.join("-");
+console.log(numberString); // Output: "1-2-3-4-5"
+
+// Joining an array of objects into a single string
+const people = [
+  { name: "John", age: 25 },
+  { name: "Jane", age: 30 },
+  { name: "Bob", age: 35 },
+];
+const personString = people
+  .map((person) => `${person.name} (${person.age})`)
+  .join("; ");
+console.log(personString); // Output: "John (25); Jane (30); Bob (35)"

11_array/array_method/reverse.js

@@ -0,0 +1,44 @@
+// reverse()
+
+// What
+// - The reverse() method in JavaScript is used to reverse the order of elements in an array.
+
+// Why
+// - The reverse() method is useful when you need to manipulate or process an array by reversing its order.
+// - It is commonly used in various programming scenarios, such as sorting data in descending order, reversing a sequence of elements, or creating user-friendly interfaces.
+
+// How
+// - The reverse() method modifies the original array in-place and does not create a new array.
+// - It reverses the order of elements in the array by swapping the first element with the last element, the second element with the second-to-last element, and so on.
+
+// Syntax
+// array.reverse()
+
+// Example
+// Reversing an array of numbers
+const numbers = [1, 2, 3, 4, 5];
+numbers.reverse();
+console.log(numbers); // Output: [5, 4, 3, 2, 1]
+
+// Reversing an array of strings
+const fruits = ["apple", "banana", "orange"];
+fruits.reverse();
+console.log(fruits); // Output: ["orange", "banana", "apple"]
+
+// Reversing an array of objects
+const people = [
+  { name: "John", age: 25 },
+  { name: "Jane", age: 30 },
+  { name: "Bob", age: 35 },
+];
+people.reverse();
+console.log(people);
+// Output: [
+//   { name: "Bob", age: 35 },
+//   { name: "Jane", age: 30 },
+//   { name: "John", age: 25 },
+// ]
+
+// Note
+// - The reverse() method modifies the original array in-place. If you need to preserve the original order of elements, you should create a copy of the array before calling the reverse() method.
+// - The reverse() method does not return a new array. Instead, it modifies the existing array.

2_output/console_table.js

@@ -1,13 +1,40 @@
 // console.table()
 
 // What
-// - This method is same as a console.log() but it will accept variable as a array and print their output in table format.
+// - console.table() is a method in JavaScript that displays tabular data in a visually appealing format in the browser's console.
+// - It takes an array or object as an argument and displays it as a table
+
+// Why
+// - console.table() is useful for debugging and inspecting complex data structures, such as arrays of objects or nested objects.
+// - It provides a clear and organized view of the data, making it easier to analyze and understand.
+
+// How
+// - console.table() iterates over the elements of the provided array or object and displays them in a table format in the console.
+// - It automatically generates column headers based on the properties of the elements.
 
 // Syntax
-// console.table([variable, variable, variable]);
+// console.table(variable,array or Object);
 
+// Example: 1
 const variable1 = 1;
 const variable2 = 2;
 const variable3 = 3;
 
 console.table([variable1, variable2, variable3]);
+
+// Example: 2
+const students = [
+  { name: "John", age: 20, grade: "A" },
+  { name: "Alice", age: 19, grade: "B" },
+  { name: "Bob", age: 21, grade: "C" },
+];
+
+console.table(students);
+
+// Note
+// - console.table() is a helpful debugging tool, but it should not be used for logging or displaying data in a production environment.
+
+// When
+// - Use console.table() when you need to inspect complex data structures, such as arrays of objects or nested objects, in the browser's console.
+// - Use console.table() to display tabular data in a more readable format for debugging purposes.
+// - Use console.table() to analyze and compare data in a structured manner.

3_directive/use_strict.js

@@ -1,7 +1,5 @@
 // Directive
 
-"use strict";
-
 // What
 // - "Use strict" is a directive in JavaScript that activates strict mode, a stricter set of rules for interpreting and executing JavaScript code.
 
@@ -10,3 +8,24 @@
 
 // How
 // - To activate strict mode, you include the string literal "use strict"; at the beginning of a script or a function. This directive tells the JavaScript engine to interpret the code that follows it in strict mode.
+
+// Syntax
+"use strict";
+
+// Example
+// Strict mode example
+function sum(a, b) {
+  return a + b;
+}
+
+console.log(sum(1, "2")); // This will throw a TypeError in strict mode
+
+// Note
+// - The use strict directive should be placed at the beginning of a script or function to enable strict mode for that scope.
+// - Strict mode can help catch common coding errors and enforce best practices, making your code more reliable and secure.
+
+// When
+// - Use the use strict directive to enable strict mode in your JavaScript code.
+// - Use strict mode to catch common coding errors and enforce best practices.
+// - Use strict mode when working on large projects or collaborating with others to ensure consistent code quality.
+// - Use strict mode when you want to write modern JavaScript code that leverages new features and best practices

4_variable/1_variable.js

@@ -11,14 +11,13 @@
 // - `var` keyword has been deprecated so it's not recommended to use. Only use `let` and `const`.
 
 // Syntax
-
 // Single variable
 var variable = 0; // Not Recommended
 let variable1 = 1;
 const variable2 = 2;
 
 // Multiple variable with same value
-// -First declare then initialize
+// - First declare then initialize
 let variable3, variable4, variable5;
 variable3 = variable4 = variable5 = 1;
 

4_variable/2_var_keyword.js

@@ -1,11 +1,4 @@
-// var Keyword
-
-// Note
-// - `var` keyword has been deprecated so it's not recommended to use.
-// - It can be initialized later.
-// - It can be redeclare.
-// - It can be reassigned.
-// - It has global scope.
+// `var` Keyword (Not Recommended)
 
 // Syntax
 // var variableName = value;
@@ -20,4 +13,11 @@ var variable = "value";
 
 // Reassigned
 var variable = "value1";
-variable = "value2";
+variable = "value2";
+
+// Note
+// - It can be initialized later.
+// - It can be redeclare.
+// - It can be reassigned.
+// - It has global scope.
+// - The var keyword is not recommended for modern JavaScript development. It has been deprecated and replaced with let and const. Using var can lead to unexpected behavior and bugs in your code.

4_variable/3_let_keyword.js

@@ -1,11 +1,4 @@
-// Let Keyword
-
-// Note
-// - It can be initialized later.
-// - It can be reassigned.
-// - It can't be redeclare.
-// - It can be redeclare but in different scope.
-// - It has block scope
+// `let` Keyword
 
 // Syntax
 // let variableName = value;
@@ -28,3 +21,15 @@ let variable2 = "value"; // Declare in global scope
 function myFunction(parameter) {
   let variable2 = "value"; // Redeclare in function scope
 }
+
+// Note
+// - It can be initialized later.
+// - It can be reassigned.
+// - It can't be re-declare.
+// - The let keyword is not hoisted, meaning it cannot be accessed before it is declared in the code.
+// - The let keyword allows you to declare variables with the same name within different blocks, as long as they are in different scopes.
+
+// When
+// - Use let when you need to declare a variable with block scope.
+// - Use let when you need to declare a variable that can be reassigned and re-declared within the same block.
+// - Use let when you need to declare a variable that is only accessible within a specific block, such as inside a function or loop.

4_variable/4_const_keyword.js

@@ -1,21 +1,15 @@
-// Const Keyword
+// `const` Keyword
 
 // What
-// - The const keyword is use to create constant.
+// - The const keyword in JavaScript is used to declare a read-only variable.
 
-// When
-// - Always declare a variable with const when you know that the value should not be changed.
-// Use const when you declare:
-// A new Array
-// A new Object
-// A new Function
-// A new RegExp
+// Why
+//- The const keyword is used to declare variables in JavaScript to store and manipulate data. It provides immutability and helps prevent accidental modifications to variables.
+//- The const keyword is recommended for modern JavaScript development as it enforces read-only variables and helps prevent bugs.
 
-// Note
-// - It can only initialized when it's declared.
-// - It can't be reassigned.
-// - It can't be redeclare.
-// - It can be redeclare but in different scope.
+// How
+// - When you declare a variable using the const keyword, JavaScript reserves memory space to store the variable's value. You can then assign a value to the variable and use it in your program.
+// - The const keyword ensures that the variable's value cannot be modified once it is assigned. If you try to reassign a value to a const variable, JavaScript will throw an error.
 
 // Syntax
 // const constantName = value;
@@ -40,13 +34,25 @@ function myFunction(parameter) {
 
 // Constant Objects and Arrays
 // - The keyword const is a little misleading.
-// - It does not define a constant value. It defines a constant reference to a value.
+// - It does not define a constant value. It defines a constant reference to a value. Because of this...
 
-// Because of this you can NOT:
+// Can't:
 // - Reassign a constant value
 // - Reassign a constant array
 // - Reassign a constant object
 
-// But you CAN:
+// Can:
 // - Change the elements of constant array
-// - Change the properties of constant object
+// - Change the properties of constant object
+
+// Note
+// - It can initialized & declared at same time.
+// - It can't be reassigned.
+// - It can't be redeclare.
+// - The const keyword is not hoisted, meaning it cannot be accessed before it is declared in the code.
+// - The const keyword allows you to declare variables with the same name within different scopes, as long as they are in different blocks.
+// - The const keyword is block-scoped, meaning that the variable's value can only be accessed within the block where it is declared.
+
+// When
+// - Always declare a variable with const when you know that the value should not be changed.
+// - Use const when you declare a new array, object or function

4_variable/var_let_and_const.md

@@ -6,15 +6,3 @@
 | - Can be reassign                       | - Can be reassign                       | - Can't be reassign                     |
 | - Can be redeclare in same scope        | - Can't be in same scope redeclare      | - Can't be in same scope redeclare      |
 | - Can be redeclare with different scope | - Can be redeclare with different scope | - Can be redeclare with different scope |
-
-# NOTE
-
-- You can declare variable without using any of this keyword. But that is not recommend.
-
-# When to Use var, let, or const?
-
-1. Always declare variables
-2. Always use const if the value should not be changed
-3. Always use const if the type should not be changed (Arrays and Objects)
-4. Only use let if you can't use const
-5. Only use var if you MUST support old browsers.

5_datatype/1_datatype.js

@@ -0,0 +1,47 @@
+// Type Of Datatype
+
+// What
+// - Data types in JavaScript are the different types of values that can be stored and manipulated in a program.
+// - They define the kind of data that a variable can hold and the operations that can be performed on that data.
+
+// Why
+// - Data types help ensure that your program behaves correctly and handles different types of data appropriately.
+// - They provide a foundation for writing robust and maintainable code.
+
+// How
+// - JavaScript has a set of built-in data types that define the kind of values that can be stored and manipulated in a program. These data types include:
+// - Number: Represents numeric values, including integers and floating-point numbers.
+// - String: Represents textual data, enclosed in quotes.
+// - Boolean: Represents logical values, which can be either true or false.
+// - Object: Represents complex data structures, such as arrays, functions, and custom objects.
+// - Undefined: Represents a variable that has not been assigned a value.
+// - Null: Represents a variable that has been explicitly assigned a value of null.
+
+// Undefined
+// - You can assign literally a value as a `undefined`
+let undefined1 = undefined;
+// - Declared variable which doesn't assigned any value yet also has undefined as a value.
+let undefined2;
+
+// Null
+// - Null is standalone value. To understand this let say you are creating weather application which give you the temperature of selected city. For any reason server unable to send you the temperature that means there is no temperature value. At that case weather app shouldn't show `0` on screen. Because 0 also refer as temperature value. At that time we use null to show there is actually no temperature and server are unable to fetch data of temperature.
+// - WHEN CHECK THE TYPEOF NULL IT WILL SHOW IT IS AN OBJECT.
+let myNull = null;
+
+// Non-Primitive Data Types (Reference, Complex)
+
+// Object
+const object = {
+  key1: "value1",
+  key2: "value2",
+  key3: "value3",
+};
+
+// Array
+const array = [1, 2, 3, 4, 5];
+
+// Function
+function myFunction(parameter) {
+  return parameter;
+}
+