Mi objetivo es buscar en una serie de objetos uno cuyo título sea similar o coincida exactamente con un término de búsqueda. El problema es que me gustaría priorizar las coincidencias exactas sobre las coincidencias que solo contienen la cadena.
El código actual hace esto repitiendo varias veces, cada vez con una condición diferente, y devuelve el objeto si coincide.
class Item { constructor(title) { this.title = title; } } function findMatch(term) { const items = [new Item("term"), new Item("Longer Term"), new Item("Completely Different Title")]; // Check if any match the search term exactly for (var item of items) { if (item.title === term) return item; } // Check if any match the search term, ignoring case for (var item of items) { if (item.title.toLowerCase() === term.toLowerCase()) return item; } // Check if any start with the search term for (var item of items) { if (item.title.toLowerCase().startsWith(term.toLowerCase())) return item; } // Check if any end with the search term for (var item of items) { if (item.title.toLowerCase().endsWith(term.toLowerCase())) return item; } // Check if any contain the search term for (var item of items) { if (item.title.toLowerCase().includes(term.toLowerCase())) return item; } return null; } console.log(findMatch("different")); // Item with title "Completely Different Title"¿Hay alguna manera de hacer esto de manera más eficiente, como en un ciclo, o hay una mejor manera de buscar cadenas?
He buscado usar el algoritmo de Levenshtein, sin embargo, esto no funciona para buscar "Comp" y obtener el elemento con el título "Título completamente diferente", ya que hay muchas más diferencias entre "Comp" y "Título completamente diferente" que entre "Comp" y "término": ¿hay alguna forma de incorporar la misma idea en esta búsqueda?
Si está buscando eficiencia , la única mejora que se me ocurre que reduciría el procesamiento sería poner en minúsculas las cadenas por adelantado, en lugar de poner en minúsculas cada valor dentro de cada bucle. Sin embargo, probablemente sería una mejora muy marginal y pasaría desapercibida en la mayoría de los casos.
class Item { constructor(title) { this.title = title; this.lowerTitle = title.toLowerCase(); } } function findMatch(term) { const lowerTerm = term.toLowerCase(); // use item.lowerTitle and lowerTerm when appropriateLa lógica que desea implementar requiere fundamentalmente un ciclo sobre todos los elementos que buscan una condición, seguido de otro ciclo sobre todos los elementos que buscan otra, etc. Por lo tanto, no hay una forma real de mejorar la complejidad computacional sobre su implementación actual.
Puede combinar algunas o todas las condiciones con una expresión regular, pero eso rompería la secuencia de prioridad de los tipos de coincidencia que se devolverán.
Si desea que el código sea más corto y más fácil de mantener, eso es bastante fácil: puede usar una serie de devoluciones de llamada que se llaman para cada elemento en orden:
const comparers = [ (a, b) => a === b, (a, b) => a.startsWith(b), (a, b) => a.endsWith(b), (a, b) => a.includes(b), ] for (const fn of comparers) { if (fn(item.lowerTitle, lowerTerm)) return item; }¿Hay alguna manera de incorporar la misma idea en esta búsqueda?
Verificar la distancia de Levenshtein sería un poco diferente. En lugar de recorrer los elementos y devolver uno cuando coincida, debe recorrer todos los elementos incondicionalmente y devolver la mejor coincidencia después de que finalice el ciclo.
let bestItem; let lowestDistance = Infinity; for (const item of items) { const dist = compare(item.lowerTitle, lowerTerm); if (dist < lowestDistance) { bestItem = item; lowestDistance = dist; } } return bestItem; Haría esto al menos en lugar de la verificación .includes al final. Dependiendo de la lógica que desee, también puede eliminar los cheques " startsWith y endsWith a cambio.
Puede asignar una score a sus elementos según la "similitud", sea lo que sea, luego filtrar y ordenar los elementos por esa puntuación y devolver las coincidencias:
class Item { constructor(title) { this.title = title; } } const items = [new Item("term"), new Item("Longer Term"), new Item("Completely Different Title")]; function findMatch(term) { for (var item of items) { // Check if any match the search term exactly if (item.title === term) item.score = 10000; // Check if any match the search term, ignoring case else if (item.title.toLowerCase() === term.toLowerCase()) item.score = 1000; // Check if any start with the search term else if (item.title.toLowerCase().startsWith(term.toLowerCase())) item.score = 100; // Check if any end with the search term else if (item.title.toLowerCase().endsWith(term.toLowerCase())) item.score = 10; // Check if any contain the search term else if (item.title.toLowerCase().includes(term.toLowerCase())) item.score = 1; } return items.filter(i => 0 < i.score).sort((a, b) => b.score - a.score).map(i => delete i.score && i) } console.log(findMatch("different")); // Item with title "Completely Different Title" console.log(findMatch("term"));