Awesome code snippet

for(let i = 0; i < array.length; i++){
    if(array[i][0] == a && array[i][1] == b){
        isFound = true;
    }
}

A bit of a workaround solution, but it gets the job done efficiently

Just a quick tip to add to your knowledge!

Consider using Lodash for this task

This approach allows you to find the position of a specific value within a 2D array.

let arr = [ [ 'bird' ], [ 'cat' ], [ 'dog' ], [ 'cow' ], [ 'bird' ] ];
let index = _.findIndex(arr, function(element) { return element[0] == 'cow'; });
console.log(index);//output will be 3

Remember, utilizing nested loops is essential when working with multidimensional arrays.

Efficient solution utilizing array.find()

let numbers = [[2,3],[5,8],[1,1],[0,9],[5,7]];
const checkDuplicate = (num1, num2) => {
   numbers.find(item => JSON.stringify(item) === JSON.stringify([num1,num2])) === undefined ? numbers.push([num1,num2]) : null;
}

console.log(checkDuplicate(2,3)) /* Result: No change in the array */
console.log(checkDuplicate(1,2)) /* Result: New item added to the array */
console.log(numbers) /* Result: Updated array to reflect changes */

In order to handle a two-dimensional Array, it becomes necessary to utilize a nested for loop.

let newArray = [3, 4],
    count;


for ( let i = 0; i < mainArray.length; i++ ) {

    for ( let x = 0; x = mainArray[i].length; x++ ) {

        if ( mainArray[i][x] === newArray[x] {

             count++ 
        }

        if (count === 2) {
            alert('New coordinate detected!')
        }
    }
    //reset counter
    count = 0;
}

Check out this ingenious solution using a prototype that allows you to search for elements in 2D arrays similar to how indexOf works. Simply use it like this: arr.indexOf2d([2,3]);

var arr = [[2,3],[5,8],[1,1],[0,9],[5,7]];

Array.prototype.indexOf2d = function(item) {
    // Convert previous coordinates to strings in the format "x|y"
    var arrCoords = JSON.stringify(this.map(function(a){return a[0] + "|" + a[1]}));

    // Use indexOf to find the item converted to a string in the format "x|y"
    return arrCoords.indexOf(item[0] + "|" + item[1]) !== -1;
}

arr.indexOf2d([2,3]); // true
arr.indexOf2d([1,1]); // true
arr.indexOf2d([6,1]); // false

Below is the code I have implemented:

findIndexInArray(arr: any[], searchArr: any[]): number{
  let index = -1;
  arr.some((element, i)=> {
    if(JSON.stringify(element) === JSON.stringify(searchArr)) {
      index = i;
      return true;
    }
  });
  return index;
}

In this function, arr represents the main array where we are looking for the index and searchArr is the array whose index we want to find.

Important Note: This function will only return the index of the first occurrence of searchArr within the arr.

Another response mentioned:

Using indexOf for complex arrays is not advisable (unless you convert it to strings for serialization)...

Here's a method to do just that. Keep in mind, if your dataset is very large, this technique may not be the best choice as it creates a duplicate of your 2D array. However, for smaller sets, it works well.

To flatten array elements consistently, you can use the following function:

// Convert array into a string with a specific separator.
function stringle( arr ) {
  return arr.join(' |-| ');
}

Although unnecessary for simple integer sub-arrays like in your example, this approach accommodates more complex data types. By using a unique separator, it prevents ambiguity when handling comma-containing string elements, for instance.

Next, transform the target array into an array of strings:

// Transform arr into a String[] for use with indexOf()
var arrSearch = arr.map(function(row) { return stringle(row); });

You can then utilize Array.indexOf() (or other array methods) to check for matches or their positions.

if (arrSearch.indexOf( stringle(newArray) ) === -1) ...

This code snippet demonstrates the process with various data types included.

// Initial array example
var arr = [[2,3],[5,8],[1,1],[0,9],[5,7]];

// Convert array into a string with a specific separator.
function stringle( arr ) {
  return arr.join(' |-| ');
}

snippet.log("arr: "+JSON.stringify(arr));

// Transform arr into a String[] for use with indexOf()
var arrSearch = arr.map(function(row) { return stringle(row); });

snippet.log("arrSearch: "+JSON.stringify(arrSearch));

var tests = [[0, 9],[1, 2],["pig","cow"],[0,9,"unicorn"],["pig","cow"]];

for (var test in tests) {
  var str = stringle(tests[test]);
  if (arrSearch.indexOf(str) === -1) {
    arr.push(tests[test]);
    arrSearch.push(str);
    snippet.log("Added "+JSON.stringify(tests[test]));
  }
  else {
    snippet.log("Already had "+JSON.stringify(tests[test]));
  }
}

snippet.log("Result: "+JSON.stringify(arr));

<!-- Provides the `snippet` object, see http://meta.stackexchange.com/a/242144/134069 -->
<script src="http://tjcrowder.github.io/simple-snippets-console/snippet.js"></script>

This technique can be utilized:

function checkArrayItem(array , item) {
    for ( var i = 0; i < array.length; i++ ) {
        if(JSON.stringify(array[i]) == JSON.stringify(item)){
            return true;
        }
    }
    return false;
}

Exciting ES2020 Update!

If you're ready to embrace ES2020, get ready for the game-changing ?. operator (optional chaining operator). It's a real game-changer for working with 2D arrays:

const arr = [[1,2],[3,4]];

if ( ! arr[5]?.[6] ) {
  console.log("Index out of bounds");
}

if ( arr[0]?.[0] ) {
  console.log("Index in bounds");
}

When using the optional chaining operator to access properties of anything that is `undefined`, it will simply evaluate to `undefined` instead of throwing errors like `Cannot read property 'foo' of 'undefined'`.

Helpful Resources

• MDN Documentation
• GitHub Overview
• All the nitty-gritty details from tc39

How to Find the Index of an Element in a 2D Array Using Array Method:

If you want to find the index of an element in a 2D array, you can use a custom method by iterating through the array layers and checking with indexOf(). This method is similar to indexOf(), but it is designed specifically for 2D arrays without the need for specifying a starting index:

Array.prototype.twoDIndexOf = function(element){
  if (this === null || this === undefined)
    throw TypeError("Array.prototype.indexOf called on null or undefined")
  for(let i = 0; i < this.length; i++){
    const curr = this[i]
    if(curr.includes(element))
      return [i, curr.indexOf(element)];
  }
  return -1;
}


const exampleArray = [
  ['1', '2', '3'],
  ['4', '5', '6'],
  ['7', '8', '9'],
  ['', '0', ''],
]

console.log(exampleArray.twoDIndexOf('7')); // [2, 0]
console.log(exampleArray.twoDIndexOf('6')); // [1, 2]
console.log(exampleArray.twoDIndexOf('')); // [3, 0]
console.log(exampleArray.twoDIndexOf('x')); // -1

Keep in mind that this method will return the index of the first occurrence of the element. If the element appears multiple times in the same array, only the first position will be returned.

If you're looking to efficiently find the index of a specific subarray in a two-dimensional array, you can utilize the "findIndexIn2dArray" one-liner function:

var arr = [[2,3],[5,8],[1,1],[0,9],[5,7]];
var pos = [0,9];


const findIndexIn2dArray = (array, search) => array.findIndex((n) => n.every((e, i) => search[i] !== undefined && search[i] === e));

const x = findIndexIn2dArray(arr, pos);

console.log(x);

This function operates by utilizing the findIndex method on the given array parameter. It then searches for the initial subarray that meets the specified condition within the received callback function.

The callback function implemented in findIndex takes 'n' as a parameter, representing each subarray contained in the array.

For every subarray 'n', the every method is invoked to check if every element in the subarray fulfills the conditions set within the callback function.

The callback function integrated into every accepts two parameters: 'e', denoting each element in the subarray, and 'i', indicating the element's index within the subarray.

This callback function verifies whether the 'i-th' element in the search array has a defined value and matches the 'i-th' element in the 'n' subarray. If these conditions are met for all elements in the subarray, the every method will return true.

If a subarray 'n' satisfies the criteria, the findIndex method will return the corresponding index within the array. Alternatively, if no subarrays meet the search criteria, the findIndex method will return -1.

In essence, this function serves as an effective tool for pinpointing the index of a particular subarray within a two-dimensional array based on the contents of said subarray.