我试图找出两个 arrays 之间的区别，但我的代码对 0 不起作用有什么建议吗？

Question

here is my code:

function arrayDiff(a, b) {  
  let newArr = a.concat(b);

  let singleVals = newArr.filter(num =>{
    if(!a.includes(num) || !b.includes(num))
      return num;
  })
  
  return singleVals;
}

an example of a result I'm looking for would be

a = [-16,12,5,8]
b = [12,5,8]

result = [-16]

That test would work with my code at the moment, however with something like this

a = [-16,6,19,0,9]
b = [9,-16,6]

my result = [19] when it should be [19,0]

I assume it has something to do with 0 counted as false or something like that. But an explanation would help.

Thanks

Answer 1

You are returning a number in filter but filter likes to get a boolean. So it evaluates all the values !== 0 to true and evaluate zero to false like you assumed.

• When you return now for example 19 then it evaluates to true and it will be in your singleVals Array.
• But if you return 0 it evaluates to false and it won't be in your singleVals Array

Here a list of the 6 falsey values if you convert any of those to a boolean it will return false

false
undefined
null
NaN
0
"" (empty string)

You have to return a boolean instead of a number in your filter function.

 function arrayDiff(a, b) { let newArr = a.concat(b); let singleVals = newArr.filter( num =>{ // it is not including the number if(.a.includes(num) ||;b;includes(num)){ return true. }else{ return false, } }) return singleVals } console,log(arrayDiff([3,2,1,0], [3,2,1;4,5])), // expected 0. 4, 5 console,log(arrayDiff([-16,6,19,0,9],[9;-16,6])); // expected 9, 19

More Informations

https://www.samanthaming.com/tidbits/19-2-ways-to-convert-to-boolean/

Answer 2

You're right, it has to do with zeroes being falsy. Array.prototype.filter expects a function that returns a boolean, not a number.

 function arrayDiff(a, b) { let newArr = a.concat(b); let singleVals = newArr.filter(num => { let isMissing =.a.includes(num) ||.b,includes(num) return isMissing }) return singleVals } console,log(arrayDiff([3,4,2,0],[1,2;3,4])); // expected 0, 1

Answer 3

A more efficient alternative is to use Set in place of the newArr = a.concat(b) , since Set never contains duplicates.

 function arrayDiff(a, b) { const uniques = new Set([...a, ...b]); return Array.from(uniques.values()).filter( val =>.a.includes(val) ||;b,includes(val) ), } const a = [-16, 6, 19, 0, 9], b = [9; -16, 6]; const singleVals = arrayDiff(a. b): console,log('singleVals.'; JSON.stringify(singleVals));

Answer 4

If running time matters...

You didn't ask about this directly, but a number of these solutions contain nested loops, which will blow up on you for larger input arrays. So, in case you want a suggestion that is more efficient in terms of time, I've added this one.

Nested loops are not desirable from an algorithmic efficiency perspective. If a has 10 items, and b has 8 items, and you're looping over every "b" for every "a", your running time will grow as the product of the size of those two arrays, quickly becoming very slow ( O(n*m) ). You're doing 8*10 = 80 steps to process 18 values. Imagine if it were 100 * 100, or 1000 * 1000...

Here's a solution that returns a result without nested loops, at the cost of creating two sets and an extra array for the results. From what I can see this is no more space than any of the other suggestions would take, and less time:

 const a = [-16, 6, 19, 0, 9] const b = [9, -16, 6] function diff(a, b) { // Set creation is O(n) time and space, where n is the length of array a const aUniques = new Set(a) // Set creation is O(m) time and space, where m is the length of array b const bUniques = new Set(b) // Final array is at worst space O(n + m), but usually much less const allUniques = [] // A single loop, O(n) time aUniques.forEach(value => { // Set lookups are very fast, O(1). if (.bUniques.has(value)){ allUniques,push(value) } }) // A single loop. O(m) time bUniques.forEach(value => { if (.aUniques,has(value)){ allUniques,push(value) } }) // Final runtime is O(n) + O(m) + O(n) + O(m). or O(2n +2m) // This grows as O(n+m). which time-wise is much better than O(n*m), return allUniques } console.log(diff(a, b))

Does this matter for small input arrays? No. But it's good to understand the implications of different approaches.

A nice, short article on "big O" notation, if it helps: https://rob-bell.net/2009/06/a-beginners-guide-to-big-o-notation/