CODEWITHSUNDEEP
javascript
Dolwin Fernandes
Dolwin Fernandes

Reputation: 73

Understanding how javascript evaluates the OR operator

I'm currently studying Javascript Algorithms. Below is the algorithm im currently trying to learn/understand.

function same(arr1, arr2){
    if(arr1.length !== arr2.length){
        return false;
    }
    let frequencyCounter1 = {}
    let frequencyCounter2 = {}
    for(let val of arr1){
        frequencyCounter1[val] = (frequencyCounter1[val] || 0) +1
        console.log(frequencyCounter1);
    }
    for(let val of arr2){
        frequencyCounter2[val] = (frequencyCounter2[val] || 0) +1        
    }


    for(let key in frequencyCounter1){
        if(!(key ** 2 in frequencyCounter2)){
            return false
        }
        if(frequencyCounter2[key ** 2] !== frequencyCounter1[key]){
            return false
        }
    }
    return true
}

same([1,2,3,2,5], [9,1,4,4,11])

I understand the code, except for 1 line.

frequencyCounter1[val] = (frequencyCounter1[val] || 0) +1

So what this algo does, is it tries compares 2 arrays. If array b is equal to the square of each number is array a, then it should return true, else it will return false.

So in this example, it will return false

If i do [1,2,3,4,5] [1,4,9,16,25], it will return true

I know what this line does:

frequencyCounter1[val] = (frequencyCounter1[val] || 0) +1

It makes a key value pair, so say for the first iteration, it makes take in 1 as the key and then (frequencyCounter1[val] || 0) +1 as the value, now this value represents the number of a times a number appears in array so if 1 appears 10 times it'll have a key value pair 1:10

I understand this very clearly, just wanted to know how this statement is evaluated and whats happening behind the scenes?

(frequencyCounter1[val] || 0) +1

Upvotes: 4

Views: 397

Answers (2)

Opeyemi Ojo
Opeyemi Ojo

Reputation: 1

This code is very unique in the sense that it starts with the first value of the array and checks if it already exists. If it does not exist, it is undefined. undefined is compared with 0 using the || operator. If undefined the val becomes registered and becomes 1. Here we are basically setting the key:value pairs as seen in the below example

obj = {
  1:1,
  2:2,
  3:5
}

obj[3] = 7
console.log(obj);

If val already exist the the OR operator is ignored and 1 is added to val. This one-liner is very useful as a counter operation in javaScript and the big O for the code is O(N) which is better than writing a nested loop O(N^2) which is a common solution for such problem.

Upvotes: 0

Havenard
Havenard

Reputation: 27854

The idea is that if frequencyCounter1[val] is undefined it defaults to 0. undefined + 1 returns NaN and it wouldn't work as the programmer intended, so he uses || to workaround that problem without having to write additional lines of code.

In JavaScript the operator || doesn't return true or false as you would expect, it returns either the first element that would evaluates as true if it was converted to boolean, or default to the last element if none is found.

For example, (null || "" || undefined || false || NaN || "test" || 2) will return "test"

Upvotes: 5

Related Questions