Hey Clement, your deepEquals function also does not work on all cases because the Object.keys() array is not ordered. Therefore you could have the same object {a: 1, b: 2} and {b: 2, a: 1} throwing false. The only wall to deepEqual objects is to use a Set and compare the size to both the object's keys and then iterate the set.

Hey Clement, do I get the opportunity to have a mock interview with you on AlgoExpert?

@@PSSMPlay I actually wrote the same comment and later found out your comment here 😅. I think I am not the only one who was able to come up with that bug 😂

deepEquals utility function was fun to watch. Though there is a failing test case. { a: 1, b: 2 } === { b: 2, a: 1 } should return true. Instead of checking equality of key arrays, we can do the following - for (let i in value1keys) { if (!value2keys.includes(value1keys[i])) { return false; } }

Especially the 2nd one 😅

Does your deepEquals work with functions or classes?

Promises are usually more difficult for front-end devs because we only use (async await)

​@@red_boum but these are still promises under the hood.

ive been doing javascript react for 5 years and i still have same feeling as you

@@thalibmuhammad9519 Thanks for your reply , it is giving me a little ray of hope ! 😅 Maybe I'm still at a very early stage of learning JS. It'll take time ig 😄

@@red_boum that's true 😅

stay faithful brother keep up the work you'll get there.

don't worry google is notorious for hard coding interviews, you got this! Stay motivated

We are all gonna make it brah

did you do the blind75 on algoexpert or do you mean the blind75 leetcode questions AND the algoexpert questions is what helped you?

Where did you learn all of that 😃

@@howuseehim in a book I believe, that's a great source. Javascript does all sort of blind conversions on values to ease equal checking

Exactly! I also wanted to write a similar comment about wierdness of isNaN(). And that Number.isNaN() is much more reliable in that type of checks :) Searched for this comment to not duplicate and if here it is! 👍

@@howuseehim Probably in You don't know JS book

@@gardelin4793 thank you I will check it out

use bit operators

came here specifically to make these two points.

100% correct

The key order issue also caught my attention. The problem is, in JavaScript, key order is never guaranteed. The lodash isEqual function does not account for key order either. _.isEqual({ "a": 0, b: "1" }, { "b": 1 , "a": 0 }) returns true;

for #1 we can use hasOwnProperty method

About 1. Does the order really matter in objects? Two objects with exactly the same keys and same values for those keys behave exactly the same regardless of the order their properties were added. Is there a case where the order of keys is actually integral to a programs functionality? About 2. Totally agree.

agree!

thats what i thought too

JSON.stringify is sensitive to the order of properties in objects. If two objects have the same properties and values but in a different order, they will be considered unequal.

The problem is objects order can be all over the place, once you stringify it the order is locked and although two objects maybe equal the order isn't and returns false but its technically true.

was thinking the same with xor, but since he checked a === b before the || call, it doesn't matter to use xor or not

Depends on what your after, they are not the exact same object allocated on memory etc but they are equal.

I was thinking in some sort of binary check but not possible in JS, I think you are totally right!

if the order of elements in 2 objects are not same, then it would return false. Hence it wouldn't work ig. Correct me if I'm wrong

I think it produces the correct result, but in a tech interview it wouldn't be a good solution. The interviewers want to see you implement the algorithm and explain your thoughts, not take a short cut. You could obviously mention that this would be an easy solution as well. Additionally this solution will be quite inefficient for large objects, both CPU and memory wise.

@@vishmaychauhan2863 you are correct, unfortunately I can only come up with a far less elequant solution in that case 🙃 const isObject = obj => typeof obj === 'object' && !Array.isArray(obj) && obj !== null; const flattenObjectToArray = (obj, parent, flatObj = {}) => { Object.keys(obj).forEach(key => { let next = parent ? parent + '.' + key : key; if (typeof obj[key] === 'object') { flattenObjectToArray(obj[key], next, flatObj); } else { flatObj[next] = obj[key]; } }) return Object.entries(flatObj).sort(); } const flattenAndSortArray = arr => arr.flatMap(x => isObject(x) ? flattenObjectToArray(x) : [x]).sort(); const handleObjectType = (x) => isObject(x) ? flattenObjectToArray(x) : flattenAndSortArray(x); const deepCompare = (a, b) => { let typeofA = typeof a let typeofB = typeof b if (typeofA !== typeofB) return false; if(typeofA === "object") a = handleObjectType(a) if(typeofB === "object") b = handleObjectType(b) let aString = JSON.stringify(a, null, 2) let bString = JSON.stringify(b, null, 2) return aString === bString }

@@RodLewis1 there's nothing less elequant, if it works, it works lol.

Noobs. Functions aren't handled.

Just pay using card

If we are going down that route, might as well stringify both objects and return in one line

Looks like they've moved on to making people implement non-optimized browser functionality instead. Also silly, imo

3rd question was really stupid, basically using an anti pattern.

I would definitely say not junior, more like mid/senior