-
+
- 5 binary representation is equal to 0101 +
- 13 binary representation is equal to 1101 +
- 0101 AND 1101 = 0101 = 5 in decimal representation +
+
+
+
+**2. Fill in the blank with the correct comparison operator to alert true, when x is equal to y.**
+
+ x = 10;
+ y = 10;
+ alert(x __ y);
+
+SHOW ANSWER
+> +
+
+
+
+**3. Fill in the blank with the correct comparison operator to alert true, when x is NOT equal to y.**
+
+ x = 10;
+ y = 5;
+ alert(x __ y);
+
+SHOW ANSWER
+== OR === +
+
+
+
+**4. Fill in the three blanks with the correct conditional (ternary) operators to alert "Too young" if age is less than 18, otherwise alert "Old enough".**
+
+ var age = n;
+ var votingStatus = (age __ 18) __ "Too young" __ "Old enough";
+ alert(votingStatus);
+
+SHOW ANSWER
+!= OR !== +
+
+
+
+**5. Will the output for this statement be true or false?**
+
+ console.log(1 == 1);
+
+SHOW ANSWER
+< ? : +
+
+
+
+**6. Will the output for this statement be true or false?**
+
+ console.log(1 == "1");
+
+SHOW ANSWER
+true +
+
+
+
+**7. Will the output for this statement be true or false?**
+
+ console.log(1 === 1);
+
+SHOW ANSWER
+true +
+
+
+
+**8. Will the output for this statement be true or false?**
+
+ console.log(1 === "1");
+
+SHOW ANSWER
+true +
+
+
+
+**9. Will the output for this statement be true or false?**
+
+ console.log(1 != "1");
+
+SHOW ANSWER
+false +
+
+
+
+**10. Will the output for this statement be true or false?**
+
+ console.log(1 !== "1");
+
+SHOW ANSWER
+false +
+
+
+
+**11. What will the value of the variable color be after the following statement is executed?**
+
+ var color = 5 < 10 ? "red" : "blue";
+
+SHOW ANSWER
+true +
+
diff --git a/docs/Exercise_Questions/continue_break.md b/docs/Exercise_Questions/continue_break.md
new file mode 100644
index 0000000..b169f43
--- /dev/null
+++ b/docs/Exercise_Questions/continue_break.md
@@ -0,0 +1,28 @@
+### Continue Exercise
+1. **Sets** a variable before the loop starts (var i = 0).
+2. **Make** the loop continue when i is 2 and 7
+3. **Sum** after the condition of the continue, add the value of the "i" into a
+accumulator variable called sum
+4. **Print** the final value of var sum
+
+ **Expected Output**:
+ 19
+
+ Reference loop
+ ```js
+ for (var i = 0; i <= 7; i++) {}
+ ```
+
+### Break Exercise
+1. **Sets** a variable before the loop starts (var i = 0).
+2. **Sum** before the condition of the break, add the value of the "i" into a accumulator variable called sum
+3. **Make** the loop break when i is 3
+4. **Print** the final value of var sum
+
+ **Expected Output**:
+ 6
+
+ Reference loop
+ ```js
+ for (var i = 0; i <= 7; i++) {}
+ ```
\ No newline at end of file
diff --git a/docs/Exercise_Questions/date.md b/docs/Exercise_Questions/date.md
new file mode 100644
index 0000000..e4d89cf
--- /dev/null
+++ b/docs/Exercise_Questions/date.md
@@ -0,0 +1,127 @@
+1.**Write** a JavaScript program to get the `current date`.
+
+**Expected Output**:
+
+**mm-dd-yyyy**, **mm/dd/yyyy** or **dd-mm-yyyy**, **dd/mm/yyyy**
+
+2. Write a JavaScript function to check whether an `input` is a date object or not.
+
+Test Data :
+```js
+console.log(is_date("October 13, 2014 11:13:00"));
+console.log(is_date(new Date(86400000)));
+console.log(is_date(new Date(99,5,24,11,33,30,0)));
+console.log(is_date([1, 2, 4, 0]));
+```
+Output :
+```js
+false
+true
+true
+false
+```
+3. Write a JavaScript function to get the current date.
+
+Note : Pass a separator as an argument.
+Test Data :
+```js
+console.log(curday('/'));
+console.log(curday('-'));
+```
+Output :
+```js
+"11/13/2014"
+"11-13-2014"
+```
+4. Write a JavaScript function to get the number of days in a month.
+
+Test Data :
+```js
+console.log(getDaysInMonth(1, 2012));
+console.log(getDaysInMonth(2, 2012));
+console.log(getDaysInMonth(9, 2012));
+console.log(getDaysInMonth(12, 2012));
+```
+Output :
+```js
+31
+29
+30
+31
+```
+5. Write a JavaScript function to get the month name from a particular date.
+
+Test Data :
+```js
+console.log(month_name(new Date("10/11/2009")));
+console.log(month_name(new Date("11/13/2014")));
+```
+Output :
+```js
+"October"
+"November"
+```
+6. Write a JavaScript function to compare dates (i.e. greater than, less than or equal to).
+
+Test Data :
+```js
+console.log(compare_dates(new Date('11/14/2013 00:00'), new Date('11/14/2013 00:00')));
+console.log(compare_dates(new Date('11/14/2013 00:01'), new Date('11/14/2013 00:00')));
+console.log(compare_dates(new Date('11/14/2013 00:00'), new Date('11/14/2013 00:01')));
+```
+Output :
+```js
+"Date1 = Date2"
+"Date1 > Date2"
+```
+7. Write a JavaScript function to add specified minutes to a Date object.
+
+Test Data :
+```js
+console.log(add_minutes(new Date(2014,10,2), 30).toString());
+```
+Output :
+```js
+"Sun Nov 02 2014 00:30:00 GMT+0530 (India Standard Time)"
+```
+8. Write a JavaScript function to test whether a date is a weekend.
+
+Note : Use standard Saturday/Sunday definition of a weekend.
+Test Data :
+```js
+console.log(is_weekend('Nov 15, 2014'));
+console.log(is_weekend('Nov 16, 2014'));
+console.log(is_weekend('Nov 17, 2014'));
+```
+Output :
+```js
+"weekend"
+"weekend"
+undefined
+```
+9. Write a JavaScript function to get difference between two dates in days.
+
+Test Data :
+```js
+console.log(date_diff_indays('04/02/2014', '11/04/2014'));
+console.log(date_diff_indays('12/02/2014', '11/04/2014'));
+```
+Output :
+```js
+216
+-28
+```
+10. Write a JavaScript function to get the last day of a month.
+
+Test Data :
+```js
+console.log(lastday(2014,0));
+console.log(lastday(2014,1));
+console.log(lastday(2014,11));
+```
+Output :
+```js
+31
+28
+31
+```
diff --git a/docs/Exercise_Questions/filter.md b/docs/Exercise_Questions/filter.md
new file mode 100644
index 0000000..755d085
--- /dev/null
+++ b/docs/Exercise_Questions/filter.md
@@ -0,0 +1,34 @@
+### Filter Exercises
+**1. Filter the array with values greated than 10**
+1. **Create** an array called numbers with the next elements
+`array` = [21,10,5,9,100,2,5,6,90,25,14,32]
+2. **Filter** the numbers greater than 10
+3. **Print** the result of filter
+
+ **Expected Output**:
+ [21,100,90,25,14,32]
+
+**2. Write a JavaScript code that filters an array of integers to even integers and odd integers.**
+```javascript
+let numbers = [1,232,143,101,73,99,23,1998];
+// let even_integers = SHOW ANSWER
+"red" +
+
diff --git a/docs/Exercise_Questions/for_each.md b/docs/Exercise_Questions/for_each.md
new file mode 100644
index 0000000..9dba3d4
--- /dev/null
+++ b/docs/Exercise_Questions/for_each.md
@@ -0,0 +1,32 @@
+## JavaScript Array forEach() Method
+
+/*
+-- forEach() method takes a callback function then loops through all the array elements and execute the callback function once for each array element
+-- forEach() method DOES NOT modify the array and unlike map() method, forEach() DOES NOT return a new array
+*/
+// assume we have an array of numbers and we need to get square of each number
+```js
+const numbers = [5, 4, 6, 12, 23, 1, 72], squares = [];
+
+[5, 4, 6, 12, 23, 1, 72].forEach(n => {
+ squares.push(n * n)
+});
+
+console.log(squares);
+```
+expected output: Array [25, 16, 36, 144, 529, 1, 5184]
+
+/*
+-- Another example using index of elements in the callback function
+-- In this example, we create an Object from an Array
+*/
+```js
+const users = ['John', 'Sally', 'Brad', 'Jack'], usersObj = {}
+
+users.forEach((user, index) => {
+ usersObj[index] = user
+})
+
+console.log(usersObj)
+```
+expected output : Object {0: "John", 1: "Sally", 2: "Brad", 3: "Jack"}
diff --git a/docs/Exercise_Questions/higher_order_functions.md b/docs/Exercise_Questions/higher_order_functions.md
new file mode 100644
index 0000000..95bef02
--- /dev/null
+++ b/docs/Exercise_Questions/higher_order_functions.md
@@ -0,0 +1,26 @@
+1. Write an function `square` which takes an array as input and return a new array use [map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) method.
+For example, `square([1,2,3,4])` should return `[1,4,9,16]`.
+
+2. Write an function `getOdd` which takes an array of number as input and return a new array contains only odd number use [filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) method.
+For example, `getOdd([1,2,3,4,5])` should return `[1,3,5]`.
+
+Solution
++ +```javascript +let numbers = [1,232,143,101,73,99,23,1998]; +let even_integers = numbers.filter(num => num%2==0); +let odd_integers = numbers.filter(num => num%2==1); + +console.log(even_integers); // [232,1998] +console.log(odd_integers); // [1,143,101,73,99,23] +``` + +
+
+
diff --git a/docs/Exercise_Questions/if_else.md b/docs/Exercise_Questions/if_else.md
new file mode 100644
index 0000000..554bc7f
--- /dev/null
+++ b/docs/Exercise_Questions/if_else.md
@@ -0,0 +1,137 @@
+### If Else Exercises
+
+**1. Write a JavaScript program to determine if a number is positive, negative, or zero.**
+
+```
+Example Input:
+6
+0
+-20
+```
+
+```
+Expected Output:
+"positive"
+"zero"
+"negative"
+```
+
+**2. Look up how to get the current time in Javascript. Based on this, create a series of if-else statements that will check against the current time and print either:**
+
+- "Good morning!" if it's from 6:00am-12:00pm
+- "Good afternoon!" if the time is between 12:00pm - 6:00pm
+- "Good evening!" if the time is from 6:00pm to Midnight
+- "Good night!" if the time is from Midnight to 6:00am.
+
+**3. Write a JavaScript code that identifies whether a number is odd or even. _Hint: A number is even if it is divisible by two, otherwise it is odd._**
+
+```
+Example Input:
+143
+27
+100
+```
+
+```
+Expected Output:
+"odd"
+"odd"
+"even"
+```
+Solution
++ +1. Use `Array.prototype.map` method. +```js +function square(arr) { + return arr.map(number => number * number); +} +``` + +2. Use `Array.prototype.filter` method. +```js +function getOdd(arr){ + return arr.filter(num => num % 2 === 1); +} +``` + +
+
+
+
+**4. Write a JavaScript function that tells the user whether a code is the right password or not. If the password is correct then the output should be "Vault opening...", if it's not the output should be "Wrong Password!".**
+
+```
+Example Input:
+"abcd12345"
+with correct password being "abcd12345"
+```
+
+```
+Expected Output:
+"Vault opening..."
+```
+Solution
++ +```javascript +let x = 143; //change value +if (x%2 == 0) { + console.log('even'); +} +else { + console.log('odd'); +} +``` + +
+
+
+
+5. Write a JavaScript conditional statement to find the sign of product of three numbers. Display an alert box with the specified sign.
+Sample numbers : 3, -7, 2
+Output : The sign is -
+
+6. Write a JavaScript conditional statement to sort three numbers. Display an alert box to show the result.
+Sample numbers : 0, -1, 4
+Output : 4, 0, -1
+
+7. Write a JavaScript program which compute, the average marks of the following students Then, this average is used to determine the corresponding grade. Go to the editor
+
+Student Name Marks
+David 80
+Vinoth 77
+Divya 88
+Ishitha 95
+Thomas 68
+The grades are computed as follows :
+
+Range Grade
+<60 F
+<70 D
+<80 C
+<90 B
+<100 A
+
+8. According to Wikipedia a happy number is defined by the following process :
+"Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1. Those numbers for which this process ends in 1 are happy numbers, while those that do not end in 1 are unhappy numbers (or sad numbers)".
+Write a JavaScript program to find and print the first 5 happy numbers.
+
+9. You are given a variable marks. Your task is to print:
+
+- AA if marks is greater than 90.
+- AB if marks is greater than 80 and less than or equal to 90.
+- BB if marks is greater than 70 and less than or equal to 80.
+- BC if marks is greater than 60 and less than or equal to 70.
+- CC if marks is greater than 50 and less than or equal to 60.
+- CD if marks is greater than 40 and less than or equal to 50.
+- DD if marks is greater than 30 and less than or equal to 40.
+- FF if marks is less than or equal to 30.
+
+10. Write a function named pluralize that:
+ takes 2 arguments, a noun and a number.
+ returns the number and pluralized form, like "5 cats" or "1 dog".
+ Call that function for a few different scores and log the result to make sure it works.
+ Bonus: Make it handle a few collective nouns like "sheep" and "geese".
+
+11. Write a JavaScript program that prompts for an employee name, SSN, rate of pay, and hours worked, and computes the total pay for the employee. If the hours worked is greater than 40, use one and the half for overtime rate (for hours beyond 40) and compute accordingly.
\ No newline at end of file
diff --git a/docs/Exercise_Questions/inheritance.md b/docs/Exercise_Questions/inheritance.md
new file mode 100644
index 0000000..8577316
--- /dev/null
+++ b/docs/Exercise_Questions/inheritance.md
@@ -0,0 +1 @@
+**Write** a Javascript function called Vehicle that has variables [Make and Model] in it. Then write another function called Car that calls Vehicle function and also add two more variables [Body and Trim]. Once that is done you can call Car function and see that it inherits from Vehicle.
\ No newline at end of file
diff --git a/docs/Exercise_Questions/looping_objects.md b/docs/Exercise_Questions/looping_objects.md
new file mode 100644
index 0000000..91ede6c
--- /dev/null
+++ b/docs/Exercise_Questions/looping_objects.md
@@ -0,0 +1,70 @@
+1. Given an object
+```js
+const person = {
+ name: 'John Doe',
+ age: 26,
+ gender: 'Male'
+}
+```
+Write code to iterate through `person` object and output something like
+```js
+person.name = John Doe
+person.age = 26
+person.gender = Male
+```
+
+2. Given the following code
+```js
+function Dog (age) {
+ this.age = age;
+}
+
+Dog.prototype = {
+ bark: () => console.log('woof')
+}
+
+const dog = new Dog(2);
+```
+
+Write code to iterate through `dog` object and output something like
+```js
+dog.age = 2
+```
+
+Solution
++ +```javascript +let password = "abcd12345"; + +function check(code){ + if (code === password) { + console.log("Vault opening..."); +} + else { + console.log("Wrong Password!"); + } +} + +``` + +
+
+
diff --git a/docs/Exercise_Questions/number_methods.md b/docs/Exercise_Questions/number_methods.md
new file mode 100644
index 0000000..a1cf641
--- /dev/null
+++ b/docs/Exercise_Questions/number_methods.md
@@ -0,0 +1,135 @@
+1. Write code to determine if the following values are _Finite_.
+The output should be a **boolean value**
+```js
+
+ var number9 = 9;
+ var infinity = Infinity;
+ var notANumber = NaN;
+ var zero = 0;
+ var exponentNumber = 2e10;
+ var stringZero = '0';
+ var nothing = null;
+ var divideByZero = 1/0;
+ var oneFourth = 1/4;
+```
+
+2. Write code to determine if the following values are _Integers_.
+The output should be a **boolean value**
+```js
+ var zero = 0;
+ var one = 1;
+ var oneTenthAsDecimal = 0.1;
+ var pi = Math.PI;
+ var stringTen = '10';
+ var fiveAnd1Decimal = 5.0;
+ var fiveAnd8Decimal = 5.00000001;
+ var fiveAnd16Decimal = 5.0000000000000001;
+```
+
+3. Write code to determine if the following values are _Not a number_.
+The output should be a **boolean value**
+```js
+ var nan = NaN;
+ var zeroDividedByZero = 0/0;
+ var stringNotANumber = 'NaN';
+ var emptyObject = {};
+ var stringThirty = '30';
+ var thirty = 30;
+ var someText = 'some text';
+ var emptyString = '';
+ var singleSpace = ' ';
+
+```
+
+4. Write code to determine if the following values are _safe integers_.
+The output should be a **boolean value**
+```js
+ var nan = NaN;
+ var infinity = Infinity;
+ var stringThirty = '30';
+ var thirty = 30;
+ var fiveAnd1Decimal = 5.0;
+ var oneTenthAsDecimal = 0.1;
+```
+
+5. Write code to convert the following values _to exponential form_.
+The output should be **string representing the Number object in exponential notation.**
+```js
+ var numbers = 123456;
+ // expect numbers to be 1.23456e+5
+
+ var numberWith5Decimals = 5.01234;
+ // expect numberWith5Decimals to be 5.01e+0
+
+ var oneTenthAsDecimal = 0.1;
+ // expect oneTenthAsDecimal to be 1e-1
+```
+
+6. Write code to convert the following values _to fixed-point notation_.
+
+```js
+ var floatingNumber1 = 123.456;
+ // expect floatingNumber1 to return 123.46
+
+ var floatingNumber2 = 123.000009;
+ // expect floatingNumber2 to return 123
+
+ var exponentNumber3 = 1.23e+10;
+ // expect exponentNumber3 to return 12300000000.00
+
+ var floatingNumber4 = 1.55;
+ // expect floatingNumber4 to return 1.6
+
+```
+
+7. Write code to return a string with a language-sensitive representation of the `Number`
+```js
+ var germanNumber = 123.34
+ // expect value to be 123,12
+ var arabicNumber = 123.11
+ // expect value to be ١٢٣٫١٢
+
+```
+
+8. Write code to returns a string representing the `Number` object to the specified precision.
+```js
+ var floatingNumber1 = 123.456;
+ // expect floatingNumber1 to be precise up to 2 digits.
+ // The expected output should be 1.2e+2
+ var exponentNumber3 = 1.23e+10;
+ // expect exponenentNumber3 to be precise up to 4 digits.
+ // The expected output should be 1.230e+10
+
+ var numberWith5Decimals = 5.01234;
+ // expect numberWith5Decimals to be precise up to 0 digits.
+ // The expected output should be 5
+```
+
+9. Write code to return a string representing the specified `Number` object.
+```js
+ // NOTE:
+ // when outputting the results to a browser's console.
+ // The double quotes will not be displayed
+ // You can verify the output by checking its 'type' and
+ // confirm that it is of type String
+
+ var floatingNumber1 = 123.456;
+ // expect floatingNumber1 to be in string format "123.456"
+
+ var exponentNumber3 = 1.23e+10;
+ // expect exponenentNumber3 to be in string format "12300000000"
+
+ var pi = Math.PI;
+ // expect pi to be in string format "3.141592653589793"
+```
+
+10. Write code to return the wrapped primitive value of a `Number` object.
+```js
+
+ var numberObject = new Number(42);
+ // expect to return the value 42 from the object
+
+ var piObject = new Number(Math.PI);
+ // expect to return the value 3.141592653589793 from the object
+
+```
\ No newline at end of file
diff --git a/docs/Exercise_Questions/object.md b/docs/Exercise_Questions/object.md
new file mode 100644
index 0000000..ec1189d
--- /dev/null
+++ b/docs/Exercise_Questions/object.md
@@ -0,0 +1,116 @@
+1. **Create** an object of class `Student` containing his/her `first name`, `last name`, `age`, `college` and `bio`.
+
+2. Encapsulate *(with getters and setters)* the user details **using normal functions**.
+
+3. **Implement** a class `Student`, which should contain his/her `first name`, `last name`, `age`, `college` and `bio`.
+
+4. Encapsulate *(with getters and setters)* the user details **using class members**.
+
+# Answer
+
+### Solution Using Object
+```js
+const student = {
+ firstName: "Swapnil",
+ lastName: "Shinde",
+ age: 19,
+ college: "SIES",
+ bio: "Web developer"
+};
+
+getFullName = () => {
+ return `${student.firstName} ${student.lastName}`;
+};
+
+getBio = () => {
+ return student.bio;
+};
+
+getAllDetails = () => {
+ return `My name is ${student.firstName} ${student.lastName} \nMy age is ${student.age} \nMy college is ${student.college}, I am ${student.bio}.`;
+};
+
+console.log(getFullName()); // Output Swapnil Shinde
+
+console.log(getBio()); // Output Web developer
+
+console.log(getAllDetails()); // Output My name is Swapnil Shinde. My age is 19. My college is SIES, I am Web developer.
+```
+
+### Solution Using Classes
+```js
+class Student {
+ // Created the constructor for student
+ constructor (firstName, lastName, age, college, bio) {
+ this.firstName = firstName;
+ this.lastName = lastName;
+ this.age = age;
+ this.college = college;
+ this.bio = bio;
+ }
+
+ // This method returns combined firstname and lastname
+ getFullName () {
+ return (`${this.firstName} ${this.lastName}`);
+ }
+
+ // This method returns bio
+ getBio () {
+ return (`${this.bio}`);
+ }
+
+ // This method returns All details
+ getAllDetails () {
+ return (`My name is ${this.firstName} ${this.lastName} \nMy age is ${this.age} \nMy college is ${this.college}, I am ${this.bio}.`);
+ }
+}
+
+const Swapnil = new Student("Swapnil", "Shinde", 19, "SIES", "Web Developer"); // Created object with arguments
+
+console.log(Swapnil.getFullName()); // Output Swapnil Shinde
+
+console.log(Swapnil.getBio()); // Output Web Developer
+
+console.log(Swapnil.getAllDetails()); // Output My name is Swapnil Shinde. My age is 19. My college is SIES, I am Web Developer.
+
+console.log(Swapnil); // This returns the object only
+/*
+ Output
+
+Student {
+ firstName: 'Swapnil',
+ lastName: 'Shinde',
+ age: 19,
+ college: 'SIES',
+ bio: 'Web Developer'
+}
+*/
+```
+
+### Solution Using Arrays
+
+```js
+const array = [1, 0.16, "Random", function () {
+ console.log("this is function in an array");
+}, { Key: "Answer" }, false];
+
+console.log("Array can contain anything");
+console.log(array);
+// add last
+array.push("add last");
+console.log(array);
+// remove last
+array.pop();
+console.log(array);
+// add first
+array.shift("add first");
+console.log(array);
+
+// remove first
+array.unshift();
+console.log(array);
+// this element is function
+array[2]();
+// object inside array
+console.log(array[3].Key);
+```
\ No newline at end of file
diff --git a/docs/Exercise_Questions/reduce.md b/docs/Exercise_Questions/reduce.md
new file mode 100644
index 0000000..05fd5ad
--- /dev/null
+++ b/docs/Exercise_Questions/reduce.md
@@ -0,0 +1,53 @@
+# Reduce exercises
+
+The reduce method allows you to "reduce" the contents of an Array into one value.
+
+## 1. Sum of prices
+Write a function that sums up the prices in a shopping cart.
+
+```js
+const items = [
+ { name: 'Flour', price: 1 },
+ { name: 'Tomatos', price: 4 },
+ { name: 'Cucumbers', price: 2 },
+ { name: 'Cheese', price: 7 },
+ { name: 'Wine', price: 14 },
+];
+
+const expectedResult = 28;
+```
+
+## 2. Grades by course
+Given a list of grades with their course, return an object where the key is the name of the course and the value is a list of the corresponding grades.
+
+```js
+const grades = [
+ { course: 'Algebra', test: 1, grade: 'A'},
+ { course: 'Algebra', test: 2, grade: 'C'},
+ { course: 'Algebra', test: 3, grade: 'B'},
+ { course: 'Algorithms & Datastructures', test: 1, grade: 'D'},
+ { course: 'Algorithms & Datastructures', test: 2, grade: 'C'},
+ { course: 'Algorithms & Datastructures', test: 3, grade: 'C+'},
+ { course: 'English', test: 1, grade: 'B'},
+ { course: 'English', test: 2, grade: 'C'},
+ { course: 'English', test: 3, grade: 'B'},
+];
+
+const expectedResult = {
+ 'Algebra': [
+ { course: 'Algebra', test: 1, grade: 'A'},
+ { course: 'Algebra', test: 2, grade: 'C'},
+ { course: 'Algebra', test: 3, grade: 'B'},
+ ],
+ 'Algorithms & Datastructures': [
+ { course: 'Algorithms & Datastructures', test: 1, grade: 'D'},
+ { course: 'Algorithms & Datastructures', test: 2, grade: 'C'},
+ { course: 'Algorithms & Datastructures', test: 3, grade: 'C+'},
+ ],
+ 'English': [
+ { course: 'English', test: 1, grade: 'B'},
+ { course: 'English', test: 2, grade: 'C'},
+ { course: 'English', test: 3, grade: 'B'},
+ ]
+};
+```
diff --git a/docs/Exercise_Questions/regex.md b/docs/Exercise_Questions/regex.md
new file mode 100644
index 0000000..3c48a59
--- /dev/null
+++ b/docs/Exercise_Questions/regex.md
@@ -0,0 +1,99 @@
+### Regex Exercises
+**1. Write a JavaScript program to test the first character of a string is uppercase or not.**
+
+Solution
++ +1. +Use `for...in loop` method. +```js +for(const key in person){ + console.log(`person.${key} = ${person[key]}`) +} +``` + +Use `Object.keys` +```js +Object.keys(person).forEach(key => console.log(`person.${key} = ${person[key]}`)) +``` + +2. +Use `for...in loop` method. +```js +for(const key in dog){ + if(dog.hasOwnProperty(key)) { + console.log(`dog.${key} = ${dog[key]}`) + } +} +``` + +Use `Object.keys` +```js +Object.keys(dog).forEach(key => { + if(dog.hasOwnProperty(key)) { + console.log(`dog.${key} = ${dog[key]}`) + } +}) +``` +
+
+
+
+
+**2. Write a JavaScript program to check a credit card number.**
+
+Solution
++ +```javascript +regexp = /^[A-Z]/; + +``` + +
+
+
+
+
+**3. Write a pattern that matches e-mail addresses.**
+ The personal information part contains the following ASCII characters.
+ Uppercase (A-Z) and lowercase (a-z) English letters.
+ Digits (0-9).
+ Characters ! # $ % & * + - / = ? ^ _ { | } ~
+ Character . ( period, dot or fullstop) provided that it is not the first or last character and it will not come one after the other.
+
+Solution
++ +```javascript + regexp = /^(?:(4[0-9]{12}(?:[0-9]{3})?)|(5[1-5][0-9]{14})|(6(?:011|5[0-9]{2})[0-9]{12})|(3[47][0-9]{13})|(3(?:0[0-5]|[68][0-9])[0-9]{11})|((?:2131|1800|35[0-9]{3})[0-9]{11}))$/ +``` + +
+
+
+
+**4. Write a JavaScript program to search a date within a string.**
+
+Solution
++ +```js +regex = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/ +``` +
+
+
+
+**5. Write a JavaScript program that work as a trim function (string) using regular expression.**
+
+Solution
++ +```js +regexp = /^(1[0-2]|0?[1-9])\/(3[01]|[12][0-9]|0?[1-9])\/(?:[0-9]{2})?[0-9]{2}$/; +``` +
+
+
+
+**6. Write a JavaScript program to count number of words in string.**
+Note :
+- Remove white-space from start and end position.
+- Convert 2 or more spaces to 1.
+- Exclude newline with a start spacing.
+
+Solution
++ +```js +result = str.replace(/^\s+|\s+$/g, ''); +``` +
+
+
diff --git a/docs/Exercise_Questions/string.md b/docs/Exercise_Questions/string.md
new file mode 100644
index 0000000..bf94a9d
--- /dev/null
+++ b/docs/Exercise_Questions/string.md
@@ -0,0 +1,89 @@
+### String Operations Exercises
+
+**1. Write a JavaScript function to convert a string in abbreviated form.**
+
+Example of call of the function
+
+**Example**
+Test Data :
+```js
+console.log(abbrev_name("Musa Bajwa"));
+```
+Example Output:-
+"Musa B."
+
+2. **Write** a JavaScript function to concatenates a given string n times (default is 1).
+
+**Example**
+Test Data :
+console.log(repeat('Lol!'));
+console.log(repeat('Lol!',2));
+console.log(repeat('Lol!',3));
+"Lol!"
+"Lol!Lol!"
+"Lol!Lol!Lol!"
+
+3. **Write** a JavaScript function to strip leading and trailing spaces from a string.
+
+**Example**
+
+Test Data :
+console.log(strip('cool '));
+console.log(strip(' cool'));
+console.log(strip(' cool '));
+Output :
+"cool"
+"cool"
+"cool"
+
+4. Write a Javascript program to get the character at the given index within the String.
+
+Sample Output:
+
+Original String = Javascript Exercises!
+The character at position 0 is J
+The character at position 10 is i
+
+5. Write a Javascript program to get the character (Unicode code point) at the given index within the String.
+
+Sample Output:
+
+Original String : w3resource.com
+Character(unicode point) = 51
+Character(unicode point) = 101
+
+6. Write a Javascript program to compare two strings lexicographically.
+
+Sample Output:
+
+String 1: This is Exercise 1
+String 2: This is Exercise 2
+"This is Exercise 1" is less than "This is Exercise 2"
+
+7. Write a Javascript program to test if a given string contains the specified sequence of char values.
+
+Sample Output:
+
+Original String: PHP Exercises and Python Exercises
+Specified sequence of char values: and
+true
+
+8. Write a Javascript program to compare a given string to another string, ignoring case considerations.
+
+Sample Output:
+
+"Stephen Edwin King" equals "Walter Winchell"? false
+"Stephen Edwin King" equals "stephen edwin king"? true
+
+9. Write a Javascript program to get the canonical representation of the string object.
+
+Sample Output:
+
+str1 == str2? false
+str1 == str3? true
+
+10. Write a Javascript program to find whether a region in the current string matches a region in another string.
+Sample Output:
+
+str1[0 - 7] == str2[28 - 35]? true
+str1[9 - 15] == str2[9 - 15]? false
\ No newline at end of file
diff --git a/docs/Exercise_Questions/switch.md b/docs/Exercise_Questions/switch.md
new file mode 100644
index 0000000..11b0004
--- /dev/null
+++ b/docs/Exercise_Questions/switch.md
@@ -0,0 +1,59 @@
+## Switch Case Exercises
+**1. Write a JavaScript function for basic arithmetic computations.** The function should accept two numbers and an operator and should return the computed value. If the operator is not included in the allowed values, return `Invalid operator`. _Hint: "operator" will be compared to each case_
+```
+Parameters:
+x - any number
+y - any number
+operator - one of the arithmetic operators:
+ + (addition)
+ - (subtraction)
+ * or x or X (multiplication)
+ / (division)
+```
+```javascript
+function compute(x,y,operator) {
+ // your code here
+}
+
+console.log(compute(1,6,"*")) //6
+console.log(compute(1,6,"%")) //Invalid operator
+```
+
+Solution
++ + ```js +function count_words() +{ + str1= document.getElementById("InputText").value; + + //exclude start and end white-space + str1 = str1.replace(/(^\s*)|(\s*$)/gi,""); + + //convert 2 or more spaces to 1 + str1 = str1.replace(/[ ]{2,}/gi," "); + // exclude newline with a start spacing + str1 = str1.replace(/\n /,"\n"); + document.getElementById("noofwords").value = str1.split(' ').length; +} +``` + +
+
+
diff --git a/docs/Exercise_Questions/two_strings.md b/docs/Exercise_Questions/two_strings.md
new file mode 100644
index 0000000..a64f4e0
--- /dev/null
+++ b/docs/Exercise_Questions/two_strings.md
@@ -0,0 +1,23 @@
+# Anagram
+
+given two strings as parameters, check whether you can make the first string into the second string. Assume the two strings have equal length
+
+# Example 1
+
+String1 = 'team'
+String2 = 'mate'
+
+should return return true because you can rearrange team to make mate
+
+# Example 2
+
+String1 = 'angered'
+String2 = 'enraged'
+
+Returns true
+
+# Example 3
+String1 = 'evils'
+String2 = 'vile'
+
+return false since the length of two strings are not equal
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/AJAX_request.md b/docs/JavaScript_Advance/AJAX_request.md
new file mode 100644
index 0000000..40c71b4
--- /dev/null
+++ b/docs/JavaScript_Advance/AJAX_request.md
@@ -0,0 +1,30 @@
+```js
+const POST = "POST";
+
+export class AJAXRequest {
+ constructor () {
+ // eslint-disable-next-line no-undef
+ this.request = new XMLHttpRequest();
+ }
+
+ open (method, url, async) {
+ this.method = method;
+ this.request.open(method, url, async);
+ }
+
+ send (string) {
+ const args = this.method === POST ? [string] : [];
+ this.request.send.apply(this.request, args);
+ }
+}
+// OR closure approach
+
+// eslint-disable-next-line no-undef
+const request = new XMLHttpRequest();
+
+let usedMethod;
+export const open = (method, url, async) => {
+ usedMethod = method;
+ request.open(method, url, async);
+};
+export const send = string => (usedMethod === POST ? request.send(string) : request.send());```
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/IEEE-754.md b/docs/JavaScript_Advance/IEEE-754.md
new file mode 100644
index 0000000..e35947b
--- /dev/null
+++ b/docs/JavaScript_Advance/IEEE-754.md
@@ -0,0 +1,19 @@
+console.log(0.1 + 0.2); // 0.3000000000000004
+console.log(0.3 + 0.6); // 0.8999999999999999
+
+/*
+Why does this happen?
+It's actually pretty simple. When you have a base 10 system (like ours),
+it can only express fractions that use a prime factor of the base.
+The prime factors of 10 are 2 and 5. So 1/2, 1/4, 1/5, 1/8, and 1/10 can all
+be expressed cleanly because the denominators all use prime factors of 10.
+In contrast, 1/3, 1/6, and 1/7 are all repeating decimals because their denominators
+use a prime factor of 3 or 7. In binary (or base 2), the only prime factor is 2.
+So you can only express fractions cleanly which only contain 2 as a prime factor.
+In binary, 1/2, 1/4, 1/8 would all be expressed cleanly as decimals.
+While, 1/5 or 1/10 would be repeating decimals. So 0.1 and 0.2 (1/10 and 1/5) while clean
+ decimals in a base 10 system, are repeating decimals in the base 2 system
+ the computer is operating in. When you do math on these repeating decimals,
+ you end up with leftovers which carry over when you convert the computer's
+ base 2 (binary) number into a more human readable base 10 number.
+*/
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/JSON.md b/docs/JavaScript_Advance/JSON.md
new file mode 100644
index 0000000..e06b9e8
--- /dev/null
+++ b/docs/JavaScript_Advance/JSON.md
@@ -0,0 +1,9 @@
+const sammy = {
+ first_name: "Sammy",
+ last_name: "Shark",
+ online: true
+};
+// accessing each value using dot notation
+console.log(sammy.first_name);
+console.log(sammy.last_name);
+console.log(sammy.online);
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/XML_http_request.md b/docs/JavaScript_Advance/XML_http_request.md
new file mode 100644
index 0000000..d934ee6
--- /dev/null
+++ b/docs/JavaScript_Advance/XML_http_request.md
@@ -0,0 +1,40 @@
+/***
+ * XMLHttpRequest
+ * can be used to retrieve a server side data without having full page refresh
+ */
+
+const createXhr = () => {
+ return new XMLHttpRequest();
+};
+
+// Request
+const request = isAbort => {
+ const xhr = createXhr();
+
+ // when xhr.send is triggered this function gonna trigger until
+ // ready state is equal 4 and status code is equal 200
+ // to log all response header
+ xhr.onreadystatechange = function () {
+ if (this.readyState == 4 && this.status == 200) {
+ // all headers
+ console.log("all header ==>", this.getAllResponseHeaders());
+ // display specific content type
+ console.log("specific ==>", this.getResponseHeader("content-type"));
+ }
+ };
+
+ // parameter open(method, url, async)
+ // this function gonna request for server side data
+ xhr.open("GET", "https://reqres.in/api/users/2", true);
+ xhr.send();
+
+ if (isAbort) {
+ xhr.abort();
+ console.log("request has been abort");
+ }
+};
+
+// in this case response header should have display
+request();
+// in this case response header should havn't display but will display "request has been abort"
+request(abort);
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/arrayFlat.md b/docs/JavaScript_Advance/arrayFlat.md
deleted file mode 100644
index 10f67f6..0000000
--- a/docs/JavaScript_Advance/arrayFlat.md
+++ /dev/null
@@ -1 +0,0 @@
-# Array Flat Method
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/arrowFunction.md b/docs/JavaScript_Advance/arrowFunction.md
deleted file mode 100644
index 91c9ac4..0000000
--- a/docs/JavaScript_Advance/arrowFunction.md
+++ /dev/null
@@ -1 +0,0 @@
-# Arrow Function
diff --git a/docs/JavaScript_Advance/arrow_function.md b/docs/JavaScript_Advance/arrow_function.md
new file mode 100644
index 0000000..04b8625
--- /dev/null
+++ b/docs/JavaScript_Advance/arrow_function.md
@@ -0,0 +1,84 @@
+```js
+let a = () => {
+ // This is arrow function came new in ES6
+ //It assigns the function to variable a as the identifier with let instead and adds arrows before the curly braces.
+
+};
+
+let multiply = (num) => num * num
+
+//arrow functions also works without curly braces {} and can directly write expression after the arrows
+// this is known as concise body as opposed to a block body (with {});
+//cannot be used with if statements, or an error will appear since it only takes one expression;
+//ternary operators can be used with arrow functions as a more concise way to write if statements
+
+let info = {
+ firstName: "Swapnil",
+ lastName: "Shinde",
+ getFullName: () => {
+ return (`My name is ${this.firstName} ${this.lastName}`); // Arrow functions don't have "this" property
+ }
+}
+//not having this. binding means it also cannot be called with new and used as a constructor
+
+console.log(info.getFullName());
+// Output My name is undefined undefined that's why we don't use this with arrow function
+
+let newInfo = {
+ firstName: "Swapnil",
+ lastName: "Shinde",
+ getFullName: () => {
+ return (`My name is ${newInfo.firstName} ${newInfo.lastName}`); // If we are using arrow function then directly use the variables as shown
+ }
+}
+
+console.log(newInfo.getFullName());
+// Output My name is Swapnil Shinde
+
+// Using arrow functions in Class
+class Student {
+ constructor() {
+ this.name = 'Vishal'
+ }
+
+ getName = () => {
+ return this.name;
+ }
+}
+
+console.log((new Student).getName()) // Gives error for node versions before 12.4.0(Approx) SyntaxError: Unexpected token =
+
+class StudentInfo {
+
+ constructor(firstName, lastName, age, branch, college) {
+ this.firstName = firstName;
+ this.lastName = lastName;
+ this.age = age;
+ this.branch = branch;
+ this.college = college;
+ };
+
+ getFullName = () => { // Returns full name using string interpolation
+ return (`My name is ${this.firstName} ${this.lastName}`); // If we are using arrow function then directly use the variables as shown
+ };
+
+ getBranch = () => { // Returns Branch
+ return (this.branch);
+ };
+
+}
+
+let Swapnil = new StudentInfo("Swapnil", "Shinde", 19, "Computer", "Sies"); // This way we can create new objects with arguments
+
+console.log(Swapnil.getFullName()); // Output My name is Swapnil Shinde
+
+//settimeout without arrow function
+setTimeout(function () {
+ console.log("hello world");
+}, 1000);
+
+//settimeout with arrow function
+setTimeout(() => {
+ console.log("hello world");
+}, 0); //arrow functions provide better readability
+```
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/assignments_arithmetic.md b/docs/JavaScript_Advance/assignments_arithmetic.md
new file mode 100644
index 0000000..3268a2a
--- /dev/null
+++ b/docs/JavaScript_Advance/assignments_arithmetic.md
@@ -0,0 +1,115 @@
+```js
+/* In javascript there are always several ways to the goal.
+Also the syntax of variable assignment can be abbreviated.
+This is particularly suitable for mathematic operators
+*/
+
+/* Default assignment
+Very basic to this point.
+*/
+
+y = "Yes"; // y: "Yes"
+
+/* Adding
+Adds two values.
+*/
+
+// Basic adding
+y = 1 + 1; // y: 2
+
+// Shortcut
+y += 1; // y: 3 (increases y by 1)
+
+// appending strings by adding
+y = "A"; // y: "A"
+y += "B"; // y: "AB"
+
+// Adding string and number
+y = 1; // y: 1
+y += "1"; // y: "11" (treated as text not as numbers)
+
+/* Subtracting
+subtracts two values
+*/
+
+// Basic adding
+y = 5 - 2; // y: 3
+
+// Shortcut
+y -= 1; // y: 2
+
+// substracting strings
+y = "A"; // y: "A"
+y -= "B"; // y: NaN (Not-a-Number aka we-don't-know-what-it-is-but-definitively-not-decimal)
+
+y = "AA"; // y: "AA"
+y -= "A"; // y: NaN (also not working)
+
+// substracting strings and numbers
+y = 3; // y: 3
+y -= "1"; // y: 2
+
+y = "3"; // y: "3"
+y -= 1; // y: 2
+
+/* Multiplication
+Multiply two values
+*/
+
+// Basic
+y = 3 * 2; // y: 6
+
+// Shortcut
+y *= 2; // y: 12 (doubles y)
+y *= 3; // y: 36 (triples y)
+
+// Multiplying strings
+y = "A" * 3; // y: NaN (doesn't work)
+
+/* Sadly you can't repeat strings by multiplying them. Alternatives:
+ https://www.freecodecamp.org/news/three-ways-to-repeat-a-string-in-javascript-2a9053b93a2d/
+ */
+
+/* Dividing
+Multiply two values
+*/
+
+// Basic
+y = 5 / 2; // y: 2.5
+
+// Shortcut
+y = 64;
+y /= 2; // y: 32 (divides y by two)
+y /= 4; // y: 8 (divides y by four)
+
+/* Modulo
+Short modulo example:
+ 5 % 3 = 2 (3 fits inside 5 one time, 2 remaining)
+ 5 % 2 = 1 (2 fits inside 5 two times, 1 remaining)
+ 5 % 5 = 0 (5 fits inside 5 one time, 0 remaining)
+By modulo 2 you get 1 if the number is odd and 0 if it's even.
+*/
+
+// Basic
+y = 5 % 4; // y: 1
+
+// Shortcut
+y = 5;
+y %= 4; // y:1
+
+// Is y odd or even?
+y = 127;
+y %= 2; // y: 1 (1 => odd)
+
+y = 128;
+y %= 2; // y: 0 (0 => even)
+
+/* Power
+*/
+
+// Basic
+y = 5 ** 2; // y: 25
+
+// Shortcut
+y = 5;
+y **= 2; // y: 25```
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/assignments_bitwise.md b/docs/JavaScript_Advance/assignments_bitwise.md
new file mode 100644
index 0000000..e538186
--- /dev/null
+++ b/docs/JavaScript_Advance/assignments_bitwise.md
@@ -0,0 +1,90 @@
+```js
+/* In javascript there are always several ways to the goal.
+Also the syntax of variable assignment can be abbreviated.
+This is also suitable for bitwise operations
+*/
+
+/* left shift
+*/
+
+// Basic
+y = 3; // y: 111 (binary)
+x = 2;
+y = y << x; // y: 11100 (binary)
+
+// Shortcut
+y = 3; // y: 111 (binary)
+x = 2;
+y <<= x; // y: 11100 (binary)
+
+/* right shift (sign preserving)
+*/
+
+// Basic
+y = -5; // y: 11111111111111111111111111111011 (binary)
+x = 1;
+y = y >> x; // y: 11111111111111111111111111111101 (binary) -3 (decimal)
+
+// Shortcut
+y = -5; // y: 11111111111111111111111111111011 (binary)
+x = 1;
+y >>= x; // y: 11111111111111111111111111111101 (binary) -3 (decimal)
+
+/* right shift (zero fill)
+*/
+
+// Basic
+y = 5; // y: 00000000000000000000000000000101 (binary)
+x = 1;
+y = y >>> x; // y: 00000000000000000000000000000010 (binary) 2 (decimal)
+
+// Shortcut
+y = 5; // y: 00000000000000000000000000000101 (binary)
+x = 1;
+y >>>= x; // y: 00000000000000000000000000000010 (binary) 2 (decimal)
+
+/* AND
+*/
+
+// Basic
+y = 12; // y: 1100 (binary)
+x = 9; // y: 1001 (binary)
+y = y & x; // y: 1000 (binary)
+
+// Shortcut
+y = 12; // y: 1100 (binary)
+x = 9; // y: 1001 (binary)
+y &= x; // y: 1000 (binary)
+
+/* OR
+*/
+
+// Basic
+y = 12; // y: 1100 (binary)
+x = 9; // y: 1001 (binary)
+y = y | x; // y: 1101 (binary)
+
+// Shortcut
+y = 12; // y: 1100 (binary)
+x = 9; // y: 1001 (binary)
+y |= x; // y: 1101 (binary)
+
+/* XOR
+*/
+
+// Basic
+y = 12; // y: 1100 (binary)
+x = 9; // y: 1001 (binary)
+y = y ^ x; // y: 0101 (binary)
+
+// Shortcut
+y = 12; // y: 1100 (binary)
+x = 9; // y: 1001 (binary)
+y ^= x; // y: 0101 (binary)
+
+/* NOT
+*/
+
+// Basic
+y = 5; // y: 00000000000000000000000000000101 (binary)
+y = ~y; // y: 11111111111111111111111111111010 (binary) -6 (decimal)```
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/asyncAwait.md b/docs/JavaScript_Advance/asyncAwait.md
deleted file mode 100644
index 86a755b..0000000
--- a/docs/JavaScript_Advance/asyncAwait.md
+++ /dev/null
@@ -1 +0,0 @@
-# Async Await
\ No newline at end of file
diff --git a/JavaScript_Advance/asyncAwait.js b/docs/JavaScript_Advance/async_await.md
similarity index 99%
rename from JavaScript_Advance/asyncAwait.js
rename to docs/JavaScript_Advance/async_await.md
index d845455..e08d4ac 100644
--- a/JavaScript_Advance/asyncAwait.js
+++ b/docs/JavaScript_Advance/async_await.md
@@ -1,3 +1,4 @@
+```js
// Async Await Flow on JavaScript
// the most common case to use async await is to handle promises for fetch request
@@ -39,3 +40,4 @@ const getUsers = async () => {
console.log('DISPLAY AN ERROR', error)
}
}
+```
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/bind.md b/docs/JavaScript_Advance/bind.md
index 8d69a83..d762f67 100644
--- a/docs/JavaScript_Advance/bind.md
+++ b/docs/JavaScript_Advance/bind.md
@@ -1,21 +1,19 @@
+```js
+/* The bind() method creates a new function that, when called, has its this keyword set
+to the provided value, with a given sequence of arguments preceding any provided
+when the new function is called.
+*/
+const module = {
+ x: 42,
+ getX: function () {
+ return this.x;
+ }
+};
-*The **bind()** method creates a new function that, when called, has its this keyword set to the provided value, with a given sequence of arguments preceding any provided when the new function is called.*
+const unboundGetX = module.getX;
+console.log(unboundGetX()); // The function gets invoked at the global scope
+// expected output: undefined
- let module = {
- x: 42,
- getX: function() {
- return this.x;
- }
- }
-
- let unboundGetX = module.getX;
-
- console.log(unboundGetX());
-
-> The above function gets invoked at the global scope
-> expected output: undefined
-
- let boundGetX = unboundGetX.bind(module);
- console.log(boundGetX());
-
-> expected output: 42
+const boundGetX = unboundGetX.bind(module);
+console.log(boundGetX());
+// expected output: 42```
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/caesar_cipher.md b/docs/JavaScript_Advance/caesar_cipher.md
new file mode 100644
index 0000000..7a59c7c
--- /dev/null
+++ b/docs/JavaScript_Advance/caesar_cipher.md
@@ -0,0 +1,47 @@
+```js
+/**
+ * Most simplest encryption scheme. Read more: [http://practicalcryptography.com/ciphers/caesar-cipher/]
+ **/
+function caesarCipher (toEncipher, shift = 0) {
+ // If required for very strict shift checking then remove '=0'
+ if (Number.isNaN(Number(shift)) === true) {
+ throw new Error("Invalid Shift Provided");
+ } else {
+ shift = parseInt(Number(shift), 10);
+ }
+
+ if (typeof (toEncipher) === "string" || (typeof (toEncipher) === "number" && Number.isNaN(toEncipher) === false)) {
+ toEncipher = String(toEncipher);
+ } else {
+ throw new Error("Invalid string provided");
+ }
+
+ // These are the valid entries aacepted, you can change it according to requirements
+ const validEntries = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+
+ shift %= validEntries.length;
+
+ let output = "";
+ for (const char of toEncipher) {
+ if (char === " ") {
+ output += " ";
+ continue;
+ // ------- If you donot want to accept invalid entries then uncomment below block
+ /*
+ ========================================================================================================
+ } else if (validEntries.indexOf(char) === -1) {return Error ('invalid character' + char)}
+ ========================================================================================================
+ and comment out the below block
+ */
+ //= ======================================================================================================
+ } else if (validEntries.indexOf(char) === -1) {
+ output += char;
+ continue;
+ }
+ //= ======================================================================================================
+ output += (validEntries.indexOf(char) + shift <= validEntries.length) ? validEntries[validEntries.indexOf(char) + shift] : validEntries[(validEntries.indexOf(char) + shift) % validEntries.length];
+ }
+ return output;
+}
+
+module.exports = caesarCipher;```
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/callback.md b/docs/JavaScript_Advance/callback.md
index c180f11..a4caf49 100644
--- a/docs/JavaScript_Advance/callback.md
+++ b/docs/JavaScript_Advance/callback.md
@@ -1,144 +1,154 @@
+```js
+/**
+ * Callback functions are derived from a programming paradigm called
+ * `functional programming`. This basically can be concluded to this sentence:
+ * You can pass (`closure`) functions as an argument to another function.
+ *
+ * Higher order functions:- In javascript, functions can be used as value.
+ * We can assign function to a variable.
+ * Pass them as parameters to another functions.
+ * Return them from a function
+ *
+ * Callback:- We pass a function as parameters to another function, which calls/invokes
+ * the provided function. Hence the name Callback
+ *
+ *
+ *
+ * look at this example:
+ */
-Callback functions are derived from a programming paradigm called
-`functional programming`. This basically can be concluded to this sentence:
-You can pass (`closure`) functions as an argument to another function.
-
-look at this example:
-
-```javascript
const sayHi = (afterHi) => {
- console.log('Hi, ')
- return afterHi()
-}
+ console.log("Hi, ");
+ return afterHi();
+};
-sayHi(() => { console.log('How are you?') })
+sayHi(() => { console.log("How are you?"); });
// [out] 'Hi, '
// [out] 'How are you?'
-```
-
-
-If you look at the way we called `sayHi`, you will see that, we have not called
-the function which is going to print `'How are you?'`, we have not even named it (Anonymous function)
-This is the prototype of the function. The passed function, will act as if it has been defined
-inside the `sayHi` function. Therefore, you can assume that your function has access to the scope
-of the other function.
-
-example:
-
-```javascript
- const transformNumber = (num, operator) => {
- let test = 2;
- console.log(num)
- console.log(test)
- operator(num)
- console.log(num)
- console.log(test)
- }
-
- transformNumber(10, () => {
- num = num * num;
- test = 3
- })
- // [out] 10
- // [out] 2
- // [out] 100
- // [out] 3
-```
-
- One of very common uses of callback functions, is in `Promises`.
- I suggest you read `promises.js` file, before continuing this section.
- If you know about javascript `Promise` concept, you should be familiar with
- `.then()` and `.catch()` functions. These are `Promise`'s prototype methods.
- When a promise gets resolved (when `.resolve()` gets called), all the arguments
- passed to the `resolve()` function, will get passed to the function passed to `.then()`
- function. Look at the following example from MDN official documents:
-
- ```javascript
- var p1 = new Promise((resolve, reject) => {
- resolve('Success!');
- // or
- // reject(new Error("Error!"));
- });
-
- p1.then(value => {
- console.log(value); // Success!
- }, reason => {
- console.error(reason); // Error!
- });
-```
-
-So, basically the function that we pass to `.then()` function, is a `callback` function.
-
-We see usage of `Promise` widely in different API call scenarios.
-Different HTTP libraries (`fetch, axios, ...`), use javascript `Promise` object,
-for handling `onSuccess` and `onError` scenarios when calling an API endpoint.
-When you make an API call, if everything goes well and server's response has some
-2xx status code, this API call will be considered as `success` and otherwise, it has `failed`,
-and some `error` messages should be returned.
-In the following example, we are going to use `axios` as our HTTP library.
-But you can simulate the exact same scenario using any other HTTP libraries.
+/**
+ * If you look at the way we called `sayHi`, you will see that, we have not called
+ * the function which is going to print `'How are you?'`, we have not even named it (Anonymous function)
+ * This is the prototype of the function. The passed function, will act as if it has been defined
+ * inside the `sayHi` function. Therefore, you can assume that your function has access to the scope
+ * of the other function.
+ *
+ * example:
+ */
+
+const transformNumber = (num, operator) => {
+ const test = 2;
+ console.log(num);
+ console.log(test);
+ operator(num);
+ console.log(num);
+ console.log(test);
+};
+
+transformNumber(10, (num) => {
+ num = num * num;
+ test = 3;
+});
+// [out] 10
+// [out] 2
+// [out] 100
+// [out] 3
+
+/**
+ * One of very common uses of callback functions, is in `Promises`.
+ * I suggest you read `promises.js` file, before continuing this section.
+ * If you know about javascript `Promise` concept, you should be familiar with
+ * `.then()` and `.catch()` functions. These are `Promise`'s prototype methods.
+ * When a promise gets resolved (when `.resolve()` gets called), all the arguments
+ * passed to the `resolve()` function, will get passed to the function passed to `.then()`
+ * function. Look at the following example from MDN official documents:
+ */
+const p1 = new Promise((resolve, reject) => {
+ resolve("Success!");
+ // or
+ // reject(new Error("Error!"));
+});
+
+p1.then(value => {
+ console.log(value); // Success!
+}, reason => {
+ console.error(reason); // Error!
+});
+
+/**
+ * So, basically the function that we pass to `.then()` function, is a `callback` function.
+ *
+ * We see usage of `Promise` widely in different API call scenarios.
+ * Different HTTP libraries (`fetch, axios, ...`), use javascript `Promise` object,
+ * for handling `onSuccess` and `onError` scenarios when calling an API endpoint.
+ * When you make an API call, if everything goes well and server's response has some
+ * 2xx status code, this API call will be considered as `success` and otherwise, it has `failed`,
+ * and some `error` messages should be returned.
+ *
+ * In the following example, we are going to use `axios` as our HTTP library.
+ * But you can simulate the exact same scenario using any other HTTP libraries.
+ *
+ */
-
-```javascript
axios
- .get('https://cat-fact.herokuapp.com/facts/random')
+ .get("https://cat-fact.herokuapp.com/facts/random")
.then(response => {
- console.log(response, 'success!')
+ console.log(response, "success!");
})
.catch(error => {
- console.log(error, 'failed!')
- })
-```
-
-This process of making HTTP requests can get pretty much complicated.
-There are many cases that you need to make several API calls which each
-of them, will rely on the response from some previous requests.
-
-(In this tutorial, we are using the `cat-facts` public API to demonstrate
- different usages of HTTP libraries. You can read the documentation related
- to this API, here: https://alexwohlbruck.github.io/cat-facts/docs/)
-
-Let's say we want to retrieve 2 random facts about cats and after retrieving
-the list of 2 facts, start making another API call to retrieve details of each.
-
-According to `cat-facts` docs, we will receive an `_id` field in the list of facts
-and when we make an API call to `/facts/:id` endpoint, we can get details of that specific fact.
+ console.log(error, "failed!");
+ });
-Look at the following code snippet:
+/**
+ * This process of making HTTP requests can get pretty much complicated.
+ * There are many cases that you need to make several API calls which each
+ * of them, will rely on the response from some previous requests.
+ *
+ * (In this tutorial, we are using the `cat-facts` public API to demonstrate
+ * different usages of HTTP libraries. You can read the documentation related
+ * to this API, here: https://alexwohlbruck.github.io/cat-facts/docs/)
+ *
+ * Let's say we want to retrieve 2 random facts about cats and after retrieving
+ * the list of 2 facts, start making another API call to retrieve details of each.
+ *
+ * According to `cat-facts` docs, we will receive an `_id` field in the list of facts
+ * and when we make an API call to `/facts/:id` endpoint, we can get details of that specific fact.
+ *
+ * Look at the following code snippet:
+ */
-```javascript
axios({
- url: 'https://cat-fact.herokuapp.com/facts/random',
- method: 'GET',
- params: {animal_type: 'cat', amount: '2'}
+ url: "https://cat-fact.herokuapp.com/facts/random",
+ method: "GET",
+ params: { animal_type: "cat", amount: "2" }
}).then(response => {
- console.log('list success!')
+ console.log("list success!");
response.data.forEach((fact, idx) => {
axios
.get(`https://cat-fact.herokuapp.com/facts/${fact._id}`)
- .then(factRes => { console.log(`fact #${idx} success: `, factRes) })
- .catch(factErr => { console.log(`fact #${idx} failed: `, factErr) })
- })
+ .then(factRes => { console.log(`fact #${idx} success: `, factRes); })
+ .catch(factErr => { console.log(`fact #${idx} failed: `, factErr); });
+ });
}).catch(err => {
- console.log(err, 'list failed!')
-})
-```
-
-You can see that sometimes, we need to make API calls that rely on
-response of some other API call, therefore we need to make those calls
-in order, and also, if one of these API calls somewhere in this chain fails,
-we do not want to continue making next API calls.
-This specific scenario, can be extended in real lif usage of APIs. You might
-face some situations that you need to chain more than 4-5 API calls. In these
-cases, one will end up writing many nested `.then().catch()` blocks. Also,
-it is not True that we "Always" want to ignore making API calls next in chain,
-if one of requests in chain fails. So, different situations and more exceptions
-to handle and apparently, more nested `.then().catch()` code blocks.
-
-This situations is referred to as `Callbacks Hell`. It really can turn in to a
-mess, if you don't take cautions in writing your clean and readable using callback
-functions. To solve this issue, one might advise to use `async` `await` syntaxes,
-instead of using callback functions. This approach also have pros and cons. One of
-the cons of this approach, is instead of nested `.then()` blocks, you are going to
-need nested `try` `catch` blocks. Sometimes this kind of problems are inevitable.
+ console.log(err, "list failed!");
+});
+
+/**
+ * You can see that sometimes, we need to make API calls that rely on
+ * response of some other API call, therefore we need to make those calls
+ * in order, and also, if one of these API calls somewhere in this chain fails,
+ * we do not want to continue making next API calls.
+ * This specific scenario, can be extended in real lif usage of APIs. You might
+ * face some situations that you need to chain more than 4-5 API calls. In these
+ * cases, one will end up writing many nested `.then().catch()` blocks. Also,
+ * it is not True that we "Always" want to ignore making API calls next in chain,
+ * if one of requests in chain fails. So, different situations and more exceptions
+ * to handle and apparently, more nested `.then().catch()` code blocks.
+ *
+ * This situations is referred to as `Callbacks Hell`. It really can turn in to a
+ * mess, if you don't take cautions in writing your clean and readable using callback
+ * functions. To solve this issue, one might advise to use `async` `await` syntaxes,
+ * instead of using callback functions. This approach also have pros and cons. One of
+ * the cons of this approach, is instead of nested `.then()` blocks, you are going to
+ * need nested `try` `catch` blocks. Sometimes this kind of problems are inevitable.
+ */```
\ No newline at end of file
diff --git a/JavaScript_Basics/classes.js b/docs/JavaScript_Advance/classes.md
similarity index 96%
rename from JavaScript_Basics/classes.js
rename to docs/JavaScript_Advance/classes.md
index 84a8e82..d2c8ce6 100644
--- a/JavaScript_Basics/classes.js
+++ b/docs/JavaScript_Advance/classes.md
@@ -1,3 +1,4 @@
+```js
class Student {
// onlyname; // This should not have let or const only in classes
constructor (name, age) { // name and age are arguments given to object at the time of creation of object
@@ -25,4 +26,4 @@ class StudentInfo {
}
const SwapnilInfo = new StudentInfo("Swapnil Bio");
-SwapnilInfo.getNameAndCollege();
\ No newline at end of file
+SwapnilInfo.getNameAndCollege();```
\ No newline at end of file
diff --git a/JavaScript_Advance/closures.js b/docs/JavaScript_Advance/closures.md
similarity index 64%
rename from JavaScript_Advance/closures.js
rename to docs/JavaScript_Advance/closures.md
index 37b2a65..2483e9f 100644
--- a/JavaScript_Advance/closures.js
+++ b/docs/JavaScript_Advance/closures.md
@@ -1,26 +1,24 @@
-/*
-
-A closure is the combination of a function bundled together (enclosed)
-with references to its surrounding state (the lexical environment).
-In other words, a closure gives you access to an outer function’s scope from an inner function.
+```js
+/*
+A closure is the combination of a function bundled together (enclosed)
+with references to its surrounding state (the lexical environment).
+In other words, a closure gives you access to an outer function’s scope from an inner function.
In JavaScript, closures are created every time a function is created, at function creation time.
-
-
*/
-function modifyString(sampleString){
- const modifier = function(){
- const modifiedString = sampleString + ' is modified';
- return 'Original String: --->'+ sampleString + ', Modified String: ---> ' + modifiedString;
- }
- return modifier;
+function modifyString (sampleString) {
+ const modifier = function () {
+ const modifiedString = sampleString + " is modified";
+ return "Original String: --->" + sampleString + ", Modified String: ---> " + modifiedString;
+ };
+ return modifier;
}
-const modifier = modifyString('sample string');
+const modifier = modifyString("sample string");
/*
-function modifyString has two variables sampleString and modifier(function).
+function modifyString has two variables sampleString and modifier(function).
Now when modifyString is invoked, it returns modifier.
Usually, when a function is invoked, the memory allocated to the variables present inside gets freed
by the garbage collector. However, in javascript when a function returns another function
@@ -29,7 +27,5 @@ explains closures
*/
-console.log(modifier());
-// [out] Original String: --->sample string, Modified String: ---> sample string is modified
-
-
+console.log(modifier());
+// [out] Original String: --->sample string, Modified String: ---> sample string is modified```
\ No newline at end of file
diff --git a/JavaScript_Advance/connectToMongo.js b/docs/JavaScript_Advance/connect_to_mongo.md
similarity index 98%
rename from JavaScript_Advance/connectToMongo.js
rename to docs/JavaScript_Advance/connect_to_mongo.md
index c314469..b9a52bf 100644
--- a/JavaScript_Advance/connectToMongo.js
+++ b/docs/JavaScript_Advance/connect_to_mongo.md
@@ -1,3 +1,4 @@
+```js
const mongo = require("mongoose");
// protocol hostname port database
@@ -18,4 +19,4 @@ mongo.connection.on("error", (err) => {
// this code will also be executed once the script fails to connect to the mongodb.
console.error("---> Error handling option two: An error occurred. Please have a look at the stacktrace beyond.");
console.error(err);
-});
\ No newline at end of file
+});```
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/cookies.md b/docs/JavaScript_Advance/cookies.md
index ce7470b..12c5754 100644
--- a/docs/JavaScript_Advance/cookies.md
+++ b/docs/JavaScript_Advance/cookies.md
@@ -1,34 +1,43 @@
-# Cookies
-
-## What are cookies?
-Cookies allow a JavaScript program to store data on the user's hard disk.
-
-A "spying" of the user hard disk is just as impossible as the placement of executable code. Because you write a cookie in a JavaScript, you can not specify where the cookie is stored to the user - this controls the browser of the user. In addition, cookies can not write uncontrolled amounts of data to the user's computer, but only a limited number of lines. Each such row defines a variable and assigns a value to that variable (name-value pairs). A cookie can therefore be compared with an entry in a configuration file - with the difference that the cookie can't change configuration data of the user's computer.
-
-## How to use cookies?
-
-### Write a cookie
-Cookies are saved as name-value pairs.
-`movie = Jungle Book`
-
-JavaScript can create, read, and delete cookies with the document.cookie property.
-With JavaScript, a cookie can be created like this:
-`document.cookie = "movie=Jungle Book;"`
-
-You can also specify when the cookie **expires** like this:
-`document.cookie = "movie=Jungle Book; expires=Thu, 18 Dec 2013 12:00:00 UTC"`
-
-You can also specify where the cookie belongs to with **path** like this:
-`document.cookie = "movie=Jungle Book; expires=Thu, 18 Dec 2013 12:00:00 UTC; path=/"`
-
-### Read a cookie
-To read a cookie you can use the following code, this will return all cookies saved by the browser:
-`var allCookies = document.cookie` returns e.g. movie=Jungle Book; cookie2=value; cookie3=value
-
-### Delete a cookie
-To delete a cookie you can use the following code, this will delete the cookie by a passed timestamp:
-`document.cookie = "movie=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/"`
-
-> You should define the cookie path to ensure that you delete the right cookie. Some browsers will not let you delete a cookie if you don't specify the path.
-
-[wiki]: https://developer.mozilla.org/en-US/docs/Web/API/Document/cookie
+```js
+// #1 Simple usage of cookies
+document.cookie = "movie=Jungle Book";
+document.cookie = "actor=Balu";
+console.log("Simple usage:" + document.cookie);
+
+// #2 Get a cookie with the name 'actor'
+document.cookie = "movie=Jungle Book";
+document.cookie = "actor=Balu";
+const cookieValue = document.cookie.replace(/(?:(?:^|.*;\s*)actor\s*\=\s*([^;]*).*$)|^.*$/, "$1");
+console.log("Cookie with the name 'actor':" + cookieValue);
+
+// #3 Set cookie and execute code only once if cookie doesn't exist yet
+if (document.cookie.replace(/(?:(?:^|.*;\s*)doThisOnlyOnce\s*\=\s*([^;]*).*$)|^.*$/, "$1") !== "true") {
+ alert("Do something here!");
+ document.cookie = "doThisOnlyOnce=true; expires=Fri, 31 Dec 9999 23:59:59 GMT";
+}
+// Reset the previous code
+document.cookie = "doThisOnlyOnce=; expires=Thu, 01 Jan 1970 00:00:00 GMT";
+
+// #4 Check a cookie existence
+// ES5
+if (document.cookie.split(";").filter(function (item) {
+ return item.trim().indexOf("actor=") == 0;
+}).length) {
+ console.log("The cookie \"reader\" exists (ES5)");
+}
+// ES2016
+if (document.cookie.split(";").filter((item) => item.trim().startsWith("actor=")).length) {
+ console.log("The cookie \"actor\" exists (ES6)");
+}
+
+// #5 Check that a cookie has a specific value
+// ES5
+if (document.cookie.split(";").filter(function (item) {
+ return item.indexOf("actor=Balu") >= 0;
+}).length) {
+ console.log("The cookie \"actor\" has \"Balu\" for value (ES5)");
+}
+// ES2016
+if (document.cookie.split(";").filter((item) => item.includes("actor=Balu")).length) {
+ console.log("The cookie \"actor\" has \"Balu\" for value (ES6)");
+}```
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/defaultValues.md b/docs/JavaScript_Advance/defaultValues.md
deleted file mode 100644
index 0541532..0000000
--- a/docs/JavaScript_Advance/defaultValues.md
+++ /dev/null
@@ -1 +0,0 @@
-# Default Values
diff --git a/docs/JavaScript_Advance/default_values.md b/docs/JavaScript_Advance/default_values.md
new file mode 100644
index 0000000..d5ba4ec
--- /dev/null
+++ b/docs/JavaScript_Advance/default_values.md
@@ -0,0 +1,30 @@
+```js
+/*
+A JavaScript function can have default parameter value.
+Using default function parameters, you can initialize parameters with default values.
+If you do not initialize a parameter with some value, then the default value of the parameter is undefined.
+*/
+
+const helpGST = (name, age) => {
+ console.log(name, age);
+};
+
+helpGST(); // Output will be undefined undefined
+
+const helpGSTWithDefaultValues = (name, age = 19) => {
+ console.log(name, age);
+};
+
+helpGSTWithDefaultValues("Swapnil"); // Output Swapnil 19
+
+helpGSTWithDefaultValues("Vishal", 23); // Output Vishal 23
+
+/*
+ You can also reuse default parameters to set another default parameter.
+*/
+
+const addOneToANumberAsDefault = (number1 = 1, number2 = number1 + 8) => {
+ console.log(number2);
+};
+
+addOneToANumberAsDefault(); // Output 9```
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/destructuring.md b/docs/JavaScript_Advance/destructuring.md
index 6c74076..08613bf 100644
--- a/docs/JavaScript_Advance/destructuring.md
+++ b/docs/JavaScript_Advance/destructuring.md
@@ -1 +1,33 @@
-# Destructuring
+```js
+// As data coming from the server is very big then there is better way of getting the data out of object
+
+const a = { // Suppose this is the object coming from server then
+ name: "Swapnil",
+ age: 19,
+ college: "SIES"
+};
+
+// By using Destructuring we can get the data of specific keys out into variables
+
+const { name, age, college } = a; // This way name variable gets "Swapnil" this is possible because the object also has same key
+
+console.log(name); // Output Swapnil
+
+const { name: Myname } = a; // This way Myname variable get assigned the value of name key in from object a
+
+console.log(Myname); // Output Swapnil
+
+array = [1, 2, 3, 4]; // Array Declaration
+
+const [first, second, , fourth] = array; // Array Destructuring
+
+// In this the Order of variables matters the most as arrays don't have keys
+
+// For skipping some values we can do that using as shown here we have skipped the third value
+console.log(fourth); // Output 4
+
+newArray = ["Swapnil", 19, "Shinde"]; // New array
+
+const [firstName, , lastName] = newArray; // Destructured the firstName and lastName
+
+console.log(`My name is ${firstName} ${lastName}`);// Output My name is Swapnil Shinde```
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/eventloop.md b/docs/JavaScript_Advance/eventloop.md
deleted file mode 100644
index c605107..0000000
--- a/docs/JavaScript_Advance/eventloop.md
+++ /dev/null
@@ -1 +0,0 @@
-# Event loop
diff --git a/docs/JavaScript_Advance/express.md b/docs/JavaScript_Advance/express.md
index a42433f..d1767d5 100644
--- a/docs/JavaScript_Advance/express.md
+++ b/docs/JavaScript_Advance/express.md
@@ -1,8 +1,15 @@
-#### install
-```sh
-npm i
-```
-#### run
-```sh
-node ./JavaScript_Advance/express.js
-```
\ No newline at end of file
+```js
+const express = require("express");
+
+const port = 3003;
+const app = express();
+
+const routes = express.Router();
+
+routes.get("/system_info", (req, res) => {
+ res.send("System on!");
+});
+
+app.use(express.json());
+app.use(routes);
+app.listen(port, () => console.log(`Server running in port ${port}`));```
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/fsModule.md b/docs/JavaScript_Advance/fsModule.md
deleted file mode 100644
index 21adac6..0000000
--- a/docs/JavaScript_Advance/fsModule.md
+++ /dev/null
@@ -1 +0,0 @@
-# fs Module
diff --git a/docs/JavaScript_Advance/function_as_object.md b/docs/JavaScript_Advance/function_as_object.md
new file mode 100644
index 0000000..abe5e09
--- /dev/null
+++ b/docs/JavaScript_Advance/function_as_object.md
@@ -0,0 +1,15 @@
+```js
+/*
+Functions are special type of objects that has key-value pairs along with some code which gets executed
+*/
+
+function returnName (name) {
+ return name;
+}
+
+returnName.hiddenObj = {
+ name: "i am a javascript object"
+};
+
+console.log(returnName("hello")); // hello
+console.log(returnName.hiddenObj); // { name : 'i am a javascript object' }```
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/generators.md b/docs/JavaScript_Advance/generators.md
new file mode 100644
index 0000000..c8fedb1
--- /dev/null
+++ b/docs/JavaScript_Advance/generators.md
@@ -0,0 +1,30 @@
+/*
+ Generators are functions with the possibility of exit and subsequent entry.
+ Their execution context (variable values) is preserved on subsequent inputs.
+*/
+
+// Let's consider a simple example:
+function* myGenerator() {
+ yield 5
+ yield 6
+}
+
+// In the example above, we wrote a simple generator function with asteriks(*) notation.
+// Next to the yield we put values that are going to be extracted from the function
+// In order to extract them one by one, we should at first call myGenerator function
+
+const gen = myGenerator()
+
+// The returning value of myGenerator function is a object-iterator. It has next() method
+// Which we may call to get the current generator function value:
+
+gen.next().value // 5
+
+// We get the value field of 'next' method's returning value, wich is an object as well
+// Let's call this again in order to get the next value:
+
+gen.next().value // 6
+
+// After we iterate through all the values, the next value is going to be undefined.
+
+gen.next().value // undefined.
diff --git a/docs/JavaScript_Advance/get_environment_variable.md b/docs/JavaScript_Advance/get_environment_variable.md
new file mode 100644
index 0000000..59e5783
--- /dev/null
+++ b/docs/JavaScript_Advance/get_environment_variable.md
@@ -0,0 +1,7 @@
+// Getting values of environment variables
+// For example, getting username of machine
+const ENV_VARIABLE_KEY = "USER";
+
+const ENV_VARIABLE_VALUE = process.env[ENV_VARIABLE_KEY];
+
+console.log(ENV_VARIABLE_VALUE);
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/hoisting.md b/docs/JavaScript_Advance/hoisting.md
index 777bc38..979fac4 100644
--- a/docs/JavaScript_Advance/hoisting.md
+++ b/docs/JavaScript_Advance/hoisting.md
@@ -1,30 +1,30 @@
-# what is hoisting?
-
-Basically, when Javascript compiles all of your code, all variable declarations using var are hoisted/lifted to the top of their functional/local scope (if declared inside a function) or to the top of their global scope (if declared outside of a function) regardless of where the actual declaration has been made. This is what we mean by “hoisting”.
-
-
-In JavaScript, a variable can be declared after it has been used. In other words; a variable can be used before it has been declared.
-
-Example 1 gives the same result as Example 2:
-```js
-Example 1 :
+/*
+Hoisting: Before executing any code, the javscript engine sets up memory for variables and functions.
+variables are assigned undefined by the engine.
+*/
+// Example 1
x = 5; // Assign 5 to x
elem = document.getElementById("demo"); // Find an element
-elem.innerHTML = x; // Display x in the element
+elem.innerHTML = x; // Display x in the element
var x; // Declare x
-```
-```js
-Example 2:
+
+// Example 2
var x; // Declare x
x = 5; // Assign 5 to x
elem = document.getElementById("demo"); // Find an element
-elem.innerHTML = x;
-```
+elem.innerHTML = x; // Display x in the element
+
+/* Conclusion :Example 1 gives the same result as Example 2
+so, Hoisting is JavaScript's default behavior of moving all declarations to the top of the current scope
+(to the top of the current script or the current function)
+*/
-To understand this, you have to understand the term "hoisting".
+console.log(foo);
+const foo = "foo"; // unable to print due to the hoisting behaviour
-Hoisting is JavaScript's default behavior of moving all declarations to the top of the current scope (to the top of the current script or the current function).
+console.log(ok);
+var ok = "this is printing";// var is hoisted
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/inheritance.md b/docs/JavaScript_Advance/inheritance.md
new file mode 100644
index 0000000..9c148f6
--- /dev/null
+++ b/docs/JavaScript_Advance/inheritance.md
@@ -0,0 +1,163 @@
+/*
+// ====================================
+// ====================================
+// BASE INHERITANCE EXAMPLE
+// ====================================
+// ====================================
+*/
+
+let baseObject = {
+ a: 1,
+ b: 2
+}
+
+// Create a new object with baseObject as the prototype for extendedObject.
+let extendedObject = Object.create(baseObject);
+
+// Define property c to the baseObject.
+// This is not explicitly defined on extendedObject
+// but is accessible via the [[Prototype]].
+baseObject.c = 3;
+
+// It appears that there are no properties on extendedObject
+console.log(extendedObject) // {}
+
+// a and b were defined on the baseObject.
+// The property looks up the prototype chain
+// until the properties of a and b exist or null is encountered for [[Prototype]].
+console.log(extendedObject.a); // 1
+console.log(extendedObject.b); // 2
+
+// Define d on the extendedObject
+// this is not accessible to the baseObject
+// as the [[Prototype]] inherits one way
+extendedObject.d = 4;
+
+// We now see property d on extendedObject
+console.log(extendedObject) // { d: 4 }
+
+// c is accessible because the prototype chain is "alive".
+// As properties are added or deleted, they can be accessed
+// by objects that share a prototype
+console.log(extendedObject.c); // 3
+
+// d is accessible on extendedObject where it was defined
+// but is inaccessible to baseObject and returns undefined
+console.log(extendedObject.d); // 4
+console.log(baseObject.d) // undefined
+
+
+/*
+// ====================================
+// ====================================
+// CLASS BASED INHERITANCE EXAMPLE
+// ====================================
+// ====================================
+*/
+
+// Animal class is defined with a property of legs and a method of getLegs
+// which returns the current value of legs.
+class Animal {
+ constructor () {
+ this.legs = 4;
+ }
+
+ getLegs () { // Function for getting legs
+ return (this.legs);
+ }
+}
+
+// Dog inherits the base properties from Animal
+// and adds its own property of age (which is not shared with Animal)
+// and the methods getAge and getSound
+class Dog extends Animal {
+ constructor (age) {
+
+ // We need to call super in order to instantiate the constructor on Animal.
+ // If super is not called, then legs would be inaccessible to the Dog class
+ super();
+ this.age = age;
+ }
+
+ getSound () {
+ return ("Bow");
+ }
+
+ getAge () {
+ return (this.age);
+ }
+}
+
+ // Create a new Dog object passing in 10 for the age parameter
+const tommy = new Dog(10);
+
+// Since the Dog class extends the Animal class
+// tommy has access to the getLegs method
+console.log(tommy.getLegs()); // Output 4
+
+console.log(tommy.getSound()); // Bow
+
+console.log(tommy.getAge()); // 10
+
+
+/*
+// ====================================
+// ====================================
+// Function Based Inheritance Example
+// ====================================
+// ====================================
+*/
+
+// This function defines the base "constructor" for us and is
+// comparable to the constructor function found in the class example
+function Animal() {
+ this.legs = 4;
+}
+
+// Adding the getLegs property to the prototype ensures that
+// it will be inherited to any objects that are created from Animal
+Animal.prototype.getLegs = function() {
+ return this.legs;
+}
+
+// The Dog function acts as the constructor, but where is the super call
+// that we use to call the constructor from Animal?
+function Dog(age) {
+ // the call method is similar in function to calling the super method in the
+ // super method in the class based example. In this case, it instantiates the
+ // legs property
+ Animal.call(this);
+
+ this.age = age;
+}
+
+// We set the prototype of Dog to the prototype of Animal
+// in order to have access to the getLegs method that is
+// defined on Animal's prototype
+Dog.prototype = Object.create(Animal.prototype);
+
+// Dog is set as the constructor property on the Dog prototype to
+// match the object structure of the class example
+Dog.prototype.constructor = Dog;
+
+// Define getSound method
+Dog.prototype.getSound = function() {
+ return ("Bow");
+}
+
+// Define getAge method
+Dog.prototype.getAge = function() {
+ return (this.age);
+}
+
+// create new Dog with age 10
+const tommy = new Dog(10);
+
+console.log(tommy); // Dog { legs: 4, age: 10 }
+
+// call getLegs that was inherited from Animal
+console.log(tommy.getLegs()); // 4
+
+// call both getSound and getAge that are defined on Dog
+console.log(tommy.getSound()); // Bow
+console.log(tommy.getAge()); // 10
diff --git a/JavaScript_Advance/jsonParseAndStringify.js b/docs/JavaScript_Advance/json_parse_and_stringify.md
similarity index 100%
rename from JavaScript_Advance/jsonParseAndStringify.js
rename to docs/JavaScript_Advance/json_parse_and_stringify.md
diff --git a/docs/JavaScript_Advance/keys.md b/docs/JavaScript_Advance/keys.md
new file mode 100644
index 0000000..aa5f297
--- /dev/null
+++ b/docs/JavaScript_Advance/keys.md
@@ -0,0 +1,45 @@
+// Object.keys() is a useful way of checking a javascrip object's enumerable property names.
+// This object method returns an array of the property names.
+
+var exampleObject = {
+ a: "apple",
+ b: "boat",
+ c: "car"
+};
+
+console.log(Object.keys(exampleObject));
+// expected output: ["a", "b", "c"]
+
+// Object.keys() can also be used on Arrays
+
+var exampleArray = ["a", "b", "c"];
+
+console.log(Object.keys(exampleArray));
+// expected output: ["0", "1", "2"]
+
+// Object.keys() can be useful in combination with array methods
+
+Object.keys(exampleObject).forEach((propertyName) => {
+ // your fancy logic here
+});
+
+// Such as
+
+var funExampleObject = {
+ look: "at",
+ all: "of",
+ the: "fine",
+ grained: "control",
+ you: "have",
+ with: "Object.keys()!"
+};
+
+var funExampleResult = [];
+
+Object.keys(funExampleObject).forEach((propertyName) => {
+ funExampleResult.push(propertyName);
+ funExampleResult.push(funExampleObject[propertyName]);
+});
+
+console.log(funExampleResult.join(" "));
+// expected output: "look at all of the fine grained control you have wiht Object.keys()!"
diff --git a/docs/JavaScript_Advance/map_object.md b/docs/JavaScript_Advance/map_object.md
new file mode 100644
index 0000000..3cc2e30
--- /dev/null
+++ b/docs/JavaScript_Advance/map_object.md
@@ -0,0 +1,106 @@
+/*
+Map : Object
+Maps allow associating keys and values similar to normal Objects except Maps allow any Object to be used as a
+key instead of just Strings and Symbols. Maps use get() and set() methods to access the values stored in the Map.
+A Map are often called a HashTable or a Dictionary in other languages.
+*/
+
+const map = new Map();
+
+map.set("1", "str1"); // a string key
+map.set(1, "num1"); // a numeric key
+map.set(true, "bool1"); // a boolean key
+
+// remember the regular Object? it would convert keys to string
+// Map keeps the type, so these two are different:
+alert(map.get(1)); // 'num1'
+alert(map.get("1")); // 'str1'
+
+alert(map.size); // 3
+
+// Map can also use objects as keys.
+
+const john = {
+ name: "John"
+};
+
+// for every user, let's store their visits count
+const visitsCountMap = new Map();
+
+// john is the key for the map
+visitsCountMap.set(john, 123);
+
+alert(visitsCountMap.get(john)); // 123
+/*
+Iteration over Map
+For looping over a map, there are 3 methods:
+
+map.keys() – returns an iterable for keys,
+map.values() – returns an iterable for values,
+map.entries()
+*/
+
+const recipeMap = new Map([
+ ["cucumber", 500],
+ ["tomatoes", 350],
+ ["onion", 50]
+]);
+
+// iterate over keys (vegetables)
+for (const vegetable of recipeMap.keys()) {
+ alert(vegetable); // cucumber, tomatoes, onion
+}
+
+// iterate over values (amounts)
+for (const amount of recipeMap.values()) {
+ alert(amount); // 500, 350, 50
+}
+
+// iterate over [key, value] entries
+for (const entry of recipeMap) { // the same as of recipeMap.entries()
+ alert(entry); // cucumber,500 (and so on)
+}
+
+/*
+Loop with forEach
+Instead of using for loop, forEach can be used.
+
+map.forEach(function(value, key){
+
+});
+
+or with array function
+
+map.forEach((value, key) => {
+
+})
+
+*/
+
+recipeMap.forEach((value, key) => {
+ alter(key + " = " + value);
+});
+
+/*
+Convert To Arrays
+A map obejct can be convert to arrays
+
+var array = Array.from(map) - create an array of the key-value pairs
+
+var array = Array.from(map.value()) - Create an array of the values
+
+var array = Array.from(map.key()) - Create an array of the keys
+
+*/
+
+// create an array of the key-value pairs
+const keyValArr = Array.from(recipeMap);
+alter(keyValArr);
+
+// Create an array of the values
+const ValArr = Array.from(recipeMap);
+alter(ValArr);
+
+// Create an array of the keys
+const keyArr = Array.from(recipeMap);
+alter(keyArr);
\ No newline at end of file
diff --git a/JavaScript_Advance/nasaimgHttps.js b/docs/JavaScript_Advance/nasaimg_https.md
similarity index 100%
rename from JavaScript_Advance/nasaimgHttps.js
rename to docs/JavaScript_Advance/nasaimg_https.md
diff --git a/docs/JavaScript_Advance/object_assign.md b/docs/JavaScript_Advance/object_assign.md
new file mode 100644
index 0000000..feeded1
--- /dev/null
+++ b/docs/JavaScript_Advance/object_assign.md
@@ -0,0 +1,45 @@
+// Object.assign() is a useful method for copying objects in javascript. This method can be useful when mutating data in javascript.
+// Object.assign() accepts two parameters: a target object and source objects.
+
+// Problem statement
+var object1 = {
+ thing1: "thing1's things",
+ thing2: "thing2's things"
+};
+
+var object2 = object1;
+
+object2.thing1 = "thing1's new things";
+
+console.log(object1);
+// expected output: { thing1: "thing1's new things", thing2: "thing2's things" }
+console.log(object2);
+// expected output: { thing1: "thing1's new things", thing2: "thing2's things" }
+
+object2 = Object.assign({}, object1);
+
+object2.thing2 = "thing2's new things";
+
+console.log(object1);
+// expected output: { thing1: "thing1's new things", thing2: "thing2's things" }
+console.log(object2);
+// expected output: { thing1: "thing1's new things", thing2: "thing2's new things" }
+
+// it is worth noting that Object.assign() will not perform a deep copy of your entire object. For this, the following is useful:
+
+var object2 = JSON.parse(JSON.stringify(object1));
+
+// Object.assign() can also be used for merging objects
+
+var newObject1 = {
+ a: "1"
+};
+
+var newObject2 = {
+ b: "2"
+};
+
+Object.assign(newObject1, newObject2);
+
+console.log(newObject1);
+// expected output: { a: "1", b: "2" }
diff --git a/docs/JavaScript_Advance/polymorphism.md b/docs/JavaScript_Advance/polymorphism.md
index f73a80b..41e0d67 100644
--- a/docs/JavaScript_Advance/polymorphism.md
+++ b/docs/JavaScript_Advance/polymorphism.md
@@ -1,63 +1,44 @@
-# Polymorphism
-Polymorphism is one of the basic principles of **object-oriented programming (OOP)**. It is the practice of designing objects to share behavior and be able to overwrite common behaviors associated with specific ones. Polymorphism uses inheritance to realize this.
+// Polymorphism is one of the basic principles of object-oriented programming (OOP)
+// It is the practice of designing objects to share behavior and be able to overwrite common behaviors associated with specific ones.
-*Related: [Inheritance](JavaScript_Basics/inheritance.md), [Classes](JavaScript_Basics/classes.md)*
-
-## Parent class
-Let's create a `class` called Person first.
-```javascript
+// First create the class Person
class Person {
- constructor(name) {
- this.name = name;
- }
+ constructor (name) {
+ this.name = name;
+ }
- getName() {
- return this.name
- }
+ getName () {
+ return this.name;
+ }
- getPosition() {
- return "Unemployed";
- }
+ getPosition () {
+ return "Unemployed";
+ }
}
-```
-## Child class
-We like to extend this `class` for Employees. This can be done by creating a `class` and adding `extends`.
-```javascript
+// Extend the class Person with Employee
class Employee extends Person {
- constructor(name, position, salary) {
- super(name); // super() calls the constructor of Person
-
- this.position = position;
- this.salary = salary;
- }
-
- getPosition() { //overwrites the method of person
- return this.position
- }
-
- getSalary() {
- return this.salary
- }
+ constructor (name, position, salary) {
+ super(name); // super() calls the constructor of Person
+
+ this.position = position;
+ this.salary = salary;
+ }
+
+ getPosition () { // overwrites the method of person
+ return this.position;
+ }
+
+ getSalary () {
+ return this.salary;
+ }
}
-```
-## Output
-As you can see in the output below, `getPosition()` gets overwritten in `Employee` and `getName()` can be used from `Person` in `Employee`
-```javascript
-let person = new Person("James");
-let employee = new Employee("Torsten", "Developer", 45000);
+const person = new Person("James");
+const employee = new Employee("Torsten", "Developer", 45000);
console.log(employee.getName()); // Output: Torsten
console.log(person.getName()); // Output: James
console.log(employee.getPosition()); // Output: Developer
-console.log(person.getPosition()); // Output: Unemployed
-```
-
-The above example describes the polymorphism in ECMAScript.
-An object "Person" can be described in many forms (e.g. Employee, ...).
-
-Another example from reality about polymorphism:
-
-When I mention an Asian person, it is very abstract. It can be Japanese, Vietnamese or Indian. But they all share the typical characteristics of Asians.
\ No newline at end of file
+console.log(person.getPosition()); // Output: Unemployed
\ No newline at end of file
diff --git a/JavaScript_Advance/postgresConnection.js b/docs/JavaScript_Advance/postgres_connection.md
similarity index 100%
rename from JavaScript_Advance/postgresConnection.js
rename to docs/JavaScript_Advance/postgres_connection.md
diff --git a/docs/JavaScript_Advance/promises.md b/docs/JavaScript_Advance/promises.md
index f6b2ea7..d2af04b 100644
--- a/docs/JavaScript_Advance/promises.md
+++ b/docs/JavaScript_Advance/promises.md
@@ -1,69 +1,48 @@
-# Promises
-
-Promises provide a more convenient syntax to handle asynchronous operations without wanting to tear your hair out.
-
-Consider this example, pre promises:
-```javascript
-// Assume we have a number of async operations that need to run in sequence - we need the result to grab the next result.
+// Promises provide a more convenient syntax to handle asynchronous operations without wanting to tear your hair out.
+// Consider this example, pre promises:
const getAsyncDataWithCallbacks = (string, cb) => {
setTimeout(() => {
cb(`${string} bar`);
}, 1000);
};
-getAsyncDataWithCallbacks('foo', firstResult => {
+// Assume we have a number of async operations that need to run in sequence - we need the result to grab the next result.
+getAsyncDataWithCallbacks("foo", firstResult => {
getAsyncDataWithCallbacks(firstResult, secondResult => {
getAsyncDataWithCallbacks(secondResult, thirdResult => {
- //on and on and on...
- })
+ // on and on and on...
+ });
});
});
-```
-
-Notice the nested layers of callbacks - callbacks inside of callbacks. This is commonly referred to as "callback hell" -
-where we have too many callbacks to the point of making our code unmanageable.
-
-This is eased via the use of promises. You can change these async calls to return a promise instead that wraps that value like so:
-```javascript
+// This is eased via the use of promises. You can change these async calls to return a promise instead that wraps that value like so:
const getAsyncDataWithPromises = string => {
return new Promise((resolve, reject) => {
- //Assume an async operation here. We'll set a timeout to give an example.
- //After 5 seconds, our data will resolve.
+ // Assume an async operation here. We'll set a timeout to give an example.
+ // After 5 seconds, our data will resolve.
setTimeout(() => resolve(`${string} bar`), 1000);
});
};
-```
-Our callback chaining above instead now becomes:
-
-```javascript
-getAsyncDataWithPromises('foo')
+getAsyncDataWithPromises("foo")
.then(firstSet => getAsyncDataWithPromises(firstSet))
.then(secondSet => getAsyncDataWithPromises(secondSet));
- //... etc. etc. etc.
+// ... etc. etc. etc.
// Or, a more simplified version using references
-getAsyncDataWithPromises('foo')
+getAsyncDataWithPromises("foo")
.then(getAsyncDataWithPromises)
.then(getAsyncDataWithPromises);
-```
-
-As shown above, using promises allows us to create "chains" of asynchronous operations that can be run one after another.
-`then` will not be called until a promise's value is resolved. `catch` will only be called if something goes wrong.
-````javascript
-getAsyncData()
+// As shown above, using promises allows us to create "chains" of asynchronous operations that can be run one after another.
+// `then` will not be called until a promise's value is resolved. `catch` will only be called if something goes wrong.
+getAsyncDataWithPromises()
.then(data => {
- //... use data
+ // ... use data
}).catch(e => {
- //... handle exception
+ // ... handle exception
});
-````
-
-Some further examples:
-```javascript
// promises promise the nodejs main thread that i'm going to come after doing a particular task
const a = new Promise((resolve, reject) => { // This is a empty promise
@@ -99,4 +78,24 @@ asyncCall
.then(val => `${val} bar`)
// console logs 'foo bar'
.then(console.log);
-```
\ No newline at end of file
+
+// promise.all();\
+const fs = require("fs");
+const dir = __dirname + "/text/";
+const promisesarray = ["Text file content start after this : "];
+function readfile () {
+ fs.readdir(dir, "utf-8", (err, File) => {
+ File.forEach(file => {
+ promisesarray.push(new Promise((resolve, reject) => {
+ fs.readFile(dir + file, "utf-8", (err, data) => {
+ if (err) reject(err);
+ else resolve(data);
+ });
+ }));
+ });
+ Promise.all(promisesarray).then(data => {
+ console.log(data);
+ });
+ });
+}
+readfile();
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/prototype.md b/docs/JavaScript_Advance/prototype.md
index 140ce77..56fc572 100644
--- a/docs/JavaScript_Advance/prototype.md
+++ b/docs/JavaScript_Advance/prototype.md
@@ -1 +1,48 @@
-# Prototype
\ No newline at end of file
+// Prototypes are an extension for objects in javascript
+// we use to encapsulate certain functionality to an Object (like a Class)
+
+// first create an Object Person
+// that receive the name and lastName
+
+function Person (firstName, lastName) {
+ this.firstName = firstName;
+ this.lastName = lastName;
+}
+
+// We user the prototype keyword to add some functionality to this Person Object
+
+// add a method getName that return the name
+Person.prototype.getName = function () {
+ return this.firstName;
+};
+
+// add a method getLastName that return the lastName
+Person.prototype.getLastName = function () {
+ return this.lastName;
+};
+
+// add a method getFullName that return the name + lastName
+Person.prototype.getFullName = function () {
+ return this.firstName + " " + this.lastName;
+};
+
+// add a method getFormalName
+Person.prototype.getFormalName = function () {
+ return this.lastName + ", " + this.firstName;
+};
+
+// these methods appear in the __proto__ property of an Object instance of Person
+
+const max = new Person("Max", "Payne");
+
+console.log(max.getName());
+// [out] Max
+
+console.log(max.getLastName());
+// [out] Payne
+
+console.log(max.getFullName());
+// [out] Max Payne
+
+console.log(max.getFormalName());
+// [out] Payne, Max
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/recursion.md b/docs/JavaScript_Advance/recursion.md
new file mode 100644
index 0000000..cd82f7f
--- /dev/null
+++ b/docs/JavaScript_Advance/recursion.md
@@ -0,0 +1,32 @@
+// Recursion is when a function calls itself.
+// Recursion gives us an interesting way to write algorithms that can solve complicated problems.
+
+// Take for example factorials which is just an integer times each of the integers below it: so 5 factorial (also written 5!) is just 5 * 4 * 3 * 2 * 1.
+// If we want to write an algorithm that can calculate the factorial of any given number without using recursion, we could do something like this:
+
+function calcuateFactorialWithoutRecursion (num) {
+ let total = num;
+ let nextNumber = num - 1;
+ while (nextNumber >= 1) {
+ total = total * nextNumber;
+ nextNumber--; // decrease the next number by 1
+ }
+ return total;
+}
+
+// calcuateFactorialWithoutRecursion(5) // 120
+// 5 * 4 * 3 * 2 * 1 = 120
+
+// We can write the same function this way using recursion:
+function calculateFactorialWithRecursion (num) {
+ if (num === 1) { // This step is critical. The num parameter will keep decreasing until it gets to 1.
+ // Once the function gets called with 1 as a parameter, the function will return without calling itself.
+ return num;
+ }
+ return num * calculateFactorialWithRecursion(num - 1);
+}
+
+calculateFactorialWithRecursion(7); // 5040
+// 7 * 6 * 5 * 4 * 3 * 2 * 1 = 5040
+
+// See how clean recursion made this algorithm!
\ No newline at end of file
diff --git a/JavaScript_Basics/regex.js b/docs/JavaScript_Advance/regex.md
similarity index 100%
rename from JavaScript_Basics/regex.js
rename to docs/JavaScript_Advance/regex.md
diff --git a/JavaScript_Advance/resources/file/order.txt b/docs/JavaScript_Advance/resources/file/order.txt
similarity index 100%
rename from JavaScript_Advance/resources/file/order.txt
rename to docs/JavaScript_Advance/resources/file/order.txt
diff --git a/JavaScript_Advance/resources/img/file.jpg b/docs/JavaScript_Advance/resources/img/file.jpg
similarity index 100%
rename from JavaScript_Advance/resources/img/file.jpg
rename to docs/JavaScript_Advance/resources/img/file.jpg
diff --git a/docs/JavaScript_Advance/set_function.md b/docs/JavaScript_Advance/set_function.md
new file mode 100644
index 0000000..35677f6
--- /dev/null
+++ b/docs/JavaScript_Advance/set_function.md
@@ -0,0 +1,12 @@
+const jobs = {
+ set current (jobName) {
+ this.jobArray.push(jobName);
+ },
+ jobArray: []
+};
+
+language.current = "Plumber";
+language.current = "Architect";
+
+console.log(language.log);
+// expected output: Array ["Plumber", "Architect"]
\ No newline at end of file
diff --git a/JavaScript_Advance/set-object.js b/docs/JavaScript_Advance/set_object.md
similarity index 55%
rename from JavaScript_Advance/set-object.js
rename to docs/JavaScript_Advance/set_object.md
index b53d123..a513294 100644
--- a/JavaScript_Advance/set-object.js
+++ b/docs/JavaScript_Advance/set_object.md
@@ -4,14 +4,14 @@ const testSet = new Set([1, 2, "orange", { name: "Frank" }]);
// Instance Methods and Properties
-console.log(testSet.size); // output: 4
+console.log(testSet.size); // output: 4
-testSet.add(4); // testSet [1, 2, "orange", {name: "Frank"}, 4]
-testSet.add(4); // Value not added, it's duplicated
-testSet.delete(2); // testSet [1, "orange", {name: "Frank"}, 4]
-testSet.has(1); // Return true
+testSet.add(4); // testSet [1, 2, "orange", {name: "Frank"}, 4]
+testSet.add(4); // Value not added, it's duplicated
+testSet.delete(2); // testSet [1, "orange", {name: "Frank"}, 4]
+testSet.has(1); // Return true
testSet.has({ name: "Frank" }); // Return false, because the use of "==="
-testSet.clear(); // testSet []
+testSet.clear(); // testSet []
// Iterating Sets
@@ -19,10 +19,10 @@ const iterSet = new Set([1, "blue", 125, "right"]);
// Using for..of
-for (let item of iterSet) console.log(item); // output: 1, "blue", 125, "right"
-for (let item of iterSet.keys()) console.log(item); // same output
-for (let item of iterSet.values()) console.log(item); // same output
-for (let item of iterSet.entries()) console.log(item); // output: [1, 1], ["blue", "blue"], ...etc
+for (const item of iterSet) console.log(item); // output: 1, "blue", 125, "right"
+for (const item of iterSet.keys()) console.log(item); // same output
+for (const item of iterSet.values()) console.log(item); // same output
+for (const item of iterSet.entries()) console.log(item); // output: [1, 1], ["blue", "blue"], ...etc
// Using for..each
@@ -31,7 +31,7 @@ iterSet.forEach(value => console.log(value)); // output: 1, "blue", 125, "right"
// Creating a Set from an Array
const array = [1, 2, 3, "Alehop"];
-const arrToSet = new Set(array);
+const arrToSet = new Set(array);
console.log(arrToSet); // output: [1, 2, 3, "Alehop"]
@@ -45,7 +45,7 @@ console.log(notDupArray); // output: [1, 2, "yes", "no", 69, 420]
// Creating a Set form an String
const text = "Nice";
-const strToSet = new Set(text);
+const strToSet = new Set(text);
console.log(strToSet); // output: ["N", "i", "c", "e"]
@@ -54,5 +54,4 @@ console.log(strToSet); // output: ["N", "i", "c", "e"]
const dupText = "Niceeee";
const notDupText = [...new Set(dupText)].join("");
-console.log(notDupText); // output: "Nice"
-
+console.log(notDupText); // output: "Nice"
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/some_method.md b/docs/JavaScript_Advance/some_method.md
new file mode 100644
index 0000000..94bde76
--- /dev/null
+++ b/docs/JavaScript_Advance/some_method.md
@@ -0,0 +1,18 @@
+// Array some() Method
+// The some() method executes the function once for each element present in the array:
+// If it finds an array element where the function returns a true value,
+// some() returns true (and does not check the remaining values)
+
+const arr = ["name", "test name", "testtwo", "ship"];
+
+// syntax
+
+const found = arr.some((element) => {
+ console.log(element); // nam ,test name, true; stop iterating
+ // if the condition matched it doesn't check for the whole array
+ // beneficial where you want to check if a property in a whole array exist
+ return element.includes("test");
+});
+console.log(found); // true
+
+// it doesn't change the original array
\ No newline at end of file
diff --git a/docs/JavaScript_Advance/spread&rest.md b/docs/JavaScript_Advance/spread&rest.md
deleted file mode 100644
index cc776fc..0000000
--- a/docs/JavaScript_Advance/spread&rest.md
+++ /dev/null
@@ -1 +0,0 @@
-# Spread & Rest
diff --git a/JavaScript_Advance/spread&rest.js b/docs/JavaScript_Advance/spread_&_rest.md
similarity index 100%
rename from JavaScript_Advance/spread&rest.js
rename to docs/JavaScript_Advance/spread_&_rest.md
diff --git a/docs/JavaScript_Advance/timerFunction.md b/docs/JavaScript_Advance/timerFunction.md
deleted file mode 100644
index 9e53e69..0000000
--- a/docs/JavaScript_Advance/timerFunction.md
+++ /dev/null
@@ -1 +0,0 @@
-# Timer Function
diff --git a/JavaScript_Advance/tryCatch.js b/docs/JavaScript_Advance/try_catch.md
similarity index 58%
rename from JavaScript_Advance/tryCatch.js
rename to docs/JavaScript_Advance/try_catch.md
index 038eff2..0192d79 100644
--- a/JavaScript_Advance/tryCatch.js
+++ b/docs/JavaScript_Advance/try_catch.md
@@ -71,4 +71,76 @@ try {
SyntaxError A syntax error has occurred
TypeError A type error has occurred
URIError An error in encodeURI() has occurred
-*/
\ No newline at end of file
+*/
+
+//Try and Catch
+
+/* In JavaScript, try/catch/finally** statement handle errors that may occur in the block.
+
+try statement eables you to test your code in the block.
+catch statement enables you to execute a block of code when it catches an error.
+finally statement enables you to execute always after try and catch, regardless of an exception was thrown or caught.
+*/
+
+
+// Syntax
+
+try {
+ throw 'exception'; // generate an exception
+} catch (error) {
+ // statements to handle any exceptions
+} finally {
+ // always runs regardless of the resulf ot try/catch
+}
+
+
+// Errors
+
+// Reference Error
+
+try {
+ hello(); // hello is not defined so it will cause a reference errorr
+} catch (error) {
+ console.log(error);
+} finally {
+ console.log('Finally runs reguardess of the reuslt');
+}
+
+
+// Type Error
+
+try {
+ null.hello(); // hello is not defined so it will cause a reference errorr
+} catch (error) {
+ console.log("You cannot call from null");
+} finally {
+ console.log('Finally runs reguardess of the reuslt');
+}
+
+
+// Syntax Error
+
+try {
+ eval('2+2'); // thsi works fine
+ eval('Hello, World!'); // this will generate error
+} catch (error) {
+ console.log("Syntax error");
+} finally {
+ console.log('Finally runs reguardess of the reuslt');
+}
+
+
+// User Defined Error
+
+const person = {name:John, age: 23};
+
+try {
+ if(!person.gender){
+ // throw 'person has no gender'
+ throw new SyntaxError('Person has no gender');
+ }
+} catch (error) {
+ console.log("You cannot call from null");
+} finally {
+ console.log('Finally runs reguardess of the reuslt');
+}
diff --git a/docs/JavaScript_Advance_Info/AJAX.md b/docs/JavaScript_Advance_Info/AJAX.md
new file mode 100644
index 0000000..44c967a
--- /dev/null
+++ b/docs/JavaScript_Advance_Info/AJAX.md
@@ -0,0 +1,48 @@
+# AJAX
+
+AJAX stands for **A**synchronous **J**avaScript **A**nd **X**ML. In a nutshell, it is the use of the XMLHttpRequest object to communicate with servers. It can send and receive information in various formats, including JSON, XML, HTML, and text files. AJAX’s most appealing characteristic is its "asynchronous" nature, which means it can communicate with the server, exchange data, and update the page without having to refresh the page.
+
+The two major features of AJAX allow you to do the following:
+
+- Make requests to the server without reloading the page
+- Receive and work with data from the server
+
+In a traditional web application, HTTP requests, that are initiated by the user's interaction with the web interface, are made to a web server. The web server processes the request and returns an HTML page to the client. During HTTP transport, the user is unable to interact with the web application.
+
+
+In an Ajax web application, the user is not interrupted in interactions with the web application. The Ajax engine or JavaScript interpreter enables the user to interact with the web application independent of HTTP transport to and from the server by rendering the interface and handling communications with the server on the user's behalf.
+
+
+Example:
+```html
+
+
+
+```
\ No newline at end of file
diff --git a/docs/JavaScript_Advance_Info/BOM_functions.md b/docs/JavaScript_Advance_Info/BOM_functions.md
new file mode 100644
index 0000000..8801798
--- /dev/null
+++ b/docs/JavaScript_Advance_Info/BOM_functions.md
@@ -0,0 +1,79 @@
+## History API [MDN](https://developer.mozilla.org/ru/docs/Web/API/History)
+
+Interface manipulates browser history in the session borders
+
+Fields
+
+- {length} integer amount of elements in session history
+- {state} field stories state existed page
+
+Methods
+
+- {go} method loads a page from the session history with integer args
+- {back} method goes to the previous page in session history the same as history.go(-1)
+- {forfard} method goes to the next page in session history the same as history.go(1)
+- {pushState} method pushes the given data onto the session history stack with the specified title and, if provided, URL
+- {replaceState} updates the most recent entry on the history stack to have the specified data, title, and, if provided, URL
+
+## Navigator API [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Navigator)
+
+provides the user-agent information
+
+- {userAgent} user agent string for the current browser
+- {language} language of the browser UI
+- {languages} list of languages known to the user
+
+Also contains a lot of user-agent information related to:
+
+- media devices
+- bluetooth
+- usb
+- geo location
+ -- etc.
+
+##### {serviceWorker} provides access to registration, removal, upgrade, and communication with service worker
+
+## Screen [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Screen)
+
+```javascript
+// Screen data sample:
+console.log(screen);
+/**
+ * {
+ * availHeight: 949,
+ * availLeft: 0,
+ * availTop: 23,
+ * availWidth: 1680,
+ * colorDepth: 24,
+ * height: 1050,
+ * orientation: {angle: 0, type: "landscape-primary", onchange: null}
+ * pixelDepth: 24,
+ * width: 1680,
+ * }
+ */
+```
+
+## Location [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Location)
+
+```javascript
+// Location data sample
+// -> https://developer.mozilla.org/en-US/docs/Web/API/Location?replace=true
+console.log(location);
+/**
+ * {
+ * ancestorOrigins: DOMStringList {length: 0},
+ * assign: ƒ assign(),
+ * hash: "",
+ * host: "developer.mozilla.org",
+ * hostname: "developer.mozilla.org",
+ * href: "https://developer.mozilla.org/en-US/docs/Web/API/Location?replace=true",
+ * origin: "https://developer.mozilla.org",
+ * pathname: "/en-US/docs/Web/API/Location",
+ * port: "",
+ * protocol: "https:",
+ * reload: ƒ reload(),
+ * replace: ƒ (),
+ * search: "?replace=true"
+ * }
+ */
+```
diff --git a/docs/JavaScript_Advance_Info/JSON.md b/docs/JavaScript_Advance_Info/JSON.md
new file mode 100644
index 0000000..03b6f58
--- /dev/null
+++ b/docs/JavaScript_Advance_Info/JSON.md
@@ -0,0 +1,14 @@
+# JSON
+JSON is a syntax for storing and exchanging data
+Since the JSON format is text only, it can easily be sent to and from a server, and used as a data format by any programming language
+
+## Where JSON is used
+
+The JSON format is often used for serializing and transmitting structured data over a network connection. It is used primarily to transmit data between a server and web application, serving as an alternative to XML.
+
+## How to use JSON
+
+JSON data is normally accessed in Javascript through dot notation
+
+The JSON.stringify() function converts an object to a JSON string.
+JSON.parse() is a secure function to parse JSON strings and convert them to objects.
diff --git a/docs/JavaScript_Advance_Info/array_flat.md b/docs/JavaScript_Advance_Info/array_flat.md
new file mode 100644
index 0000000..c74ed13
--- /dev/null
+++ b/docs/JavaScript_Advance_Info/array_flat.md
@@ -0,0 +1,24 @@
+# Array Flat Method
+
+The `flat()` method creates a new array with nested sub-array elements concatenated into it recursively up to the specified depth. The default depth is one level but the `Infinity` parameter may be used to recursively flatten an array completely until no nested arrays remain.
+
+```js
+var array1 = [1, 2, [3, 4]];
+array1.flat();
+// [1, 2, 3, 4]
+```
+```js
+var array2 = [1, 2, [3, 4, [5, 6, [7, 8]]]];
+array2.flat(2);
+// [1, 2, 3, 4, 5, 6, [7, 8]]
+```
+```js
+var array3 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
+array3.flat(Infinity);
+// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+```
+```js
+var array4 = [1, 2, [3, 4], [5, 6], [7, 8, [9, 10]]];
+array4.flat();
+// [1, 2, 3, 4, 5, 6, 7, 8, [9, 10]]
+```
diff --git a/docs/JavaScript_Advance_Info/arrow_function.md b/docs/JavaScript_Advance_Info/arrow_function.md
new file mode 100644
index 0000000..355c3b9
--- /dev/null
+++ b/docs/JavaScript_Advance_Info/arrow_function.md
@@ -0,0 +1,23 @@
+# Arrow Function
+An arrow function expression is a syntactically compact alternative to a regular function expression.
+
+Example:
+```javascript
+// Regular function
+function greet(name){
+ console.log("Hello " + name);
+}
+
+// Arrow function equivalent
+const greet = name => {
+ console.log("Hello " + name)
+}
+```
+Both functions above are equivalent to each other.
+
+If we have more than one function argument then we should put them in paranthesis like this:
+```javascript
+const exampleFunc = (name,age,eyeColor) => {
+ // ...
+}
+```
diff --git a/docs/JavaScript_Advance/assignments.md b/docs/JavaScript_Advance_Info/assignments.md
similarity index 97%
rename from docs/JavaScript_Advance/assignments.md
rename to docs/JavaScript_Advance_Info/assignments.md
index 84fb0ef..4c208a0 100644
--- a/docs/JavaScript_Advance/assignments.md
+++ b/docs/JavaScript_Advance_Info/assignments.md
@@ -1,4 +1,5 @@
-### Assignments
+# Assignments
+
## Arithmetic
|Operation|Operator|Basic|Shortcut|
|---|---|---|---|
diff --git a/docs/JavaScript_Advance_Info/async_await.md b/docs/JavaScript_Advance_Info/async_await.md
new file mode 100644
index 0000000..5a1511d
--- /dev/null
+++ b/docs/JavaScript_Advance_Info/async_await.md
@@ -0,0 +1,126 @@
+# Async Await
+
+`async` and `await` is **syntactic sugar** for using `promises`. That means that the `async` and `await` keywords are transpiled to normal `promise` syntax.
+
+A simple example of usage of `async` and `await`:
+
+```JavaScript
+// A simple example:
+async function example(){
+ const aVariable = await aFunction();
+ console.log(aVariable)
+}
+
+example();
+```
+
+`async` is written before the function keyword when creating a new function, and enables the usage of the `await` keyword within the function. `await` is only used before function calls that return a promise. We can therefore directly see that `aFucntion` above will be run asynchronously, and return a promise.
+
+Let's say that `aFunction` returns a promise that resolves to the string `hello`. What happens when using the `Async / Await` keyword is:
+
+0. The function `example` is invoked.
+1. The function `aFunction`, which returns a `promise`, is executed asynchronously.
+1. The code waits for the promise returned by `aFunction` to resolve.
+1. When the `promise` is resolved, then `aVariable` is assigned whatever the `promise` is resolved to (`'hello'`).
+1. The `console.log` prints `hello` to the standard output.
+
+Let's remove the `Async / Await`.
+
+```JavaScript
+// A simple example:
+function example(){
+ const aVariable = aFunction();
+ console.log(aVariable)
+}
+
+example();
+```
+
+What happens in this example is:
+
+1. The function `aFunction`, which returns a `promise`, is executed asynchronously.
+2. `aVariable` is assigned the promise.
+3. The `console.log` prints `Promise { Solution
++ +```javascript +function compute(x,y,operator) { + let answer; + // checking if x and y are numbers is optional + if(isNaN(x) || isNaN(y)) { + return "Invalid number"; + } + + switch (operator) { + case "+": + answer = x + y; + break; + case "-": + answer = x - y; + break; + case "*": + case "x": + case "X": + answer = x * y; + break; + case "/": + answer = x / y; + break; + default: + answer = "Invalid operator"; + } + return answer; +} + +console.log(compute(1,6,"*")); //6 +``` + +
+| one | +two | +
| three | +four | +
div one
+ * div two
+ * div three
+ * paragraph one
+ *div four
+ * paragraph three
+ */ + +var firstDiv = document.querySelector('div'); +firstDiv.style.color = 'red'; + +var firstP = document.querySelector('p'); +firstDiv.style.color = 'blue'; + + + // Query Selector All + + /** + * Syntax: + * + */ + var elements = document.querySelectorAll(selectorType); + + /** + * It returns all elements that match the specified CSS selector + */ + +/** + * Example: + *div one
+ * div two
+ * div three
+ * paragraph one
+ *div four
+ * paragraph three
+ */ + +var divs = document.querySelectorAll('div'); +for(var singleDiv of divs) +singleDiv.style.color = 'blue'; + + // Query selectorAll + + /** + * Syntax: + * + */ + + var pElement = document.createElement('p') + + /** + * It creates a new HTML element using the name of the HTML tag to be created. + */ + + +// See more at https://www.hongkiat.com/blog/dom-manipulation-javascript-methods/``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/exercise-1-using-classes.md b/docs/JavaScript_Basics/exercise-1-using-classes.md deleted file mode 100644 index 80448be..0000000 --- a/docs/JavaScript_Basics/exercise-1-using-classes.md +++ /dev/null @@ -1 +0,0 @@ -# Exercise 1 Using Classes diff --git a/docs/JavaScript_Basics/exercise-1-using-object.md b/docs/JavaScript_Basics/exercise-1-using-object.md deleted file mode 100644 index 002f6e6..0000000 --- a/docs/JavaScript_Basics/exercise-1-using-object.md +++ /dev/null @@ -1 +0,0 @@ -# Exercise 1 Using Object diff --git a/docs/JavaScript_Basics/exercise-1.md b/docs/JavaScript_Basics/exercise-1.md deleted file mode 100644 index ff78e6f..0000000 --- a/docs/JavaScript_Basics/exercise-1.md +++ /dev/null @@ -1 +0,0 @@ -# Exercise 1 diff --git a/docs/JavaScript_Basics/filter.md b/docs/JavaScript_Basics/filter.md index 75293f0..ac5dc28 100644 --- a/docs/JavaScript_Basics/filter.md +++ b/docs/JavaScript_Basics/filter.md @@ -1,37 +1,26 @@ +```js +// JavaScript Array filter() Method -**JavaScript Array filter() Method** - -The filter() method creates a new array with all elements that +/* The filter() method creates a new array with all elements that pass the test implemented by the provided function. +*/ +const words = ["spray", "limit", "elite", "exuberant", "destruction", "present"]; +const result = words.filter(word => word.length > 6); - - - let words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present']; - const result = words.filter(word => word.length > 6); - console.log(result); - - - -> expected output: Array ["exuberant", "destruction", "present"] - - - -*Another example* +console.log(result); +// expected output: Array ["exuberant", "destruction", "present"] +/* +Another example Filtering out all small values - -The following example uses filter() to create a filtered array that has all elements with values less than 10 removed. - - - - function isBigEnough(value) { - - return value >= 10; - - } - - var filtered = [12, 5, 8, 130, 44].filter(isBigEnough); - -> filtered is [12, 130, 44] +The following example uses filter() to create a filtered array that has all elements +with values less than 10 removed. +*/ +function isBigEnough (value) { + return value >= 10; +} + +const filtered = [12, 5, 8, 130, 44].filter(isBigEnough); +// filtered is [12, 130, 44]``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/filtering_array.md b/docs/JavaScript_Basics/filtering_array.md new file mode 100644 index 0000000..5994a89 --- /dev/null +++ b/docs/JavaScript_Basics/filtering_array.md @@ -0,0 +1,21 @@ +```js +const animals = ["cats", "dogs", "bunnies", "birds"]; + +const start_with_b = animals.filter(name => name.indexOf("b") === 0); + +console.log(start_with_b); // ['bunnies', 'birds'] + +// function of filter (basic callback for filter) +const arr = [1, 3, 42, 2, 4, 5]; +function filter (array, callback) { + const callback_list = []; + for (const i of array) { + callback_list.push(callback(i)); + } + return callback_list; +} +// modifyable callback function +function callback (num) { + return Math.pow(num, 2); +} +console.log(filter(arr, callback));``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/forEach.md b/docs/JavaScript_Basics/forEach.md deleted file mode 100644 index 95ae9fe..0000000 --- a/docs/JavaScript_Basics/forEach.md +++ /dev/null @@ -1,22 +0,0 @@ - -**Map.forEach method in JavaScript** - -The forEach() method executes a provided function once per each - -key/value pair in the Map object, in insertion order. - - function logMapElements(value, key, map) { - - console.log(`map.get('${key}') = ${value}`); - - } - - new Map([['foo', 3], ['bar', {}], ['baz', undefined]]).forEach(logMapElements); - -> logs: -> -> "map.get('foo') = 3" -> -> "map.get('bar') = [object Object]" -> -> "map.get('baz') = undefined" diff --git a/JavaScript_Advance/fsModule.js b/docs/JavaScript_Basics/fs_module.md similarity index 95% rename from JavaScript_Advance/fsModule.js rename to docs/JavaScript_Basics/fs_module.md index 74110e3..3ce93a9 100644 --- a/JavaScript_Advance/fsModule.js +++ b/docs/JavaScript_Basics/fs_module.md @@ -1,3 +1,4 @@ +```js // Fs is a inbuilt function in nodejs to perform operations on files // There are always two ways to do fs operation as sync and async @@ -44,4 +45,4 @@ fsModule File ends */ -// This is a kind of publish , subscribe system our stream is subscriber and file is publisher we can use that using MQTT \ No newline at end of file +// This is a kind of publish , subscribe system our stream is subscriber and file is publisher we can use that using MQTT``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/functions.md b/docs/JavaScript_Basics/functions.md index 0c5faf5..5f4e241 100644 --- a/docs/JavaScript_Basics/functions.md +++ b/docs/JavaScript_Basics/functions.md @@ -1 +1,64 @@ -# Functions +```js +// Functions in Javascript +// Functions are used to structure and generalize the code. It will become more flexible and you will have a better overview. + +/* What is a function? +A Function is a type of varable which essentially contains code you can run. +There are different ways to write code into a variable (declare a function). +*/ + +function foo () { // Puts codes inside if the curly brackets into the variable "foo". + console.log("Hello World") +} + +// Shows that "foo" is a variable with the type function +console.log(typeof foo) // "function" +console.log(typeof 1) // "number" +console.log(typeof "hello") // "string" + +/* How to call a function? +The function is defined. Now we want to execute the code inside the Function +*/ + +// The most common way to execute a function by appending the variable name with brackets +foo() // "Hello World" + +/* Functions with output +Printing text is acually the wrong format of getting informations out of variables. +To get usable informations back we can use the return keyword. +*/ + +// Nothing is returned -> x is empty +x = foo() // "Hello World" and x: undefined + + +function foo () { // get a value from the inside of the function to te outside. + text = "Hello World" + return text +} + +// text is returned, nothing prited into the console. +x = foo() // x: "Hello World" + +// You can see that variables from inside the function are not accessible anymore +console.log(text) // undefined +// the string from the "text" variable was retuned an is now "x" +console.log(x) // "Hello World" + +/* Functions with input +Input for functions is called parameters. +When you define the function you can also define what input variables the function can have. +That is the purpose of the "()". "()" means no input both wen you define and call a function. +*/ + +// define with parameters +function add(a, b) { // in the "()" you define what variable names the inputs get. Multiple parameters are septerated by a "," + c = a + b // add the value of the two variables + return c +} + +// call with parameters +// Depending on the sequence, the values separated by a "," are assigned to the parameter variables. +// a = 5; b = 8; +result = add(5, 8) // result: 13 +``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/higherOrderFunctions.md b/docs/JavaScript_Basics/higherOrderFunctions.md deleted file mode 100644 index 8768c4a..0000000 --- a/docs/JavaScript_Basics/higherOrderFunctions.md +++ /dev/null @@ -1 +0,0 @@ -# Higher Order Functions \ No newline at end of file diff --git a/JavaScript_Basics/higherOrderFunctions.js b/docs/JavaScript_Basics/higher_order_functions.md similarity index 92% rename from JavaScript_Basics/higherOrderFunctions.js rename to docs/JavaScript_Basics/higher_order_functions.md index f33e55f..f28d814 100644 --- a/JavaScript_Basics/higherOrderFunctions.js +++ b/docs/JavaScript_Basics/higher_order_functions.md @@ -1,9 +1,10 @@ +```js // HIGHER ORDER FUNCTIONS FOR ARRAYS // the arrays in javascript have 3 main HOF // SUCH MAP, FILTER AND REDUCE -const list = [1,2,3,4,5] +const list = [1, 2, 3, 4, 5]; // map @@ -14,8 +15,8 @@ const list = [1,2,3,4,5] // 3rd arg is the entire list [1,2,3,4,5] const newList = list.map(function (item, index, list) { - return item * 2 -}) + return item * 2; +}); // this return a new array with new values like [2, 4, 6, 8, 10] @@ -29,7 +30,7 @@ const newList = list.map(function (item, index, list) { const newListFiltered = list.map(function (item, index, list) { // condition to return a value for the new array - return item % 2 === 0 + return item % 2 === 0; }) // this return a new array with some filtered values based on a condition [2, 4] @@ -41,6 +42,7 @@ const newListFiltered = list.map(function (item, index, list) { // if you don't add a function sort numbers in incremental way and text in alphabetic way // the sort receive a function that receives 3 arguments -[1, 10, 2, 21].sort() + [1, 10, 2, 21].sort(); // this return [1, 10, 2, 21] +``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/if.md b/docs/JavaScript_Basics/if.md index 009b493..a7bf661 100644 --- a/docs/JavaScript_Basics/if.md +++ b/docs/JavaScript_Basics/if.md @@ -1 +1,33 @@ -# IF, ELSE IF, ELSE CONDITION \ No newline at end of file +```js +// IF keyword condition +// this is used to create condition block of code + +// the if needs a condition that the result is true and execute the +// code inside of the if block + +const condition = 2 % 2 === 0; + +if (condition) { + // run this code + console.log("YEAH THIS RUN BECAUSE THE CONDITION IS A HARDCODE true"); +} + +// have a default value if the condition is false +// this runs in the else code block + +if (condition) { + // this block of code is never executed +} else { + // run this code + console.log("YEAH THIS RUN BECAUSE THE CONDITION IS A HARDCODE false"); +} + +// and you can make more conditions with an ELSE IF keyword + +if (!condition) { + // this block of code is never executed +} else if (condition) { + // this code is executed because 1 is true like binary +} else { + // this block of code is never executed +}``` \ No newline at end of file diff --git a/JavaScript_Basics/iife.js b/docs/JavaScript_Basics/iife.md similarity index 64% rename from JavaScript_Basics/iife.js rename to docs/JavaScript_Basics/iife.md index d9a87b6..8d57c00 100644 --- a/JavaScript_Basics/iife.js +++ b/docs/JavaScript_Basics/iife.md @@ -1,3 +1,4 @@ +```js /* IIFE: Immediately Invoked Function Expression or Anonymous functions @@ -6,7 +7,7 @@ Functions that are invoked immediately after definition. Can be used as shown below:-- */ -(function(value){ - var modified = value + 4 - console.log(modified); -}(3)) +(function (value) { + const modified = value + 4; + console.log(modified); +}(3));``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/includes.md b/docs/JavaScript_Basics/includes.md new file mode 100644 index 0000000..daf0775 --- /dev/null +++ b/docs/JavaScript_Basics/includes.md @@ -0,0 +1,9 @@ +```js +// Find substring in a string. Similar to contains in java. + +// Defining dummy variables +var string = "foo", substring1 = "oo", substring2="a"; + +console.log(string.includes(substring1)); // true +console.log(string.includes(substring2)); // false +``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/inheritance.md b/docs/JavaScript_Basics/inheritance.md deleted file mode 100644 index 1384947..0000000 --- a/docs/JavaScript_Basics/inheritance.md +++ /dev/null @@ -1 +0,0 @@ -# Inheritance diff --git a/docs/JavaScript_Basics/looping-an-object.md b/docs/JavaScript_Basics/looping-an-object.md deleted file mode 100644 index 18a6886..0000000 --- a/docs/JavaScript_Basics/looping-an-object.md +++ /dev/null @@ -1 +0,0 @@ -# Looping an object \ No newline at end of file diff --git a/JavaScript_Basics/looping-an-object.js b/docs/JavaScript_Basics/looping_an_object.md similarity index 97% rename from JavaScript_Basics/looping-an-object.js rename to docs/JavaScript_Basics/looping_an_object.md index 6838652..5fbcf77 100644 --- a/JavaScript_Basics/looping-an-object.js +++ b/docs/JavaScript_Basics/looping_an_object.md @@ -1,3 +1,4 @@ +```js // Let's create a student object which contains their Roll. No and their names. const studentObject = { 101: "Hitesh", @@ -12,4 +13,4 @@ for (const key in studentObject) { if (key === 105) { console.log("The Student's name is ", studentObject[key]); } -} \ No newline at end of file +}``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/map.md b/docs/JavaScript_Basics/map.md index 609b1a7..9e8f8cb 100644 --- a/docs/JavaScript_Basics/map.md +++ b/docs/JavaScript_Basics/map.md @@ -1,33 +1,17 @@ -# Array.prototype.map() - -We can use `map()` when we want to manipulate each data inside an array without changing the values of the original array. - -The `map()` method creates a new array with the results of calling the provided function for each element in the array. - -**Note:** `map()` does not execute the function if the array has no values. - -**Note:** this method does not change the original array. - -## Example - -The following code takes an array of numbers and creates a new array containing the square roots of the numbers in the first array. - -Using a callback function ```js -var numbers = [1, 4, 9]; -var roots = numbers.map(function(num) { - return Math.sqrt(num) +// Let's create an array of numbers that we want to get the square of each number in the array +const numbers = [1, 2, 3, 4, 5]; + +// pass a function to map +const square = numbers.map(function (num) { + return num * num; }); -// roots is now [1, 2, 3] -// numbers is still [1, 4, 9] -``` +// You can also do this using an arrow function +const square2 = numbers.map(num => num * num); -Using an arrow function -```js -var numbers = [1, 4, 9]; -var roots = numbers.map(num => Math.sqrt(num)); +console.log(square); +// expected output: Array [1, 4, 9, 16, 25] -// roots is now [1, 2, 3] -// numbers is still [1, 4, 9] -``` \ No newline at end of file +console.log(square2); +// expected output: Array [1, 4, 9, 16, 25]``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/math.md b/docs/JavaScript_Basics/math.md new file mode 100644 index 0000000..278351a --- /dev/null +++ b/docs/JavaScript_Basics/math.md @@ -0,0 +1,53 @@ +```js +// Math functions + +// ceil and floor functions +Math.ceil(2.3); // will return 3 +Math.floor(3.9); // will return 3 + +// sin and cos functions +Math.sin(20 * Math.PI / 180); // will return 0.5 (the sine of 30 degrees) +Math.cos(30 * Math.PI / 180); // will return 0.5 (the cos of 60 degrees) + +// min and max functions +Math.min(50, 50, 810, 2200, -900); // will return -900 +Math.max(230, 250, 10, 300, -900); // will return 300 + +// round function +Math.round(5.899); + +// returns a random number that is not an integer between 1 to 10. +Math.random() * (10 - 1) + 1; + +// Defining variables to carry out the mathematical functions on. +value1 = 10; +value2 = -20; +value3 = 15.7; +value4 = 40; +value5 = 3; + +// This is a javacript document, wrote to outline the use of the math functions - inbuilt javascript functions used for carrying out maths! +function round (value) { + console.log("The round function has been called, what this does is perform the javascript math.round on a value."); + return Math.round(value); +} + +function pow (value1, value2) { + console.log("The power - pow() function, takes one number and calculates the power of the number off a second inputted value."); + return Math.round(value1, value2); +} + +function sqrt (value) { + console.log("The Math.sqrt() calculates the square root of a number entered."); + return Math.sqrt(value); +} + +function abs (value) { + console.log("The Math.abs() returns the absolute value of a number."); + return Math.abs(value); +} + +console.log(round(value3)); +console.log(pow(value4, value5)); +console.log(sqrt(value5)); +console.log(abs(99.99));``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/number_methods.md b/docs/JavaScript_Basics/number_methods.md new file mode 100644 index 0000000..c64c516 --- /dev/null +++ b/docs/JavaScript_Basics/number_methods.md @@ -0,0 +1,153 @@ +```js +// isFinite() + +/* +Checks whether a value is a finite number. +Finite is a number that isn't infinite and can be measured or given a value. + +It only takes a single parameter which is the value you'd like to check. +It's return value will be a boolean (true or false) + +Numbers that pass as finite: +0 +whole numbers +negative numbers +decimals +equations + +*/ + +console.log(Number.isFinite(80)); // output = true +console.log(Number.isFinite(-1.80)); // output = true +console.log(Number.isFinite(2 * 2)); // output = true +console.log(Number.isFinite(80)); // output = true +console.log(Number.isFinite(0)); // output = true +console.log(Number.isFinite("10/17/2019")); // output = false +console.log(Number.isFinite("3")); // output = false + +// isInteger() + +/* +Checks whether the value passed is an integer. +It's return value will be a boolean (true / false) +*/ +console.log(Number.isInteger(2)); // output = true +console.log(Number.isInteger(-10)); // output = true +console.log(Number.isInteger(2.50)); // output = false +console.log(Number.isInteger(0)); // output = true + +// isNaN() + +/* +Checks whether the value passed is NaN (Not a number) or if the value is a number +true = NaN +false = A number +*/ + +console.log(Number.isNaN(436)); // output = false +console.log(Number.isNaN(91.9)); // output = false +console.log(Number.isNaN("76")); // output = false +console.log(Number.isNaN(true)); // output = false +console.log(Number.isNaN(NaN)); // output = true +console.log(Number.isNaN("NaN")); // output = false + +// isSafeInteger() + +/* +Checks whether the method passed is a safe integer. The returned value will provide a boolean. + +A safe integer is represented as an IEEE-754 double precision number. This is simply any number between -9007199254740991 and 9007199254740991. + +Note that the value isn't changed to a number if a string is passed in. +*/ + +Number.isSafeInteger(9); // true +Number.isSafeInteger(-234); // true +Number.isSafeInteger("234"); // false +Number.isSafeInteger(0.7); // true +Number.isSafeInteger(2.0); // true + +// toExponential() + +/* +Converts a number to its exponential form. The returned value is a string that represents the Number object in exponential notation +*/ + +const num1 = 89.0; +num.toExponential(); // '"8.9e+1" + +const num2 = 2.5692; +num.toExponential(); // "2.5691e+0" + +const num3 = -100.45; +num.toExponential(); // "-1.0045e+2" + +// toFixed() + +/* +Formats a number using the fixed-point notation. It allows you to format a number with a specific number of digits to the right of the decimal. Numbers will be rounded is ncessary. + +Its return value is a string with the given number using fixed-point notation. If the number given is negative, the return value will be a number and won't be converted into a string. +*/ + +3.45.toFixed(); // '"3" +3.45.toFixed(1); // "3.5" +48573.120.toFixed(5); // "48573.12000" +3.45.toFixed() - // "3" + 180.45.toFixed(); // -100 + +// toLocaleString() + +/* +Converts a number into a language-sensitive representation of said number. +It can take in two optional parameters: +- locales: A string with a language tag (bali, latn) +- options: A set of options for the given locale (curency, style) + +The return value is a string. +*/ + +let number = 8000; +number.toLocaleString(); // "8,000" because the locale is English + +number = 800; +number.toLocaleString("ja-JP", { style: "currency", currency: "JPY" }); // "￥800" because we set the the locale and options + +// toPrecision() + +/* +Converts a number to the specified precision. + +The returned value is in the form of a string. The value will be rounded and padded with 0's if there are not enough digits. +*/ + +const precisionNum = 9.473739; + +console.log(precisionNum.toPrecision()); // "9.473739" +console.log(precisionNum.toPrecision(4)); // "9.474" +console.log(precisionNum.toPrecision(1)); // "9" + +// toString() + +/* +Converts a given number to a string with the specified base number (an integer betwen 2 and 36) + +The return value is given in the form of a string if no radix is given. + +*/ + +const toStringNum = 100; +toStringNum.toString(2); // "1100100" +toStringNum.toString(); // "100" +toStringNum.toString(4); // "1210" + +// valueOf() + +/* +Returns the number value in primitive form of a Number object. +This is rarely something done on your own, as JavaScript invokes this automatically. +*/ + +const age = new Number(45); +typeof age; // object +age.valueOf(); // 45``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/objects.md b/docs/JavaScript_Basics/objects.md index 2e79c08..69d9969 100644 --- a/docs/JavaScript_Basics/objects.md +++ b/docs/JavaScript_Basics/objects.md @@ -1 +1,62 @@ -# Objects +```js +// Object in basically collection of key value pairs +const old = { + name: "Swapnil", // left is key and right one is value + rollno: 76 // We assign any type to keys +}; + +console.log(old); +// Output { name: 'Swapnil', rollno: 76 } + +const a = { + name: "Swapnil", // We can omit the " " in keys but for string values it is necessary + rollno: 76 // We assign any type to keys +}; + +console.log(a); +// Output { name: 'Swapnil', rollno: 76 } + +const b = { + name: "Swapnil", + rollno: 76, + rollno: "Swap" // If we repeat the same key then the latest value is stored +}; + +console.log(b); +// Output { name: 'Swapnil', rollno: 'Swap' } + +console.log(a.name); // This way we can get a particular value for a key. " " around are imp. + +console.log(a.name); // This way you can get the value of particular element +// Output Swapnil +a.name = "Swapnil Satish Shinde"; // This way we can change a particular property of object + +console.log(a.name); // This way you can get the value of particular element +// Output Swapnil Satish Shinde + +console.log(a); +// Output { name: 'Swapnil Satish Shinde', rollno: 76 } + +const objectWithFunction = { + name: "Swapnil", // We can omit the " " in keys but for string values it is necessary + rollno: 76, // We assign any type to keys + getfull: function () { // Don't use arrow function here as arrow functions don't have this property + console.log(`${this.name} ${this.rollno}`); + } +}; + +console.log(objectWithFunction); +// Output { name: 'Swapnil', rollno: 76, getfull: [Function: getfull] } + +objectWithFunction.getfull(); // Output Swapnil 76 + +const canAddValue = { // This is normal object having 2 keys name and rollno + name: "Swapnil", + rollno: 76 +}; + +// We can add the keys we want any time into the object by directly assigning value to it +canAddValue.branch = "Computer"; + +console.log(canAddValue); +// Output { name: 'Swapnil', rollno: 76, branch: 'Computer' }``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/page-redirect.md b/docs/JavaScript_Basics/page-redirect.md deleted file mode 100644 index 0161723..0000000 --- a/docs/JavaScript_Basics/page-redirect.md +++ /dev/null @@ -1,50 +0,0 @@ -### `Page Redirection and Auto Refresh` - -- ***Use:*** -Syntax: `Window.location ` [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/location) takes parameters as `location = 'http://www.example.com'` - - -Example of how to use page redirect. -```html - - - - - - -Click the following button, you will be redirected to home page.
- - - - - -``` -An example of how to perform an Auto Refresh -```html - - - - - - - - -This page will refresh every 5 seconds.
- - - -``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/page_redirects.md b/docs/JavaScript_Basics/page_redirects.md new file mode 100644 index 0000000..4db439d --- /dev/null +++ b/docs/JavaScript_Basics/page_redirects.md @@ -0,0 +1,62 @@ +```js +/** + * + * JAVASCRIPT PAGE REDIRECTS + * The file shows various usages of JS methods to facilitate the Page Redirects + * There are two techniques that are listed here. + * i) General JS Page redirects + * ii) Auto-refresh of the HTML Pages + * + */ + +// Using the window.location assigned with a DOMString (URL) +window.location = "https://www.example.com"; + +// Using the href property of the Location object +window.location.href = "https://www.example.com"; + +// Using the window.location.assign() method +window.location.assign("https://www.example.com"); + +// Using the window.location.replace() method +window.location.replace("https://www.example.com"); + +/// //////////////////////////////////////////////////////////////// +/// / Auto-Refresh /// +/// //////////////////////////////////////////////////////////////// + +// Using the window.location.reload(forcedReload) method +// The optional parameter forcedReload accepts a boolean value +// If it is set to true, the page is downloaded from the server +// If the value is false, the page is reloaded from cache + +// The following code demonstrates the auto-refresh +function autoRefresh (intervalInMilliSeconds) { + // Using setTimeout() + setTimeout(window.location.reload(), intervalInMilliSeconds); + + /** ***** OR *******/ + + // Using setInterval() + setInterval(window.location.reload(), intervalInMilliSeconds); +} +// Run the function onload of the page +autoRefresh(); + +/** ***** OR *******/ + +// A redirect is when a web page is visited at a certain URL, it changes to a different URL. +// This can be done for many reasons like moving your domain to a new one or You have built-up various pages based on browser versions or their names or may be based on different countries. +// Most popular way to redirect to another webpage using JavaScript is location.href and location.replace + +function Redirect () { + window.location = "https://www.google.com"; +} + +// For an auto refresh you would use the following script + +function AutoRefresh (t) { + setTimeout("location.reload(true);", t); +} + +// Please look at the page-redirect.md file to see where you would include these scripts``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/popup_boxes.md b/docs/JavaScript_Basics/popup_boxes.md new file mode 100644 index 0000000..a735566 --- /dev/null +++ b/docs/JavaScript_Basics/popup_boxes.md @@ -0,0 +1,42 @@ +```js +/* eslint-disable no-unused-vars */ +/* eslint-disable no-undef */ + +/** + * Alert + * @description alert is popup displays message and blocks any user operation + * till the popup will be closed + * @param {string} message - message to display in popup + */ +const callAlertMessage = (message) => alert(message); // display alert with passed message +console.log(callAlertMessage("message in alert popup")); // undefined + +/** + * Confirm + * @description confirm is popup displays message with accept/reject options + * and block any user operation till the popup will be closed + * Once the confirm message will resolved/rejected the appropriate result will be returned + * @param {string} condition - message to display in popup + * @returns {boolean} confirm/reject from user on passed condition + */ +const isUserConfirmCondition = (condition) => confirm(condition); +console.log(isUserConfirmCondition("Do you agree?")); // true if user will press OK button else false + +// sample +const sendNotificationIfUserAgreed = (notificationMessage, doOnApply, doOnReject) => ( + isUserConfirmCondition(notificationMessage) ? doOnApply() : doOnReject() +); + +/** + * Prompt + * @description prompt is popup displays message with input field and block any user operation. + * Once the user enter the input value the appropriate result will be returned. + * null will be returned if user will press cancel or close the popup + * @param {string} message - message to display in popup + * @returns {string | null} - entered by user value or null on cancel + */ +const getUserEnterredValue = (message) => prompt(message); + +// sample +const getUserPrimaryLanguage = (message) => getUserEnterredValue(message); +console.log(getUserEnterredValue("which language is primary for you?")); // return sring with answer or null``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/reduce.md b/docs/JavaScript_Basics/reduce.md index a3af62d..9774a22 100644 --- a/docs/JavaScript_Basics/reduce.md +++ b/docs/JavaScript_Basics/reduce.md @@ -1,23 +1,15 @@ - -**JavaScript | Array reduce() Method** +```js +// JavaScript | Array reduce() Method +/* The array reduce() method in JavaScript is used to reduce the array to a single value and executes a provided function for each value of the array (from left-to-right) and the return value of the function is stored in an accumulator. +*/ +const pokemon = ["squirtle", "charmander", "bulbasaur"]; +const pokeLength = pokemon.reduce(function (previous, current) { + return previous + current.length; +}, 0); - var pokemon = ["Squirtle", "Charmander", "Bulbasaur"]; - - - - var pokeLength = - - pokemon.reduce(function(previous, current) { - - return previous + current.length; - - }, 0); - - - -> Outputs 27 +// Outputs 27``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/regex.md b/docs/JavaScript_Basics/regex.md deleted file mode 100644 index f84685f..0000000 --- a/docs/JavaScript_Basics/regex.md +++ /dev/null @@ -1 +0,0 @@ -# Regex \ No newline at end of file diff --git a/JavaScript_Basics/resources/img/substr.png b/docs/JavaScript_Basics/resources/img/substr.png similarity index 100% rename from JavaScript_Basics/resources/img/substr.png rename to docs/JavaScript_Basics/resources/img/substr.png diff --git a/docs/JavaScript_Basics/scope.md b/docs/JavaScript_Basics/scope.md new file mode 100644 index 0000000..6b13f6c --- /dev/null +++ b/docs/JavaScript_Basics/scope.md @@ -0,0 +1,66 @@ +```js +//JavaScript Scope + +//Global scope +var a = 1; + +function accessingGlobalVariable() { + console.log(a); // return 1 +} +//End global scope + +//Local scope +var a = 1; +function accessingGlobalVariable2() { + console.log(a); // return 1 +} + +function accessingLocalVariable() { + var a = 3; + console.log(a); // return 3 +} +//End local scope + +//Automatic global variable +function declaringAutomaticGlobalVariable() { + b = 'Hello'; +} + +declaringAutomaticGlobalVariable(); +console.log(b); // return 'Hello' +//End automatic global variable + +//Block scoping +//var +var a = 1; +function accessingVariable() { + if (true) { + var a = 4; + } + console.log(a); +} +accessingVariable(); // return 4 +//end var + +//let +var a = 1; +function accessingVariable() { + if (true) { + let a = 4; + } + console.log(a); +} +accessingVariable(); // return 1 +//end let + +//const +var a = 1; +function accessingVariable() { + if (true) { + const a = 4; + } + console.log(a); +} +accessingVariable(); // return 1 +//end const +//End Block scoping``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/some.md b/docs/JavaScript_Basics/some.md new file mode 100644 index 0000000..4325437 --- /dev/null +++ b/docs/JavaScript_Basics/some.md @@ -0,0 +1,31 @@ +```js +// JavaScript | some() Method +/* +some() method in JavaScript is used to check if leasts one element of the set meets the condition implemented by +determinated function +*/ + +const array = [ + { + id: 1, + name: "John" + }, + { + id: 2, + name: "David" + }, + { + id: 3, + name: "Lisa" + }, + { + id: 4, + name: "Ashley" + } +]; + +const existAshley = array.some(element => element.name === "Ashley"); + +// The const existAshley return true or false if the condition is correct + +// In this example the const existAshley return true``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/splice-slice.md b/docs/JavaScript_Basics/splice-slice.md deleted file mode 100644 index 9c356d1..0000000 --- a/docs/JavaScript_Basics/splice-slice.md +++ /dev/null @@ -1 +0,0 @@ -# Splice and Slice \ No newline at end of file diff --git a/JavaScript_Basics/splice-slice.js b/docs/JavaScript_Basics/splice_slice.md similarity index 96% rename from JavaScript_Basics/splice-slice.js rename to docs/JavaScript_Basics/splice_slice.md index b91fc2e..095c3a3 100644 --- a/JavaScript_Basics/splice-slice.js +++ b/docs/JavaScript_Basics/splice_slice.md @@ -1,3 +1,4 @@ +```js //########### // SPLICE # //########### @@ -46,4 +47,4 @@ let coding = languages.slice(-3, -1); // ["C++", "Java", "Javascript", "R"] // -4 -3 -2 -1 // -// Slice excludes the last index when its negative. Hence, it will return elements at -3 and -2, ignoring element at -1. \ No newline at end of file +// Slice excludes the last index when its negative. Hence, it will return elements at -3 and -2, ignoring element at -1.``` \ No newline at end of file diff --git a/JavaScript_Basics/strictMode.js b/docs/JavaScript_Basics/strict_mode.md similarity index 54% rename from JavaScript_Basics/strictMode.js rename to docs/JavaScript_Basics/strict_mode.md index 49be55e..b4b93f7 100644 --- a/JavaScript_Basics/strictMode.js +++ b/docs/JavaScript_Basics/strict_mode.md @@ -1,24 +1,25 @@ -'use strict'; +```js +"use strict"; // examples taken from: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode // Assignment to a non-writable global -var undefined = 5; // throws a TypeError -var Infinity = 5; // throws a TypeError +const undefined = 5; // throws a TypeError +const Infinity = 5; // throws a TypeError // Assignment to a non-writable property -var obj1 = {}; -Object.defineProperty(obj1, 'x', { value: 42, writable: false }); +const obj1 = {}; +Object.defineProperty(obj1, "x", { value: 42, writable: false }); obj1.x = 9; // throws a TypeError // Assignment to a getter-only property -var obj2 = { get x() { return 17; } }; +const obj2 = { get x () { return 17; } }; obj2.x = 5; // throws a TypeError // Assignment to a new property on a non-extensible object -var fixed = {}; +const fixed = {}; Object.preventExtensions(fixed); -fixed.newProp = 'ohai'; // throws a TypeError +fixed.newProp = "ohai"; // throws a TypeError // deleting undeletable properties -'use strict'; -delete Object.prototype; // throws a TypeError +"use strict"; +delete Object.prototype; // throws a TypeError``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/stringOperation.md b/docs/JavaScript_Basics/stringOperation.md deleted file mode 100644 index a14523a..0000000 --- a/docs/JavaScript_Basics/stringOperation.md +++ /dev/null @@ -1 +0,0 @@ -# String Operation diff --git a/JavaScript_Basics/stringOperation.js b/docs/JavaScript_Basics/string_operation.md similarity index 63% rename from JavaScript_Basics/stringOperation.js rename to docs/JavaScript_Basics/string_operation.md index 023aa92..26d2f68 100644 --- a/JavaScript_Basics/stringOperation.js +++ b/docs/JavaScript_Basics/string_operation.md @@ -1,3 +1,4 @@ +```js const into = "My college is SIESGST. Our seniors and alumnus are best in Mumbai"; const fullName = "My name is Swapnil Satish Shinde"; @@ -12,4 +13,18 @@ console.log(oldBio); // My college is SIESGST. Our seniors and alumnus are best console.log(bio); // My college is SIESGST. Our seniors and alumnus are best in Mumbai My name is Swapnil Satish Shinde I belong to Computer Science branch -// Output by both the methods is same but string interpolation is more beautiful as we only have to right 1 line for all we want \ No newline at end of file +// Output by both the methods is same but string interpolation is more beautiful as we only have to right 1 line for all we want + +/** Capitalizing a string + * + * Here's a simple way to capitalize a string + */ +String.prototype.capitalize = (string) => string.slice(0, 1).toUpperCase() + string.slice(1) +console.log("a casual lower case string") +// Prints out: "A casual lower case string" + + +/** EXERCISE **/ +// Add a function to the string prototype that counts the occurrences of a substring +// 'cheese and Bananas, and more cheese'.count('cheese') -----> 2 +``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/substr.md b/docs/JavaScript_Basics/substr.md index b80489b..388124b 100644 --- a/docs/JavaScript_Basics/substr.md +++ b/docs/JavaScript_Basics/substr.md @@ -1,26 +1,20 @@ - ### `substr and substring` +```js +// define a dummy string +const str = "commonSourceOfTruth"; -- ***Use:*** -Syntax: `substr` [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr) takes parameters as `(from, ?length).` -Syntax: `substring` [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring) takes parameters as `(start, ?end(exclusive)).` +// get value using substr +console.log(str.substr(1, 10)); // 'ommonSourc' -```js - // get value using substr - console.log(str.substr(1, 10)); // 'ommonSourc' - - // get value using substring - console.log(str.substring(1, 10)); // 'ommonSour' - // if we start from 0 both behave the same. - console.log(str.substr(0, 10)); // 'commonSour' - console.log(str.substring(0, 10)); // 'commonSour' +// get value using substring +console.log(str.substring(1, 10)); // 'ommonSour' - // Example: Remove first and last character from a given string +// if we start from 0 both behave the same. +console.log(str.substr(0, 10)); // 'commonSour' +console.log(str.substring(0, 10)); // 'commonSour' - console.log(str.substr(1, str.length - 2)) // ommonSourceOfTrut +// Example: Remove first and last character from a given string - // Substring takes indices - console.log(str.substring(1, str.length - 1)) // ommonSourceOfTrut -``` +console.log(str.substr(1, str.length - 2)); // ommonSourceOfTrut -## Substr Browser compatibility -
+// Substring takes indices
+console.log(str.substring(1, str.length - 1)); // ommonSourceOfTrut```
\ No newline at end of file
diff --git a/JavaScript_Advance/swapValuesES6.js b/docs/JavaScript_Basics/swap_values_ES6.md
similarity index 90%
rename from JavaScript_Advance/swapValuesES6.js
rename to docs/JavaScript_Basics/swap_values_ES6.md
index 698e695..b153fd7 100644
--- a/JavaScript_Advance/swapValuesES6.js
+++ b/docs/JavaScript_Basics/swap_values_ES6.md
@@ -1,3 +1,4 @@
+```js
// Swap values before ES6
// BAD because you need temp variable z to hold x value
let x = 5, y = 7; // x = 5, y = 7;
@@ -8,4 +9,4 @@ y = z; // y = 5
// ES6 way
let x = 5, y = 7;
[x, y] = [y, x];
-// x = 7, y = 5
\ No newline at end of file
+// x = 7, y = 5```
\ No newline at end of file
diff --git a/docs/JavaScript_Basics/switch_case.md b/docs/JavaScript_Basics/switch_case.md
new file mode 100644
index 0000000..176786b
--- /dev/null
+++ b/docs/JavaScript_Basics/switch_case.md
@@ -0,0 +1,219 @@
+```js
+/**
+ * 1. Where we use the Switch
+ * 2. More info about Switch
+ */
+
+// 1. Where we use the Switch
+
+// The switch statement is used to perform different actions based on different conditions.
+
+// The JavaScript Switch Statement
+// Use the switch statement to select one of many code blocks to be executed.
+
+Syntax;
+switch (expression) {
+ case x:
+ // code block
+ break;
+ case y:
+ // code block
+ break;
+ default:
+ // code block
+}
+
+// This is how it works:
+
+// The switch expression is evaluated once.
+// The value of the expression is compared with the values of each case.
+// If there is a match, the associated block of code is executed.
+// Example
+// The getDay() method returns the weekday as a number between 0 and 6.
+
+// (Sunday=0, Monday=1, Tuesday=2 ..)
+
+// This example uses the weekday number to calculate the weekday name:
+
+switch (new Date().getDay()) {
+ case 0:
+ day = 'Sunday';
+ break;
+ case 1:
+ day = 'Monday';
+ break;
+ case 2:
+ day = 'Tuesday';
+ break;
+ case 3:
+ day = 'Wednesday';
+ break;
+ case 4:
+ day = 'Thursday';
+ break;
+ case 5:
+ day = 'Friday';
+ break;
+ case 6:
+ day = 'Saturday';
+}
+
+/**
+ * The result of day will be:Thursday
+ */
+
+// 2. More info about Switch
+
+// The break Keyword
+// When JavaScript reaches a break keyword, it breaks out of the switch block.
+
+// This will stop the execution of inside the block.
+
+// It is not necessary to break the last case in a switch block. The block breaks (ends) there anyway.
+
+// Note: If you omit the break statement, the next case will be executed even if the evaluation does not match the case.
+
+// The default Keyword
+// The default keyword specifies the code to run if there is no case match:
+
+// Example
+// The getDay() method returns the weekday as a number between 0 and 6.
+
+// If today is neither Saturday (6) nor Sunday (0), write a default message:
+
+switch (new Date().getDay()) {
+ case 6:
+ text = 'Today is Saturday';
+ break;
+ case 0:
+ text = 'Today is Sunday';
+ break;
+ default:
+ text = 'Looking forward to the Weekend';
+}
+
+// The result of text will be:
+
+// Looking forward to the Weekend
+// The default case does not have to be the last case in a switch block:
+
+// Example
+
+switch (new Date().getDay()) {
+ default:
+ text = 'Looking forward to the Weekend';
+ break;
+ case 6:
+ text = 'Today is Saturday';
+ break;
+ case 0:
+ text = 'Today is Sunday';
+}
+
+// If default is not the last case in the switch block, remember to end the default case with a break.
+
+// Common Code Blocks
+// Sometimes you will want different switch cases to use the same code.
+
+// In this example case 4 and 5 share the same code block, and 0 and 6 share another code block:
+
+// Example
+
+switch (new Date().getDay()) {
+ case 4:
+ case 5:
+ text = 'Soon it is Weekend';
+ break;
+ case 0:
+ case 6:
+ text = 'It is Weekend';
+ break;
+ default:
+ text = 'Looking forward to the Weekend';
+}
+
+// Switching Details
+// If multiple cases matches a case value, the first case is selected.
+
+// If no matching cases are found, the program continues to the default label.
+
+// If no default label is found, the program continues to the statement(s) after the switch.
+
+// Strict Comparison
+// Switch cases use strict comparison (===).
+
+// The values must be of the same type to match.
+
+// A strict comparison can only be true if the operands are of the same type.
+
+// In this example there will be no match for x:
+
+Example: var x = '0';
+switch (x) {
+ case 0:
+ text = 'Off';
+ break;
+ case 1:
+ text = 'On';
+ break;
+ default:
+ text = 'No value found';
+}
+
+/** Exercise for You Complete it */
+
+// Create a switch statement that will alert "Hello" if fruits is "banana", and "Welcome" if fruits is "apple".
+
+switch (fruits) {
+ case 'Banana':
+ alert('Hello');
+ break;
+
+ case 'Apple':
+ alert('Welcome');
+ break;
+}
+
+// Create a switch statement that will tell you what to wear based on the temperature outside. For temps below 50 degrees Fahrenheit, alert "Wear a coat." For temps between 51 and 70 degrees, alert "Bring a sweater." For temps above 70, alert "It should be warm."
+
+var temp = 49;
+
+switch (true) {
+ case temp <= 50:
+ 'Wear a coat.';
+ break;
+ case temp > 50 && temp <= 70:
+ 'Bring a sweater.';
+ break;
+ case temp > 70:
+ 'It should be warm.';
+}
+
+// Create a switch statement to determine who wins in a game of rocks, paper, scissors.
+
+var player1 = 'scissors';
+var player2 = 'paper';
+
+switch (true) {
+ case player1 === 'paper' && player2 === 'rock':
+ case player1 === 'scissors' && player2 === 'paper':
+ case player1 === 'rock' && player2 === 'scissors':
+ 'Player 1 wins';
+ break;
+ case player1 === 'rock' && player2 === 'paper':
+ case player1 === 'paper' && player2 === 'scissors':
+ case player1 === 'scissors' && player2 === 'rock':
+ 'Player 2 wins';
+ break;
+ default:
+ 'Tie. Go again.';
+}
+
+
+/* Exercice for you to try to build the switch compeltely*/
+
+// Create a switch statement to convert abriged bytes values (Kb,Mb,Gb,Tb ) to their complete values in bytes, example : 1K = 1 * 1024, 1M = 1 * 1024 * 1024, 1G = 1 * 1024 * 1024 * 1024 , etc...
+// how to convert bytes : 1Kb = 1024 b, 1Mb = 1024 Kb, 1Gb = 1024 Mb, 1 Tb = 1024 Gb.
+// Hint: the switch will test the value of 'unit', and will have to multiply the var "quantity" by the right number before putting it in the var "result". don't forget to add a default response!
+
+```
\ No newline at end of file
diff --git a/docs/JavaScript_Basics/switchcase.md b/docs/JavaScript_Basics/switchcase.md
deleted file mode 100644
index d7b9f0c..0000000
--- a/docs/JavaScript_Basics/switchcase.md
+++ /dev/null
@@ -1,55 +0,0 @@
-# Switch Case
-
-### 1. The switch statement is used to perform different actions based on different conditions.
-The JavaScript Switch Statement use the switch statement to select one of many code blocks to be executed.
-
-### Syntax
-```js
-switch(expression) {
- case x:
- // code block
- break;
- case y:
- // code block
- break;
- default:
- // code block
-}
-```
-This is how it works:
-
-The switch expression is evaluated once.
-The value of the expression is compared with the values of each case.
-If there is a match, the associated block of code is executed.
-
-
-
-The getDay() method returns the weekday as a number between 0 and 6.
-```js
-(Sunday=0, Monday=1, Tuesday=2 ..)
-```
-This example uses the weekday number to calculate the weekday name:
-```js
-switch (new Date().getDay()) {
- case 0:
- day = "Sunday";
- break;
- case 1:
- day = "Monday";
- break;
- case 2:
- day = "Tuesday";
- break;
- case 3:
- day = "Wednesday";
- break;
- case 4:
- day = "Thursday";
- break;
- case 5:
- day = "Friday";
- break;
- case 6:
- day = "Saturday";
-}
-```
diff --git a/docs/JavaScript_Basics/this.md b/docs/JavaScript_Basics/this.md
index 56cda30..0aa98dd 100644
--- a/docs/JavaScript_Basics/this.md
+++ b/docs/JavaScript_Basics/this.md
@@ -1 +1,32 @@
-# This
+```js
+console.log(this); // This gives empty object
+// Output {}
+
+const aa = 1;
+console.log(global.aa); // Global scope is accessible to every where
+// Output undefined
+
+// Nodejs has Global object which is accessible in all file it has some predefined functions
+
+// Blocked Objects
+{
+ var a = 1;
+ const b = 2;
+ console.log(b);
+}
+console.log(a);// Output 1 as variable a is declared using var
+console.log(a);
+
+// console.log(b) // Output ReferenceError: b is not defined as b is defined using let it is going to be declared only in that block
+
+const help = () => {
+ const a = 4;
+ const b = 2; // variables defined by let and const are accessible to there scope only
+ console.log(a); // This will not get printed unless and until function is called
+};
+
+console.log(a);// Output 1
+
+// console.log(b); // Output ReferenceError: b is not defined as b is in function scope only
+
+help(); // Output 4```
\ No newline at end of file
diff --git a/JavaScript_Advance/timerFunctions.js b/docs/JavaScript_Basics/timer_functions.md
similarity index 77%
rename from JavaScript_Advance/timerFunctions.js
rename to docs/JavaScript_Basics/timer_functions.md
index 8226cad..5642660 100644
--- a/JavaScript_Advance/timerFunctions.js
+++ b/docs/JavaScript_Basics/timer_functions.md
@@ -1,9 +1,10 @@
+```js
// setTimeout setInterval in both functions the time is specified in millisecond
-// setTimeout This runs a code after given time starting form calling this method in program.
+// setTimeout This runs a code after given time starting from calling this method in program.
setTimeout(() => {
- console.log("SetTimeout is Called");
+ console.log("SetTimeout is Called");
}, 5000); // This will print SetTimeout is Called after 5sec after calling it
// For stopping this we can use ClearTimeout
@@ -11,12 +12,12 @@ setTimeout(() => {
// setInterval This runs a code after specific interval of time till we stop the timer.
starting = setInterval(() => {
- console.log("SetInterval is Called");
+ console.log("SetInterval is Called");
}, 3000); // This will print setInterval is Called after every 3sec
// We can stop the interval and timeout using clearTimeout and clearInterval
setTimeout(() => {
- clearInterval(starting);
+ clearInterval(starting);
}, 7000);
// Output of this whole program is
@@ -24,4 +25,4 @@ setTimeout(() => {
SetInterval is Called
SetTimeout is Called
SetInterval is Called
-*/
\ No newline at end of file
+*/```
\ No newline at end of file
diff --git a/JavaScript_Basics/type-conversions.js b/docs/JavaScript_Basics/type_conversions.md
similarity index 59%
rename from JavaScript_Basics/type-conversions.js
rename to docs/JavaScript_Basics/type_conversions.md
index 0dfb160..1048d5b 100644
--- a/JavaScript_Basics/type-conversions.js
+++ b/docs/JavaScript_Basics/type_conversions.md
@@ -1,3 +1,4 @@
+```js
// Example 1
let boo = false;
alert(typeof boo); // boolean
@@ -5,10 +6,10 @@ alert(typeof boo); // boolean
boo = String(boo); // now value is a string "true"
alert(typeof boo); // string
-//Example 2
-let str = "123";
+// Example 2
+const str = "123";
alert(typeof str); // string
-let num = Number(str); // becomes a number 123
+const num = Number(str); // becomes a number 123
-alert(typeof num); // number
+alert(typeof num); // number```
\ No newline at end of file
diff --git a/docs/JavaScript_Basics/variables.md b/docs/JavaScript_Basics/variables.md
index d9d249b..5009a3a 100644
--- a/docs/JavaScript_Basics/variables.md
+++ b/docs/JavaScript_Basics/variables.md
@@ -1 +1,22 @@
-# Variables
+```js
+/* eslint no-var: "off" */
+
+// There is only 3 types of variables in javascript
+
+var day26 = 26;// This is Deprecated as this creates many problems in future.
+//Variables created with var can be rewrite but the most important problem is about the scope.
+
+let userNickname = "Swapnil"; // New type introduced in ES6. Value of let can change any time.
+userNickname = "Swap76";
+console.log(userNickname) // Output {"Swap76"}
+
+const PI = 3.14;// New type introduced in ES6. Value of pi now cannot be changed as this is defined as const.
+PI = 2; // Output {Error: PI is read only}
+console.log(PI) // Output {3.14}
+
+
+//Tips: *use significatives variables names, example:
+// let a = "User's name" for let userNickName = "User's name"
+//*CammelCase for a better understaning, JS has case sensitive.
+//*Variables names must begin with a letter.
+//*write constants with Upper case.```
\ No newline at end of file
diff --git a/docs/JavaScript_Basics_Info/arrays.md b/docs/JavaScript_Basics_Info/arrays.md
new file mode 100644
index 0000000..66755de
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/arrays.md
@@ -0,0 +1,41 @@
+# Arrays
+
+## push
+The push() method adds new items to the end of an array, and returns the new length.
+
+## pop
+The pop() method removes the last element from an array.
+
+## shift
+shift() is equivalent to popping, working on the first element instead of the last.
+
+## length
+length property provides an easy way to append a new element to an array.
+
+## delete
+delete will delete the object property, but will not reindex the array or update its length. This makes it appears as if it is undefined.
+Using delete may leave undefined holes in the array. Use pop() or shift() instead.
+
+## splice
+The splice() method removes items from array and/or adds items to array and returns the removed items.
+
+## concat
+The concat() method returns a new array of two or more arrays joined together.
+
+## slice
+The slice() method returns a new array from a selected range.
+
+## unshift
+The unshift() method Add elements at the front of an Array.
+
+## every
+The every() function is used when you need to validate each element of a given array.
+
+## filter
+The filter() method is used to filter out values from an array
+
+## map
+The map() method is used to apply a function to every value of an array
+
+## reduce
+The reduce() method is used to reduce arrays via an function
\ No newline at end of file
diff --git a/docs/JavaScript_Basics_Info/boolean.md b/docs/JavaScript_Basics_Info/boolean.md
new file mode 100644
index 0000000..4c2077e
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/boolean.md
@@ -0,0 +1,36 @@
+# What are boolean data types?
+
+JavaScript **Boolean** is a data type which can store any one of two values, **true** or **false**.
+E.g. -
+
+```
+// Javascript has a specific constructor for creating Boolean type objects
+const testValue = new Boolean(true);
+console.log(testValue); // it prints **Boolean {true}** since testValue is an Object of type Boolean
+```
+
+We can directly assign boolean value to any variable, like below:
+
+```
+const isTrue = true;
+const isfalse = false;
+```
+
+In JavaScript, a **truthy** value is a value that translates to true when evaluated in a Boolean context.
+All values are truthy unless they are defined as **falsy**.
+
+Javascript treats an empty string (**""**), **0**, **undefined** **null** and **NaN** as **falsy**.
+
+Not operator or **!** is the operator which is used to **negate** the boolean aspect of a value.
+
+For example:
+```
+const val = 12;
+// using ! operator
+console.log( !false ); // prints true
+console.log( !12 ); // prints false, since 12 is truthy value and negation of a truthy value is falsy
+// using !! operator - this returns just the boolean context of any value
+console.log( !!true ); // prints true
+console.log( !!false ); // prints false
+console.log( !!12 ); // prints true, since 12 is truthy value and negation of a truthy value is falsy, and again negation of that false value is truthy
+```
diff --git a/docs/JavaScript_Basics_Info/call.md b/docs/JavaScript_Basics_Info/call.md
new file mode 100644
index 0000000..396b8df
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/call.md
@@ -0,0 +1,11 @@
+# Function Call
+It is a predefined javascript method, which is used to write methods for different objects. It calls the method, taking the owner object as argument. The keyword this refers to the “owner” of the function or the object it belongs to.
+
+Syntax:
+
+```javascript
+call()
+```
+Return Value: It calls and returns a method with the owner object being the argument.
+
+Source [GeeksforGeeks](https://www.geeksforgeeks.org/javascript-function-call/)
\ No newline at end of file
diff --git a/docs/JavaScript_Basics/comparisonOperators.md b/docs/JavaScript_Basics_Info/comparison_operators.md
similarity index 51%
rename from docs/JavaScript_Basics/comparisonOperators.md
rename to docs/JavaScript_Basics_Info/comparison_operators.md
index 2860ed6..f8d6eac 100644
--- a/docs/JavaScript_Basics/comparisonOperators.md
+++ b/docs/JavaScript_Basics_Info/comparison_operators.md
@@ -1,6 +1,7 @@
# Comparison Operators
Javascript has 2 comparison operators, equality `==` and identity/strict equality `===`.
-### Equality
+
+## Equality
Equality operator (`==` and `!=`) converts operands if they are not the same type.
Example:
@@ -14,7 +15,7 @@ Example:
'' == 0 //return true
null == undefined //return true
```
-### Identity
+## Identity
Identity operator (`===` and `!==`) behave like equality operator except no type conversion done.
Example:
@@ -27,3 +28,11 @@ Example:
0 === false //return false
'' === 0 //return false
```
+
+## The importance of type conversion
+As we just discussed `2 === '2'` will return false but `2 == '2'` will return true.
+Why does this matter?
+If you're doing math and get `2+2` will evaluate to 4 `'2'+'2'` will evaluate to '22' because it's putting the 2 numbers together. But what happens if you have `2+'2'`?
+In this case you get '22' as well because Javascript is doing type conversion on the number 2, converting it from a number to a string.
+Why doesn't it convert the string to a number? This happens because the value of the string isn't being evaluated just the type.
+So `2+'a'` evaluates to '2a' because it's changing the number 2 to the string '2'.
diff --git a/docs/JavaScript_Basics_Info/condition_statments.md b/docs/JavaScript_Basics_Info/condition_statments.md
new file mode 100644
index 0000000..2f9f3f8
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/condition_statments.md
@@ -0,0 +1,74 @@
+# Condition Statements
+Conditional statements run specific blocks of code based on certain parameters that you set. Like other code it reads top to bottom so the order that you put your conditions in matter.
+
+Example of an if/else if/else:
+```js
+if(this statement is true){
+ do this
+} else if (this statement is true){
+ do this
+} else{
+ do this
+}
+```
+`If` always comes first and have a set of parenthesis with a statement in them that you are checking to see if it's true. If it is, the code in the curly brackets is run, otherwise it would move on to the `else if`, and see if that statement is true. If `else if` is true then it runs that block of code, if not then it would run the code in the `else` statement. Once a statement is deemed true and the code is run it doesn't continue to read through the code even if there is a more accurate statement lower down. A good example of where this matters would be the common coding challenge fizzbuzz. The idea of fizzbuzz is that you want to log all the numbers from 1-100 however if it's divisible by 3 print "fizz", 5 print "buzz", and if it's divisible by both 3 and 5 print "fizzbuzz".
+If we write our if's the way the problem is stated we would would write:
+```
+if(num % 3 == 0){
+ console.log("fizz")
+} else if(num % 5 == 0){
+ console.log("buzz")
+} else if(num % 3 == 0 && num % 5 == 0){
+ console.log("fizzbuzz")
+} else {
+ console.log(num)
+}
+```
+In this case every time we'd hit a number that should print fizzbuzz we'd get fizz because that is a truthful statement and it's not looking for a more correct answer.
+To account for that we'd want to adjust our statement order to:
+```js
+if(num % 3 == 0 && num % 5 == 0){
+ console.log("fizzbuzz")
+} else if(num % 5 == 0){
+ console.log("buzz")
+} else if(num % 3 == 0){
+ console.log("fizz")
+} else {
+ console.log(num)
+}
+```
+
+## What if we don't write else if but just another if?
+Sometimes you see code that has a number of `if`'s in a row but no `else if`'s or `else`'s in this case it's checking each condition in that case each `if`
+
+This code will only print "it's a number":
+```js
+var number = 2
+if(typeof number === "number"){
+console.log("it's a number")
+} else if(number % 2 === 0){
+console.log("it's even")
+}
+```
+However this code will print both "it's a number" and "it's even"
+```js
+var number = 2
+if(typeof number === "number"){
+console.log("it's a number")
+}
+if(number % 2 === 0){
+console.log("it's even")
+}
+```
+
+## What if we only have an if?
+If there is only one `if` then it only does that code `if` the condition is true and nothing if it's false.
+
+For example:
+```js
+if(number % 2 === 0){
+console.log("it's even")
+}
+console.log(number)
+```
+In this case if `number` is even it will print it's even and it will always print the number.
diff --git a/docs/JavaScript_Basics_Info/continue_break.md b/docs/JavaScript_Basics_Info/continue_break.md
new file mode 100644
index 0000000..b1973e6
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/continue_break.md
@@ -0,0 +1,92 @@
+# Continue & Break
+
+## Where to use them
+
+[`continue`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/continue) and [`break`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/break) are two javascript [keywords](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords) that are used in loops (`while` and `for`). `break` can also be used in the [`switch`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/switch) statement. Both can be used with [labels](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/label).
+
+## Break
+
+Break is used to terminate the current loop, switch or label statement and go to the next statement following the terminated one.
+
+```js
+const helloWorld = 'Hello, world!'.split('');
+while (helloWorld.length > 0) {
+ if (helloWorld[0] == ',')
+ break;
+ console.log(helloWorld.shift());
+}
+```
+
+Will output: *'Hello'* with a carriage return between each letters.
+
+```js
+const color = 'red';
+switch (color) {
+ case 'red':
+ case 'yellow':
+ case 'blue':
+ console.log(color + ' is a primary color');
+ break;
+ case 'green':
+ case 'purple':
+ case 'orange':
+ console.log(color + ' is a secondary color');
+ break;
+ default:
+ console.log("Sorry, I don't know this color...");
+ break;
+}
+```
+
+Will output: *'red is a primary color'*.
+
+In a switch statement, a case statement allow to filter the input variable, and execute the code that is right after it. The break statement is used here to signal the end of the case, or group of cases.
+
+```js
+const array = [1, 2, 3, 4, 5];
+const array2 = [];
+firstFor: for (let i = 0; i < array.length; i++) {
+ for (let j = 0; j < array.length; j++) {
+ if (array[i] * array[j] > 5)
+ break firstFor;
+ array2.push(array[i] * array[j]);
+ }
+}
+console.log(array2);
+```
+
+Will output: *'[1, 2, 3, 4, 2, 4]'* with 'break firstFor;' and *'[1, 2, 3, 4, 2, 4, 3, 4]'* with a simple break statement.
+
+Indeed in th first case, when `array[i] * array[j] > 5`, the code execution continue right at the last line with the `console.log` call, in the second case it will continue after the second loop, so inside of the first one.
+
+## Continue
+
+Continue is used to terminate the current iteration in a loop, labeled loop, and continues execution of the loop with the next iteration.
+
+```js
+let result = '';
+for (let i = 0; i < 5; i++) {
+ if (i === 3)
+ continue;
+ result = result + i;
+}
+console.log(result);
+```
+
+Will output: *0124*, the digit `3` is ommited because of the continue statement.
+
+```js
+let result = [];
+firstFor: for (let i = 0; i < 5; i++) {
+ let numbers = '';
+ for (let j = 0; j < 2; j++) {
+ if (i === 3)
+ continue firstFor;
+ numbers = numbers + ' ' + (i + j);
+ }
+ result.push(numbers.trim());
+}
+console.log(result);
+```
+
+Will output: *'["0 1", "1 2", "2 3", "4 5"]'* with 'continue firstFor' and *'["0 1", "1 2", "2 3", "", "4 5"]'* with a simple continue statement.
diff --git a/docs/JavaScript_Basics_Info/date.md b/docs/JavaScript_Basics_Info/date.md
new file mode 100644
index 0000000..e314d4b
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/date.md
@@ -0,0 +1,83 @@
+# Date
+The Date object in JavaScript is used to work with dates and times.
+
+## Current time
+The date object initialization
+```javascript
+const date = new Date();
+```
+
+Current time and date in your local time zone
+```javascript
+console.log(date);
+```
+
+## Create a date object
+Date from year, month, date, hour, minute, second, millisecond as arguments
+```javascript
+const dateWithYear = new Date(2019, 10, 10, 22, 10, 0); //
+console.log(dateWithYear); //Output : Sun Nov 10 2019 22:10:00 GMT+0530
+```
+
+Date from a date-string
+```javascript
+const dateString = new Date("October 10, 2019 11:13:00");
+console.log(dateString); // Output : creates a new date object from date string
+```
+
+Date from a milliseconds-timestamp
+Here 100000000000 ms from 1st January 1970
+```javascript
+const dateMilli = new Date(100000000000); //
+console.log(dateMilli); // approximately October 31 1966
+```
+Date from a date-string
+Here ISO 8601 syntax (YYYY-MM-DD)
+```javascript
+const isoDate = new Date("2019-10-10");
+console.log(isoDate); // 2019-10-10
+```
+
+Date from a "MM/DD/YYYY" date format
+```javascript
+const shortDate = new Date("03/25/2015");
+console.log(shortDate); // Thu Jan 01 1970 05:30:00 GMT+0530
+```
+
+Date from a "MM DD YYYY" date format
+```javascript
+const longDate = new Date("Oct 10 2019");
+console.log(longDate); // Sun Oct 10 2010 00:00:00 GMT+0530
+```
+
+## Get methods
+The year of a date as a four digit number
+```javascript
+date.getFullYear(); // 2019
+```
+
+Month of a date as a number (0-11)
+```javascript
+date.getMonth(); // 9
+```
+The number of milliseconds since midnight Jan 1 1970, and a specified date
+```javascript
+date.getTime(); // 1570726799950
+```
+
+## Maniupulate a date
+
+Set the date to November 3, 2020
+```javascript
+date.setFullYear(2020, 10, 3);
+```
+
+Set the month to 4 (May)
+```javascript
+date.setMonth(4);
+```
+
+Set the date with a timestamp
+```javascript
+date.setTime(1332403882588); // Thu Mar 22 2012 13:41:22 GMT+0530
+```
diff --git a/docs/JavaScript_Basics/domManipulation.md b/docs/JavaScript_Basics_Info/dom_manipulation.md
similarity index 95%
rename from docs/JavaScript_Basics/domManipulation.md
rename to docs/JavaScript_Basics_Info/dom_manipulation.md
index 4975fa4..0296d67 100644
--- a/docs/JavaScript_Basics/domManipulation.md
+++ b/docs/JavaScript_Basics_Info/dom_manipulation.md
@@ -18,9 +18,7 @@ Example scenarios, that can be solved using DOM manipulation:
- Create a new list item when the user clicks on a button
- Remove a row from a table, when the user clicks on a button.
-## How to manipulate the DOM?
-
-### Finding elements in the DOM
+## Finding elements in the DOM
The first step of manipulation a node that is in the DOM, is to find it. For example, to find the first hyperlink (``) in the document, you can:
@@ -36,7 +34,7 @@ const allDivs= document.querySelector('div');
You can use more advanced selectors as well, please visit the MDN Selectors page to learn more: https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors
-### Creating new nodes
+## Creating new nodes
You can create new elements with `document.createElement`:
@@ -54,7 +52,7 @@ const body = document.querySelector('body');
body.appendChild(node);
```
-### Removing nodes from the DOM
+## Removing nodes from the DOM
Removing a node is pretty simple, just find the node, and cal; `remove()`:
diff --git a/docs/JavaScript_Basics_Info/filter.md b/docs/JavaScript_Basics_Info/filter.md
new file mode 100644
index 0000000..f713ff7
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/filter.md
@@ -0,0 +1,37 @@
+# Filter Function
+
+## JavaScript Array filter() Method
+
+The filter() method creates a new array with all elements that
+pass the test implemented by the provided function.
+```js
+ let words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];
+ const result = words.filter(word => word.length > 6);
+ console.log(result);
+```
+
+
+expected output: Array ["exuberant", "destruction", "present"]
+
+Another example
+
+Filtering out all small values
+
+The following example uses filter() to create a filtered array that has all elements with values less than 10 removed.
+```js
+ function isBigEnough(value) {
+ return value >= 10;
+ }
+
+ var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
+```
+filtered is [12, 130, 44]
+
+## Object Example
+
+Filters people with more than 32 year out
+```js
+const people = [{ name: 'John', age: 20 }, { name: 'Mary', age: 35 }, { name: 'Clark', age: 40 }];
+
+const youngPeople = people.filter( ({ age }) => age <= 32 )
+```
\ No newline at end of file
diff --git a/docs/JavaScript_Basics_Info/for_each.md b/docs/JavaScript_Basics_Info/for_each.md
new file mode 100644
index 0000000..7ce9cb1
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/for_each.md
@@ -0,0 +1,33 @@
+# Array forEach method
+
+
+forEach() method DOES NOT modify the array and unlike map() method, forEach() DOES NOT return a new array
+
+```javascript
+// assume we have an array of numbers and we need to get square of each number
+const numbers = [5, 4, 6, 12, 23, 1, 72],
+ squares = [];
+
+[5, 4, 6, 12, 23, 1, 72].forEach(n => {
+ squares.push(n * n);
+});
+
+console.log(squares);
+
+// expected output: Array [25, 16, 36, 144, 529, 1, 5184]
+```
+
+Another example using index of elements in the callback function
+
+```javascript
+// In this example, we create an Object from an Array
+const users = ["John", "Sally", "Brad", "Jack"],
+ usersObj = {};
+
+users.forEach((user, index) => {
+ usersObj[index] = user;
+});
+
+console.log(usersObj);
+// expected output : Object {0: "John", 1: "Sally", 2: "Brad", 3: "Jack"}
+```
diff --git a/docs/JavaScript_Basics_Info/functions.md b/docs/JavaScript_Basics_Info/functions.md
new file mode 100644
index 0000000..e9e9da6
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/functions.md
@@ -0,0 +1,80 @@
+# Functions
+Functions are used to structure and generalize the code. It will become more flexible and you will have a better overview.
+
+## What is a function?
+A Function is a type of varable which essentially contains code you can run.
+There are different ways to write code into a variable (declare a function).
+
+```javascript
+function foo () { // Puts codes inside if the curly brackets into the variable "foo".
+ console.log("Hello World")
+}
+```
+
+Shows that "foo" is a variable with the type function
+```javascript
+console.log(typeof foo) // "function"
+console.log(typeof 1) // "number"
+console.log(typeof "hello") // "string"
+```
+
+## How to call a function?
+The function is defined. Now we want to execute the code inside the Function
+
+
+The most common way to execute a function by appending the variable name with brackets
+```javascript
+foo() // "Hello World"
+```
+
+## Functions with output
+Printing text is acually the wrong format of getting informations out of variables.
+To get usable informations back we can use the return keyword.
+
+```javascript
+x = foo() // "Hello World" and x: undefined
+```
+Nothing is returned -> x is empty
+
+```javascript
+function foo () { // get a value from the inside of the function to te outside.
+ text = "Hello World"
+ return text
+}
+```
+Call the updated function
+```javascript
+x = foo() // x: "Hello World"
+```
+Text is returned, but nothing prited into the console.
+
+```javascript
+console.log(text) // undefined
+```
+You can see that variables from inside the function are not accessible anymore
+
+```javascript
+console.log(x) // "Hello World"
+```
+The string from the "text" variable was retuned an is now "x"
+
+## Functions with input
+Input for functions is called parameters.
+When you define the function you can also define what input variables the function can have.
+That is the purpose of the "()". "()" means no input both wen you define and call a function.
+
+Define with parameters
+```javascript
+function add(a, b) { // in the "()" you define what variable names the inputs get. Multiple parameters are septerated by a ","
+ c = a + b // add the value of the two variables
+ return c
+}
+```
+
+## Call with input
+Depending on the sequence, the values separated by a "," are assigned to the parameter variables.
+
+`a = 5` `b = 8;`
+```javascript
+result = add(5, 8) // result: 13
+```
diff --git a/docs/JavaScript_Basics_Info/higher_order_functions.md b/docs/JavaScript_Basics_Info/higher_order_functions.md
new file mode 100644
index 0000000..3c42543
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/higher_order_functions.md
@@ -0,0 +1,125 @@
+# Higher Order Functions
+
+A **Higher Order function** or **HOF** is a function that receives a function as an argument or returns the function as output.
+
+There are some built-in HOF for Arrays in Javascript, such as
+
+- _Array.prototype.map_
+- _Array.prototype.filter_
+- _Array.prototype.reduce_.
+
+Let's understand each of these through examples.
+
+We will use the below array `list` as the base array to operate over.
+
+```js
+const list = [1, 2, 3, 4, 5];
+```
+
+## 1. map
+
+- The **map** function iterates over an input array and returns a new array.
+- It does not change the original array, but creates a new array.
+- The map receives a callback function as its argument. This callback function receives 3 arguments
+ - 1st arg is the **elememt** of the array, like 1, 2, 3, 4, 5
+ - 2nd arg is the **index** of the item in the list (index for first element is 0, and so on)
+ - 3rd arg is the original array [1,2,3,4,5] on which map is being called
+
+```js
+const newList = list.map(function (item, index, list) {
+ return item * 2;
+});
+
+console.log(list); // prints [1, 2, 3, 4, 5]
+console.log(newList); // prints [2, 4, 6, 8, 10]
+```
+
+## 2. filter
+
+- the **filter** function iterates over an input array and returns a new array based on a condition
+- the filter receive a callnack function as its argument. This callback functions receives 3 arguments:
+ - 1st arg is the **element** in the list like "1" or "2" in the list example
+ - 2nd arg is the **index** of the item in the list (index for first element is 0, and so on)
+ - 3rd arg is the original array [1,2,3,4,5] on which filter is being called
+
+```js
+// this filtered list will contain only even numbers
+
+const newListFiltered = list.filter(function (item, index, list) {
+ // filter will return the value if it satisfies the below condition
+ return item % 2 === 0;
+});
+
+console.log(list); // prints [1, 2, 3, 4, 5]
+console.log(newList); // prints [2, 4]
+```
+
+## 3. reduce
+
+- the **reduce** function iterates over an input array and returns a single output value
+- it receives two arguments:
+ - a callback function, also called as **reducer** function
+ - an **initialValue** (this is optional parameter)
+- the reducer function accepts four parameters:
+ - 1st arg is **accumulator** which contains the accumulated value which will be returned when the array is reduced.
+ If initalvalue is provided, accumulator will be equal to initialvalue, else it will be equal to the first element in the array
+ - 2nd arg is **currentValue** which points to the current value of the array which is being iterated over.
+ If initalvalue is provided, currentValue will be equal to the first element in the array, else it will be equal to the second element in the array
+ - 3rd arg is **index** which contains the index of the currentValue in the input array
+ - 4th arg is the **sourceArray** which is the input array on which reduce is called
+
+```js
+// Example 1
+// this will return sum of all items in list. here, there is no initialvalue provided
+
+const sumOfListItems = list.reduce(function (accumulator, currentValue) {
+ return accumulator + currentValue;
+});
+
+console.log(list); // prints [1, 2, 3, 4, 5]
+console.log(sumOfListItems); // prints 15
+```
+
+```js
+// Example 2
+// this will return sum of all items in list. here, the initialvalue is provided as 20
+
+const newSumOfListItems = list.reduce(function (accumulator, currentValue) {
+ return accumulator + currentValue;
+}, 20);
+
+console.log(list); // prints [1, 2, 3, 4, 5]
+console.log(newSumOfListItems); // prints 35 (the sum of list items is 15, and the initial value was 20, so, 20 + 15 = 35)
+```
+
+## 4. sort
+
+- If no input function is provided, values are sorted as strings by default, which means even if the elements are numbers, it converts them to strings and compare them with alphabetic order.
+- To sort numbers, a compare function is needed. The compare function takes two arguments (a, b).
+- Ascending oder: If the return (a-b) is negative, a comes before b. If the return (a-b) is positive, a comes after b.
+- Descending oder: If the return (b-a) is negative, a comes before b. If the return (b-a) is positive, a comes after b.
+
+```js
+// Example 1
+const fruits = ['apple', 'orange', 'grape'];
+console.log(fruits.sort()); // prints ["apple","grape","orange"]
+```
+
+```js
+// Example 2
+const numList = [34, 67, 100, 20];
+console.log(numList.sort()); // prints [100,20,34,67]
+```
+
+```js
+// Example 3
+const numList = [34, 67, 100, 20];
+console.log(numList.sort()); // prints [100,20,34,67]
+```
+
+```js
+// Example 4
+const numList = [34, 67, 100, 20];
+console.log(numList.sort((a, b) => a - b)); // prints [20,34,67,100]
+console.log(numList.sort((a, b) => b - a)); // prints [100,67,34,20]
+```
diff --git a/docs/JavaScript_Basics_Info/looping_an_object.md b/docs/JavaScript_Basics_Info/looping_an_object.md
new file mode 100644
index 0000000..8bae72a
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/looping_an_object.md
@@ -0,0 +1,48 @@
+# Looping an Object
+A for...in loop iterates over properties of an object.
+
+```javascript
+for (const key in studentObject) {
+ if (key === 105) {
+ console.log("The Student's name is ", studentObject[key]);
+ }
+}
+```
+In this code we are iterating over all the properties of the studentObject and if the property is __105__ we are logging to the console the value of that property.
+
+The issue with type of looping is that we need to check if the property belongs to the object. We can do this with **hasOwnProperty**
+```javascript
+for (const key in studentObject) {
+ if(studentObject.hasOwnProperty(key)){
+ if (key === 105) {
+ console.log("The Student's name is ", studentObject[key]);
+ }
+ }
+}
+```
+
+We can also use other methods to convert an object into an array, loop through the array and check for a specific key.
+- Object.keys
+- Object.entries
+
+## Object.keys
+We can use **Object.Keys** to convert into an array of property values and we can loop through the array as follows,
+```javascript
+const keys = Object.keys(studentObject)
+for(const key of keys){
+ if (key === 105) {
+ console.log("The Student's name is ", studentObject[key]);
+ }
+}
+```
+
+## Object.entries
+We can use **Object.Keys** to convert into an array of property values and we can loop through the array as follows,
+```javascript
+const entries = Object.entries(studentObject)
+for(const [key, value] of keys){
+ if (key === 105) {
+ console.log("The Student's name is ", value);
+ }
+}
+```
diff --git a/docs/JavaScript_Basics_Info/loops.md b/docs/JavaScript_Basics_Info/loops.md
new file mode 100644
index 0000000..d02a0ec
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/loops.md
@@ -0,0 +1,69 @@
+# Loops
+There are different four main types of loops in Javascript. All of them are a way move over a set of data and interact with it but they have different applications and syntax.
+
+## For Loops
+For loops are the most common types of loops in JS.
+
+```js
+var food = ["rice", "beans", "tortilla"]
+for (var i = 0; i < food.length; i++){
+ console.log("Burritos have " + food[i])
+}
+```
+
+This code will output:
+`"Burritos have rice"`
+`"Burritos have beans"`
+`"Burritos have tortilla"`
+
+*But how is this happening?*
+2 important things to remember:
+ - Arrays are 0 indexed
+ - the `.length` method counts the number of items in the array
+
+The syntax of the for loop says that we have a variable `i` that is equal to 0, as long as `i` is less than the length of food, and `i++` means every time we get through the code increase the value of `i` by one. So the first time through `food[i]` is equal to `food[0]` which is "rice", then `i` increases by one making it `food[1]` which is "beans". The third time through `i` = 2 which is `food[2]` which is "tortilla". When `i` increases this time it's equal to 3 which is not less than 3 so we have completed the for loop and the code would move on to whatever was below the for loop.
+*An important thing to remember to make your i less than your length or you run the risk of causing an infinite loop.*
+
+## While Loops
+While loops are less common than for loops but also very powerful. While loops say while this thing is true do this
+
+```js
+var num = 0
+while(num < 5){
+ console.log(num)
+ num++
+}
+```
+
+This code is running while num is less than 5.
+If we had this code instead:
+
+```js
+var num = 5
+while(num < 5){
+ console.log(num)
+ num++
+}
+```
+The while loop would never run because that condition is never true
+
+*An important thing to remember to make sure your condition has a way to be false or you will get an infinite loop.*
+
+## Do While Loops
+Do While loops are similar to while loops but they will alway run once.
+
+```js
+var num = 5
+do {
+ console.log(num)
+ num++
+} while(num < 5)
+```
+
+Even though this wouldn't run in a while loop a do while loops always run at least once so you would see `num` in the console
+
+*An important thing to remember to make sure your condition has a way to be false or you will get an infinite loop.*
+
+
+## For In Loops
+Our article [looping an object](./looping_an_object.md) covers for in loops. While these are primarily used with objects they can also be used with arrays. the down side of this is that you cannot access the index like you can with a regular for loop. If you need the index I'd suggest a regular for loop.
diff --git a/docs/JavaScript_Basics_Info/map.md b/docs/JavaScript_Basics_Info/map.md
new file mode 100644
index 0000000..9e55f1a
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/map.md
@@ -0,0 +1,40 @@
+# Map Function
+
+We can use `map()` when we want to manipulate each data inside an array without changing the values of the original array.
+
+The `map()` method creates a new array with the results of calling the provided function for each element in the array.
+
+**Note:** `map()` does not execute the function if the array has no values.
+
+**Note:** this method does not change the original array.
+
+## Example
+
+The following code takes an array of numbers and creates a new array containing the square roots of the numbers in the first array.
+
+Using a callback function
+```js
+var numbers = [1, 4, 9];
+var roots = numbers.map(function(num) {
+ return Math.sqrt(num)
+});
+
+// roots is now [1, 2, 3]
+// numbers is still [1, 4, 9]
+```
+
+Using an arrow function
+```js
+var numbers = [1, 4, 9];
+var roots = numbers.map(num => Math.sqrt(num));
+
+// roots is now [1, 2, 3]
+// numbers is still [1, 4, 9]
+```
+
+Using map method to extract keys from objects
+```js
+const sampleArray = [{ user: 'John', id: 1, age: 20 },{ user: 'Mike', id: 5, age: 30 },{ user: 'Paul', id: 2, age: 40 }]
+console.log( sampleArray.map( ({ user, age}) => ({ user, age}) ) )
+// prints the sample array but with only the user and age key
+```
\ No newline at end of file
diff --git a/docs/JavaScript_Basics_Info/math.md b/docs/JavaScript_Basics_Info/math.md
new file mode 100644
index 0000000..5a49470
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/math.md
@@ -0,0 +1,86 @@
+# Math Functions
+
+* Math is a global, static Javascript object
+* They are used on the `Number` type
+* I will discuss the following Javascript Math operators, `Math.round()`, `Math.power()`, `Math.sqrt()`, `Math.abs()`.
+
+## Math.round()
+* This function rounds a number to the nearest round number
+* or as described by the documentation:
+> _Returns the nearest single precision float representation of a number._
+
+## Math.pow()
+* This calculates the power of a number for you, you remeber that from math class right? The small number floating above the number to be powered.
+* or as described by the documentation:
+> _Returns base to the exponent power,that is:_
+> baseexponent
+
+## Math.sqrt()
+* This function calculates the square root of a number
+* or as described by the documentation:
+> _Returns the positive square root of a number._
+
+## Math.abs()
+* Returns the absolute value of a number.
+
+## Math.ceil()
+
+The JavaScript math.ceil(n) method returns the largest integer for the given number. For example 4 for 3.7, 6 for 5.9 etc.
+
+```javascript
+Math.ceil(4.4); // returns 5
+```
+
+## Math.floor()
+
+The JavaScript math.floor(n) method returns the lowest integer for the given number. For example 3 for 3.7, 5 for 5.9 etc.
+
+```javascript
+Math.floor(4.7); // returns 4
+```
+## Math.sin()
+
+Math.sin(x) returns the sine (a value between -1 and 1) of the angle x (given in radians).
+
+If you want to use degrees instead of radians, you have to convert degrees to radians:
+
+Angle in radians = Angle in degrees x PI / 180.
+
+```javascript
+Math.sin(30 * Math.PI / 180); // returns 0.5 (the sine of 30 degrees)
+```
+
+## Math.cos()
+
+Math.cos(x) returns the cosine (a value between -1 and 1) of the angle x (given in radians).
+
+If you want to use degrees instead of radians, you have to convert degrees to radians:
+
+Angle in radians = Angle in degrees x PI / 180.
+
+```javascript
+Math.cos(60 * Math.PI / 180); // returns 0.5 (the cos of 60 degrees)
+```
+## Math.min()
+
+Math.min() can be used to find the lowest value in a list of arguments:
+
+```javascript
+Math.min(100, 550, 80, 200, -8, -900); // returns -900
+```
+
+## Math.max()
+
+Math.max() can be used to find the highest value in a list of arguments:
+
+```javascript
+Math.max(100, 550, 80, 200, -8, -900); // returns 550
+```
+
+## Math.random()
+
+Math.random() returns a random number between 0 (inclusive), and 1 (exclusive):
+
+```javascript
+Math.random(); // returns a random number
+```
diff --git a/docs/JavaScript_Basics_Info/number_methods.md b/docs/JavaScript_Basics_Info/number_methods.md
new file mode 100644
index 0000000..293243b
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/number_methods.md
@@ -0,0 +1,61 @@
+# Number Methods
+
+## isFinite()
+Checks whether a value is a finite number.
+Finite is a number that isn't infinite and can be measured or given a value.
+
+It only takes a single parameter which is the value you'd like to check.
+It's return value will be a boolean (true or false)
+
+Numbers that pass as finite:
+- 0
+- whole numbers
+- negative numbers
+- decimals
+- equations
+
+## .isInteger()
+Checks whether the value passed is an integer.
+It's return value will be a boolean (true / false)
+
+## .isNaN()##
+Checks whether the value passed is NaN (Not a number) or if the value is a number
+
+true = NaN
+
+## .isSafeInteger()
+Checks whether the method passed is a safe integer. The returned value will provide a boolean.
+
+A safe integer is represented as an IEEE-754 double precision number. This is simply any number between -9007199254740991 and 9007199254740991.
+
+Note that the value isn't changed to a number if a string is passed in.
+
+## .toExponential()
+Converts a number to its exponential form. The returned value is a string that represents the Number object in exponential notation
+
+## .toFixed()
+Formats a number using the fixed-point notation. It allows you to format a number with a specific number of digits to the right of the decimal. Numbers will be rounded if necessary.
+
+Its return value is a string with the given number using fixed-point notation. If the number given is negative, the return value will be a number and won't be converted into a string.
+
+## .toLocaleString()
+Converts a number into a language-sensitive representation of said number.
+It can take in two optional parameters:
+- locales: A string with a language tag (bali, latn)
+- options: A set of options for the given locale (currency, style)
+
+The return value is a string.
+
+## .toPrecision()
+Converts a number to the specified precision.
+
+The returned value is in the form of a string. The value will be rounded and padded with 0's if there are not enough digits.
+
+## .toString()
+Converts a given number to a string with the specified base number (an integer between 2 and 36)
+
+The return value is given in the form of a string if no radix is given.
+
+## .valueOf()
+Returns the number value in primitive form of a Number object.
+This is rarely something done on your own, as JavaScript invokes this automatically.
diff --git a/docs/JavaScript_Basics_Info/objects.md b/docs/JavaScript_Basics_Info/objects.md
new file mode 100644
index 0000000..091d1d1
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/objects.md
@@ -0,0 +1,120 @@
+# Objects
+In JavaScript, almost "everything" is an object.
+
+- Booleans can be objects (if defined with the new keyword)
+
+- Numbers can be objects (if defined with the new keyword)
+
+- Strings can be objects (if defined with the new keyword)
+
+- Dates are always objects
+
+- Maths are always objects
+
+- Regular expressions are always objects
+
+- Arrays are always objects
+
+- Functions are always objects
+
+- Objects are always objects
+
+All JavaScript values, except primitives, are objects.
+
+Objects are variables too. But objects can contain many values.
+
+The values are written as key : value pairs (key and value separated by a colon).
+
+Example:
+```js
+var person = {
+ firstName:"John",
+ lastName:"Doe",
+ age:50,
+ eyeColor:"blue"
+ };
+```
+
+A function can be used as an object property:
+```javascript
+const objectWithFunction = {
+ name: "Swapnil", // We can omit the " " in keys but for string values it is necessary
+ rollno: 76, // We assign any type to keys
+ getfull: function () { // Don't use arrow function here as arrow functions don't have this property
+ console.log(`${this.name} ${this.rollno}`);
+ }
+};
+
+console.log(objectWithFunction);
+// Output { name: 'Swapnil', rollno: 76, getfull: [Function: getfull] }
+
+objectWithFunction.getfull(); // Output Swapnil 76
+```
+
+Object property values can be changed using dot notation:
+```javascript
+const a = {
+ name: "Swapnil", // We can omit the " " in keys but for string values it is necessary
+ rollno: 76 // We assign any type to keys
+};
+
+a.name = "Swapnil Satish Shinde"; // This way we can change a particular property of object
+
+console.log(a.name); // This way you can get the value of particular element
+// Output Swapnil Satish Shinde
+```
+
+New properties can be added to an object after its creation:
+```javascript
+const canAddValue = { // This is normal object having 2 keys name and rollno
+ name: "Swapnil",
+ rollno: 76
+};
+
+// We can add the keys we want any time into the object by directly assigning value to it
+canAddValue.branch = "Computer";
+
+console.log(canAddValue);
+// Output { name: 'Swapnil', rollno: 76, branch: 'Computer' }
+```
+
+Value of a property(key) can be accessed and can be changed using __Dot Notation__ or __Bracket Notation__.
+
+```javascript
+const student = {
+ name: "Franc",
+ age: 21
+};
+
+console.log(student.name); // dot notation
+console.log(student['name']); // bracket notation
+
+student['age'] = 22; // updates student age to 22
+console.log(student);
+
+```
+Property of an object can be removed using **delete** keyword. _Note: Dot Notation or Bracket Notation can also be used._
+
+```javascript
+const student = {
+ name: "Franc",
+ age: 21,
+ birthyear: 1998
+};
+console.log(student);
+delete student.age; // removes age property
+delete student['birthyear']; // removes birthyear property
+console.log(student); // prints with only name as property
+
+```
+
+Deconstruct keys into variables
+```js
+const person = {
+ age: 20,
+ name: 'John',
+ height: 1.67
+}
+
+const { age, name, height } = person
+```
\ No newline at end of file
diff --git a/docs/JavaScript_Basics/javascript-page-redirects.md b/docs/JavaScript_Basics_Info/page_redirects.md
similarity index 97%
rename from docs/JavaScript_Basics/javascript-page-redirects.md
rename to docs/JavaScript_Basics_Info/page_redirects.md
index d446faa..7341543 100644
--- a/docs/JavaScript_Basics/javascript-page-redirects.md
+++ b/docs/JavaScript_Basics_Info/page_redirects.md
@@ -1,14 +1,13 @@
# JavaScript Page Redirects
-
-### 1. Where are the page redirects used?
+## Where are the page redirects used?
JavaScript page redirects are an essential part of any web application and are there on every part of the applications. A few of the many are listed below:
- when an user fills in credentials and clicks the 'Login' button, the user should be `redirected` to the application's login page.
- When an user completes booking the tickets for the movie, on completing the payment the user has to be `redirected` to the confirmation page.
- Onclick of the results of a Google search would take the user to the respective website.
- The list goes on like that.
-### 2. How are the `Page Redirects` used?
+## How are the `Page Redirects` used?
The Web Api provides us with an interface called `window` that provides us with a lot of functions, variables, constructors that could be used for this purpose. A variable named `window` is exposed to the JavaScript code running in the browser window where the DOM Document is loaded.
`window.location` is a readonly property that returns a `Location` object. The Location object contains properties and methods that are useful for the navigation and page redirects in the webpage. Here are a few ways in which we could use the Location object to perform redirects.
@@ -38,7 +37,7 @@ iv. Location.replace( url ) method
window.location.replace('https://www.example.com');
```
-### 3. Auto-Refresh
+## Auto-Refresh
This is a special scenario which could be accomplished with a proper usage of a mix of location object and the `setInterval` method of the Window interface. Here is an implementation of it.
- Using setInterval function and window.location.reload()
@@ -85,5 +84,3 @@ To achieve the refresh without using JavaScript, the `meta` tag could be used in
```
-
-
diff --git a/docs/JavaScript_Basics_Info/reduce.md b/docs/JavaScript_Basics_Info/reduce.md
new file mode 100644
index 0000000..8c8cdce
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/reduce.md
@@ -0,0 +1,25 @@
+# Reduce Method
+
+The array reduce() method in JavaScript is used to reduce
+the array to a single value and executes a provided function
+for each value of the array (from left-to-right) and the return
+value of the function is stored in an accumulator.
+
+```js
+ var pokemon = ["Squirtle", "Charmander", "Bulbasaur"];
+
+ var pokeLength = pokemon.reduce(function(accumulator, current) {
+ return accumulator + current.length;
+ }, 0);
+```
+**Output**
+
+27
+
+# Example
+
+Sum all the numbers in an array
+```js
+const array = [1, 2, 3, 4, 5, 6]
+const sum = array.reduce( (acc, curr) => acc + curr, 0 )
+```
\ No newline at end of file
diff --git a/docs/JavaScript_Basics_Info/some.md b/docs/JavaScript_Basics_Info/some.md
new file mode 100644
index 0000000..f139b00
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/some.md
@@ -0,0 +1,49 @@
+# Some Method
+
+This method returns true if at least one element in the array passes the test in the provided function.
+
+**Note:** This method returns false if used on an empty array.
+
+The `some` method will iterate over the elements in the given array until it finds an element that, when provided as an argument to the callback function, returns a truthy value (a value that, when converted to Boolean, becomes `true`).
+When that happens, the method stops and returns false.
+If none of the elements in the given array pass the test, this method returns false.
+
+The callback function can take up to three arguments:
+The value of the current element, it's index (optional), and the array object being traversed (optional).
+
+## Example
+
+The following code tests two differents arrays of numbers to see if any of the numbers is bigger than 10.
+
+
+```js
+function isBiggerThan10(element) {
+ return element > 10;
+}
+
+[2, 5, 8, 1, 4].some(isBiggerThan10); // returns false
+[12, 5, 8, 1, 4].some(isBiggerThan10); // returns true
+```
+The above can also be written like this:
+
+```js
+[2, 5, 8, 1, 4].some(function(element) {
+ return element > 10;
+}); // returns false
+
+[12, 5, 8, 1, 4].some(function(element) {
+ return element > 10;
+}); // returns true
+```
+
+Or with an arrow function:
+
+```js
+[2, 5, 8, 1, 4].some((element) => {
+ return element > 10;
+}); // returns false
+
+[12, 5, 8, 1, 4].some((element) => {
+ return element > 10;
+}); // returns true
+```
diff --git a/docs/JavaScript_Basics_Info/splice_slice.md b/docs/JavaScript_Basics_Info/splice_slice.md
new file mode 100644
index 0000000..1fbf003
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/splice_slice.md
@@ -0,0 +1,62 @@
+# Splice and Slice
+
+## Splice
+
+ Splice is used to add and delete new elements at a specific index in an array.
+
+#### Example 1: Adding an element at specific index
+
+```javascript
+let languages = ["C++", "Java", "Javascript", "R"];
+languages.splice(2, 0, "Python", "Pearl");
+ ```
+This will add Python and Perl starting at index 2.
+As of result we get an output of `["C++", "Java", "Python", "Pearl", "Javascript", "R"]`
+
+**NOTE**+First argument denotes the Index of Array while second denotes +the number of elements we want to delete from the array. + +#### Example 2: Deleting and Adding an element at specific index + +```javascript +let languages = ["C++", "Java", "Javascript", "R"]; +languages.splice(2, 1, "Python", "Pearl"); + ``` + This will add Python and Perl starting at index 2 and delete one element which was at index 2 originally. + As of result we get an output of `["C++", "Java", "Python", "Pearl", "R"]` + +#### Example 3: Deleting an element at a specific index + +```javascript +let languages = ["C++", "Java", "Javascript", "R"]; +languages.splice(1, 1); + ``` +This will delete one element at index 1. +As of result we get an output of `["C++", "Javascript", "R"]` + +## Slice + +Slice is used to return a selected number of elements from an array depending on their index + +#### Example 1: Specifying index 1 and 2 as the arguments + +```javascript +let languages = ["C++", "Java", "Javascript", "R"]; +let coding = languages.slice(1, 2); + ``` + This will return elements from an array starting at index 1 and ending at index 2. As of result we get an output of `["Java", "Javascript"]` + + #### Example 2: Specifying index -3 and -1 as the arguments +```javascript +let languages = ["C++", "Java", "Javascript", "R"]; +let coding = languages.slice(-3, -1); + ``` + Since negative numbers are being used. We indicate an offset from the end of the sequence. The elements returned from the array starts at index -3 and ends at index -1. As of result we get an output of `["Java", "Javascript"]` + +**Explanation**
+``` + index-> 0 1 2 3 + ["C++", "Java", "Javascript", "R"] + -4 -3 -2 -1 +``` \ No newline at end of file diff --git a/docs/JavaScript_Basics/strictMode.md b/docs/JavaScript_Basics_Info/strict_mode.md similarity index 100% rename from docs/JavaScript_Basics/strictMode.md rename to docs/JavaScript_Basics_Info/strict_mode.md diff --git a/docs/JavaScript_Basics_Info/string_operation.md b/docs/JavaScript_Basics_Info/string_operation.md new file mode 100644 index 0000000..b0850a7 --- /dev/null +++ b/docs/JavaScript_Basics_Info/string_operation.md @@ -0,0 +1,65 @@ +# String Operation + +#### JavaScript strings are used for storing and manipulating text, just like in any other language. + +Strings are written inside quotes: +```javascript +const variableName = "Hello JavaScript"; +// or with single quotes +const variableName = 'Hello JavaScript'; +``` + +## Concatenation + +String concatenation is joining 2 or more strings together in one string + +There are several method to achieve this in javascript and here we will mention some: + +1. Using .concat() method ( same as Array.concat() method ) + ```javascript + + let str = 'hello '.concat('world!') + console.log(str) // hello world! + + let user = 'jack' + console.log('welcome '.concat(user)) // welcome jack + + ``` + +2. Using plus operator + ```javascript + + let str = 'hello ' + 'world!' + console.log(str) // hello world! + + let user = 'jack' + console.log('welcome '+ user) // welcome jack + + ``` +2. Using Template literals (Template strings): + - using back-ticks + - new feature from ES6 + - you can add multiple lines in one string without the need to add \
diff --git a/docs/JavaScript_Basics_Info/switchcase.md b/docs/JavaScript_Basics_Info/switchcase.md
new file mode 100644
index 0000000..a0382cc
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/switchcase.md
@@ -0,0 +1,78 @@
+# Switch
+
+OK, now you now how to check condition and then execute a block of code depending on that condition.
+
+Assume we have 5 conditions to check. Let's try it.
+
+```javascript
+
+// assume we check for user age between 5 numbers
+let age = 30, desc = '';
+if (age == 10) {
+ desc = 'boy'
+} else if (age == 15) {
+ desc = 'teenager'
+} else if (age == 20) {
+ desc = 'young man'
+} else if (age == 30) {
+ desc = 'grown man'
+} else if (age == 50) {
+ desc = 'old man'
+}
+ // desc = grown man
+
+```
+
+but that's boring in case we have 50 conditions!
+
+And here comes the **SWITCH** use. Basically, it is used when we have multiple choices or cases and we have different result depending on each case.
+Let's try the previous example in the switch way
+
+```javascript
+
+switch (age) {
+ case 10:
+ desc = 'boy'
+ break;
+ case 15:
+ desc = 'teenager'
+ break;
+ case 20:
+ desc = 'young man'
+ break;
+ case 30:
+ desc = 'grown man'
+ break;
+ default:
+ desc = 'old man'
+}
+ // desc = grown man
+
+```
+
+but let's clarify the new syntax:
+```javascript
+ Switch(here gos the variable which value is compared){
+ case (value to compare):
+ code to execute if value is matched
+ break; ((will be explained at the end))
+
+ case (value to compare):
+ code to execute if value is matched
+ break; ((will be explained at the end))
+
+ default: ((will be explained at the end))
+
+ }
+
+ ```
+How switch works:
+- Switch accepts a variable to compare its value, then loops from the first case to the last case to check if the variable value matches any case of its cases and here we have two possibilities:
+
+ - variable value matched any case: then code of this case will be executed and then the BREAK statement works to break or end the loop and exit the Switch statement
+
+ - variable value didn't match any case then if there is a default case, it will be executed otherwise no case will be executed
+- **BREAK** statement is used to break the loop of the Switch if case is matched. If a break is missed then the code will keep executing cases code to the end of the switch statement which may cause wrong results.
+- **DEFAULT** case is an optional case which used as a backup case that applies when all cases are not matched. We don't need break after default case because we are already at the end of the Switch statement
+
+
diff --git a/docs/JavaScript_Basics_Info/try_and_catch.md b/docs/JavaScript_Basics_Info/try_and_catch.md
new file mode 100644
index 0000000..24ea13c
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/try_and_catch.md
@@ -0,0 +1,70 @@
+# Try and Catch
+
+In JavaScript, **try**/**catch**/**finally** statement handle errors that may occur in the block.
+
+**try** statement eables you to test your code in the block.
+**catch** statement enables you to execute a block of code when it catches an error.
+**finally** statement enables you to execute always after try and catch, regardless of an exception was thrown or caught.
+
+## Syntax
+```js
+try {
+ throw 'exception'; // generate an exception
+} catch (error) {
+ // statements to handle any exceptions
+} finally {
+ // always runs regardless of the resulf ot try/catch
+}
+```
+
+## Errors
+
+### Reference Error
+```js
+try {
+ hello(); // hello is not defined so it will cause a reference errorr
+} catch (error) {
+ console.log(error);
+} finally {
+ console.log('Finally runs reguardess of the reuslt');
+}
+```
+
+### Type Error
+```js
+try {
+ null.hello(); // hello is not defined so it will cause a reference errorr
+} catch (error) {
+ console.log("You cannot call from null");
+} finally {
+ console.log('Finally runs reguardess of the reuslt');
+}
+```
+
+### Syntax Error
+```js
+try {
+ eval('2+2'); // thsi works fine
+ eval('Hello, World!'); // this will generate error
+} catch (error) {
+ console.log("Syntax error");
+} finally {
+ console.log('Finally runs reguardess of the reuslt');
+}
+```
+
+### User Defined Error
+```js
+const person = {name:John, age: 23};
+
+try {
+ if(!person.gender){
+ // throw 'person has no gender'
+ throw new SyntaxError('Person has no gender');
+ }
+} catch (error) {
+ console.log("You cannot call from null");
+} finally {
+ console.log('Finally runs reguardess of the reuslt');
+}
+```
\ No newline at end of file
diff --git a/docs/JavaScript_Basics_Info/variables.md b/docs/JavaScript_Basics_Info/variables.md
new file mode 100644
index 0000000..8686b39
--- /dev/null
+++ b/docs/JavaScript_Basics_Info/variables.md
@@ -0,0 +1,172 @@
+# Variables
+
+## Datatypes
+One of the most fundamental characteristics of a programming language is the set of data types it
+supports. These are the type of values that can be represented and manipulated in a
+programming language.
+
+JavaScript allows you to work with three primitive data types −
+Numbers, eg. 123, 120.50 etc.
+
+Strings of text e.g. "This text string" etc.
+Boolean e.g. true or false.
+
+JavaScript also defines two trivial data types, null and undefined, each of which defines only a
+single value. In addition to these primitive data types, JavaScript supports a composite data type
+known as object. We will cover objects in detail in a separate chapter.
+
+Note − Java does not make a distinction between integer values and floating-point values. All
+numbers in JavaScript are represented as floating-point values.
+
+Like many other programming languages, JavaScript has variables. Variables can be thought of as
+named containers. You can place data into these containers and then refer to the data simply by
+naming the container.
+
+Before you use a variable in a JavaScript program, you must declare it. Variables are declared with
+the var keyword as follows.
+```js
+
+```
+You can also declare multiple variables with the same var keyword as follows −
+```js
+
+```
+Storing a value in a variable is called variable initialization. You can do variable initialization at
+the time of variable creation or at a later point in time when you need that variable.
+For instance, you might create a variable named money and assign the value 2000.50 to it later.
+For another variable, you can assign a value at the time of initialization as follows.
+```js
+
+```
+Note − Use the var keyword only for declaration or initialization, once for the life of any variable
+name in a document. You should not re-declare same variable twice.
+
+JavaScript is untyped language. This means that a JavaScript variable can hold a value of any
+data type. Unlike many other languages, you don't have to tell JavaScript during variable
+declaration what type of value the variable will hold. The value type of a variable can change
+during the execution of a program and JavaScript takes care of it automatically.
+
+JavaScript Variable Scope
+The scope of a variable is the region of your program in which it is defined. JavaScript variables
+have only two scopes.
+
+Global Variables − A global variable has global scope which means it can be defined
+anywhere in your JavaScript code.
+
+Local Variables − A local variable will be visible only within a function where it is defined.
+Function parameters are always local to that function.
+
+Within the body of a function, a local variable takes precedence over a global variable with the
+same name. If you declare a local variable or function parameter with the same name as a global
+variable, you effectively hide the global variable. Take a look into the following example.
+```js
+
+```
+This produces the following result −
+local
+JavaScript Variable Names
+While naming your variables in JavaScript, keep the following rules in mind.
+
+You should not use any of the JavaScript reserved keywords as a variable name. These
+keywords are mentioned in the next section. For example, break or boolean variable names
+are not valid.
+
+JavaScript variable names should not start with a numeral 0 − 9. They must begin with a letter
+or an underscore character. For example, 123test is an invalid variable name but _123test
+is a valid one.
+
+JavaScript variable names are case-sensitive. For example, Name and name are two
+different variables.
+
+A variable is a value, can be changed, paired with an associated symbolic name, make your code more useful and easyful
+
+--------------------
+
+In the Javascript has this types of variables:
+
+**Number**
+```javascript
+var exemple = 0; //Any number
+```
+
+**String**
+```javascript
+var exemple = "text"; //Any character in quotation marks
+```
+
+**Bool**
+```javascript
+var exemple = true; //or false
+```
+
+**Object**
+```javascript
+var exemple = {name:'carl',years:15}; //any object
+```
+
+**Array**
+```javascript
+var exemple = [1,"test"]; //list of any type of variable
+```
+
+**Class**
+```javascript
+var exemple = new Class(); //any classes
+```
+
+In the Javascript you don't need to declare the variable type.
+
+--------------------
+
+There are also ways to declare the variable:
+
+**Var**
+```javascript
+if(true){
+ var exemple = 1; //Declare like this
+ exemple = 2; //Can be changed
+ console.log(exemple);
+}
+console.log(exemple); //Is globally
+```
+
+**Let**
+```javascript
+if(true){
+ let exemple = 1; //Declare like this
+ exemple = 2; //Can be changed
+ console.log(exemple);
+}
+console.log(exemple); //Isn't globally, just work in blocks
+```
+
+**Const**
+```javascript
+if(true){
+ const exemple = 1; //Declare like this
+ exemple = 2; //Can't be changed, can only be declare one time
+ console.log(exemple);
+}
+console.log(exemple); //Is globally
+```
\ No newline at end of file
diff --git a/docs/README.md b/docs/README.md
index bcb5df8..d3b4097 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,9 +1,45 @@
-# Javascript Basics
+# Learn JavaScript
This repository was made for beginners to start learning Javascript from Scratch
-### Documentation
+## Documentation
-This repository using [Docsify](https://docsify.js.org) for generate documentation website on the fly.
+This repository uses [Docsify](https://docsify.js.org) for generating documentation website on the fly.
-You can run the local server with command `docsify serve docs` and preview documentation site in your browser on http://localhost:3000.
+If you want run Docsify you must use latest version of node (now is v13.0.1)
+read this issue [#299](https://github.com/Swap76/Learn-JavaScript/issues/299)
+
+
+**Steps:**
+1. Install dependencies
+ ```
+ npm install
+ ```
+2. Then run the following command to serve the documentation.
+ ```
+ npm run serve-docs
+ ```
+3. Now you can preview documentation site in your browser by visiting `http://localhost:3000`.
+
+## ESLint
+
+After making your changes or adding your contributions, lint your javascript files with eslint by running following command.
+While linting many errors may arise don't try to fix errors from other files except yours as this is tutorial repo some mistakes are intenstion.
+
+```sh
+$ npm run lint:fix
+```
+
+## References
+
+### [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript)
+One of the famous reference site for Javascript, it introduces from beginning to the advance concept
+
+### [w3schols.com](https://www.w3schools.com/js/)
+W3Schools is an educational website for learning web technologies online. Content includes tutorials and references relating to HTML, CSS, JavaScript
+
+### [The Modern JavaScrit Tutoial](https://javascript.info/)
+This web site introduces JavaScript with well-sorted topics, so it helps to see overview
+
+### [TutorialPoint](https://www.tutorialspoint.com/index.htm)
+They provides a vaiety of media such as video, eBooks, so it would be helpful, it you look for another learning materials
diff --git a/docs/Reference/reference.md b/docs/Reference/reference.md
new file mode 100644
index 0000000..9228611
--- /dev/null
+++ b/docs/Reference/reference.md
@@ -0,0 +1,13 @@
+# Reference
+
+## [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript)
+One of the famous reference site for Javascript, it introduces from beginning to the advance concept
+
+## [we3schools.com](https://www.w3schools.com/js/)
+W3Schools is an educational website for learning web technologies online. Content includes tutorials and references relating to HTML, CSS, JavaScript
+
+## [The Modern JavaScrit Tutoial](https://javascript.info/)
+This web site introduces JavaScript with well-sorted topics, so it helps to see overview
+
+## [TutorialPoint](https://www.tutorialspoint.com/index.htm)
+They provides a vaiety of media such as video, eBooks, so it would be helpful, it you look for another learning materials
\ No newline at end of file
diff --git a/docs/_sidebar.md b/docs/_sidebar.md
index 51b0067..c8ec629 100644
--- a/docs/_sidebar.md
+++ b/docs/_sidebar.md
@@ -1,28 +1,197 @@
+- [Home](README.md)
+
+- JavaScript Basics Info
+
+ - [arrays](JavaScript_Basics_Info/arrays.md)
+ - [boolean](JavaScript_Basics_Info/boolean.md)
+ - [call](JavaScript_Basics_Info/call.md)
+ - [comparison operators](JavaScript_Basics_Info/comparison_operators.md)
+ - [condition statments](JavaScript_Basics_Info/condition_statments.md)
+ - [continue break](JavaScript_Basics_Info/continue_break.md)
+ - [date](JavaScript_Basics_Info/date.md)
+ - [dom manipulation](JavaScript_Basics_Info/dom_manipulation.md)
+ - [filter](JavaScript_Basics_Info/filter.md)
+ - [for each](JavaScript_Basics_Info/for_each.md)
+ - [functions](JavaScript_Basics_Info/functions.md)
+ - [higher order functions](JavaScript_Basics_Info/higher_order_functions.md)
+ - [looping an object](JavaScript_Basics_Info/looping_an_object.md)
+ - [loops](JavaScript_Basics_Info/loops.md)
+ - [map](JavaScript_Basics_Info/map.md)
+ - [math](JavaScript_Basics_Info/math.md)
+ - [number methods](JavaScript_Basics_Info/number_methods.md)
+ - [objects](JavaScript_Basics_Info/objects.md)
+ - [page redirects](JavaScript_Basics_Info/page_redirects.md)
+ - [reduce](JavaScript_Basics_Info/reduce.md)
+ - [some](JavaScript_Basics_Info/some.md)
+ - [splice slice](JavaScript_Basics_Info/splice_slice.md)
+ - [strict mode](JavaScript_Basics_Info/strict_mode.md)
+ - [string operation](JavaScript_Basics_Info/string_operation.md)
+ - [substr](JavaScript_Basics_Info/substr.md)
+ - [switchcase](JavaScript_Basics_Info/switchcase.md)
+ - [try and catch](JavaScript_Basics_Info/try_and_catch.md)
+ - [variables](JavaScript_Basics_Info/variables.md)
+
+
+- JavaScript Advance Info
+
+ - [AJAX](JavaScript_Advance_Info/AJAX.md)
+ - [BOM functions](JavaScript_Advance_Info/BOM_functions.md)
+ - [JSON](JavaScript_Advance_Info/JSON.md)
+ - [array flat](JavaScript_Advance_Info/array_flat.md)
+ - [arrow function](JavaScript_Advance_Info/arrow_function.md)
+ - [assignments](JavaScript_Advance_Info/assignments.md)
+ - [async await](JavaScript_Advance_Info/async_await.md)
+ - [bind](JavaScript_Advance_Info/bind.md)
+ - [bitwise operaors](JavaScript_Advance_Info/bitwise_operaors.md)
+ - [browser object model](JavaScript_Advance_Info/browser_object_model.md)
+ - [callback](JavaScript_Advance_Info/callback.md)
+ - [classes](JavaScript_Advance_Info/classes.md)
+ - [connect to mongo](JavaScript_Advance_Info/connect_to_mongo.md)
+ - [cookies](JavaScript_Advance_Info/cookies.md)
+ - [currying](JavaScript_Advance_Info/currying.md)
+ - [destructuring](JavaScript_Advance_Info/destructuring.md)
+ - [do while loop](JavaScript_Advance_Info/do_while_loop.md)
+ - [dom manipulation html](JavaScript_Advance_Info/dom_manipulation_html.md)
+ - [express](JavaScript_Advance_Info/express.md)
+ - [filtering array](JavaScript_Advance_Info/filtering_array.md)
+ - [for in](JavaScript_Advance_Info/for_in.md)
+ - [fs module](JavaScript_Advance_Info/fs_module.md)
+ - [hoisting](JavaScript_Advance_Info/hoisting.md)
+ - [inheritance](JavaScript_Advance_Info/inheritance.md)
+ - [json parse and stringify](JavaScript_Advance_Info/json_parse_and_stringify.md)
+ - [keys](JavaScript_Advance_Info/keys.md)
+ - [map object](JavaScript_Advance_Info/map_object.md)
+ - [object assign](JavaScript_Advance_Info/object_assign.md)
+ - [polymorphism](JavaScript_Advance_Info/polymorphism.md)
+ - [popup boxes](JavaScript_Advance_Info/popup_boxes.md)
+ - [postgres connection](JavaScript_Advance_Info/postgres_connection.md)
+ - [promises](JavaScript_Advance_Info/promises.md)
+ - [prototype](JavaScript_Advance_Info/prototype.md)
+ - [redis](JavaScript_Advance_Info/redis.md)
+ - [regex](JavaScript_Advance_Info/regex.md)
+ - [set function](JavaScript_Advance_Info/set_function.md)
+ - [set object](JavaScript_Advance_Info/set_object.md)
+ - [spread & rest](JavaScript_Advance_Info/spread_&_rest.md)
+ - [this](JavaScript_Advance_Info/this.md)
+ - [timer function](JavaScript_Advance_Info/timer_function.md)
+ - [while loop](JavaScript_Advance_Info/while_loop.md)
+
+
- JavaScript Basics
- - [Variables](JavaScript_Basics/variables.md)
- - [String Operation](JavaScript_Basics/stringOperation.md)
- - [Comparison Operators](JavaScript_Basics/comparisonOperators.md)
- - [Functions](JavaScript_Basics/functions.md)
- - [Arrays](JavaScript_Basics/arrays.md)
- - [Objects](JavaScript_Basics/objects.md)
- - [This](JavaScript_Basics/this.md)
- - [Classes](JavaScript_Basics/classes.md)
- - [Inheritance](JavaScript_Basics/inheritance.md)
- - [Exercise 1](JavaScript_Basics/exercise-1.md)
- - [Exercise 1 Using Object](JavaScript_Basics/exercise-1-using-object.md)
- - [Exercise 1 Using Classes](JavaScript_Basics/exercise-1-using-classes.md)
- - [Math](JavaScript_Basics/Cookies.md)
+ - [BOM functions](JavaScript_Basics/BOM_functions.md)
+ - [Datatypes](JavaScript_Basics/Datatypes.md)
+ - [array flat](JavaScript_Basics/array_flat.md)
+ - [array methods](JavaScript_Basics/array_methods.md)
+ - [arrays](JavaScript_Basics/arrays.md)
+ - [bitwise operators](JavaScript_Basics/bitwise_operators.md)
+ - [boolean](JavaScript_Basics/boolean.md)
+ - [bugs](JavaScript_Basics/bugs.md)
+ - [call](JavaScript_Basics/call.md)
+ - [comparison operators](JavaScript_Basics/comparison_operators.md)
+ - [continue break](JavaScript_Basics/continue_break.md)
+ - [count repeated values](JavaScript_Basics/count_repeated_values.md)
+ - [date](JavaScript_Basics/date.md)
+ - [do while loop](JavaScript_Basics/do_while_loop.md)
+ - [dom manipulation](JavaScript_Basics/dom_manipulation.md)
+ - [filter](JavaScript_Basics/filter.md)
+ - [filtering array](JavaScript_Basics/filtering_array.md)
+ - [fs module](JavaScript_Basics/fs_module.md)
+ - [functions](JavaScript_Basics/functions.md)
+ - [higher order functions](JavaScript_Basics/higher_order_functions.md)
+ - [if](JavaScript_Basics/if.md)
+ - [iife](JavaScript_Basics/iife.md)
+ - [includes](JavaScript_Basics/includes.md)
+ - [looping an object](JavaScript_Basics/looping_an_object.md)
+ - [map](JavaScript_Basics/map.md)
+ - [math](JavaScript_Basics/math.md)
+ - [number methods](JavaScript_Basics/number_methods.md)
+ - [objects](JavaScript_Basics/objects.md)
+ - [page redirects](JavaScript_Basics/page_redirects.md)
+ - [popup boxes](JavaScript_Basics/popup_boxes.md)
+ - [reduce](JavaScript_Basics/reduce.md)
+ - [resources](JavaScript_Basics/resources)
+ - [scope](JavaScript_Basics/scope.md)
+ - [some](JavaScript_Basics/some.md)
+ - [splice slice](JavaScript_Basics/splice_slice.md)
+ - [strict mode](JavaScript_Basics/strict_mode.md)
+ - [string operation](JavaScript_Basics/string_operation.md)
+ - [substr](JavaScript_Basics/substr.md)
+ - [swap values ES6](JavaScript_Basics/swap_values_ES6.md)
+ - [switch case](JavaScript_Basics/switch_case.md)
+ - [this](JavaScript_Basics/this.md)
+ - [timer functions](JavaScript_Basics/timer_functions.md)
+ - [type conversions](JavaScript_Basics/type_conversions.md)
+ - [variables](JavaScript_Basics/variables.md)
+
- JavaScript Advance
- - [Arrow Function](JavaScript_Advance/arrowFunction.md)
- - [Filtering Arrays](JavaScript_Advance/FilteringArray.md)
- - [Destructuring](JavaScript_Advance/destructuring.md)
- - [Spread & Rest](JavaScript_Advance/spread&rest.md)
- - [Timer Function](JavaScript_Advance/timerFunction.md)
- - [Event loop](JavaScript_Advance/eventloop.md)
- - [Promises](JavaScript_Advance/promises.md)
- - [fs Module](JavaScript_Advance/fsModule.md)
- - [Default Values](JavaScript_Advance/defaultValues.md)
- - [Polymorphism](JavaScript_Advance/polymorphism.md)
+ - [AJAX request](JavaScript_Advance/AJAX_request.md)
+ - [IEEE-754](JavaScript_Advance/IEEE-754.md)
+ - [JSON](JavaScript_Advance/JSON.md)
+ - [XML http request](JavaScript_Advance/XML_http_request.md)
+ - [arrow function](JavaScript_Advance/arrow_function.md)
+ - [assignments arithmetic](JavaScript_Advance/assignments_arithmetic.md)
+ - [assignments bitwise](JavaScript_Advance/assignments_bitwise.md)
+ - [async await](JavaScript_Advance/async_await.md)
+ - [bind](JavaScript_Advance/bind.md)
+ - [caesar cipher](JavaScript_Advance/caesar_cipher.md)
+ - [callback](JavaScript_Advance/callback.md)
+ - [classes](JavaScript_Advance/classes.md)
+ - [closures](JavaScript_Advance/closures.md)
+ - [connect to mongo](JavaScript_Advance/connect_to_mongo.md)
+ - [cookies](JavaScript_Advance/cookies.md)
+ - [default values](JavaScript_Advance/default_values.md)
+ - [destructuring](JavaScript_Advance/destructuring.md)
+ - [express](JavaScript_Advance/express.md)
+ - [function as object](JavaScript_Advance/function_as_object.md)
+ - [generators](JavaScript_Advance/generators.md)
+ - [get environment variable](JavaScript_Advance/get_environment_variable.md)
+ - [hoisting](JavaScript_Advance/hoisting.md)
+ - [inheritance](JavaScript_Advance/inheritance.md)
+ - [json parse and stringify](JavaScript_Advance/json_parse_and_stringify.md)
+ - [keys](JavaScript_Advance/keys.md)
+ - [map object](JavaScript_Advance/map_object.md)
+ - [nasaimg https](JavaScript_Advance/nasaimg_https.md)
+ - [object assign](JavaScript_Advance/object_assign.md)
+ - [polymorphism](JavaScript_Advance/polymorphism.md)
+ - [postgres connection](JavaScript_Advance/postgres_connection.md)
+ - [promises](JavaScript_Advance/promises.md)
+ - [prototype](JavaScript_Advance/prototype.md)
+ - [recursion](JavaScript_Advance/recursion.md)
+ - [regex](JavaScript_Advance/regex.md)
+ - [resources](JavaScript_Advance/resources)
+ - [set function](JavaScript_Advance/set_function.md)
+ - [set object](JavaScript_Advance/set_object.md)
+ - [some method](JavaScript_Advance/some_method.md)
+ - [spread & rest](JavaScript_Advance/spread_&_rest.md)
+ - [try catch](JavaScript_Advance/try_catch.md)
+
+- Exercise Questions
+
+ - [Splice & Slice](Exercise_Questions/Splice_&_Slice.md)
+ - [array method](Exercise_Questions/array_method.md)
+ - [bitwise operator](Exercise_Questions/bitwise_operator.md)
+ - [boolean](Exercise_Questions/boolean.md)
+ - [classes](Exercise_Questions/classes.md)
+ - [comparison operators](Exercise_Questions/comparison_operators.md)
+ - [continue break](Exercise_Questions/continue_break.md)
+ - [date](Exercise_Questions/date.md)
+ - [filter](Exercise_Questions/filter.md)
+ - [for each](Exercise_Questions/for_each.md)
+ - [higher order functions](Exercise_Questions/higher_order_functions.md)
+ - [if else](Exercise_Questions/if_else.md)
+ - [inheritance](Exercise_Questions/inheritance.md)
+ - [looping objects](Exercise_Questions/looping_objects.md)
+ - [number methods](Exercise_Questions/number_methods.md)
+ - [object](Exercise_Questions/object.md)
+ - [reduce](Exercise_Questions/reduce.md)
+ - [regex](Exercise_Questions/regex.md)
+ - [string](Exercise_Questions/string.md)
+ - [switch](Exercise_Questions/switch.md)
+ - [two strings](Exercise_Questions/two_strings.md)
+
+- Reference
+
+ - [reference](Reference/reference.md)
\ No newline at end of file
diff --git a/docs/index.html b/docs/index.html
index 9d25b2e..7a209f3 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -2,25 +2,39 @@
-