Autocompletado y coincidencia aproximada
Configurará un analizador de autocompletado en un campo y escribirá consultas aproximadas para gestionar errores tipográficos en las búsquedas de los usuarios.
Autocompletado y coincidencia aproximada es una lección gratuita de MongoDB Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de MongoDB Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de MongoDB Academy incluye 4 lecciones en total.
Por qué son importantes el autocompletado y la búsqueda difusa
Las experiencias de búsqueda modernas requieren dos funciones clave: autocompletado (sugerir continuaciones mientras el usuario escribe) y coincidencia difusa (encontrar resultados incluso cuando el usuario escribe mal una consulta). Estas funciones mejoran significativamente la experiencia del usuario: el autocompletado reduce la fricción de búsqueda al guiar a los usuarios hacia consultas válidas, mientras que la coincidencia difusa evita que un error tipográfico produzca el mensaje «no se encontraron resultados». Atlas Search proporciona ambas funciones mediante operadores y analizadores específicos.
Configuración de un analizador de autocompletado
El autocompletado requiere una configuración de campo especial en el índice de Atlas Search. Use el tipo de datos autocomplete en la asignación del índice para el campo que desea habilitar para la escritura predictiva. Esto hace que Atlas indexe n-gramas y n-gramas de borde del valor del campo: subcadenas que coinciden con entradas parciales. La opción tokenization puede ser 'edgeGram' (subcadenas ancladas a la izquierda) o 'nGram' (todas las subcadenas), con tamaños opcionales minGrams y maxGrams.
// Atlas Search index definition with autocomplete field
{
'mappings': {
'dynamic': false,
'fields': {
'name': [
{
'type': 'string', // for regular text search
'analyzer': 'lucene.standard'
},
{
'type': 'autocomplete', // for type-ahead queries
'tokenization': 'edgeGram', // 'mongod' -> 'm', 'mo', 'mon', 'mong', 'mongo', 'mongod'
'minGrams': 2,
'maxGrams': 10
}
]
}
}
}Ejecución de una consulta de autocompletado
Use el operador autocomplete dentro de una etapa $search para realizar consultas de escritura predictiva. Especifique query (la entrada parcial escrita hasta el momento) y path (el campo indexado para autocompletado). A medida que el usuario escribe cada carácter, envíe una nueva consulta y devuelva las principales sugerencias ordenadas por puntuación. Limite los resultados a entre 5 y 10 sugerencias para mantener una interfaz ágil.
// As user types 'mon', suggest matching product names
async function getAutocompleteSuggestions(partialQuery) {
const results = await db.collection('products').aggregate([
{
$search: {
autocomplete: {
query: partialQuery, // e.g., 'mon' -> suggests 'Monitor', 'MongoDB Atlas', etc.
path: 'name'
}
}
},
{ $limit: 8 },
{ $project: { name: 1, _id: 0 } }
]).toArray();
return results.map(r => r.name);
}Tokenización edgeGram frente a nGram
edgeGram crea subcadenas ancladas al inicio de cada palabra: 'MongoDB' produce 'Mo', 'Mon', 'Mong', 'Mongo', 'MongoD', 'MongoDB'. Esto coincide con consultas que comienzan con los caracteres correctos, por lo que es una buena opción predeterminada para buscar nombres. nGram crea todas las subcadenas de una palabra, lo que permite coincidencias en el interior de la palabra: 'ongo' también coincidiría con 'MongoDB'. nGram es más flexible, pero produce un índice mucho mayor y puede devolver sugerencias menos precisas.
// edgeGram: 'Python' generates:
// 'Py', 'Pyt', 'Pyth', 'Pytho', 'Python'
// -> matches queries starting with 'Py', 'Pyt', etc.
// nGram: 'Python' generates:
// 'Py', 'yt', 'th', 'ho', 'on', 'Pyt', 'yth', 'tho', ... etc.
// -> matches mid-word queries like 'ytho'
// For product name autocomplete, edgeGram is almost always the right choiceCoincidencia difusa con la opción fuzzy
El operador text admite una opción fuzzy que habilita la coincidencia basada en la distancia de edición. Encuentra documentos cuyos tokens están a una cantidad especificada de ediciones de caracteres (inserciones, eliminaciones, sustituciones o transposiciones) de los tokens de la consulta. Esto hace que la búsqueda tolere errores tipográficos. El parámetro maxEdits controla la tolerancia (1 = se permite un error tipográfico, 2 = se permiten dos).
// Fuzzy search: 'Monggodb' matches 'MongoDB' (1 extra 'g')
db.tutorials.aggregate([
{
$search: {
text: {
query: 'Monggodb aggregaton', // two typos
path: 'title',
fuzzy: {
maxEdits: 1, // allow 1 edit per token
prefixLength: 3 // first 3 chars must match exactly
}
}
}
},
{ $limit: 10 }
])Parámetros fuzzy: maxEdits y prefixLength
maxEdits puede ser 1 o 2 (Lucene no admite valores superiores). Los valores más altos aumentan la cobertura, pero reducen la precisión: con maxEdits: 2, pueden coincidir muchas palabras no relacionadas. prefixLength especifica cuántos caracteres al principio de cada token de consulta deben coincidir exactamente antes de aplicar la coincidencia difusa. Una longitud de prefijo de 2 o 3 ofrece un equilibrio entre rendimiento y precisión, ya que evita que el algoritmo aplique coincidencias difusas a cada token del índice.
// Conservative fuzzy: only 1 edit, first 3 chars must be exact
// Good for search boxes where users make occasional typos
fuzzy: { maxEdits: 1, prefixLength: 3 }
// Aggressive fuzzy: 2 edits, no prefix requirement
// Useful for voice-to-text or low-quality input
fuzzy: { maxEdits: 2, prefixLength: 0 }
// Balanced (recommended default):
fuzzy: { maxEdits: 1, prefixLength: 2, maxExpansions: 50 }Combinación de autocompletado y búsqueda difusa
El autocompletado y la coincidencia difusa responden a casos de uso distintos, pero pueden combinarse en una consulta compound. El operador autocomplete gestiona las coincidencias por prefijo mientras el usuario escribe, mientras que la coincidencia difusa de un operador text ayuda cuando los usuarios envían una consulta completa con errores tipográficos. Un patrón habitual consiste en probar primero el autocompletado (mientras se escribe) y cambiar a una búsqueda de texto difusa cuando el usuario envía su consulta.
// Hybrid: autocomplete for prefix + fuzzy for full query
async function search(query, isTyping) {
if (isTyping) {
// During typing: use autocomplete
return db.collection('products').aggregate([
{ $search: { autocomplete: { query, path: 'name' } } },
{ $limit: 6 },
{ $project: { name: 1 } }
]).toArray();
} else {
// On submit: use fuzzy text search
return db.collection('products').aggregate([
{ $search: { text: { query, path: ['name', 'description'], fuzzy: { maxEdits: 1 } } } },
{ $limit: 20 },
{ $project: { name: 1, price: 1, score: { $meta: 'searchScore' } } }
]).toArray();
}
}Orden de los tokens en el autocompletado
De forma predeterminada, el operador autocomplete compara la consulta parcial con tokens individuales (palabras) del campo. Puede establecer tokenOrder: 'sequential' para exigir que los tokens aparezcan en orden, lo que resulta útil para entradas de varias palabras como 'node js' que sugieren 'Node.js Developer Guide'. El valor predeterminado tokenOrder: 'any' devuelve resultados en los que cualquier palabra comienza con el prefijo, independientemente del orden.
// Sequential token order: 'node js' must match 'Node.js' in order
db.courses.aggregate([
{
$search: {
autocomplete: {
query: 'node js',
path: 'title',
tokenOrder: 'sequential' // words must appear in this order
}
}
},
{ $limit: 5 }
])
// Any order: 'js node' would also match 'Node.js'
db.courses.aggregate([
{
$search: {
autocomplete: { query: 'js node', path: 'title', tokenOrder: 'any' }
}
}
])Control de solicitudes de autocompletado
Las consultas de autocompletado se ejecutan con cada pulsación de tecla, lo que puede saturar el backend con solicitudes rápidas. Implemente siempre un debounce en el cliente: espere entre 200 y 300 ms después de la última pulsación antes de enviar la consulta. Cancele también las solicitudes en curso cuando emita una nueva para evitar respuestas fuera de orden. En React, use un hook o una biblioteca de debounce; en un frontend sencillo, use clearTimeout y setTimeout.
// Simple debounce in JavaScript
let debounceTimer;
function onSearchInput(event) {
const query = event.target.value;
clearTimeout(debounceTimer);
debounceTimer = setTimeout(async () => {
if (query.length < 2) return; // minimum length check
const suggestions = await fetch('/api/autocomplete?q=' + encodeURIComponent(query));
renderSuggestions(await suggestions.json());
}, 250); // 250ms debounce
}Puntuación y relevancia en el autocompletado
Atlas Search devuelve los resultados de autocompletado ordenados según su puntuación de relevancia. Los campos que tienen el prefijo de consulta al principio de todo el valor del campo (en lugar de más adelante en la cadena) reciben puntuaciones más altas. Puede influir aún más en la puntuación mediante la opción score para aplicar aumentos, usar puntuaciones constantes o reducir resultados en función de otros factores, como la popularidad o la actualidad. Así, las sugerencias más útiles aparecen primero.
// Boost products with higher view counts in autocomplete results
db.products.aggregate([
{
$search: {
autocomplete: {
query: 'wire',
path: 'name',
score: {
boost: {
path: 'viewCount', // boost by view count field
modifier: 'log1p' // log1p smoothing prevents extreme boosts
}
}
}
}
},
{ $limit: 8 },
{ $project: { name: 1, viewCount: 1 } }
])Práctica recomendada para la longitud mínima de consulta
Evite ejecutar consultas de autocompletado con entradas muy cortas (1 carácter), ya que devuelven una cantidad abrumadora de sugerencias irrelevantes y resultan costosas para el motor Lucene. Exija una longitud mínima de consulta de 2 o 3 caracteres antes de enviar la solicitud de autocompletado. Del mismo modo, en la coincidencia difusa, habilite fuzzy solo después de que el usuario haya escrito al menos entre 3 y 4 caracteres, para proporcionar a Lucene suficiente contexto para calcular una distancia de edición significativa. Estos límites mejoran tanto el rendimiento como la calidad de las sugerencias.
// Client-side minimum length enforcement
async function handleSearchInput(query) {
if (query.length < 2) {
clearSuggestions(); // don't search on 0 or 1 char
return;
}
// Autocomplete: good from 2 chars
if (query.length <= 4) {
return getAutocompleteSuggestions(query);
}
// Fuzzy search: enable after 4 chars for better precision
return getFuzzySearchResults(query);
}Comprobación rápida
Compruebe sus conocimientos sobre los conceptos de MongoDB y las bases de datos NoSQL de esta lección.
Resumen de la lección
En esta lección aprendió que el autocompletado requiere un tipo de datos 'autocomplete' en la asignación del índice, con tokenización (edgeGram o nGram) para indexar subcadenas, que el operador autocomplete de $search habilita la coincidencia por prefijo para las sugerencias mientras se escribe y que la opción fuzzy del operador text utiliza la coincidencia por distancia de edición para gestionar errores tipográficos con los parámetros configurables maxEdits y prefixLength. A continuación, exploraremos las facetas y las consultas compound para crear experiencias de búsqueda sofisticadas.
Aprende JavaScript con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 30
- Lecciones
- 120
Preguntas frecuentes
¿La lección «Autocompletado y coincidencia aproximada» es gratis?
Sí — el texto completo de «Autocompletado y coincidencia aproximada» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de MongoDB Academy, actualiza a CoddyKit PRO. El curso de MongoDB Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Autocompletado y coincidencia aproximada»?
Configurará un analizador de autocompletado en un campo y escribirá consultas aproximadas para gestionar errores tipográficos en las búsquedas de los usuarios. Practicas MongoDB Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar MongoDB Academy?
No se requiere experiencia previa. MongoDB Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Autocompletado y coincidencia aproximada»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de MongoDB Academy?
Sí. Cada lección de MongoDB Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Creación de un índice de Atlas Search
- Escritura de consultas $search: texto, frases y comodines
- Autocompletado y coincidencia aproximada
- Facetas y consultas compuestas