- LET tilldelar namn till mellanresultat och förbättrar tydlighet och prestanda.
- LAMBDA skapar anpassade funktioner och validerar med ett in-cell-anrop.
- BYROW, BYCOL, MAP, SCAN, REDUCE och MAKEARRAY tillämpar LAMBDA på arrayer.
- Färdiga exempel: delsummor, mappningar, kumulativ och matrisgenerering.
När man arbetar med data i Excel kommer det en punkt där upprepade formler och oändliga räckvidder blir ohanterliga; det är där de kommer in i bilden LET- och LAMBDA-funktionerna, två viktiga delar för att skapa rena, återanvändbara och snabbare att underhålla beräkningar.
Med dessa funktioner, och med flera moderna matrisfunktioner som förlitar sig på dem kan du definiera mellannamn, inkapsla beräkningar och tillämpa transformationer på matriser som om du loopar; BYROW, BYCOL, MAP, SCAN, REDUCE och MAKEARRAY De är grädden på moset som låter dig tillämpa en LAMBDA på rader, kolumner eller element i en matris på ett elegant och effektivt sätt.
Vad är LET och LAMBDA i Excel?
LAMBDA-funktionen tillåter skapa anpassade funktioner med hjälp av själva språket excel-formler, utan makron eller VBA: du definierar parametrar, skriver beräkningen och, om du vill, anropar den med argument för att få ett omedelbart resultat.
LET-funktionen används däremot för att tilldela namn till mellanliggande resultat inom samma formel, så att du kan återanvända dem flera gånger utan att omräkna dem, vilket förbättrar läsbarheten och effektiviteten i komplexa ark.
Runt LAMBDA har det kommit funktioner som behandlar arrayer som om de vore samlingar som ska genomsökas: BYROW (radvis), BYCOL (efter kolumner), KARTA (kartelement), SCAN (ackumulerar och returnerar mellanliggande tillstånd), MINSKA (returnerar endast det slutliga kumulativa värdet) och MAKEARRAY (genererar matriser på begäran).
Tänk på den här uppsättningen som verktyg som simulera loopar och traverseringar över arrayerDu skickar en LAMBDA med önskad transformation och Excel gör resten och returnerar vektorer eller matriser med resultaten.
Resultatet är att du kan bygga sofistikerade beräkningar utan att behöva tillgripa hjälpkolumner eller extern kod; allt är inkapslat i rena formler, med mindre risk för fel och bättre underhåll.
Hur man testar och definierar en LAMBDA utan fel
En bra praxis är bygga och validera LAMBDA direkt i en cell innan du definierar den som en återanvändbar funktion: definiera parametrar, skriv beräkningen och lägg till testanropet med önskade argument i slutet.
Om du inte gör det testsamtalet är det relativt lätt att snubbla över #CALC-felet! I ofullständiga formler tvingar det slutliga anropet dig att utvärdera beräkningen och bekräftar att strukturen är korrekt.
Det tydligaste arbetssättet är: LAMBDA(parameter1; parameter2; …; beräkning)(argument1; argument2; …); så, i en enda cell skriver du definitionen och dess exekvering för att validera resultatet.
Till exempel, för att addera 1 till ett tal kan du prova: =LAMBDA(number; number + 1)(1)Detta uttryck returnerar värdet 2, vilket bekräftar att LAMBDA och dess anrop är välplanerade.
När den har verifierats kan du registrera den LAMBDA som en anpassad funktion (med ett namn) eller infoga det i andra formler och matrisfunktioner för att lösa mer ambitiösa problem.
LET: syntax, argument och överväganden
Den allmänna syntaxen för LET är: =LET(nombre1; nombre_valor1; cálculo_o_nombre2; ); dess mål är namnge mellanresultat och använd dessa namn i en slutlig beräkning.
Viktiga argument för LET: namn1 (obligatoriskt) är den första identifieraren du tilldelar; den måste börja med en bokstav, får inte vara resultatet av en formel, och får inte hamna i konflikt med intervallsyntax i Excel.
Argumentet namn_värde1 (obligatoriskt) är värdet eller uttrycket som ska associeras med namn1; på så sätt undviker du att upprepa samma beräkning och Förbättra prestanda om du ska återanvända den.
Det tredje argumentet, beräkning_eller_namn2 (obligatoriskt), det kan vara en av två saker: antingen slutlig beräkning som använder alla deklarerade namnen, eller ett andra namn som ska definieras; om du väljer att deklarera ett namn måste du också ange namn_värde2 y beräkning_eller_namn3.
namn_värde2 (valfritt) tilldelar ett värde till namnet som deklarerades i föregående steg; om du fortsätter att kedja namn, upprepa mönstret namn/värde tills det sista argumentet är en beräkning.
Slutligen, beräkning_eller_namn3 (valfritt) kan vara den slutliga beräkningen eller ett tredje namn; kom ihåg att Det sista argumentet i LET måste alltid vara en beräkning som returnerar det förväntade resultatet.
Detta skalbara mönster låter dig kedja definitioner tydligt och förhindrar att du duplicerar uttryck inom samma formel; kort sagt, LET förenklar, förtydligar och accelererar komplexa arbetsböcker.
Moderna matrisfunktioner som utnyttjar LAMBDA
Dessa funktioner går igenom arrayer som tillämpar en transformation definierad med LAMBDA och beter sig som om de vore iteratorer; ange delsummor per rad eller kolumn, mappningar, ackumulerade och konstruktionen av anpassade matriser.
BYRÅD: Applicera en LAMBDA på varje rad
BYROW Utvärderar en LAMBDA för varje rad i indataområdet och returnerar en kolumnvektor av resultaten; den är idealisk för att skapa rad-för-rad-delsummor eller indikatorer utan hjälpkolumner.
Dess syntax är: =BYROW(rango; LAMBDA(fila; cálculo_por_fila)), där parametern kö representerar den aktuella raden som bearbetas av funktionen; LAMBDA returnerar ett enda värde per rad.
Praktiskt exempel: om din matris är i B2:D7 och du vill lägga ihop varje rad, i E2 escribe =BYROW(B2:D7; LAMBDA(fila; SUMA(fila))); du kommer att få en vektor med summan av varje rad, redo för användning i analys eller grafik.
BYCOL: tillämpa en LAMBDA på varje kolumn
BYCOL Fungerar på liknande sätt som BYROW, men den loopar igenom kolumner; den returnerar en kolumnvektor med ett resultat för varje kolumn i källområdet.
Syntaksen är: =BYCOL(rango; LAMBDA(columna; cálculo_por_columna)); parametern kolonn exponerar den aktuella kolumnen för LAMBDA, vilket producerar ett värde per kolumn.
Praktiskt exempel: med data i B2:D7, plats i B8 formeln =BYCOL(B2:D7; LAMBDA(columna; PROMEDIO(columna))); du kommer att få en vektor med medelvärdet av varje kolumn, användbar som sammanfattning eller kvalitetskontroll.
MAKEARRAY: skapa beräknade arrayer
MAKEARRAY genererar en matris av den storlek du anger, och beräknar varje element med en LAMBDA som tar emot radindex och kolumnindex; i vissa spanska miljöer har det setts som MAKEARRAY-FIL.
Dess allmänna form är: =MAKEARRAY(n_filas; n_columnas; LAMBDA(fila; columna; cálculo_por_posición))Varje skärningspunkt mellan rad och kolumn går igenom LAMBDA och returnerar det önskade värdet för den koordinaten.
Exempel på positionsidentifiering: använd i valfri cell =ARCHIVOMAKEARRAY(3; 2; LAMBDA(fila; col; -(fila&col))) att skapa en matris av 3 rader gånger 2 kolumner där varje element sammanfogar sin rad och kolumn (och tvingas numrera med minustecken).
Ett annat exempel som kombinerar flera funktioner: =LET(arrPos; ARCHIVOMAKEARRAY(3; 2; LAMBDA(fila; col; -(fila&col))); arrPosF; COINCIDIR(arrPos; K.ESIMO.MENOR(arrPos; SECUENCIA(6))); INDICE(G8:G13; arrPosF))Med denna konstruktion, du genererar positioner, du får de 6 minderåriga och du mappar dem över ett intervall med INDEX.
MAP: transformera element till element
KARTA tar en eller flera arrayer och returnerar en annan av samma storlek genom att tillämpa en LAMBDA på varje element; det är perfekt för rensningar, normaliseringar eller villkorliga taggar utan hjälpkolumner.
Den grundläggande syntaxen är: =MAP(matriz; LAMBDA(valor; transformación)); om du skickar flera arrayer tar LAMBDA emot flera parametrar, en per array; resultatet bevarar dimensioner av inmatningsmatrisen.
Klassiskt exempel för att markera jämna och udda tal i A21:A26: =MAP($A$21:$A$26; LAMBDA(param1; SI(ES.PAR(param1); param1; "-")))Således ersätts varje element av sig självt om det är jämnt, eller av ett bindestreck om det inte är det; all bearbetning är vektor.
SCAN: ackumulerat med mellanliggande tillstånd
SCAN Itererar genom en array med en ackumulator LAMBDA och returnerar alla mellanliggande tillstånd, inte bara det sista; den är idealisk för löpande totalsummor, kumulativa procentsatser och beräkningar som är beroende av det tidigare resultatet.
Strukturen är: =SCAN(valor_inicial; matriz; LAMBDA(acumulador; valor; nuevo_acumulado))Där initialvärde ackumulatorn startar, matris är det intervall som ska bearbetas och LAMBDA definierar övergången mellan stater.
För en klassisk jackpott över A31:A36skriver: =SCAN(0; A31:A36; LAMBDA(acum; param1; acum + param1)); du kommer att få sekvensen av partiella summor i ett steg.
Och om du vill ha det kumulativa förhållandet kan du kombinera LET och SCAN: =LET(total; SUMA(A31:A36); SCAN(0; A31:A36; LAMBDA(acum; param1; (acum + param1))) / total)Här beräknar du först totalt med LET och sedan dividerar du varje mellanliggande tillstånd med den summan.
MINSKA: det slutliga ackumulerade
MINSKA Det fungerar som SCAN men returnerar bara ackumulatorns sista tillstånd; det vill säga, reducerar hela arrayen till ett enda värde tillämpar transformationen definierad av LAMBDA.
Dess mönster är: =REDUCE(valor_inicial; matriz; LAMBDA(acumulador; valor; nuevo_acumulado)); det slutliga värdet är vanligtvis en summa, en produkt, en logisk skärningspunkt eller resultatet av den process du är intresserad av.
Exempel på slutlig löpande summa på A1:A6: =REDUCE(0; A1:A6; LAMBDA(acum; param1; acum + param1)); i ett enda uttryck, du får den totala summan utan att exponera mellansteg.
Passionerad författare om bytesvärlden och tekniken i allmänhet. Jag älskar att dela med mig av min kunskap genom att skriva, och det är vad jag kommer att göra i den här bloggen, visa dig alla de mest intressanta sakerna om prylar, mjukvara, hårdvara, tekniska trender och mer. Mitt mål är att hjälpa dig att navigera i den digitala världen på ett enkelt och underhållande sätt.