> For the complete documentation index, see [llms.txt](https://overleaf-pro.ayaka.space/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://overleaf-pro.ayaka.space/latex/da/dybtgaende-artikler/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md).
# Hvordan virker \expandafter: En detaljeret undersøgelse af på hinanden følgende \expandafter-kommandoer
[Del 1](/latex/da/dybtgaende-artikler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/da/dybtgaende-artikler/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/da/dybtgaende-artikler/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/da/dybtgaende-artikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/da/dybtgaende-artikler/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/da/dybtgaende-artikler/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md)
## Casestudie: Forståelse af \expandafter\expandafter\expandafter...
Avancerede makroer, såsom dem man finder i LaTeX-pakker, gør ofte omfattende brug af flere på hinanden følgende `\expandafter` kommandoer for at udføre sofistikeret token-“jonglering”. For de fleste af os kan sådanne makroer være svære at forstå eller skræmmende at skrive. I dette afsnit gennemgår vi mekanikken bag TeX’s behandling af på hinanden følgende `\expandafter` kommandoer:
```
\expandafter\expandafter\expandafter...
```
For at hjælpe vores forklaring tilføjer vi indeks til hver `\expandafter`—for at angive, hvilken vi henviser til:
```
\expandafter1\expandafter2\expandafter3...
```
Derudover udvider vi notation for tokens, der behandles af hver `\expandafter` til at bruge $$\mathrm{T^i\_1}$$ og $$\mathrm{T^i\_2}$$ der repræsenterer de tokens $$\mathrm{T\_1}$$ og $$\mathrm{T\_2}$$ læst ind af `\expandafter` med indeks `i`: `\expandafter`i $$\mathrm{T^i\_1T^i\_2}$$. Vi antager også, at to tokens $$\mathrm{T\_X}$$ og $$\mathrm{T\_Y}$$ følger efter `\expandafter3` så vores input ser sådan ud: `\expandafter1\expandafter2\expandafter3` $$\mathrm{T\_{X}T\_{Y}}$$.
Når TeX begynder at behandle dette input, vil den for `\expandafter1` se
* $$\mathrm{T^1\_1} =$$`\expandafter2` som gemmes til senere *genindsættelse* tilbage i inputtet
* $$\mathrm{T^1\_2} =$$`\expandafter3`, som ekspanderes
Hvis vi vender tilbage til vores tidligere diskussion af [koden inde i TeX](/latex/da/dybtgaende-artikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) som implementerer `\expandafter`, er det med ekspansion af `\expandafter3` at vi ser rekursion finde sted. For at behandle `\expandafter1` har TeX allerede kaldt sin interne funktion `expand()`, så for at behandle (ekspandere) `\expandafter3` TeX foretager et *andet* kald til `expand()`—indefra selve `expand()` funktionen.
For `\expandafter3` har vi
* $$\mathrm{T^3\_1 = T\_X}$$, som gemmes til senere *genindsættelse* tilbage i inputtet
* $$\mathrm{T^3\_2 = T\_Y}$$, som vi antager er ekspanderbar
Lad os yderligere antage, at ekspansionen af $$\mathrm{T\_Y}$$ giver følgende sekvens af tokens: $$\mathrm{{T^1\_Y}{T^2\_Y}{T^3\_Y}}\cdots\mathrm{T^N\_Y}$$. Vi har nu nået slutningen af den ekspansionsproces, der blev startet af kommandosekvensen `\expandafter1\expandafter2\expandafter3` $$\mathrm{T\_{X}T\_{Y}}$$ og TeX fortsætter med at “afvikle” den rekursionsproces, som begyndte med `\expandafter1`.
Efter behandling af `\expandafter3` har TeX i sin hukommelse en tokenliste, der indeholder tokens fra ekspansionen af $$\mathrm{T\_Y\text{: }{T^1\_Y}{T^2\_Y}{T^3\_Y}}\cdots\mathrm{T^N\_Y}$$. TeX begynder nu at genindsætte de tokens, det gemte, mens det behandlede `\expandafter` kommandoer:
1. TeX begynder med at genindsætte token $$\mathrm{T\_X}$$ gemt af `\expandafter3`. $$\mathrm{T\_X}$$ genindsættes *foran* ekspansionen af $$\mathrm{T\_Y}$$, hvilket resulterer i en token-sekvens: $$\mathrm{{{T\_X}T^1\_Y}{T^2\_Y}{T^3\_Y}}\cdots\mathrm{T^N\_Y}$$.
2. Men vi mangler stadig at fuldføre den proces, der blev startet af `\expandafter1` som gemte tokenet, der repræsenterer `\expandafter2`
3. Den endelige sekvens af tokens, som TeX samler, og som er klar til at blive læst i næste fase af TeX’s behandling, er `\expandafter2 (token)` $$\mathrm{T\_{X}T^1\_{Y}T^2\_{Y}T^3\_{Y}\cdots T^N\_Y}$$
4. TeX er nu færdig med den “første omgang” af behandlingen og skifter til at læse den sekvens af tokenlister, det har genereret—den sekvens begynder med `\expandafter2 (token)` som TeX fortsætter med at behandle. For `\expandafter2` har vi
* $$\mathrm{T^2\_1} =\ \mathrm{T\_X}$$ som gemmes til senere *genindsættelse* tilbage i inputtet
* $$\mathrm{T^2\_2} = \mathrm{T^1\_Y}$$ som er det første token, der opstår ved ekspansionen af $$\mathrm{T\_Y}$$; hvis den kan ekspanderes, ekspanderes den
5. Hvis vi antager, at token $$\mathrm{T^1\_Y}$$, det første token fra ekspansionen af $$\mathrm{T\_Y}$$, ekspanderer til $$\mathrm{{T^A\_{Y1}}{T^B\_{Y1}}{T^C\_{Y1}}}$$ så ville den resulterende token-sekvens, efter at TeX har genindsat $$\mathrm{T\_X}$$, som TeX skal behandle igen, være: $$\mathrm{{T\_X}{T^A\_{Y1}}{T^B\_{Y1}}{T^C\_{Y1}}{T^2\_Y}{T^3\_Y}\cdots{T^N\_Y}}$$
som vi kan omformulere som
$$\mathrm{T\_X}\text{\\}$$
Det følgende diagram illustrerer de tokenlister, der oprettes af TeX-koden
```
\expandafter1\expandafter2\expandafter3TXTY
```
### Teori omsat til praksis
Som eksempel definerer vi følgende makroer, som skal tjene som $$\mathrm{T\_X}$$ og $$\mathrm{T\_Y}$$
* $$\mathrm{T\_X}=$$`\foo` hvor vi definerer `\foo` som `\def\foo#1{\textbf{#1}}`
* $$\mathrm{T\_Y}=$$`\bar` hvor vi først definerer `\def\abc{Hello}`, `\def\xyz{, World!}` og derefter `\def\bar{\abc\xyz}`
Vi bruger følgende kodefragment til at demonstrere vores tidligere analyse:
\expandafter\expandafter\expandafter\foo\bar
Ud fra vores diskussion er resultatet af `\expandafter1\expandafter2\expandafter3` $$\mathrm{T\_X}\mathrm{T\_Y}$$ giver en sekvens af tokens af formen:
$$\mathrm{T\_X}\text{\\}$$
hvor den præcise sekvens afhænger af tokenets art $$\mathrm{T\_Y}$$. Hvis vi indsætter vores eksempelkald ved hjælp af $$\mathrm{T\_X}=$$`\foo` og $$\mathrm{T\_Y}=$$`\bar`, som er defineret som `\def\bar{\abc\xyz}`, ser vi:
* det første token i $$\mathrm{T\_Y}$$ er `\abc` og dets ekspansion er en sekvens af tegntokens: `Hello`
* de resterende tokens i $$\mathrm{T\_Y}$$ er det enkelte token, der repræsenterer `\xyz`.
Hvis vi sætter disse oplysninger ind i vores “analyse”, får vi
$$\begin{align\*} &\mathrm{T\_X}\text{\\}\ &=\text{foo}*{\text{token}}\text{\}*\text{token list (characters)}\text{xyx}*\text{token}\ &=\text{foo}*\text{token}\text{Hello}*\text{token list (characters)}\text{xyx}*\text{token}\\\[10pt] \end{align\*}$$
Bemærk, at indeks token og tokenliste (tegn) bruges for at understrege (minde os om), at TeX læser *heltals-tokenværdier*, ikke *teksttegn*, og derfor er der ingen grund til at vise mellemrumstegn eller andre skilletegn efter `\foo`: sådanne skilletegn er for længst blevet behandlet eller kasseret; her befinder vi os solidt i TeX’s indre verden af tokenlister og heltals-tokenværdier.
Når TeX behandler tokenliste-sekvensen, der er skabt af vores `\expandafter` kommandoer, vil det sætte `**H**ello, World!`—kun `H` sættes i fed. Vi kunne opnå det samme resultat ved at skrive den tilsvarende TeX-kode `\foo Hello\xyz`. Bemærk, at definitionen af `\foo` brugte en enkelt parameter; derfor `\foo` absorberer det enkelte `H` tegntoken til sit argument og efterlader de resterende tegntokens (`ello`) uberørte.
**Bemærkninger:**
* at skrive `\foo\bar` giver et meget anderledes output: tokenet for `\bar` vil blive brugt som argument for `\foo` hvilket resulterer i typografisk sætning af **`Hello, World`**—alt sættes i fed.
* at skrive `\expandafter\foo\bar` får `\bar` til at blive ekspanderet, hvilket giver to tokens: $$\text{abc}*\text{token}\text{xyz}*\text{token}$$. Derefter, efter at $$\text{foo}*\text{token}$$ genindsættes af `\expandafter` behandler TeX token-sekvensen $$\text{foo}*\text{token}\text{abc}*\text{token}\text{xyz}*\text{token}$$ som sætter `**Hello**, World`—kun **`Hello`** i fed. Her behandles det enkelte token $$\text{abc}*\text{token}$$ som argument for makro-tokenet $$\text{foo}*\text{token}$$, mens tokenet $$\text{xyz}\_\text{token}$$ efterlades uberørt, og dets indhold sættes med den aktuelle skrifttype.
## Bemærkning om \expandafter og makroer med argumenter
Når man bruger `\expandafter` til at tvinge ekspansion af makroer, er det værd at vide, hvordan makroekspansion virker—især for makroer, der tager argumenter. Før TeX kan køre en makro—dvs. læse og behandle tokens indeholdt i makroens definition—skal TeX gøre makroen “klar til at køre” ved at udføre den indledende makroekspansionsproces. Hvis en makrodefinition inkluderer brug af parametre (`#1`, `#2`, ... `#9`), kræver en del af makroekspansionsprocessen, at TeX scanner inputtet for at finde tokens, der udgør det/de argument(er), som brugeren har angivet: disse argumenttokens absorberes (fjernes) fra inputtet. Under makroekspansion læser og absorberer TeX tokens fra inputtet for at skabe små tokenlister, én liste pr. argument; disse tokenlister vil senere blive indsat på den passende placering i makroens krop—når TeX udfører den. Det sidste trin i makroekspansionen indebærer, at TeX lokaliserer den makrodefinition, der er gemt i hukommelsen, og sørger for, at denne placering bliver den kilde, hvorfra TeX skal læse sit næste sæt inputtokens. Makroeksekvering begynder, når TeX begynder at læse og behandle disse tokens og føder de tidligere oprettede tokenlister ind, som gemmer argumenterne.
### Delimiter-tokens absorberes også
Hvis den oprindelige makrodefinition også brugte tokens, der fungerede som skilletegn, skulle TeX også sammenligne den oprindelige makrodefinition med brugerens brug (kald) af den makro for at finde og matche delimiter-tokens. Når de først er matchet/fundet, ignoreres delimiter-tokens efterfølgende, fordi deres eneste formål er at fungere som “sætningstegn” og hjælpe TeX med at udpege og identificere de faktiske tokens, der skal danne hvert argument.
[Del 1](/latex/da/dybtgaende-artikler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/da/dybtgaende-artikler/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/da/dybtgaende-artikler/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/da/dybtgaende-artikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/da/dybtgaende-artikler/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/da/dybtgaende-artikler/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md)
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://overleaf-pro.ayaka.space/latex/da/dybtgaende-artikler/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.