Merge branch 'master' of https://github.com/lgope/JavaScript

Author: lgope

01 - JavaScript-Basics/emailValidate.js

@@ -0,0 +1,8 @@
+function validateEmail(email) {
+  const re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+  return re.test(String(email).toLowerCase());
+}
+
+console.log(validateEmail('[email protected]')); // true
+console.log(validateEmail('[email protected]')); // true
+console.log(validateEmail('example121.gmail.com')); // false

01 - JavaScript-Basics/outputGuess.js

@@ -0,0 +1,89 @@
+'use strict';
+function logThis() {
+  this.desc = 'logger';
+  console.log(this); // { desc: 'logger' }
+}
+
+new logThis();
+
+// '''''''''''''''''''''''''''''
+var Storm = function () {};
+Storm.prototype.precip = 'rain';
+var WinterStorm = function () {};
+WinterStorm.prototype = new Storm();
+WinterStorm.prototype.precip = 'snow';
+var bob = new WinterStorm();
+console.log(bob.precip); // snow
+
+// lllllllllllllllllllllllllllllll
+const obj = {
+    a: 1,
+    b: 2,
+    c: 3,
+};
+
+const obj2 = {
+    ...obj,
+    a: 0,
+};
+
+console.log(obj2.a, obj2.b); // 0 2
+
+// llllllllllllllllllllllllllll
+console.log(sum(10, 20));  // 30 ReferenceError
+// console.log(diff(10, 20));
+    function sum(x, y) {
+        return x + y;
+    }
+    let diff = function(x, y) {
+        return x - y;
+    }
+
+
+
+// lllllllllllllllllllllll
+function sayHello() {
+    console.log("hello");
+}
+
+var func = sayHello;
+func.answer = 42;
+
+console.log(sayHello.answer); // 42
+
+
+var a = ['dog', 'cat', 'hen'];
+a[100] = 'fox';
+
+console.log(a.length);
+
+var a;
+var b = (a=3) ? true: false
+
+let arr = [];
+
+console.log(arr);
+console.log([] ==[]);
+
+class X {
+    get Y() {return 42;}
+}
+
+
+var x = new X();
+
+console.log(x.Y);
+
+
+
+var v = 1;
+var f1 = function () {
+    console.log(v);   
+}
+
+var f2 = function () {
+   var v = 2;
+   f1();
+}
+
+f2();

Asynchronous-JavaScript/byeTryCatchErrorHandling.js

@@ -0,0 +1,46 @@
+// catchAwait.js
+const catchAwait = promise =>
+  promise
+    .then(data => ({ data, error: null }))
+    .catch(error => ({ error, data: null }));
+
+module.exports = catchAwait;
+
+// working file
+const { getItems } = require('./api/items');
+const catchAwait = require('./utils/catchAwait');
+
+const allItems = async () => {
+  const { error, data } = await catchAwait(getItems());
+  if (!error) {
+    // code
+  }
+  console.error(error);
+};
+
+allItems();
+
+/**
+ * Another way
+ */
+
+// catchAsync.js
+module.exports = fn => {
+  return (req, res, next) => {
+    fn(req, res, next).catch(next);
+  };
+};
+
+// createOne.js
+
+exports.createOne = Model =>
+  catchAsync(async (req, res, next) => {
+    const doc = await Model.create(req.body);
+
+    res.status(201).json({
+      status: 'success',
+      data: {
+        data: doc,
+      },
+    });
+  });

BuildIn-Methods/indexOf.js

@@ -0,0 +1,8 @@
+let str = 'Hello world, welcome to the JS Universe.';
+console.log(str.indexOf('welcome')); // 13
+console.log(str.indexOf('wall')); // -1
+
+const fruits = ['Orange', 'Pineapple', 'Apple', 'Melon'];
+console.log(fruits.indexOf('Melon')); // 3
+
+console.log(fruits.indexOf('klkljkh')); // -1

BuildIn-Methods/lastIndexOf.js

@@ -0,0 +1,4 @@
+const fruits = ['Orange', 'Pineapple', 'Apple', 'Melon'];
+console.log(fruits.lastIndexOf('Melon')); // 3
+
+console.log(fruits.lastIndexOf('klkljkh')); // -1

BuildIn-Methods/length.js

@@ -0,0 +1,5 @@
+const fruits = ['Orange', 'Pineapple', 'Apple', 'Melon'];
+console.log(fruits.length); // 4
+
+let str = 'Hello world, welcome to the JS Universe.';
+console.log(str.length); // 40

BuildIn-Methods/map.js

@@ -0,0 +1,16 @@
+// The map() method creates a new array populated with the results of calling a provided function on every element in the calling array.
+
+const array = [1, 4, 9, 16, 15, 48];
+
+// pass a function to map
+const map1 = array.map(ar => ar * 2);
+
+console.log(map1);
+// expected output: Array [2, 8, 18, 32]
+
+function myFunction(num) {
+  return num * 10;
+}
+
+let newArray = array.map(myFunction);
+console.log(newArray);

BuildIn-Methods/reduce.js

@@ -0,0 +1,12 @@
+// The reduce() method executes a reducer function (that we provide) on each element of the array, resulting in single output value.
+
+const array = [1, 2, 3, 4, 5];
+const reducerFunc = (accumulator, currentValue) => accumulator + currentValue;
+
+// 1 + 2 + 3 + 4 + 5
+console.log(array.reduce(reducerFunc));
+// expected output: 15
+
+// 5 + 1 + 2 + 3 + 4 + 5
+console.log(array.reduce(reducerFunc, 5));
+// expected output: 20

BuildIn-Methods/slice.js

@@ -0,0 +1,9 @@
+// The slice() method returns a shallow copy of a portion of an array into a new array object selected from begin to end (end not included) where begin and end represent the index of items in that array. The original array will not be modified.
+
+const array = [1, 2, 3, 4, 5];
+
+const anotherArr = array.slice(1, 4);
+
+console.log(anotherArr);
+
+console.log(array.slice(2, 5));

BuildIn-Methods/toString.js

@@ -0,0 +1,6 @@
+let num = 10;
+let n = num.toString();
+
+console.log(typeof num); // number
+
+console.log(typeof n); // string

BuildIn-Methods/typeOf.js

@@ -0,0 +1,8 @@
+console.log(typeof 44); // number
+
+console.log(typeof 'something'); // string
+
+console.log(typeof true); // boolean
+
+let num = 12;
+console.log(typeof num); // number

README.md

@@ -1,2 +1,71 @@
 # JavaScript
-The of this repo is to save my js programs. Basics of JavaScript. Beginner level.
+*JavaScript, often abbreviated as JS, is a programming language that conforms to the ECMAScript specification. JavaScript is high-level, often just-in-time compiled, and multi-paradigm. It has curly-bracket syntax, dynamic typing, prototype-based object-orientation, and first-class functions. The of this repo is to save my js programs. Basics of JavaScript. Beginner level.*
+
+## Table of Contents
+
+  1. [Important Methods](#methods)
+  
+## Methods
+>  Most important javascript build in methods
+
+<a name="typeof"></a><a name="1.1"></a>
+- [1.1](#typeof) **typeof**: Returns the type.
+ 
+ ```javascript
+ console.log(typeof 44); // number
+
+ console.log(typeof 'something'); // string 
+ 
+ console.log(typeof true); // boolean
+ 
+ let num = 12;
+ console.log(typeof(num)); // number
+ 
+ ```
+
+<a name="toString"></a><a name="1.2"></a>
+- [1.2](#toString) **toString**: Returns the string representation of the number's value.
+ 
+ ```javascript
+ let num = 10;
+ let n = num.toString();
+ 
+ console.log(typeof(num)); // number
+ 
+ console.log(typeof(n)); // string
+ ```
+
+<a name="indexOf"></a><a name="1.3"></a>
+- [1.3](#indexOf) **indexOf**: Returns the first index at which a given element can be found in the array, or -1 if it is not present.
+ 
+ ```javascript
+ let str = "Hello world, welcome to the JS Universe.";
+ console.log(str.indexOf("welcome")); // 13
+ console.log(str.indexOf("wall")); // -1
+ 
+ const fruits = ['Orange', 'Pineapple', 'Apple', 'Melon'];
+ console.log(fruits.indexOf('Melon')); // 3
+ 
+ console.log(fruits.indexOf('klkljkh')); // -1
+ ```
+ 
+<a name="lastIndexOf"></a><a name="1.4"></a>
+- [1.4](#lastIndexOf) **lastIndexOf**: Returns the last index at which a given element can be found in the array, or -1 if it is not present.
+ 
+ ```javascript 
+ const fruits = ['Orange', 'Pineapple', 'Apple', 'Melon'];
+ console.log(fruits.lastIndexOf('Melon')); // 3
+ 
+ console.log(fruits.lastIndexOf('klkljkh')); // -1
+ ```
+ 
+ <a name="length"></a><a name="1.5"></a>
+- [1.5](#length) **length**: Returns the number of characters or size in a string or array.
+ 
+ ```javascript 
+ const fruits = ['Orange', 'Pineapple', 'Apple', 'Melon'];
+ console.log(fruits.length); // 4
+ 
+ let str = "Hello world, welcome to the JS Universe.";
+ console.log(str.length); // 40
+ ```

js-coding-technique/loops.js

@@ -0,0 +1,99 @@
+const mil = 1000000;
+const arr = Array(mil);
+
+console.time('⏲️');
+
+for (let i = 0; i < mil; i++) {} // 1.6ms
+
+for (const v of arr) {
+} // 11.7ms
+
+arr.forEach(v => v); // 2.1ms
+
+for (let i = mil; i > 0; i--) {} // 1.5ms
+
+console.timeEnd('⏲️');
+
+const equine = { unicorn: '🦄', horse: '🐴', zebra: '🦓' };
+
+for (const key in equine) {
+  // Filters out properties inherited from prototype
+  if (equine.hasOwnProperty(key)) {
+    console.log(equine[key]);
+  }
+}
+
+// Unwrap the the Values
+
+for (const val of Object.values(equine)) {
+  console.log(val);
+}
+
+// Create a Map
+const equine = new Map(Object.entries(equine));
+
+for (const v of equine.values()) {
+  console.log(v);
+}
+
+const equine = [
+  ['unicorn', '🦄'],
+  ['horse', '🐴'],
+  ['zebra', '🦓'],
+];
+
+// 😒 Meh Code
+for (const arr of equine) {
+  const type = arr[0];
+  const face = arr[1];
+  console.log(`${type} looks like ${face}`);
+}
+
+// 🤯 Destructured Code
+for (const [type, face] of equine) {
+  console.log(`${type} looks like ${face}`);
+}
+
+///////////////
+arr[Symbol.iterator] = function () {
+  let i = 0;
+  let arr = this;
+  return {
+    next: function () {
+      if (i >= arr.length) {
+        return { done: true };
+      } else {
+        const value = arr[i] + '🙉';
+        i++;
+        return { value, done: false };
+      }
+    },
+  };
+};
+
+////////////////////////////////
+
+const faces = ['😀', '😍', '🤤', '🤯', '💩', '🤠', '🥳'];
+
+// Transform values
+const withIndex = faces.map((v, i) => `face ${i} is ${v}`);
+
+// Test at least one value meets a condition
+const isPoopy = faces.some(v => v === '💩');
+// false
+
+// Test all values meet a condition
+const isEmoji = faces.every(v => v > 'ÿ');
+// true
+
+// Filter out values
+const withoutPoo = faces.filter(v => v !== '💩');
+
+// Reduce values to a single value
+const pooCount = faces.reduce((acc, cur) => {
+  return acc + (cur === '💩' ? 1 : 0);
+}, 0);
+console.log(pooCount);
+
+// Sort the values
+const sorted = faces.sort((a, b) => a < b);