spread, rest and symbol(basic)

coderzaman · coderzaman · commit 92293d029361 · 2024-10-04T12:26:48.000+06:00
diff --git a/22. ES6/index.html b/22. ES6/index.html
@@ -21,9 +21,14 @@
 
 <body>
 
-    <div class="container not_found"></div>
+
+
+
     <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/js/bootstrap.bundle.min.js"></script>
-    <script src="js/objectdestructing.js"></script>
+    <script src="js/symbol_op.js"></script>
+    <!-- <script src="js/rest_operator.js"></script> -->
+    <!-- <script src="js/spread_operator.js"></script> -->
+    <!-- <script src="js/objectdestructing.js"></script> -->
     <!-- <script src="js/arraydestructing.js"></script> -->
     <!-- <script src="js/templeteLiteral.js"></script> -->
     <!-- <script src="js/arrowFunction.js"></script> -->
diff --git a/22. ES6/js/rest_operator.js b/22. ES6/js/rest_operator.js
@@ -0,0 +1,36 @@
+// Rest Operator
+// In JavaScript, the rest operator (...) allows you to represent an indefinite number of arguments as an array. 
+
+numbers = [10, 20, 30, 40, 50, 60];
+
+var [num1, num2, num3] = numbers;
+console.log(num1, num2, num3);
+
+var [num1, num2, ...num3] = numbers;
+console.log(num1, num2, num3);
+
+
+// Use with Object 
+let person = {
+    name: 'John',
+    age: 34,
+    dob : '19-09-1998'
+}
+
+let {name, ...age} = person;
+console.log(name, age);
+
+// Use with function
+
+function sum(name, num2, ...num3) {
+        console.log(name, num2, num3);
+}
+
+sum("Abdullah", 10,30,34,33);
+// When we pass the arguments numbers function num3 parameters make an array to store the array
+sum(5, 7, numbers);
+// When we pass the arguments spread the array the when passed it separted to multiple numbers and ...num3 make it as an array and receive it as an array Like 
+// ... make it array to indvidual item like [numbers = 10,20,30,40,50,60]
+// sum function receives it as an array in ...num3 parameters
+
+sum(5, 7, ...numbers);
diff --git a/22. ES6/js/spread_operator.js b/22. ES6/js/spread_operator.js
@@ -0,0 +1,55 @@
+// Spread Operator 
+// The JavaScript spread operator (...) allows us to quickly copy all or part of an existing array or object into another array or object.
+// Split the array element or object make it to array or object or add array with another array
+
+let name = "Abu Huraria";
+name = [...name];
+console.log(name);
+
+name = {...name};
+console.log(name);
+
+
+// Concat Array
+let fruits1 = ["Apple", "Banana", "Cherry", "Date"];
+let fruits2 = ["Emblic", "fig", "Guava"];
+let fruits3 = ["Hog Plum", "Imbe"];
+let fruits4 = ["Jackfruit"];
+
+// It make array to two D arrays
+let fruits = [fruits1, fruits2, fruits3, fruits4];
+console.log(fruits);
+
+// but we need make arrays to concat with  one 
+fruits = [...fruits1, ...fruits2, ...fruits3, ...fruits4];
+console.log(fruits);
+
+// spread Object
+let person = {
+    name: "Abdullah",
+    occupation: "Student"
+}
+
+let person1 = {
+    name: "Abdur Rahman",
+    occupation: "Student"
+}
+
+
+let p3 = {...person1, dob:"22/12/1998"};
+console.log(p3);
+
+
+// Spread in function 
+let numbers = [1, 2, 30, 4, 5, 6, 7];
+// console.log(Math.max(numbers)); // none because it dose not work on array
+console.log(Math.max(...numbers));
+
+let fullName = ["Abdullah", "Abdur Rahman"];
+
+function fname(fname, lname){
+    console.log("Name:", fname, lname);
+}
+
+
+fname(...fullName);
diff --git a/22. ES6/js/symbol_op.js b/22. ES6/js/symbol_op.js
@@ -0,0 +1,31 @@
+// Symbol Operator 
+// In JavaScript, the Symbol is a built-in primitive data type introduced in ES6 (ECMAScript 2015). It represents a unique and immutable identifier, often used for creating properties on objects that are guaranteed to be unique, even if they have the same name as other properties.
+
+// Each symbol created using Symbol() is guaranteed to be unique. Even if two symbols have the same description, they are not the same.
+
+let sym1 = Symbol('foo');
+let sym2 = Symbol('foo');
+
+console.log(sym1 === sym2); // false
+
+// Symbols as Object Properties
+// Symbols are often used as unique property keys for objects. This prevents accidental overwriting of properties, as symbols are always unique.
+
+// Use Cases for Symbols
+// Unique Object Properties: You can use symbols to ensure that property keys are unique and won’t conflict with other properties.
+
+// Avoid Property Name Collisions: Symbols can prevent name collisions when adding properties to objects, especially when extending third-party libraries or built-in objects.
+
+// Iteration and Hidden Properties: Properties keyed by symbols are not enumerable in for...in loops or Object.keys(), so they can be used to create "hidden" properties.
+
+let obj = {
+    [Symbol('hidden')]: 'secret',
+    name: 'public'
+  };
+  
+  for (let key in obj) {
+    console.log(key); // logs 'name', but not the Symbol property
+  }
+let symbols = Object.getOwnPropertySymbols(obj);
+console.log(symbols); // [Symbol(hidden)]
+console.log(obj[symbols[0]]); // 'secret'
