Leer los errores: #N/D, #¡REF! y por qué SI.ERROR es una trampa

Hay dos maneras de reaccionar a un #N/D en una hoja. La primera es taparlo para que el informe quede limpio. La segunda es leerlo. La diferencia entre las dos es, en buena medida, la diferencia entre alguien que maneja hojas de cálculo y un analista.

Porque un error de celda no es un castigo por haberlo hecho mal. Es un mensaje, y es un mensaje bastante preciso: la hoja te está diciendo exactamente qué no ha podido hacer. El problema es que lo dice en un código de seis caracteres que nadie te ha enseñado a descifrar, así que la reacción habitual es hacerlo desaparecer. Y ahí es donde se pierde la información más valiosa que te iba a dar la hoja ese día.

### Los seis que te vas a encontrar

Excel tiene más, pero con estos seis cubres prácticamente todo lo que verás en una hoja de trabajo real. Lo importante de la lista no es el nombre: es la columna de qué SIGNIFICA, porque de ahí sale lo que tienes que hacer.

• ▹#N/D — «He buscado y no lo he encontrado.» Sale de un BUSCARV, un COINCIDIR o un BUSCARX cuya clave no está en la tabla de destino. En inglés es `#N/A`, de not available.
• ▹#¡REF! — «La celda a la que apuntaba esta fórmula ya no existe.» Alguien borró una fila, una columna o una hoja entera. También sale de un BUSCARV cuyo número de columna se sale del rango.
• ▹#¡VALOR! — «Me has dado texto donde esperaba un número.» El clásico: una columna de importes donde alguien escribió «pendiente» o «6 uds».
• ▹#¡DIV/0! — «Has dividido por cero, o por una celda vacía.» Muy típico al calcular porcentajes de variación cuando el mes anterior fue cero.
• ▹#¿NOMBRE? — «No conozco ese nombre.» Casi siempre una función mal escrita (`=SUMAR(A1:A9)` en vez de `=SUMA(...)`), o un rango con nombre que no existe, o texto sin comillas.
• ▹#¡NUM! — «El cálculo no da un número que pueda representar.» Una raíz de un negativo, o un resultado tan grande que se sale.

### La distinción que lo cambia todo: información contra avería

Aquí está la idea central de esta lección, y si te llevas una sola cosa que sea ésta. Esos seis errores no son seis cosas del mismo tipo. Se parten en dos familias que piden reacciones opuestas.

El #N/D es información. Dice «este código no está en el catálogo», y eso puede ser perfectamente normal: un pedido de un producto descatalogado, un cliente nuevo que aún no está en la tabla maestra, una devolución sin factura asociada. El #N/D no significa que tu fórmula esté mal. Significa que tu fórmula ha funcionado y la respuesta es «no hay».

Los otros cinco son averías. Un #¡REF! significa que la hoja está rota. Un #¡VALOR! significa que hay basura en los datos. Un #¿NOMBRE? significa que has escrito mal una función. Ninguno de los cinco es una respuesta a una pregunta: son síntomas de que algo hay que arreglar.

### El #¡REF!, o por qué borrar una columna es más peligroso de lo que parece

Este error merece un apartado propio porque es el único de los seis que no se puede deshacer con información.

Piensa en lo que pasa cuando borras una columna que te sobra. La hoja no borra solo esa columna: reajusta todas las referencias del libro. Las fórmulas que apuntaban a columnas posteriores se desplazan solas y siguen funcionando. Pero las que apuntaban a LA columna que has borrado no tienen a dónde apuntar, y lo que queda escrito en ellas no es «la celda que había ahí»: es literalmente `#¡REF!`. La referencia no está mal. La referencia ha desaparecido.

1Antes:   =B2*Datos!D2              en la hoja «Resumen»
2         =SUMA(Datos!D2:D400)      en la hoja «Trimestre»
3         =BUSCARV(A2;Datos!A:D;4)  en la hoja «Dirección»
4
5Borras la columna D de «Datos».
6
7Después:  =B2*#¡REF!
8          =SUMA(#¡REF!)
9          =BUSCARV(A2;Datos!A:C;4)   ->  #¡REF!

Y ahora la parte que de verdad importa, que es de organización y no de fórmulas. El #¡REF! aparece en la celda, así que no es invisible: si estás mirando esa celda, lo ves. Lo que pasa es que no tienes ninguna manera de saber qué celdas se han roto. Puede haber tres fórmulas afectadas en una hoja que nadie abre desde marzo, en un fichero distinto que está vinculado al tuyo, o en la pestaña oculta de la que sale el número que presentas en el comité. El error grita, pero grita en una habitación en la que no hay nadie.

Un consejo que evita la mitad de estos episodios: cuando una columna te sobra, ocúltala en vez de borrarla. Una columna oculta sigue existiendo, así que ninguna fórmula se rompe, y si dentro de un mes descubres que alguien la usaba, la vuelves a mostrar y no ha pasado nada. Borrar es irreversible; ocultar, no.

### Los errores se contagian

Otra cosa que conviene tener clara antes de ponerse a arreglar: un error no se queda quieto. Cualquier fórmula que use una celda con error devuelve error. Si tu BUSCARV da #N/D, el total que multiplica por ese precio da #N/D, la suma de esa columna da #N/D y el porcentaje del informe da #N/D.

Esto tiene una consecuencia práctica muy útil y otra muy molesta. La molesta es que un solo hueco en los datos puede dejar en blanco un informe entero, y eso es lo que empuja a la gente a tapar errores a lo bruto. La útil es que el error que ves casi nunca está donde está el problema: si la fila del total da #N/D, no busques el fallo en el total, busca hacia atrás en la cadena hasta encontrar la primera celda que falla. Ésa es la que hay que arreglar; las demás se curan solas.

### SI.ERROR: la función que resuelve el síntoma y esconde la enfermedad

SI.ERROR hace una cosa muy simple: si el primer argumento da cualquier error, devuelve el segundo. Y es utilísima. El problema está en esa palabra: cualquiera.

1=SI.ERROR(BUSCARV(A2;catalogo!$A$2:$C$50;3;FALSO); "sin precio")

Fíjate en el mecanismo del daño, porque es más sutil que «tapar errores es malo». Un error en pantalla es fácil de detectar: es raro, es feo y llama la atención. Un texto plausible como «sin precio» o un cero no llaman la atención de nadie. Al envolver la fórmula en SI.ERROR no has ocultado el error: lo has disfrazado de dato. Y un dato falso hace mucho más daño que un error visible, porque un error visible se investiga y un dato falso se suma.

### SI.ND: la que deberías estar usando

Existe una función que hace lo mismo que SI.ERROR pero solo con el #N/D, y es la respuesta a casi todo lo anterior. Se llama SI.ND.

1=SI.ERROR(BUSCARV(...); "sin precio")   tapa los seis errores
2=SI.ND(BUSCARV(...); "sin precio")      tapa SOLO el #N/D

Y hay un tercer camino que conviene tener presente porque a veces es el mejor de los tres: no tapar nada. Si estás explorando datos, si estás validando una migración o si el informe lo vas a leer solo tú, deja los errores a la vista. Son tu lista de tareas. Tapar errores es una decisión de presentación, y las decisiones de presentación van al final, cuando ya sabes qué está pasando.

### ESERROR, ESERR y ESNOD

Las tres devuelven VERDADERO o FALSO en vez de sustituir el valor, y sirven para contar y para construir condiciones. Se reparten el mundo así:

• ▹ESERROR(celda) — VERDADERO con cualquier error, incluido el #N/D.
• ▹ESNOD(celda) — VERDADERO solo con el #N/D.
• ▹ESERR(celda) — VERDADERO con cualquier error EXCEPTO el #N/D.

Esa tercera parece un capricho de Microsoft y es, en realidad, la más interesante de las tres: alguien en los años ochenta ya tenía clara la distinción de esta lección y le hizo una función. ESERR es «¿hay algo roto aquí, sin contar los datos que simplemente no están?». Con ella se monta la mejor alarma que puedes poner en una hoja grande:

1En una columna auxiliar, arrastrada por toda la tabla:
2  E2:  =ESERR(D2)          VERDADERO si esta fila está ROTA
3
4Y arriba del informe, dos celdas de vigilancia:
5  =CONTAR.SI(D2:D400; "#N/D")      cuántos huecos de datos tengo
6  =CONTAR.SI(E2:E400; VERDADERO)   cuántas fórmulas tengo rotas

### Lo que hace SQL en su lugar

Cierra el círculo compararlo con lo que ya sabes de SQL, porque el contraste explica por qué esta lección es necesaria en una hoja y no en una base de datos.

Cuando un LEFT JOIN no encuentra pareja, no devuelve un error: devuelve NULL. Y NULL es un valor, con reglas claras y documentadas. Puedes filtrarlo con `IS NULL`, contarlo, sustituirlo con `COALESCE`. Es la misma situación que el #N/D —«no lo he encontrado»— pero tratada como parte normal del resultado en vez de como una excepción.

Y en la otra familia el contraste es aún más claro. En SQL no existe el equivalente al #¡REF!: si borras una columna que una vista usa, la consulta falla al ejecutarse y te lo dice en la cara. No te devuelve un informe con «sin precio» en la mitad de las filas. Esa diferencia —fallar ruidosamente en vez de seguir adelante con un hueco— es una de las razones de fondo por las que los informes que importan acaban saliendo de una base de datos.

### Resumen

• ▹Un error es un mensaje, no un castigo. Cada uno dice algo distinto y concreto.
• ▹Hay dos familias. El #N/D es información («no lo he encontrado»); los otros cinco son averías.
• ▹El #¡REF! es el único irrecuperable: la referencia no está mal, ha desaparecido. Control+Z inmediato, o una copia anterior.
• ▹Antes de borrar una columna, rastrea dependientes. Y después, busca «#¡REF!» en TODO el libro, no en la hoja actual. Mejor aún: oculta en vez de borrar.
• ▹Los errores se contagian, así que el error que ves casi nunca está donde está el problema. Ve hacia atrás en la cadena.
• ▹SI.ERROR tapa los seis, y eso convierte una hoja rota en un informe de aspecto normal. Disfraza el error de dato.
• ▹=SI.ERROR(...; 0) es el peor caso: un cero se suma y se promedia. Si tapas, tapa con un texto que se pueda contar.
• ▹SI.ND tapa solo el #N/D, que es lo que casi siempre querías. Tapa el error que sabes explicar y deja pasar el que no.
• ▹ESERR cuenta averías ignorando los huecos. En una columna auxiliar más un CONTAR.SI encima, es la mejor alarma de una hoja grande: su valor correcto es siempre cero.
• ▹A veces lo correcto es no tapar nada. Mientras investigas, los errores son tu lista de tareas.