Add files via upload

Author: jaydattpatel

021-Spread_and_Rest_Operator.js

@@ -0,0 +1,77 @@
+/*
+ * Author : Jaydatt Patel
+spread and rest operator : (...array) or (...array[size_limit])
+
+In Javascript, both the spread operator and rest parameter have the same syntax which is three dots(...). Even though they have the same syntax they differ in functions.
+
+Spread operator: The spread operator helps us expand an iterable such as an array where multiple arguments are needed, it also helps to expand the object expressions. In cases where we require all the elements of an iterable or object to help us achieve a task, we use a spread operator.
+spread operator used to:
+- Add new members to arrays without using the push() method,
+- Convert a string to an array and
+- Copy either an object or an array into a separate object 
+
+Rest operator: The rest parameter is converse to the spread operator. while the spread operator expands elements of an iterable, the rest operator compresses them. It collects several elements. In functions when we require to pass arguments but were not sure how many we have to pass, the rest parameter makes it easier. 
+
+*/
+console.log("---------0--------");
+const greeting = "Hello";
+const arrayOfChars = [...greeting];
+console.log(arrayOfChars); //  ['H', 'e', 'l', 'l', 'o']
+
+console.log("---------1--------");
+const fruits = ['apple', 'pear', 'plum']
+const berries = ['blueberry', 'strawberry']
+const fruitsAndBerries = [...fruits, ...berries] // concatenate
+console.log(fruitsAndBerries); // outputs a single array
+
+console.log("---------2--------");
+const flying = { wings: 2 }
+const car = { wheels: 4 }
+const flyingCar = {...flying, ...car} // concatenate
+console.log(flyingCar) // {wings: 2, wheels: 4}
+
+console.log("---------3--------");
+let veggies = ['onion', 'parsley'];
+veggies = [...veggies, 'carrot', 'beetroot'];
+console.log(veggies);
+
+console.log("---------4--------");
+const car1 = {
+    speed: 200,
+    color: 'yellow'
+}
+const car2 = {...car1}
+car1.speed = 201
+console.log('car1: ', car1.speed,', car2: ', car2.speed)
+
+console.log("---------5--------");
+let obj = {
+    key: 1,
+    value: 4
+};
+let output = { ...obj };
+output.value -= obj.key;
+console.log(output.value);
+
+console.log("---------6--------");
+function count(...basket) {
+    console.log(basket.length)
+}
+count(10, 9, 8, 7, 6);
+
+console.log("---------7--------");
+const myNames = ["Amit", "Rahul"];
+const bio = { ...myNames, runs: "codes.com" };
+console.log(bio);
+// { '0': 'Amit', '1': 'Rahul', runs: 'codes.com' }
+
+//rest operator example
+console.log("---------8--------");
+function average(...args) {
+    console.log(args);
+    var avg =
+        args.reduce(function (a, b) {return a + b;}, 0) / args.length;
+    return avg;
+}
+console.log("average of numbers is : " + average(1, 2, 3, 4, 5));
+console.log("average of numbers is : " + average(1, 2, 3));

022-Objects.js

@@ -0,0 +1,134 @@
+/*
+ * Author : Jaydatt Patel
+Object literals and the dot notation
+One of the most common ways of building an object in JavaScript is using the object literal syntax: {}.
+
+*/
+
+console.log("--------Method-1---------");
+var student = {}; //create an object
+student.id  = 123; 
+student.name  = "Rahul";
+student.degree  = "BCA";
+student.subjects =  ["C","C++","JAVA","Python"];
+student.printdata = function() //add function in objects
+    {     
+        console.log(this);
+    };
+student.getdata = function() //add function in objects
+    {     
+        console.log(this.id,this.name,this.degree,this.subjects );
+    };
+
+student.printdata();
+student.getdata();
+
+
+console.log("--------Method-2---------");
+var address = {
+    city: "Jaipur",
+    pincode: 123456,
+    state: "Rajasthan",
+    contry: "India",
+    show : function(){
+        console.log(this.city,this.pincode,this.state,this.contry);
+    } 
+}
+address.show();
+console.log(address.city)
+address.city = "Ajmer";
+console.log(address)
+
+/*
+Object literals and the brackets notation. There is an alternative syntax to the dot notation I used up until this point. This alternative syntax is known as the brackets notation.
+*/
+console.log("--------Method-3---------");
+var house = {};
+house["rooms"] = 4;
+house['color'] = "pink";
+house["price"] = 12345;
+console.log(house); 
+
+console.log("--------Method-4---------");
+var Keys = ['speed', 'altitude', 'color'];
+var drone = {
+    speed: 100,
+    altitude: 200,
+    color: "red"
+}
+for (const k of Keys) {
+    console.log(k,'-',drone[k])
+}
+
+console.log("--------constructor-Method-5---------");
+//constructor functions for the built-in objects, I can also define custom constructor functions.  (looks like class) same as above. No return type is required and it is optional..
+function Icecream(product) {
+    this.flavor = product;
+    this.melt = function() {
+        console.log(`The ${this.flavor} icecream has melted`);
+    }
+}
+let kiwi_Icecream = new Icecream("kiwi");
+let apple_Icecream = new Icecream("apple");
+kiwi_Icecream.melt(); 
+apple_Icecream.melt(); 
+
+console.log("-------constructor-Method-6---------"); 
+//constructor functions for the built-in objects, I can also define custom constructor functions. (looks like class) same as above. No return type is required and it is optional..
+function createPerson(name) {
+    const obj = {};
+    obj.name = name;
+    obj.introduceSelf = function () {
+      console.log(`Hi! I'm ${this.name}.`);
+    };
+    return obj;
+  }
+
+const person = createPerson("Alex");
+person.name;
+person.introduceSelf();
+
+
+console.log("--------Method-8---------");
+// access target value by nesting keys of passed array of keys.    
+const userProfile = {
+    name: "John Doe",
+    email: "john.doe@example.com",
+    address: {
+      city: "New York",
+      street: "123 Main St",
+      zipCode: "10001"
+    }
+};
+
+// access target value by nesting keys of passed array of keys.       
+function getUserDetail(profile, keys) {
+    let obj = profile;
+    for(let key of keys){
+        obj = obj[key];
+    }
+    return (obj != undefined) ? obj : 'Not available';
+  }
+  
+console.log(getUserDetail(userProfile, ["address", "city"]));
+console.log(getUserDetail(userProfile, ["address", "block"]));
+
+
+//create new object from old object using prototype inheritance
+console.log("--------Method-8---------");
+var o1 = {}
+o1.obj1 = "Object-1";
+console.log("Object.getPrototypeOf(o1) :",Object.getPrototypeOf(o1));
+
+var o2 = Object.create(o1); //create new obj with prototypes of old objects
+o2.obj2 = "Object-2";
+console.log("Object.getPrototypeOf(o2) :",Object.getPrototypeOf(o2));
+
+var o3 = Object.create(o2);
+o3.obj3 = "Object-3";
+console.log("Object.getPrototypeOf(o3) :",Object.getPrototypeOf(o3));
+
+console.log("o3.obj1 :",o3.obj1); 
+console.log("o3.obj2 :",o3.obj2); 
+console.log("o3.obj3 :",o3.obj3); 
+

023-Objects-functions.js

@@ -0,0 +1,89 @@
+/*
+ * Author : Jaydatt Patel
+Built-in methods: Object.keys(obj), Object.values(obj), and Object.entries(obj).
+
+- Object.keys(obj) : return an array list of properties
+- Object.values(obj) :  returns an array list values. 
+- Object.entries(obj) : returns an array listing both the keys and the values. 
+- Object.assign(target, source1, source2, …, sourceN) : update or overwrite object Properties from other object 
+- Object.create(obj) : to create new object by inheriting object prototyps
+- Object.freeze(obj) : to create new object by static method freezes an object. Freezing an object prevents extensions and makes existing properties non-writable and non-configurable. A frozen object can no longer be changed: new properties cannot be added, existing properties cannot be removed, their enumerability, configurability, writability, or value cannot be changed, and the object's prototype
+- Object.getPrototypeOf(obj): to get the properties of object
+- Object.setPrototypeOf(target, source) :  to set the properties of object
+- Object.hasOwn(obj, property) : check property exist or not
+
+*/
+
+
+console.log("-----------------");
+const target = { a: 1, b: 2 };
+const source = { b: 4, c: 5 };
+const returnedTarget = Object.assign(target, source);
+console.log(target);
+console.log(returnedTarget);
+console.log(returnedTarget === target);
+console.log(returnedTarget == target);
+
+console.log("-----------------");
+// copy object using  Object.assign() Method
+var obj = { k :'world'}
+var copy = Object.assign({}, obj)
+console.log(obj);
+console.log(copy === obj);
+console.log(copy == obj);
+
+console.log("-----------------");
+// copy object using Spread Method 
+var obj = { k :'hello'}
+var copy = { ...obj }
+console.log(obj);
+console.log(copy === obj);
+console.log(copy == obj);
+
+console.log("-----------------");
+const car2 = {
+    speed: 200,
+    color: "red"
+}
+console.log(Object.keys(car2));
+console.log(Object.values(car2)); 
+console.log(Object.entries(car2));
+
+console.log("-----------------");
+function testBracketsDynamicAccess() {
+    var dynamicKey;
+    if(Math.random() > 0.5) {
+      dynamicKey = "speed";
+    }
+    else{
+       dynamicKey = "color";
+    }
+    var drone = {
+        speed: 15,
+        color: "orange"
+    }
+  
+    console.log("drone[dynamicKey] : ",drone[dynamicKey]);
+}
+testBracketsDynamicAccess();
+
+
+//create new object from old object using prototype inheritance
+console.log("---------------------------");
+var o1 = {}
+o1.obj1 = "Object-1";
+console.log('o1.obj1 : ',o1.obj1);
+console.log("Object.getPrototypeOf(o1) :",Object.getPrototypeOf(o1));
+
+var o2 = Object.create(o1); //create new obj with prototypes of old objects
+o2.obj2 = "Object-2";
+console.log('o2.obj1 : ',o2.obj1);
+console.log('o2.obj2 : ',o2.obj2);
+console.log("Object.getPrototypeOf(o2) :",Object.getPrototypeOf(o2));
+
+var o3 = Object.create(o2);
+o3.obj3 = "Object-3";
+console.log('o3.obj1 : ',o3.obj1);
+console.log('o3.obj2 : ',o3.obj2);
+console.log('o3.obj3 : ',o3.obj3);
+console.log("Object.getPrototypeOf(o3) :",Object.getPrototypeOf(o3));

024-Destruct_array_and_object.js

@@ -0,0 +1,86 @@
+/* 
+ * Author : Jaydatt Patel
+Destructur the array or object property and copy them in other variable or object without affecting original data.
+*/
+console.log("--------------Destructure Array-------");
+
+console.log("-----------1-----------");
+const meal = ["soup", "steak", "ice cream"]
+let [starter] = meal;
+console.log(starter);
+
+console.log("-----------2-----------");
+const fruits = ['Apple','Mango','Kiwi','Berry','banana','lichi'];
+// skip elements by adding comma
+var [a, , , k] = fruits;
+console.log('[a, , , k]');
+console.log('a :', a,', k :',k);
+  
+var [a, m, ...arr] = fruits;
+console.log('\n[a, m, ...arr]');
+console.log('a :',a,', m: ', m,', arr :',arr);
+
+var [a, m, ...[, be, ba]] = fruits;
+console.log('\n[a, m, [ , be, ba]]');
+console.log('a :',a,', m: ', m,', be :',be,', ba : ', ba);
+
+console.log("-----------3-----------");
+
+let nestedArray = ["orange", ["apple", "banana", ["grape", "mango"]], "peach"]; let [first, [ , ,[third]]] = nestedArray;
+console.log('\n[first, [ , ,[third]]]');
+console.log('first :',first,', third: ', third);
+
+console.log("--------------Destructure Object-------");
+
+var student = {}; //create an object
+student.id  = 123;
+student.name  = "Rahul";
+student.degree  = "BCA";
+student.subjects =  ["C","C++","JAVA","Python"];
+student.printdata = function() //add function in objects
+    {
+        console.log(student);
+    };
+student.getdata = function() //add function in objects
+    {     
+        console.log(this.id,this.name,this.degree,this.subjects );
+    };
+
+//get copy value of id property of student
+console.log("-----------1-----------");
+console.log((id === student.id)); // check the same property 
+var {id} = student; //copy value of id from student obj if not found then undefined 
+console.log(id);
+console.log((id === student.id));
+
+//get values of multiple properties of object in local variable 
+console.log("-----------2-----------");
+
+var {id,name,subjects,xyz} = student; //copy from student obj if not found then undefined 
+console.log('id :', id);
+console.log('name :', name);
+console.log('subjects :', subjects);
+console.log('xyz :', xyz);
+
+//get values of multiple properties of object in local variable 
+console.log("-----------3-----------");
+var {id : roll, name : nm , subjects : sub} = student; //copy from student obj if not found then undefined 
+console.log('roll :', roll);
+console.log('nm :', nm);
+console.log('sub :', sub);
+console.log((roll === student.id)); // check the same property 
+
+//get copy of multiple property of object in new variable name
+console.log("-----------4-----------");
+var num, fullname, dg;
+({id : num, name : fullname , degree : dg} = student); //copy from student obj if not found then undefined 
+console.log('num :', num);
+console.log('fullname :', fullname);
+console.log('dg :', dg);
+
+//try to copy unkonwn property 
+console.log("-----------5-----------");
+console.log((pop === student.id)); // check the same property 
+var {pop} = student; //copy pop from student obj if not found then undefined 
+console.log(pop);
+console.log((pop === student.id));