Search in a two dimensional array and return the array list as a array

This:

var dataSet = new Array(new Array());

...is not a two-dimentional array. It results in an array with (initially) one element, which is a reference to another array with (initially) zero elements. The closest you'll come to a two-dimensional array in JavaScript is an array of arrays, such as:

function create2DArray(rows, columns) {
    var outer, index;

    outer = new Array(rows);
    for (index = 0; index < rows; ++index) {
        outer[index] = new Array(columns);
    }

    return outer;
}

Searching through such a thing is easy:

function find(thing, theArray) {
    var results, col, row, subArray;

    results = []; // Empty array
    for (row = 0; row < theArray.length; ++row) {
        subArray = theArray[row];
        for (col = 0; col < subArray.length; ++col) {
            value = subArray[col];
            if (value == thing) { // or whatever your criterion
                results.push({row: row, col: col});
            }
        }
    }

    return results;
}

That creates an array of objects, each with an col and row property, that tells you where the things in theArray are such that theArray[row][col] == thing.

Note that rather than doing theArray[row][col] every time in the loop, I grab the sub-array reference once for each row. Also note that since theoretically the sub-arrays could have different lengths, I don't assume they all have the same length.

I recommend reading up on JavaScript's arrays, which are fairly different from traditional arrays. They're really dictionaries, associative arrays, not contiguous blocks of memory indexed by an offset. When you do theArray[5], you're looking up a property called "5" on the array in exactly the way that when you say theObject['frog'] you're looking up a property "frog" on the object. (Not that implementations can't optimize that, but since JavaScript arrays are sparse, they have to be careful when doing so.)