Find largest connected cells of value 1 or greater
You have a lot of global variables. Almost all of them, actually. I only see two var declarations, and those two are probably the ones that matter least (though all declarations matter - don't skip 'em).

You're lucky you're not calling functions with loops from inside other loops. Otherwise they'd both be using the same i variable, and things would get weird. Or rather, get broken.

So fix that first! Try running your code through jshint, for instance, to get some basic refactoring/bug checking.

Secondly, while I applaud striving for object-oriented JS, it seems overwrought in this case.

If the task is indeed to find cells with a 1 in them, and all other cells have a 0, then there's a shortcut to take. Since zero is false'y, and one is truth'y, they can pull double-duty as the visited flag: If a cell is zero, it's either been visited or is not worth visiting. In other words, we can ignore every cell that's false'y.

So if you just set cells to 0, false, or null along the way, they'll be ignored later on. Same effect as your visited, but without the need for instantiating objects.

As for recursion, that's definitely an option here. Here's one such implementation:

function largestGroup(matrix) {
  var counts = [0];

  // count connected cells, starting with cell i,j
  function countConnected(i, j) {
    if(matrix[i][j]) {
      matrix[i][j] = null;
      return neighborsOf(i, j).reduce(function (sum, coord) {
        return sum + countConnected(coord[0], coord[1]); // recursion
      }, 1);
    }
    return 0;
  }

  // get neighbor coordinates of i,j
  // (ignores those that are false'y)
  function neighborsOf(i, j) {
    return [
      [i-1, j], [i+1, j],     // up and down
      [i, j-1], [i, j+1],     // left and right
      [i-1, j-1], [i-1, j+1], // diagonally up
      [i+1, j-1], [i+1, j+1]  // diagonally down
    ].filter(function (coord) {
      // keep only those coordinates that match cells that
      // a) exist, and
      // b) contain something thruthy
      return matrix[coord[0]] &amp;&amp; matrix[coord[0]][coord[1]];
    });
  }

  // copy matrix to avoid modifying the original
  matrix = matrix.slice().map(function (row) {
    return row.slice();
  });

  // look for cells with something in 'em, and
  // start counting connected cells from there
  for(var i = 0 ; i &lt; matrix.length ; i++) {
    for(var j = 0 ; j &lt; matrix[i].length ; j++) {
      if(matrix[i][j]) {
        counts.push(countConnected(i, j));
      }
    }
  }

  return Math.max.apply(null, counts);
}


It starts by copying the matrix, since it's going to be modifying it, and we don't want to modify the input - other code may hold references to it. 

After that, it starts looping through its copy, looking for the first truth'y cell. It then calls countConnected with that cell's coordinates, which, in turn, calls itself on each neighboring cell that's of interest (i.e. not zero). Any cell that's visited gets set to null, which, like zero, is false'y. Thus visited cells are ignored.

Each truthy cell that's visited by countConnected will add 1 to the count; any false'y cells will add zero. And since cells are set to null the first time they're counted, they won't be counted twice.