The syntax for the lastIndexOf is:

string.lastIndexOf(searchValue[, fromIndex])

where fromIndex is optional and represents the index from which to start looking. However, the search is performed backwards, so starting from position 3 in your example would be searching through string "This";

You can map into an array of booleans:

    var lastIndex =sample.map(s => 
  s.id === 0).lastIndexOf(true);

then access your array by last index:

console.log(sample[lastIndex]);

You're misinterpreting .indexOf(). indexOf returns the first index at which a given element can be found in the array, or -1 if it is not present. So index would be the index of the counter in counters. In short, you're comparing an object (counter) to a number (index).

That said, it also depends on how you're searching for the object in the array. If trying to find an object which matches a certain key/value structure, .indexOf won't work for the reason you mentioned. As pointed out by Gabriele, if searching using a reference, it will work.

If using a reference isn't an option, as an alternative you could use .findIndex(), or .map(), and find the object based on one of its properties, like id.

const counters = [{id: 1, value: 0}, {id: 2, value: 0}, {id: 3, value: 0}, {id: 4, value: 0}];

const findBySameness = {id: 3, value: 0};
const findByRef = counters[2];

const indexBySameness = counters.indexOf(findBySameness);
console.log('Index by sameness: ', indexBySameness); // Do not find the object index
const indexByRef = counters.indexOf(findByRef);
console.log('Index by reference: ', indexByRef); // Found the object index

// If a reference to the object is not available you can use the following methods

// With .findIndex
const index3 = counters.findIndex(item => item.id === findBySameness.id)
console.log('Index: ', index3); // Found the object index

// With .map
const index2 = counters.map(item => item.id).indexOf(findBySameness.id);
console.log('Index: ', index2); // Found the object index

There are many ways to achieve it.

All depends on Your "creativity".

I'll write 3 of them:

1) Straight looping until last match:

const lastIndexOf = (haystack, needle) => {
  let index = -1;
  haystack.forEach(function(element, i) {
    if (element === needle) index = i;
  });
  return index;
}


let fruits = ['apple', 'mango', 'pear', 'strawberry', 'bananas', 'mango', 'cherry']

console.log('Index of:', fruits.indexOf('mango')); 
console.log('Last Index of:', lastIndexOf(fruits, 'mango'));
console.log('Last Index of:', lastIndexOf(fruits, 'potato'));

console.log(lastIndexOf([ 0, 1, 4, 1, 2 ], 1), "=?", 3);

2) Looping using -1 step and stopping at first match:

const lastIndexOf = (haystack, needle) => {
  for (let i = haystack.length -1; i >= 0; i--) {
    if (haystack[i] === needle) return i;
  }
  return -1;
}


let fruits = ['apple', 'mango', 'pear', 'strawberry', 'bananas', 'mango', 'cherry']

console.log('Index of:', fruits.indexOf('mango')); 
console.log('Last Index of:', lastIndexOf(fruits, 'mango'));
console.log('Last Index of:', lastIndexOf(fruits, 'potato'));

console.log(lastIndexOf([ 0, 1, 4, 1, 2 ], 1), "=?", 3);

3) Reverse sorting + "length math":

const lastIndexOf = (haystack, needle) => {
  const rIndex = haystack.reverse().indexOf(needle);
  return (rIndex > -1) ? haystack.length - rIndex - 1 : -1;
}


let fruits = ['apple', 'mango', 'pear', 'strawberry', 'bananas', 'mango', 'cherry']

console.log('Index of:', fruits.indexOf('mango')); 
console.log('Last Index of:', lastIndexOf(fruits, 'mango'));
console.log('Last Index of:', lastIndexOf(fruits, 'potato'));

console.log(lastIndexOf([ 0, 1, 4, 1, 2 ], 1), "=?", 3);

P.S. In case of very big arrays these 3 methods can be less optimal, since You cannot predict the value You're looking for is near to end or beginning of array.

So for such cases You can inspire from binary tree algorithm.

Everything depends on complexity of task.

Objects are only equal to each other if they refer to the exact same instance of the object. If you pass the reference of object in the array to indexOf function, it will find the index by comparing reference but if you pass new object, it wont compare each key of the object to find the index of of object in the array. For your second example, try this and see it will work:

const state = {
  counters: [
    { id: 1, value: 4 },
    { id: 2, value: 0 },
    { id: 3, value: 0 },
    { id: 4, value: 0 }
  ]
};
let obj=state.counters[3]
let myArr = state.counters.indexOf(obj);
console.log( myArr );

The counter object passed to handleIncrement function in your first react example, is a reference to an object in you state.counters hence it returns its index.

The indexOf() method is case-sensitive, that's why you got these results, check the documentation. You can use the .toLowerCase() or the .toUpperCase() function before check with indexOf(). You need to use any of them on both of the strings you test.

For example with .toLowerCase(), change your code to:

test={product.name.toLowerCase().indexOf(filterText.toLowerCase())}

And

if(product.name.toLowerCase().indexOf(filterText.toLowerCase())===false)