AlegsaOnline.com

Lukning i datalogi (closure) - definition, eksempler og anvendelse

Få klar forståelse af lukninger (closures) i datalogi: definition, konkrete eksempler, anvendelse og forskel på anonyme funktioner.

Forfatter: Leandro Alegsa

07-03-2026

Inden for datalogi er en lukning en funktion, der bærer sit eget miljø med sig. I dette miljø findes mindst én bundet variabel (et navn, der har en værdi, f.eks. et tal), og miljøet gemmer disse bundne variabler i hukommelsen mellem kald af funktionen. En lukning bevarer altså referencerne til de variable, der var tilgængelige, da lukningen blev oprettet, så de fortsat kan bruges, selv om det oprindelige kaldende sted er færdigt.

Idéen fik navnet lukning af Peter J. Landin i 1964. Programmeringssproget Scheme var med til at gøre lukninger almindelige i sprogdesign efter 1975, og de fleste moderne sprog understøtter i dag mekanismer, der svarer til lukninger.

Anonyme funktioner (funktioner uden navn) bliver nogle gange fejlagtigt omtalt som synonyme med closures. Mange sprog, der tilbyder anonyme funktioner, tilbyder også lukninger. En anonym funktion er kun en lukning, hvis den har sit eget miljø med mindst én bundet variabel. Omvendt kan en navngiven funktion også være en lukning, hvis den f.eks. oprettes dynamisk og fanger omgivelser.

Formel og praktisk forståelse

Formelt er en lukning en første-klasse funktion sammen med et miljø (en bindingsgraf eller en række navne-værdi-par), der binder de frie variable i funktionen. Praktisk betyder det, at når en funktion defineres inde i en anden funktion og refererer til den ydre funktions variable, får den en indkapslet tilstand, der kan overleve efter, at den ydre funktion er afsluttet.

Enkle eksempler

JavaScript:

function gørTæller() {     let count = 0;     return function() {         count += 1;         return count;     }; } const tæller = gørTæller(); console.log(tæller()); // 1 console.log(tæller()); // 2

Her er den indre anonymfunktion en lukning — den husker og opdaterer variablen count fra det ydre miljø.

Python (med nonlocal):

def gør_tæller():     count = 0     def tæller():         nonlocal count         count += 1         return count     return tæller  t = gør_tæller() print(t())  # 1 print(t())  # 2

Scheme (illustrativt):

(define (gør-tæller)   (let ((count 0))     (lambda ()       (set! count (+ count 1))       count)))

Anvendelser

Indkapsling / datahiding: Lukninger kan erstatte objekters private felter ved at gemme data i et lukningsmiljø.
Konstruktionsfunktioner (function factories): Funktionen kan oplades med konfiguration og returnere specialiserede funktioner.
Callbacks og event-handling: Lukninger bevarer kontekst mellem registrering og udførelse af callback-kode.
Currying og partial application: Lukninger bruges til at binde nogle argumenter og returnere en ny funktion, der venter på resten.
Iterators og generator-mønstre: Intern tilstand kan holdes i lukninger frem for globale variabler.
Decorator-/middleware-mønstre: Lukninger gør det nemt at indkapsle ekstra opførsel omkring en eksisterende funktion.

Implementering og hukommelse

For at lukninger fungerer skal de bundne variable ikke destrueres, når det ydre funktionskald slutter. Dette kræver typisk, at disse variable flyttes fra stacken til heapen eller gemmes i en særlig miljøstruktur (activation record eller closure object). Derfor afhænger lukningers levetid ofte af sprogrun-time-systemet og garbage collection: så længe mindst én reference til lukningen findes, holdes miljøet i live.

Implementeringsdetaljer varierer: nogle sprog kopierer miljøet ved oprettelse, andre bruger delte miljørecords. Valget påvirker ydeevne (kopieringsomkostning vs. indirektion) og semantik ved mutation.

Typiske faldgruber og bedste praksis

Variabelfanging i løkker: I JavaScript kan brug af var i en løkke føre til, at alle lukninger fanger samme variabel. Løsningen er at bruge let/const (let) eller indkapsle per-iteration værdier i et nyt scope.
Uventet deling af tilstand: Når lukninger deler et miljø, kan mutation ved ét sted påvirke andre. Overvej immutability eller kopiering, hvis dette er et problem.
Memory leaks: Langlivede lukninger kan fastholde store datastrukturer, så vær opmærksom på referencer og ryd op, hvis nødvendigt.
Debugging: Hvis miljøet er komplekst, kan det være sværere at overskue tilstand – gode navne og begrænset omfang hjælper.

Yderligere bemærkninger

Lukninger er et centralt koncept i funktionel og moderne imperativ programmering. De tilbyder en simpel, kraftfuld måde at kombinere kode og data, hvilket fremmer abstraktion og genbrug. Når du arbejder med lukninger, er det nyttigt at forstå det underliggende scoping (lexical vs. dynamic scoping) og hvordan dit valgte sprog implementerer miljøer.

Lukninger og førsteklasses funktioner

Værdier kan være tal eller en anden type data, f.eks. bogstaver, eller datastrukturer, der består af enklere dele. I reglerne for et programmeringssprog er førsteklasses værdier værdier, der kan gives til funktioner, returneres af funktioner og bindes til et variabelnavn. Funktioner, der tager eller returnerer andre funktioner, kaldes funktioner af højere orden. De fleste sprog, der har funktioner som førsteklassesværdier, har også funktioner af højere orden og closures.

Se f.eks. på følgende Scheme-funktion:

; Returner en liste over alle bøger med mindst THRESHOLD solgte eksemplarer. (define (best-selling-books threshold) (filter (lambda (book) (>= (book-sales book) threshold)) book-list)))

I dette eksempel er lambda-udtrykket (lambda (book) (>= (book-sales book) threshold))) en del af funktionen best-selling-books. Når funktionen køres, skal Scheme lave værdien af lambdaen. Det gør det ved at lave en closure med koden for lambdaen og en henvisning til tærskelvariablen, som er en fri variabel inden for lambdaen. (En fri variabel er et navn, der ikke er bundet til en værdi).

Filterfunktionen kører derefter lukningen på hver bog på listen for at vælge, hvilke bøger der skal returneres. Da lukningen selv har en reference til tærskelværdien, kan lukningen bruge denne værdi, hver gang filteret kører lukningen. Selve filterfunktionen kan skrives i en helt separat fil.

Her er det samme eksempel omskrevet i ECMAScript (JavaScript), et andet populært sprog med understøttelse af closures:

// Returnerer en liste over alle bøger med mindst "tærskelværdi" solgte eksemplarer. function bestSellingBooks(tærskelværdi) { return bookList. filter( function(book) { return book. sales >= tærskelværdi; } ); }

ECMAScript bruger ordet funktion her i stedet for lambda og Array.filter-metoden i stedet for filterfunktionen, men ellers gør koden det samme på samme måde.

En funktion kan oprette en lukning og returnere den. Følgende eksempel er en funktion, der returnerer en funktion.

I ordningen:

; Returner en funktion, der tilnærmer sig den afledte af f ; ved hjælp af et interval af dx, som skal være passende lille. (define (derivative f dx) (lambda (x) (/ (- (f (+ x dx))) (f x))) dx)))))

I ECMAScript:

// Returner en funktion, der tilnærmer sig den afledte af f // ved hjælp af et interval af dx, som skal være passende lille. function derivative(f, dx) { return function(x) { return (f(x + dx) - f(x)) / dx; }; }; }

Lukningsmiljøet beholder de bundne variabler f og dx, efter at den omsluttende funktion (afledning) vender tilbage. I sprog uden lukninger ville disse værdier gå tabt, når den omsluttende funktion vender tilbage. I sprog med lukninger skal en bundet variabel bevares i hukommelsen, så længe en lukning har den.

En lukning behøver ikke nødvendigvis at blive dannet ved hjælp af en anonym funktion. Programmeringssproget Python har f.eks. begrænset understøttelse af anonyme funktioner, men har lukninger. Ovenstående ECMAScript-eksempel kunne f.eks. implementeres i Python på følgende måde:

# Returner en funktion, der tilnærmer sig den afledte af f # ved hjælp af et interval af dx, som skal være passende lille. def derivative(f, dx): def gradient(x): return (f(x + dx) - f(x)) / dx return gradient

I dette eksempel danner funktionen gradient en lukning sammen med variablerne f og dx. Den ydre omsluttende funktion ved navn derivative returnerer denne lukning. I dette tilfælde ville en anonym funktion også fungere.

def derivative(f, dx): return lambda x: (f(x + dx) - f(x)) / dx

Python skal ofte bruge navngivne funktioner i stedet, fordi lambdaudtryk kun kan indeholde andre udtryk (kode, der returnerer en værdi) og ikke statements (kode, der har virkninger, men ingen værdi). Men i andre sprog, f.eks. i Scheme, returnerer al kode en værdi; i Scheme er alting et udtryk.

Anvendelse af lukninger

Lukninger har mange anvendelsesmuligheder:

Designere af softwarebiblioteker kan give brugerne mulighed for at tilpasse adfærd ved at sende lukninger som argumenter til vigtige funktioner. En funktion, der sorterer værdier, kan f.eks. acceptere et lukningsargument, der sammenligner de værdier, der skal sorteres, i henhold til et brugerdefineret kriterium.
Fordi lukninger udskyder evalueringen - dvs. at de ikke "gør" noget, før de bliver kaldt - kan de bruges til at definere kontrolstrukturer. F.eks. er alle Smalltalks standard kontrolstrukturer, herunder forgreninger (if/then/else) og sløjfer (while og for), defineret ved hjælp af objekter, hvis metoder accepterer closures. Brugere kan også nemt definere deres egne kontrolstrukturer.
Der kan produceres flere funktioner, der er tæt på det samme miljø, hvilket gør det muligt for dem at kommunikere privat ved at ændre dette miljø (i sprog, der tillader tildeling).

I ordningen

(define foo #f) (define bar #f) (let ((secret-message "none")) (set! foo (lambda (msg) (set! secret-message msg)))) (set! bar (lambda () secret-message))) (display (bar))) ; udskriver "none" (newline) (foo "meet me by the docks at midnight") (display (bar)) ; udskriver "meet me by the docks at midnight"

Lukninger kan bruges til at implementere objektsystemer.

Bemærk: Nogle talere kalder enhver datastruktur, der binder et leksikalsk miljø, for en lukning, men udtrykket henviser normalt specifikt til funktioner.

Spørgsmål og svar

Spørgsmål: Hvad er en afslutning i datalogi?

A: En closure er en funktion, der har sit eget miljø.

Spørgsmål: Hvad indeholder en closures miljø?

Svar: En closures miljø indeholder mindst én bundet variabel.

Spørgsmål: Hvem gav ideen om lukning sit navn?

Svar: Peter J. Landin gav navnet til lukningstanken i 1964.

Spørgsmål: Hvilket programmeringssprog gjorde closures populære efter 1975?

Svar: Programmeringssproget Scheme gjorde lukninger populære efter 1975.

Spørgsmål: Er anonyme funktioner og closures det samme?

Svar: Anonyme funktioner kaldes nogle gange fejlagtigt for closures, men ikke alle anonyme funktioner er closures.

Sp: Hvad gør en anonym funktion til en closure?

Svar: En anonym funktion er en lukning, hvis den har sit eget miljø med mindst én bundet variabel.

Sp: Er en navngiven lukning anonym?

Svar: Nej, en navngiven lukning er ikke anonym.