Update README.md

Author: rachleona

README.md

@@ -593,23 +593,30 @@ Firstly, we'll do the most simple check of ```a === b``` to avoid unnecessary co
 if(a === b) return true
 ```
 
-Then comes the interesting part! There are several data types we need to look out for: Objects, Arrays(which JS treats as an object), and Dates(which is also treated as an object!), thus all we have to do is check if both a and is type object. If not, we can just return false as they didn't pass the ```a === b``` test.
+Then comes the interesting part! There are several data types we need to look out for: Objects, Arrays(which JS treats as an object), and Dates(which is also treated as an object!), thus all we have to do is check if both a and b are of type object. If not, we can just return false as they didn't pass the ```a === b``` test.
 
 ```js if(typeof a === "object" && typeof b === "object")...```
 
-Next, we can process the dates first, as that doesn't require iteration. Make sure to compare ```Date.valueOf()``` instead of the date itself.
+Note that we use ```===``` here to differentiate between data types strictly.
+
+Next, we can process the dates first, as that doesn't require iteration. Make sure to compare ```Date.valueOf()``` instead of the date object itself.
 
 ```js if(a instanceof Date && b instanceof Date) return a.valueOf() === b.valueOf() ```
 
 Lastly, by taking the keys of the iterables we can compare the length of ```a``` and ```b```, then make use of built-in Array.some method to check if any values of the two iterables don't match.
 
 ```js
-const keysA = Object.keys(a)    //get keys/index of object/array
-if(keysA.length !== Object.keys(b).length) return false    //make sure a and b are same length
+//get keys/index of object/array a
+const keysA = Object.keys(a)
+
+//make sure a and b are the same length
+if(keysA.length !== Object.keys(b).length) return false
 
-//Array.some stops executing nested code the moment there is one different value 
-return !keysA.some( key => {   
-  return !deepCompare(a[key], b[key])    //run deepCompare recursively
+//Array.some() iterates through the values in an array and stops executing nested code until there is one that returns true
+//in this case that would be when there is one different value between a and b
+return !keysA.some( key => { 
+  //run deepCompare recursively
+  return !deepCompare(a[key], b[key])
 })
  ```
 
@@ -635,9 +642,18 @@ const deepCompare = (a, b) => {
   else return false
 }
 
-deepCompare(1, 2) //false
+deepCompare(1, 2) 
+//false
+
+deepCompare({"first": 1, "second": 2}, {"first": 1, "second": 2})
+//true
+
+deepCompare([1, "2", 3.0], [1, "2", 3])
+//false
+
 const arr = [1, 2, "3", [{4: "5", 6: 7}, 8.0, new Date(), undefined]]
-deepCompare(arr, [1, 2, "3", [{4: "5", 6: 7}, 8.0, new Date(), undefined]]) //true
+deepCompare(arr, [1, 2, "3", [{4: "5", 6: 7}, 8.0, new Date(), undefined]]) 
+//true
 
   ```