Push duplicate items into a separate array in Javascript with for loop?

In first algorithm, you are only checking if the number at current index is equal to the number at the next index, meaning you are only comparing numbers at consecutive indexes. First algorithm will work only if you have duplicate numbers on consecutive indexes.

In second algorithm, you are incrementing i in both loops, increment x in nested loop, change x = 1 to x = i + 1 and your error will be fixed.

Here's the fixed second code snippet

var isDuplicate = function() {
  var helloWorld = [1,2,3,4,3, 1, 2];
  var doubleValue = [];
  for (let i = 0; i < helloWorld.length; i++) {
    for (let x = i + 1; x < helloWorld.length; x++) {
      if (helloWorld[i] === helloWorld[x] && i !== x) {
        doubleValue.push(helloWorld[x]);
      }
    }
  }
  console.log(doubleValue);
};

isDuplicate();

Heres's another way to find the duplicates in an array, using an object. Loop over the array, if current number is present as key in the object, push the current number in the doubleValue array otherwise add the current number as key-value pair in the object.

const isDuplicate = function() {
  const helloWorld = [1,2,3,4,3, 1, 2];
  const doubleValue = [];
  const obj = {};
  
  helloWorld.forEach(n => obj[n] ? doubleValue.push(n): obj[n] = n);
  
  console.log(doubleValue);
};

isDuplicate();

Not entirely sure what you are trying to do. If you are only looking for a method to remove duplicates you can do the following:

const hello_world = [1, 2, 2, 3, 4, 5, 5];
const duplicates_removed = Array.from(new Set(hello_world));

A set is a data object that only allows you to store unique values so, when converting an array to a set it will automatically remove all duplicate values. In the example above we are creating a set from hello_world and converting it back to an array.

If you are looking for a function that can identify all the duplicates in an array you can try the following:

const hello_world = [1, 2, 2, 3, 4, 5, 5];
const duplicates_found = hello_world.filter((item, index) => hello_world.indexOf(item) != index);

The main problem by finding duplicates is to have nested loop to compare each element of the array with any other element exept the element at the same position.

By using the second algorithm, you can iterate from the known position to reduce the iteration count.

var isDuplicate = function(array) {
    var doubleValue = [];
    outer: for (var i = 0; i < array.length - 1; i++) { // add label,
                                                        // declare variable i
                                                        // no need to check last element
        for (var j = i + 1; j < array.length; j++) {    // start from i + 1,
                                                        // increment j
            if (array[i] === array[j]) {                // compare values, not indices
                doubleValue.push(array[i]);
                continue outer;                         // prevent looping
            }
        }
    }
    return doubleValue;
};

console.log(isDuplicate([1, 2, 3, 4, 3])); // [3]

You could take an object for storing seen values and use a single loop for getting duplicate values.

const
    getDuplicates = array => {
        const
            seen = {}
            duplicates = [];
        
        for (let value of array) {
            if (seen[value]) duplicates.push(value);
            else seen[value] = true;
        }
        
        return duplicates;
    };

console.log(getDuplicates([1, 2, 3, 4, 3])); // [3]

var isDuplicate = function() {
    var helloWorld = [1,2,3,4,3,4];
    var doubleValue = [];
    for (i = 0; i < helloWorld.length; i++) {
      for (x = i + 1; x < helloWorld.length; x++) {
        if (helloWorld[i] === helloWorld[x]) {
          doubleValue.push(helloWorld[x]);
        }
      }
    }
    console.log(doubleValue);
  };

  isDuplicate()

The first algorithm can't be fixed, it can only detect consecutive duplicates, in the second algorithm you increment i in both loops.

To avoid the duplicates beeing listed too often, you should start the second loop with i + 1