Add files via upload

Author: jaydattpatel

001-Hello.js

@@ -0,0 +1,4 @@
+/**
+ * Author : Jaydatt Patel
+ */
+console.log('Hello World');

002-Variables-and-Scope.js

@@ -0,0 +1,148 @@
+/*
+ * Author : Jaydatt Patel
+variables using var, let , const------
+ES5: var (does not support scope)
+ES6: let, const (support scope)
+----------------------------------------------
+var  : 
+    - You can use access this variable before declaration with undefined value.
+    - You can declare variable using var and also You can assign values later. 
+    - You can redeclare same name variable anywhere by assining new value. If You do not assign value then it will hold previous assigned value.
+    - It does not support scope resolution means it can access anywhere. So, declared variable in outside block {} and inside block {} with same name, both variables are same and hold same value and accessible both side. So if You modify or redeclare variable then it will make changes for all.
+    - var variable can be access in functions if and only if function must not have redeclaration of same name variable with var, let and const. If You redeclare same variable in function with var,let or const, then it will create seperate local variable with same name only for function with assigned new value or undefined by default.
+
+let : 
+    - You can not access this variable before declaration otherwise you will get error.
+    - You can declare variable using let and also You can assign values later. 
+    - You can not redeclare same name variable within block{} but You can redeclare same name variable in other {} block.
+    - It supports scope resolution means variable can be access only within scope block{} and inner all {} and functions. It can not be accessed out of the scope means inner block{} variables can not be access in outside block.
+    - let variable can be access in functions if and only if function must not have redeclaration of same name variable with var, let and const. If You redeclare same variable in function with var,let or const, then it will create seperate local variable with same name only for function with assigned new value or undefined by default. 
+
+const : 
+    - You can not access this variable before declaration otherwise you will get error.
+    - You can declare variable using const and you must by assigning values otherwise it will create error. 
+    - Const variable must be initialized when it was declared. You can not initialize later. 
+    - Only Primitive data type can be constant so other can modify even if You assign constant. 
+    - After assiging value, You can not modify value. 
+    - You can not redeclare same name variable within block{} but You can redeclare same name variable in other {} with assign value.
+    - It supports scope resolution means variable can be access only within scope block{} and inner all {} and functions. It can not be accessed out of the scope means inner block{} variables can not be access in outside block.
+    - const variable can be access in functions if and only if function must not have redeclaration of same name variable with var, let and const. If You redeclare same variable in function with var,let or const, then it will create seperate local variable with same name only for function with assigned new value.
+------------------------------------------------------------------
+* Variable names follow these rules:
+
+- Variable names are case-sensitive. This means that the message and Message are different variables.
+- Variable names can only contain letters, numbers, underscores, or dollar signs.
+- Variable names cannot contain spaces.
+- variable names can not begin number.
+- Variable names can not use the reserved words.
+
+*/
+
+
+//var variables
+console.log("----------var variables---------");
+
+var vx = 10;
+var vy = 20;
+{
+    console.log('Inner-1 {} :',vx,vy);
+}
+
+{
+    var vx = 11;//this variable is same in outer and inner
+    var vz = 30;
+    console.log('Inner-2 {} :',vx,vy);
+}
+
+console.log('Globle-after-{} :',vx,vy,vz);
+
+
+function Vfoo1(){
+    console.log('Vfoo1:',vx,vy,vz);
+}
+Vfoo1();
+
+function Vfoo2(){
+    //here function have same variables so it will assign as local variable.
+    var vx = 1; //create local variable
+    let vy = 2; //create local variable
+    const vz = 3; //create local variable
+    console.log('Vfoo2:',vx,vy,vz);
+
+}
+Vfoo2();
+
+console.log('Globle-after-fun :',vx,vy,vz);
+
+//let letiables
+console.log("----------let variables---------");
+
+let lx = 10;
+let ly = 20;
+{
+    let lx = 11;// local variable with block. 
+    let lz = 30;// local variable with block. 
+    console.log('Inner {} :',lx,ly,lz);
+}
+
+console.log("\nconsole.log('Globle-after-{} :',lx,ly,lz); //Error: lz is not defined means lz can not be access outside the block.\n")
+// console.log('Globle-after-{} :',lx,ly,lz); //Error: lz is not defined means lz can not be access outside the block.
+
+console.log('Globle-after-{} :',lx,ly);
+
+
+function Lfoo1(){
+    console.log('Lfoo1:',lx,ly);
+}
+Lfoo1();
+
+function Lfoo2(){
+    //here function have same variables so it will assign as local variable.
+    var lx = 1;     //Local variable
+    let ly = 2;     //Local variable
+    const lz =3;    //Local variable
+    console.log('Lfoo2:',lx,ly,lz);
+
+}
+Lfoo2();
+
+console.log("\nconsole.log('Globle-after-fun :',lx,ly,lz); //Error: lz is not defined means lz can not be access outside the function.\n")
+// console.log('Globle-after-fun :',lx,ly,lz); //Error: lz is not defined means lz can not be access outside the function.
+console.log('Globle-after-fun :',lx,ly);
+
+//const constiables
+console.log("----------const variables---------");
+
+
+let cx = 10;
+let cy = 20;
+{
+    let cx = 11;// local variable with block. 
+    let cz = 30;// local variable with block. 
+    console.log('Inner {} :',cx,cy,cz);
+}
+
+console.log("\nconsole.log('Globle-after-{} :',cx,cy,cz); //Error: cz is not defined means cz can not be access outside the block.\n")
+// console.log('Globle-after-{} :',cx,cy,cz); //Error: cz is not defined means cz can not be access outside the block.
+
+console.log('Globle-after-{} :',cx,cy);
+
+
+function Cfoo1(){
+    console.log('Cfoo1:',cx,cy);
+}
+Cfoo1();
+
+function Cfoo2(){
+    //here function have same variables so it will assign as local variable.
+    var cx = 1;     //Local variable
+    let cy = 2;     //Local variable
+    const cz =3;    //Local variable
+    console.log('Cfoo2:',cx,cy,cz);
+
+}
+Cfoo2();
+
+console.log("\nconsole.log('Globle-after-fun :',cx,cy,cz); //Error: cz is not defined means cz can not be access outside the function.\n")
+// console.log('Globle-after-fun :',cx,cy,cz); //Error: cz is not defined means cz can not be access outside the function.
+console.log('Globle-after-fun :',cx,cy);

003-Variable-Strict-mode.js

@@ -0,0 +1,21 @@
+/*
+
+Author : Jaydatt Patel
+'use strict' : 
+ This mode allow to use variable which are defined with var,let and const. If you use variable without declare then it will give error 'ReferenceError': variable is not defined 
+*/
+
+
+//error 'ReferenceError': variable is not defined 
+// 'use strict';
+// a = 10;
+// console.log(a); 
+
+
+//error 'ReferenceError': variable is not defined 
+// function foo(){
+//     'use strict';
+//     a = 10;
+//     console.log(a)
+// }
+// foo();

004-Typeof-and-DataTypes.js

@@ -0,0 +1,66 @@
+/*
+ * Author : Jaydatt Patel
+Data types and Typeof function
+*/
+
+var obj = typeof("Hello");
+console.log("\"Hello\" :", obj);
+
+var obj = typeof('Hello"s world');
+console.log("\'Hello\"s world\':", obj);
+
+var obj = typeof(`"Hello's world"`);
+console.log("`\"Hello's world\"` :", obj);
+
+obj = typeof(10);
+console.log("10 :", obj);
+
+obj = typeof(10n);
+console.log("10n:", obj);
+
+obj = typeof(3.14);
+console.log("3.14 :", obj);
+
+obj = typeof(true);
+console.log("true :",obj);
+
+obj = typeof(1<=2);
+console.log("(1<=2) :",obj);
+
+obj = typeof([1,2,3]);
+console.log("[1,2,3] :",obj);
+
+obj = typeof({ city : 'Ahme'});
+console.log("{ city : 'Ahme'} :",obj);
+
+var obj = typeof(null);
+console.log("NULL:", obj);
+
+var obj = typeof(var_undefine);
+console.log("var_undefine :", obj);
+
+obj = typeof(function sum(a,b) {return(a+b)});
+console.log("function sum(a,b) {return(a+b)} :",obj);
+
+
+obj = typeof (new Date()) //=== "object";
+console.log("(new Date()) :",obj);
+
+obj = typeof /regex/ //=== "object";
+console.log("/regex/ :",obj);
+
+// The following are confusing, dangerous, and wasteful. Avoid them.
+obj = typeof (new Boolean(true)) //=== "object";
+console.log("(new Boolean(true)) :",obj);
+obj = typeof (new Number(1)) //=== "object";
+console.log("(new Number(1)) :",obj);
+obj = typeof (new String("abc")) //=== "object";
+console.log("(new String(\"abc\"):",obj);
+
+// Functions
+obj = typeof function () {} //=== "function";
+console.log("function () {} :",obj);
+obj = typeof class C {} //=== "function";
+console.log("class C {} :",obj);
+obj = typeof Math.sin //=== "function";
+console.log("Math.sin :",obj);

005-String_function.js

@@ -0,0 +1,104 @@
+/**
+  * Author : Jaydatt Patel
+  * String Functions:
+  - string.concat(string)
+  - str.charAt(number)
+  - str.charCodeAt(number)
+  - str.indexOf(char)
+  - str.lastIndexOf(char)
+  - str.toUpperCase()
+  - str.toLowerCase()
+  - str.match(string)
+  - str.startsWith(string)
+  - str.endsWith(string)
+  - str.padStart(number, char)
+  - str.padEnd(number, char)
+  - str.substring(start index, stop index)
+  - str.slice(start index, stop index)
+  - str.replace(string ,string)
+  - str.replaceAll(string ,string)
+  - str.includes(string)
+  - str.repeat(number)
+  - str.trim()
+  - str.trimStart()
+  - str.trimEnd()
+  - str.split(String seperator, limit)  
+ */
+
+console.log("Hello, World");
+console.log("Hello " + "there, " + "World");//Not space add automatically
+console.log("Hello","there,","World");//space add automatically
+
+
+var str = "Hello";
+console.log(str,'World');
+var year = 2023;
+
+console.log(str,'World',year);
+
+console.log(`${str} World ${year}`);
+
+var price = 10;
+var VAT = 0.25;
+console.log(`Total: ${(price * (1 + VAT)).toFixed(2)}`);
+
+
+// string.concat(string).concat(string).concate(string)...............
+console.log("concate: ", str.concat('World').concat(year)); //
+
+console.log(("Hello " + "there, " + "World").length);
+console.log("str.length : ", str.length);
+
+console.log("str.charAt(1) : ", str.charAt(1));
+console.log("str.charCodeAt(1) : ", str.charCodeAt(1));
+console.log("str.indexOf('l') : ", str.indexOf('l'));
+console.log("str.lastIndexOf('l') : ", str.lastIndexOf('l'));
+
+console.log("str.toUpperCase() : ", str.toUpperCase());
+console.log("str.toLowerCase() : ", str.toLowerCase());
+
+//find or match string 
+console.log("str.match('ll') : ", str.match('ll'));
+console.log("str.match('He') : ", str.startsWith('He'));
+console.log("str.match('lo') : ", str.endsWith('lo'));
+
+//string padding
+console.log("str.padStart(10,'*') : ", str.padStart(10,'*'));
+console.log("str.padStart(10) : ", str.padStart(10));
+console.log("str.padEnd(10,'#') : ", str.padEnd(10,'#'));
+console.log("str.padEnd(10) : ", str.padEnd(10));
+
+//substring(strart index)  , substring(strart index, end index)
+console.log("str.substring(1) : ", str.substring(1));
+console.log("str.substring(1,4) : ", str.substring(1,4));
+
+
+//slice(strart index)  , slice(strart index, end index)
+console.log("str.slice(1) : ", str.slice(1));
+console.log("str.slice(1,4) : ", str.slice(1,4));
+console.log("str.slice(-1) : ", str.slice(-1));
+console.log("str.slice(-1,-4) : ", str.slice(-3,-1));
+
+
+//get new string with replace characters. 
+console.log("str.replace('l','L') : ", str.replace('l','L'));
+console.log("str.replaceAll('l','L') : ", str.replaceAll('l','L'));
+
+console.log("str.includes('ll') : ", str.includes('ll'));
+console.log("str.repeat(2) : ", str.repeat(2));
+
+console.log("'   Hello  '.trim() : ", '   Hello  '.trim());
+console.log("'   Hello  '.trimStart() : ", '   Hello  '.trimStart());
+console.log("'   Hello  '.trimEnd() : ", '   Hello  '.trimEnd());
+
+
+//str.split(String seperator, limit)  for string convert into array
+var str =  "11-12-13-14-15";
+console.log("String : ", str);
+var values = str.split('-'); // convert string to array 
+console.log("str.split('-') :", values);
+var values = str.split('-',3); // convert string to array 
+console.log("str.split('-',3) :", values);
+
+var spl = 'ho-ho-ho'.split('-');
+console.log("'ho-ho-ho'.split('-') : ", spl);

006-Template_literal.js

@@ -0,0 +1,18 @@
+/*
+ * Author : Jaydatt Patel
+Template Literal :  `...text..${obj}..text..`
+Template literals are an alternative way of working with strings, which was introduced in the ES6 addition to the JavaScript language.
+
+ With template literals, an expression can be embedded in a placeholder. A placeholder is represented by ${}, with anything within the curly brackets treated as JavaScript and anything outside the brackets treated as a string 
+*/
+
+var greet = "Hello";
+var place = "World";
+console.log(greet + " " + place + " !");
+console.log(`${greet} ${place} !`) //display both variables using template literals
+
+var multi = `Hello
+World
+${2023}
+!`
+console.log(multi);