feat: 🎸 added shallow copy and deep copy eg

Author: Pratham82

Important concepts/deepCopyShalowCopy.js

@@ -0,0 +1,40 @@
+// https://doesitmutate.xyz/
+/*
+A shallow copy of an object is a copy whose properties share the same references (point to the same underlying values) as those of the source object from which the copy was made. 
+
+As a result, when you change either the source or the copy, you may also cause the other object to change too.
+
+A shallow copy means that certain (sub-)values are still connected to the original variable.
+*/
+
+/*
+
+A deep copy means that all of the values of the new variable are copied and disconnected from the original variable. 
+*/
+
+const a = { a: 100 }
+const b = a // shallow copy i.e(mutates the source)
+const c = { ...a } // deep copy i.e(does not mutate the source)
+
+console.log(a === b) // true
+console.log(a == b) // true
+console.log(a == c) // false
+console.log(a === c) // false
+
+//* Nested objects
+
+const a1 = {
+  foods: {
+    dinner: 'Pasta',
+  },
+}
+let b1 = { ...a1 } // mutates a1
+// let b1 = structuredClone(a1) // does not mutates
+
+b1.foods.dinner = 'Soup' // changes for both objects
+console.log(b1.foods.dinner) // Soup
+console.log(a1.foods.dinner) // Soup
+
+//* How make deep copy of nested objects
+// const copy = JSON.parse(JSON.stringify(original))
+// const copy = structuredClone(original)

Important concepts/passByValuepassByReference.js

@@ -0,0 +1,69 @@
+/*
+Primitive values:
+
+These are the most basic values one can think of, which includes, undefined, null, boolean, string, and numbers. Primitive values are passed by value in javascript
+
+Whereas all objects (including functions) are passed by reference in javascript.
+*/
+
+/*
+Javascript pass by reference:
+In Pass by Reference, a function is called by directly passing the reference/address of the variable as the argument. Changing the argument inside the function affects the variable passed from outside the function. In Javascript objects and arrays are passed by reference.
+*/
+
+//javascript pass by reference
+function callByReference(varObj) {
+  console.log('Inside Call by Reference Method')
+
+  varObj.a = 100
+
+  console.log(varObj)
+}
+
+let myObj = {
+  a: 1,
+}
+
+console.log('Before Call by Reference Method')
+
+console.log({ myObj }) // { myObj: { a: 1 } }
+
+callByReference(myObj)
+
+console.log('After Call by Reference Method')
+
+console.log({ myObj }) // { myObj: { a: 100 } }
+
+/*
+
+In javascript pass by value, the function is called by directly passing the value of the variable as the argument. Therefore, even changing the argument inside the function doesn’t affect the variable passed from outside the function.
+
+It is important to note that in javascript, all function arguments are always passed by value. That is, JavaScript copies the values of the passing variables into arguments inside of the function.
+*/
+
+//javascript pass by value
+function square(x) {
+  x = x * x
+
+  return x
+}
+
+var y = 10
+
+var result = square(y)
+
+console.log(y) // 10 -- no change
+console.log(result) // 100
+
+//
+const arr = [1, 2, 3, 4]
+
+const updateArr = (arr, newValue) => arr.push(newValue) // Will mutate original array
+const updateArrWithoutMut = (arr, newValue) => [...arr].push(newValue) // Will not mutate original array
+
+console.log({ arr })
+
+// updateArr(arr, 10)
+updateArrWithoutMut(arr, 10)
+
+console.log({ arr })