When using indexOf, it compares searchElement to elements of the Array strictly, just like the === operator.

To check if two objects are equal, you cannot use ===.

In a discussion on the matter, @RobG mentioned

Keep in mind that according to the definition, two objects are never equal unless they reference the same object, regardless of property names and values. You would use code only if both objectA and objectB point to the exact same object.

If you want to check for equality in objects, you can create a custom indexOf function.

function myIndexOf(obj) {    
    for (var i = 0; i < arr.length; i++) {
        if (arr[i].x == obj.x && arr[i].y == obj.y) {
            return i;
        }
    }
    return -1;
}

DEMO: http://jsfiddle.net/zQtML/

While discussing functions for searching within arrays, it's worth noting the built-in function Array.prototype.findIndex(). This particular function aligns perfectly with the author's requirements.

The findIndex() method is designed to identify the index of the first element in the array that meets the specified testing condition. If no such element is found, the method will return -1.

var array1 = [5, 12, 8, 130, 44];

function findFirstLargeNumber(element) {
  return element > 13;
}

console.log(array1.findIndex(findFirstLargeNumber));
// expected output: 3

In another scenario, the code might look like this:

arr.findIndex(function(element) {
 return element.x == 1 && element.y == 2;
});

An alternative using ES6 syntax would be:

arr.findIndex( element => element.x == 1 && element.y == 2 );

For further details and examples, visit: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex

It is important to remember that two objects are never equal, but their references can be if they point to the same object. In order to achieve the desired outcome in your code:

var a = {x:1, y:2};
var b = {x:3, y:4};
var arr = [a, b];

alert(arr.indexOf(a)); // 0

Edit

Below is a more versatile function called specialIndexOf. Note that this function assumes the values of objects are primitive; additional precautions must be taken for non-primitive values.

function specialIndexOf(arr, value) {
  var a;
  for (var i=0, iLen=arr.length; i<iLen; i++) {
    a = arr[i];

    if (a === value) return i;

    if (typeof a == 'object') {
      if (compareObj(arr[i], value)) {
        return i;
      }
    } else {
      // handle other data types
    }
  }
  return -1;

  // This function is simple and expects all enumerable properties of objects to be primitives.
  function compareObj(o1, o2, cease) {
    var p;

    if (typeof o1 == 'object' && typeof o2 == 'object') {

      for (p in o1) {
        if (o1[p] != o2[p]) return false; 
      }

      if (cease !== true) {
        compareObj(o2, o1, true);
      }

      return true;
    }
  }
}

var a = new String('fred');
var b = new String('fred');

var arr = [0,1,a];

alert(specialIndexOf(arr, b)); // 2

This method does not require any specialized code

let array, element, isFound;
array = [{x: 1, y: 2}];
element = {x: 1, y: 2};
isFound = JSON.stringify(array).indexOf(JSON.stringify(element)) > - 1;
// isFound === true

Please note: this approach does not return the exact index, it simply indicates whether your object exists within the current data structure

Those items are not identical.

You need to create your own custom function.

One possible way to do this is:

var position = -1;
items.forEach(function(val, ind) {
   if (this.a==val.a && this.b==val.b) position=ind;
}, target); 

where target represents an object of your choice (or something else).

(Personally, I would use a basic loop but foreach looks neater.)

When comparing two separate objects, it's important to note that they are not identical to each other based on the `===` comparison operator. The method `indexOf` also utilizes this strict equality check. Even using the `==` operator will show that they are not equivalent.

For instance:

var obj1 = {a: 1, b: 2};
var obj2 = {a: 1, b: 2};
console.log(obj1 === obj2);

The `===` and `==` operators specifically determine if the objects being compared refer to the exact same object in memory. They do not consider whether the objects have similar prototypes or properties.

Consider this alternative approach, where a compare function is included as an argument:

function findIndexInArray(ar, value, startIdx, comp) {

  if (!comp) {
    if (startIdx instanceof Function) {
      comp = startIdx;
      startIdx = 0;
    }
    else return ar.__origFindIndex(value, startIdx);
  }

  if (!startIdx) startIdx = 0;

  for (var i=startIdx ; i < ar.length ; i++) {
    if (comp(ar[i], value))
      return i;
  }
  return -1;
}

// Preserve original findIndex method to maintain default functionality
Array.prototype.__origFindIndex = Array.prototype.findIndex;

// Modify the Array.findIndex to accommodate a custom comparison function.
Array.prototype.findIndex = function(value, startIndex, comp) {
  return findIndexInArray(this, value, startIndex, comp);
}

You can utilize it in the following manner:

findIndexInArray(arr, {x:1, y:2}, function (a,b) {
 return a.x == b.x && a.y == b.y;
});

arr.findIndex({x:1, y:2}, function (a,b) {
 return a.x == b.x && a.y == b.y;
});

arr.findIndex({x:1, y:2}, 1, function (a,b) {
 return a.x == b.x && a.y == b.y;
});

An advantage of this method is that it will fall back to the original findIndex if no custom comparison function is provided.

[1,2,3,4].findIndex(3);

It seems like this particular answer may not have piqued your interest, but it offers a straightforward solution for those who are curious:

let coordinates = new Array(
    {x:1, y:2},
    {x:3, y:4}
);

coordinates.map(function(point) {
    return pointToString(point);
}).indexOf(pointToString({x:1, y:2}));

function pointToString(point) {
    return "(" + point.x + ", " + point.y + ")"
}