- LET asigna nombres a resultados intermedios y mejora claridad y rendimiento.
- LAMBDA crea funciones personalizadas y se valida con una llamada en celda.
- BYROW, BYCOL, MAP, SCAN, REDUCE y MAKEARRAY aplican LAMBDA a matrices.
- Ejemplos listos: subtotales, mapeos, acumulados y generación de matrices.
Cuando trabajas con datos en Excel, llega un punto en el que las fórmulas repetidas y los rangos interminables se vuelven inmanejables; ahí es donde entran en juego las funciones LET y LAMBDA, dos piezas clave para crear cálculos limpios, reutilizables y más rápidos de mantener.
Con estas funciones, y con varias funciones matriciales modernas que se apoyan en ellas, puedes definir nombres intermedios, encapsular cálculos y aplicar transformaciones sobre matrices como si recorrieras un bucle; BYROW, BYCOL, MAP, SCAN, REDUCE y MAKEARRAY son la guinda que permite aplicar una LAMBDA a filas, columnas o elementos de una matriz de forma elegante y eficiente.
Qué son LET y LAMBDA en Excel
La función LAMBDA permite crear funciones personalizadas usando el propio lenguaje de fórmulas de Excel, sin macros ni VBA: defines parámetros, escribes el cálculo y, si quieres, la llamas con argumentos para obtener un resultado al instante.
La función LET, por su parte, sirve para asignar nombres a resultados intermedios dentro de una misma fórmula, de modo que puedes reutilizarlos varias veces sin recalcularlos, ganando legibilidad y eficiencia en hojas complejas.
Alrededor de LAMBDA han llegado funciones que tratan matrices como si fueran colecciones a recorrer: BYROW (por filas), BYCOL (por columnas), MAP (mapea elementos), SCAN (acumula y devuelve estados intermedios), REDUCE (devuelve solo el acumulado final) y MAKEARRAY (genera matrices bajo demanda).
Piensa en este conjunto como en herramientas que simulan bucles y recorridos sobre matrices: pasas una LAMBDA con la transformación deseada y Excel hace el resto, devolviendo vectores o matrices con los resultados.
El resultado es que puedes construir cálculos sofisticados sin recurrir a columnas auxiliares ni a código externo; todo queda encapsulado en fórmulas puras, con menos riesgo de errores y mejor mantenimiento.
Cómo probar y definir una LAMBDA sin errores
Una buena práctica es construir y validar la LAMBDA directamente en una celda antes de definirla como función reutilizable: define parámetros, redacta el cálculo y añade al final la llamada de prueba con los argumentos deseados.
Si no haces esa llamada de prueba, es relativamente fácil tropezar con el error #CALC! en fórmulas incompletas; la llamada final obliga a evaluar el cálculo y te confirma que la estructura es correcta.
La forma de trabajo más clara es: LAMBDA(parámetro1; parámetro2; …; cálculo)(argumento1; argumento2; …); así, en una sola celda escribes la definición y su ejecución para validar el resultado.
Por ejemplo, para sumar 1 a un número, puedes probar con: =LAMBDA(number; number + 1)(1)
. Esta expresión devuelve el valor 2, lo que te confirma que la LAMBDA y su llamada están bien planteadas.
Una vez verificada, podrás registrar esa LAMBDA como función personalizada (con nombre) o insertarla dentro de otras fórmulas y funciones matriciales para resolver problemas más ambiciosos.
LET: sintaxis, argumentos y consideraciones
La sintaxis general de LET es: =LET(nombre1; nombre_valor1; cálculo_o_nombre2; )
; su objetivo es dar nombre a resultados intermedios y usar esos nombres dentro de un cálculo final.
Argumentos clave de LET: nombre1 (obligatorio) es el primer identificador que asignas; debe comenzar con una letra, no puede ser el resultado de una fórmula y no puede entrar en conflicto con la sintaxis de rangos en Excel.
El argumento nombre_valor1 (obligatorio) es el valor o expresión que quedará asociado a nombre1; así evitas repetir el mismo cálculo y mejoras el rendimiento si vas a reutilizarlo.
El tercer argumento, cálculo_o_nombre2 (obligatorio), puede ser una de dos cosas: o bien el cálculo final que usa todos los nombres declarados, o bien un segundo nombre a definir; si decides declarar un nombre, entonces necesitarás aportar también nombre_valor2 y cálculo_o_nombre3.
nombre_valor2 (opcional) asigna valor al nombre declarado en el paso anterior; si continuas encadenando nombres, repite el patrón nombre/valor hasta que el último argumento sea un cálculo.
Por último, cálculo_o_nombre3 (opcional) puede ser el cálculo definitivo o un tercer nombre; recuerda que el último argumento de LET debe ser siempre un cálculo que devuelva el resultado esperado.
Este patrón escalable te permite encadenar definiciones con claridad, y te evita duplicar expresiones dentro de la misma fórmula; en resumen, LET simplifica, aclara y acelera los libros de trabajo complejos.
Funciones matriciales modernas que aprovechan LAMBDA
Estas funciones recorren matrices aplicando una transformación definida con LAMBDA, comportándose como si fueran iteradores; facilitan subtotales por filas o columnas, mapeos, acumulados y la construcción de matrices a medida.
BYROW: aplicar una LAMBDA a cada fila
BYROW evalúa una LAMBDA por cada fila del rango de entrada y devuelve un vector columna con los resultados; es ideal para crear subtotales o indicadores fila a fila sin columnas auxiliares.
Su sintaxis es: =BYROW(rango; LAMBDA(fila; cálculo_por_fila))
, donde el parámetro fila representa la fila actual que procesa la función; la LAMBDA devuelve un único valor por fila.
Ejemplo práctico: si tu matriz está en B2:D7
y quieres sumar cada fila, en E2
escribe =BYROW(B2:D7; LAMBDA(fila; SUMA(fila)))
; conseguirás un vector con la suma de cada fila, listo para su uso en análisis o gráficos.
BYCOL: aplicar una LAMBDA a cada columna
BYCOL trabaja de forma similar a BYROW, pero recorriendo columnas; devuelve un vector columna con un resultado por cada columna del rango de origen.
La sintaxis es: =BYCOL(rango; LAMBDA(columna; cálculo_por_columna))
; el parámetro columna expone la columna en curso a la LAMBDA, que produce un valor por columna.
Ejemplo práctico: con datos en B2:D7
, coloca en B8
la fórmula =BYCOL(B2:D7; LAMBDA(columna; PROMEDIO(columna)))
; obtendrás un vector con el promedio de cada columna, útil como resumen o control de calidad.
MAKEARRAY: crear matrices calculadas
MAKEARRAY genera una matriz del tamaño que indiques, calculando cada elemento con una LAMBDA que recibe índice de fila e índice de columna; en algunos entornos en español se ha visto como ARCHIVOMAKEARRAY.
Su forma general es: =MAKEARRAY(n_filas; n_columnas; LAMBDA(fila; columna; cálculo_por_posición))
. Cada intersección fila/columna pasa por la LAMBDA y devuelve el valor deseado para esa coordenada.
Ejemplo identificador de posiciones: en cualquier celda, usa =ARCHIVOMAKEARRAY(3; 2; LAMBDA(fila; col; -(fila&col)))
para crear una matriz de 3 filas por 2 columnas donde cada elemento concatena su fila y su columna (y se fuerza a número con el signo menos).
Otro ejemplo combinando varias funciones: =LET(arrPos; ARCHIVOMAKEARRAY(3; 2; LAMBDA(fila; col; -(fila&col))); arrPosF; COINCIDIR(arrPos; K.ESIMO.MENOR(arrPos; SECUENCIA(6))); INDICE(G8:G13; arrPosF))
. Con esta construcción, generas posiciones, obtienes los 6 menores y los mapeas sobre un rango con INDICE.
MAP: transformar elemento a elemento
MAP toma una o varias matrices y devuelve otra del mismo tamaño aplicando una LAMBDA a cada elemento; es perfecto para limpiezas, normalizaciones o etiquetas condicionales sin columnas auxiliares.
La sintaxis básica es: =MAP(matriz; LAMBDA(valor; transformación))
; si pasas varias matrices, la LAMBDA recibe varios parámetros, uno por matriz; el resultado conserva las dimensiones de la matriz de entrada.
Ejemplo clásico para marcar pares e impares en A21:A26
: =MAP($A$21:$A$26; LAMBDA(param1; SI(ES.PAR(param1); param1; "-")))
. Así, cada elemento se reemplaza por sí mismo si es par, o por un guion si no lo es; todo el procesamiento es vectorial.
SCAN: acumulados con estados intermedios
SCAN recorre una matriz con una LAMBDA acumuladora y devuelve todos los estados intermedios, no solo el final; es ideal para totales corridos, acumulados porcentuales y cálculos que dependen del resultado anterior.
La estructura es: =SCAN(valor_inicial; matriz; LAMBDA(acumulador; valor; nuevo_acumulado))
, donde valor_inicial arranca el acumulador, matriz es el rango a procesar y la LAMBDA define la transición entre estados.
Para un acumulado clásico sobre A31:A36
, escribe: =SCAN(0; A31:A36; LAMBDA(acum; param1; acum + param1))
; obtendrás la secuencia de sumas parciales en un solo paso.
Y si quieres la proporción acumulada, puedes combinar LET y SCAN: =LET(total; SUMA(A31:A36); SCAN(0; A31:A36; LAMBDA(acum; param1; (acum + param1))) / total)
. Aquí primero calculas el total con LET y luego divides cada estado intermedio entre ese total.
REDUCE: el acumulado final
REDUCE funciona como SCAN pero devuelve únicamente el último estado del acumulador; es decir, reduce toda la matriz a un único valor aplicando la transformación definida por la LAMBDA.
Su patrón es: =REDUCE(valor_inicial; matriz; LAMBDA(acumulador; valor; nuevo_acumulado))
; el valor final suele ser una suma, un producto, una intersección lógica o el resultado del proceso que te interese.
Ejemplo de suma corrida final sobre A1:A6
: =REDUCE(0; A1:A6; LAMBDA(acum; param1; acum + param1))
; en una sola expresión, obtienes la suma total sin exponer pasos intermedios.
Redactor apasionado del mundo de los bytes y la tecnología en general. Me encanta compartir mis conocimientos a través de la escritura, y eso es lo que haré en este blog, mostrarte todo lo más interesante sobre gadgets, software, hardware, tendencias tecnológicas, y más. Mi objetivo es ayudarte a navegar por el mundo digital de forma sencilla y entretenida.