Función IFERROR en Excel — Atrapa errores sin ocultar tus bugs (IFERROR vs IFNA)

Resumen — IFERROR(formula, valor_si_error) ejecuta tu fórmula y, si da error, devuelve una alternativa en su lugar: =IFERROR(A2/B2, 0). La trampa que le cuesta horas a la gente: IFERROR atrapa todos los tipos de error — #REF!, #NAME?, #VALUE!, #DIV/0!, todos — así que oculta alegremente el bug real (una columna borrada, una función mal escrita) junto con el que esperabas. Para una búsqueda que puede no encontrar coincidencia, usa IFNA en su lugar: solo atrapa #N/A y deja que los errores genuinos salgan a la superficie. Mejor aún, las búsquedas nuevas deberían usar el if_not_found integrado de XLOOKUP. Tanto IFERROR como IFNA necesitan Excel 2013+.

=IFERROR(A2/B2, 0)                          ' B2 es 0 o está vacío -> 0 en lugar de #DIV/0!
=IFNA(XLOOKUP(A2, Ids, Names), "Not found")  ' solo se atrapa la no-coincidencia

IFERROR es la función a la que la gente echa mano en cuanto ve un error en una celda — y ese reflejo es exactamente el problema. Bien usada, hace robusto un modelo; usada como manta, convierte tu hoja en una que parece limpia mientras te miente en voz baja. Esta guía gira en torno a una recomendación contundente: atrapa el error que esperas, no todos los errores que haya.

Nota: en una interfaz de Excel en español, IFERROR se llama SI.ERROR e IFNA se llama SI.ND. Relacionadas: IF = SI, ISERROR = ESERROR, NA = NOD, VLOOKUP = BUSCARV, XLOOKUP = BUSCARX, AVERAGE = PROMEDIO, SUM = SUMA, FILTER = FILTRAR, ISNUMBER = ESNUMERO. Las fórmulas siguientes usan los nombres en inglés — el comportamiento es el mismo. En Excel en español los errores aparecen como: #N/A, #REF!, #¿NOMBRE?, #¡VALOR!, #¡DIV/0!.

Lo que aprenderás

El modelo mental: IFERROR es una red de seguridad, no un arreglo
El antipatrón: envolverlo todo en IFERROR oculta bugs reales
Por qué IFNA suele ser la herramienta correcta para búsquedas
La trampa de rendimiento del viejo patrón IF(ISERROR(…))
Elegir un valor alternativo que no envenene tus totales
Por qué el if_not_found de XLOOKUP hace innecesario a IFERROR a menudo

El modelo mental: una red de seguridad, no un arreglo

IFERROR no previene un error — atrapa la fórmula después de que ya ha fallado y te devuelve otra cosa:

' "Calcula A2/B2. Si eso revienta, dame 0 en su lugar."
=IFERROR(A2/B2, 0)

Piénsalo como una red tensada bajo la cuerda floja. La red es sensata para una caída que puedes prever — un divisor que a veces es cero, una búsqueda que a veces no está. Pero una red no sabe por qué te caíste. Si te caíste porque cortaron la cuerda (borraste una columna referenciada, o tecleaste =VLOOKUP como =VLOOKP), la red te atrapa igual — y ahora nunca te enteras de que la cuerda está rota. Esa ceguera es todo el peligro.

El antipatrón: IFERROR como manta

Aquí está el movimiento que oculta bugs. Algo muestra un error, así que envuelves la fórmula entera y sigues adelante:

=IFERROR(SomeBigFormula(...), "")     ' que desaparezca el rojo

La celda parece limpia ahora. Pero IFERROR se traga todos los tipos de error por igual:

Error	Lo que suele significar	¿Deberías ocultarlo?
`#N/A`	Una búsqueda no encontró coincidencia	A menudo sí — es esperado
`#DIV/0!`	El divisor es cero o está vacío	A veces — si cero es válido
`#REF!`	Una celda referenciada fue borrada	No — eso es un bug real
`#NAME?`	Función o nombre mal escrito	No — eso es un bug real
`#VALUE!`	Tipo equivocado (texto donde se esperaba número)	No — suele ser un bug real

Un IFERROR manta trata a los tres de abajo exactamente igual que a los dos de arriba. Borras una columna tres meses después, la fórmula se va a #REF!, y en lugar de un error a gritos obtienes un blanco pulcro — y un informe que está silenciosamente equivocado. La regla: nunca envuelvas una fórmula en IFERROR para hacer desaparecer un error. Envuélvela solo para manejar un fallo concreto y esperado — y demuestra primero que la fórmula es correcta sobre datos limpios.

IFNA: atrapa solo lo que querías atrapar

La mayoría de las veces, el error que de verdad esperas es el #N/A de una búsqueda que no encontró coincidencia. Para eso es exactamente IFNA — atrapa #N/A y nada más:

' IFERROR — oculta por igual una no-coincidencia Y una referencia rota
=IFERROR(VLOOKUP(A2, Table, 2, 0), "Not found")

' IFNA — maneja la no-coincidencia, deja que #REF!/#NAME? sigan gritando
=IFNA(VLOOKUP(A2, Table, 2, 0), "Not found")

Ambas dan "Not found" cuando falta el id. La diferencia aparece el día en que se rompe otra cosa: con IFNA, una columna borrada sigue sacando #REF! alto y claro; con IFERROR, queda enterrada bajo "Not found". Para búsquedas — VLOOKUP, XLOOKUP, MATCH, INDEX/MATCH — IFNA es el valor por defecto correcto, no IFERROR. Echa mano de IFERROR solo cuando el error que esperas genuinamente no sea #N/A (una división deliberada que puede dar en cero, pongamos).

La trampa de rendimiento: no calcules la fórmula dos veces

Antes de que existiera IFERROR (pre-2007), la única forma de atrapar un error era el patrón IF(ISERROR(…)) — y tiene un coste oculto:

' Patrón viejo — ejecuta el VLOOKUP DOS VECES (la prueba, y otra vez para el valor)
=IF(ISERROR(VLOOKUP(A2, T, 2, 0)), "", VLOOKUP(A2, T, 2, 0))

' IFERROR — lo ejecuta una vez
=IFERROR(VLOOKUP(A2, T, 2, 0), "")

La forma vieja evalúa la búsqueda costosa una vez para probarla y una segunda vez para devolverla — el doble de trabajo en cada fila, lo cual se acumula rápido en hojas grandes. IFERROR (e IFNA) evalúan la fórmula interna una sola vez. Si todavía tienes patrones IF(ISERROR(…)) en libros heredados, colapsarlos a IFERROR/IFNA es una aceleración gratis y una mejora de legibilidad.

Elige una alternativa que no envenene tus números

El tipo del segundo argumento importa más de lo que la gente espera, porque lo que devuelvas fluye hacia todo lo que viene aguas abajo:

Devuelve 0 por un valor ausente y se promedia — AVERAGE y los gráficos tratan ahora «sin datos» como un cero real y arrastran el resultado hacia abajo.
Devuelve "" (texto vacío) y cualquier fórmula numérica sobre esa celda puede lanzar #VALUE!, y SUM la saltará pero ISNUMBER lee FALSE.
Para «sin datos», NA() suele ser la alternativa más honesta — los gráficos saltan los puntos #N/A en vez de dibujarlos como cero.

El criterio: elige la alternativa según cómo se consume la celda, no solo para limpiar el error. «Blanco para mostrar, NA() para gráficos, 0 solo cuando cero es genuinamente el número correcto» es un buen valor por defecto.

Por qué XLOOKUP hace innecesario a IFERROR a menudo

Para trabajo nuevo, el arreglo más limpio es no envolver en absoluto. XLOOKUP tiene un cuarto argumento integrado, if_not_found, que maneja el caso ausente dentro de la búsqueda:

=XLOOKUP(A2, Ids, Names, "Not found")     ' sin necesidad de IFERROR/IFNA

Esto es estrictamente mejor que envolver: se evalúa una vez, solo se dispara en una no-coincidencia real (no en un #REF! de otra parte), y la intención está ahí mismo en la fórmula. La misma idea aparece por todas las funciones modernas — el argumento if_empty de FILTER juega el mismo papel para «ninguna fila coincidió». Cuando la función ofrece su propio manejador de «no encontrado», prefiérelo a un IFERROR externo.

Cómo ayuda ExcelMaster

El problema con el manejo de errores es que el enfoque equivocado se ve idéntico al correcto — ambos hacen desaparecer el rojo. ExcelMaster escribe la versión que no miente: IFNA para búsquedas, para que las roturas reales sigan saliendo a la superficie; el if_not_found de XLOOKUP en lugar de un envoltorio externo; y un valor alternativo elegido según cómo alimenta la celda tus totales y gráficos. Tú describes lo que debería mostrar «no encontrado»; él se asegura de que una referencia rota no pueda esconderse detrás.

Preguntas frecuentes

¿Cuál es la diferencia entre IFERROR e IFNA?

IFERROR atrapa todos los tipos de error (#REF!, #NAME?, #VALUE!, #DIV/0!, #N/A, …). IFNA atrapa solo #N/A. Para búsquedas, IFNA es más segura porque maneja una no-coincidencia mientras sigue dejando que bugs genuinos como #REF! se muestren.

¿Por qué es mala idea envolverlo todo en IFERROR?

Porque oculta bugs reales. Una columna borrada (#REF!) o una función mal escrita (#NAME?) queda reemplazada en silencio por tu alternativa, así que una fórmula rota parece bien y tu resultado está silenciosamente equivocado. Atrapa solo el error concreto que esperas.

¿Cómo oculto un error #DIV/0!?

Envuelve solo esa división y devuelve un valor sensato: =IFERROR(A2/B2, 0) o =IFERROR(A2/B2, ""). Asegúrate de que 0 sea de verdad la respuesta correcta para «sin divisor» — si la celda alimenta un AVERAGE, un 0 arrastrará la media hacia abajo.

¿Debería usar IFERROR con VLOOKUP o XLOOKUP?

Con VLOOKUP, prefiere IFNA sobre IFERROR para que solo se atrape una no-coincidencia. Con XLOOKUP, sáltate el envoltorio por completo y usa su cuarto argumento: =XLOOKUP(A2, Ids, Names, "Not found").

¿IFERROR funciona en versiones antiguas de Excel?

IFERROR viene de serie desde Excel 2007 e IFNA desde Excel 2013. El viejo apaño IF(ISERROR(…)) sigue funcionando pero evalúa tu fórmula dos veces — cambia a IFERROR/IFNA cuando puedas.

Probado en

Probado en: Excel 365 (Windows 11) — última verificación: 25/06/2026.

Guías relacionadas: Excel IF · Excel IFS y SWITCH · Excel XLOOKUP · Excel FILTER