En lugar de findIndex , puede ejecutar un forloop con la condición adicional de que el índice no debe ser el mismo índice que está buscando .

En base a eso, puede regresar directamente desde dentro del bucle.

 var data = [ { name: 'x', latitude: '45.9', longitude: '50.2'}, { name: 'y', latitude: '45.9', longitude: '50.2'}, { name: 'z', latitude: '40.5', longitude: '85.7'}, ]; var duplicates = data.filter((obj, index, array) => { for(let i = 0 ; i < array.length;i++){ if(i!=index && array[i].latitude == obj.latitude && array[i].longitude == obj.longitude ){ return true; } } return false; }); console.log(duplicates);

Este enfoque basado en reduce detecta duplicados por su firma de coordenadas geográficas, que es una clave basada en cadena, concatenada por los valores de propiedad de latitude y longitude de cada elemento.

Esta clave se utiliza para la agrupación de elementos de coordenadas, y el valor del tipo de grupo indica si la firma se refiere a un solo elemento oa los mismos elementos de coordenadas (duplicados). Tan pronto como se encuentra al menos un doble, estos elementos también son recopilados por el objeto de list de acumuladores internos. Por lo tanto, este enfoque itera solo una vez y también entrega el resultado final con el final del ciclo de reducción simple...

 function collectDuplicates(collector, item) { const { index, list } = collector; const { latitude, longitude } = item; const key = [ parseFloat(latitude), parseFloat(longitude), ].join('/'); const grouped = index[key]; if (Array.isArray(grouped)) { // already more than 2 duplicates detected. grouped.push(item); list.push(item); } else if (grouped) { // first time duplicate detection (2 same items). index[key] = [grouped, item]; list.push(grouped, item); } else { // register first item of its kind. index[key] = item; } return collector; } const data = [{ name: 'x', latitude: '45.9', longitude: '50.2' }, { name: 'y', latitude: '45.9', longitude: '50.2' }, { name: 'z', latitude: '40.5', longitude: '85.7' }]; const duplicates = data.reduce(collectDuplicates, { index: {}, list: [] }).list; console.log({ duplicates }); console.log( 'data.reduce(collectDuplicates, { index: {}, list: [] }) ...', data.reduce(collectDuplicates, { index: {}, list: [] }) )

 .as-console-wrapper { min-height: 100%!important; top: 0; }

Una solución simple a su código para hacer esto podría ser similar a la siguiente:

 const duplicates = (data) => data .filter((obj, index, array) => array.find((o, i) => o.latitude === obj.latitude && o.longitude === obj.longitude && i != index ) )

Simplemente necesitamos probar índices no coincidentes dentro de la devolución de llamada de find .

Pero creo que se puede ganar mucho separando la lógica de filtrado/comprobación duplicada del código que prueba si dos elementos son iguales. El desglose es más lógico y de él obtenemos una función potencialmente reutilizable.

Así que podría escribirlo así:

 const keepDupsBy = (eq) => (xs) => xs .filter ( (x, i) => xs .find ((y, j) => i !== j && eq (x, y)) ) const dupLocations = keepDupsBy ((a, b) => a .latitude == b.latitude && a .longitude == b .longitude ) const data = [{name: 'x', latitude: '45.9', longitude: '50.2'}, {name: 'y', latitude: '45.9', longitude: '50.2'}, {name: 'z', latitude: '40.5', longitude: '85.7'}]; console .log (dupLocations (data))

 .as-console-wrapper {max-height: 100% !important; top: 0}

Esto mantiene todos los elementos en la matriz original que tienen duplicados en otros lugares y los devuelve en su orden relativo desde la matriz original. Este es el mismo orden que el anterior, pero diferente del enfoque interesante en la respuesta de Peter Seliger que agrupa todos los valores coincidentes, devueltos en el orden relativo de los primeros elementos de cada grupo.

Tenga en cuenta también la diferencia de rendimiento si espera usar esto en listas grandes. Su original y todas las respuestas, excepto la de Peter, operan en O (n^2) . Peter's opera en O (n) . Para listas más grandes, la diferencia podría ser sustancial. La compensación es diferente cuando se trata de recursos de memoria, ya que Peter opera en O (n) memoria adicional, mientras que todos los demás aquí operan en memoria constante: O (1) . Es probable que nada de esto haga una diferencia a menos que esté trabajando en decenas de miles de elementos o más, pero a menudo vale la pena considerarlo.