> 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/no/dybdeartikler/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md).
# Hvordan fungerer \expandafter: En detaljert studie av påfølgende \expandafter-kommandoer
[Del 1](/latex/no/dybdeartikler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/no/dybdeartikler/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/no/dybdeartikler/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/no/dybdeartikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/no/dybdeartikler/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/no/dybdeartikler/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md)
## Eksempelstudie: Forstå \expandafter\expandafter\expandafter...
Avanserte makroer, som de som finnes i LaTeX-pakker, bruker ofte i stor grad flere påfølgende `\expandafter` kommandoer for å utføre avansert «sjonglering» med tokener. For de fleste av oss kan slike makroer være vanskelige å forstå eller skremmende å skrive. I denne delen skal vi gjennomgå mekanikken bak TeXs behandling av påfølgende `\expandafter` kommandoer:
```
\expandafter\expandafter\expandafter...
```
For å hjelpe forklaringen vår legger vi til senket indeks på hver `\expandafter`—for å angi hvilken vi viser til:
```
\expandafter1\expandafter2\expandafter3...
```
I tillegg utvider vi notasjonen for tokener som behandles av hver `\expandafter` til å bruke $$\mathrm{T^i\_1}$$ og $$\mathrm{T^i\_2}$$ som representerer tokene $$\mathrm{T\_1}$$ og $$\mathrm{T\_2}$$ lest inn av `\expandafter` med senket indeks `i`: `\expandafter`i $$\mathrm{T^i\_1T^i\_2}$$. Vi antar også at to tokener $$\mathrm{T\_X}$$ og $$\mathrm{T\_Y}$$ følger etter `\expandafter3` slik at inndataen vår ser slik ut: `\expandafter1\expandafter2\expandafter3` $$\mathrm{T\_{X}T\_{Y}}$$.
Når TeX begynner å behandle denne inndataen, vil den for `\expandafter1` se
* $$\mathrm{T^1\_1} =$$`\expandafter2` som lagres til senere *innsetting på nytt* tilbake i inndataen
* $$\mathrm{T^1\_2} =$$`\expandafter3`, som utvides
Hvis vi ser tilbake på den tidligere diskusjonen vår om [koden inne i TeX](/latex/no/dybdeartikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) som implementerer `\expandafter`, er det med utvidelsen av `\expandafter3` at vi ser at rekursjon finner sted. For å behandle `\expandafter1` har TeX allerede kalt sin interne funksjon `expand()`, så for å behandle (utvide) `\expandafter3` gjør TeX et *andre* kall til `expand()`—inne fra `expand()` selve funksjonen.
For `\expandafter3` har vi
* $$\mathrm{T^3\_1 = T\_X}$$, som lagres til senere *innsetting på nytt* tilbake i inndataen
* $$\mathrm{T^3\_2 = T\_Y}$$, som vi antar er utvidbar
La oss videre anta at utvidelsen av $$\mathrm{T\_Y}$$ gir følgende sekvens av tokener: $$\mathrm{{T^1\_Y}{T^2\_Y}{T^3\_Y}}\cdots\mathrm{T^N\_Y}$$. Vi har nå nådd slutten av utvidelsesprosessen som ble startet av kommandosekvensen `\expandafter1\expandafter2\expandafter3` $$\mathrm{T\_{X}T\_{Y}}$$ og TeX fortsetter med å «avvikle» rekursjonsprosessen som startet med `\expandafter1`.
Etter behandling av `\expandafter3` har TeX i minnet en tokenliste som inneholder tokener fra utvidelsen av $$\mathrm{T\_Y\text{: }{T^1\_Y}{T^2\_Y}{T^3\_Y}}\cdots\mathrm{T^N\_Y}$$. TeX begynner nå å sette inn tokene den lagret mens den behandlet `\expandafter` kommandoer:
1. TeX begynner med å sette inn tokenen $$\mathrm{T\_X}$$ lagret av `\expandafter3`. $$\mathrm{T\_X}$$ settes inn på nytt *foran* utvidelsen av $$\mathrm{T\_Y}$$, noe som resulterer i en tokensekvens: $$\mathrm{{{T\_X}T^1\_Y}{T^2\_Y}{T^3\_Y}}\cdots\mathrm{T^N\_Y}$$.
2. Vi må imidlertid fortsatt fullføre prosessen som ble startet av `\expandafter1` som lagret tokenen som representerer `\expandafter2`
3. Den endelige tokensekvensen som TeX har satt sammen, klar til å leses i neste fase av TeXs behandling, er `\expandafter2 (token)` $$\mathrm{T\_{X}T^1\_{Y}T^2\_{Y}T^3\_{Y}\cdots T^N\_Y}$$
4. TeX er nå ferdig med den «første runden» av behandlingen og går over til å lese sekvensen av tokenlister den har generert—den sekvensen begynner med `\expandafter2 (token)` som TeX deretter fortsetter å behandle. For `\expandafter2` har vi
* $$\mathrm{T^2\_1} =\ \mathrm{T\_X}$$ som lagres til senere *innsetting på nytt* tilbake i inndataen
* $$\mathrm{T^2\_2} = \mathrm{T^1\_Y}$$ som er den første tokenen som oppstår ved utvidelsen av $$\mathrm{T\_Y}$$; hvis den er utvidbar, utvides den
5. Hvis vi antar at tokenen $$\mathrm{T^1\_Y}$$, den første tokenen fra utvidelsen av $$\mathrm{T\_Y}$$, utvides til $$\mathrm{{T^A\_{Y1}}{T^B\_{Y1}}{T^C\_{Y1}}}$$ så, etter at TeX har satt inn på nytt $$\mathrm{T\_X}$$, ville den resulterende tokensekvensen som skal behandles på nytt av TeX 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{\\}$$
Følgende diagram illustrerer tokenlistene som opprettes av TeX-koden
```
\expandafter1\expandafter2\expandafter3TXTY
```
### Teori i praksis
Som et eksempel definerer vi følgende makroer som skal fungere som $$\mathrm{T\_X}$$ og $$\mathrm{T\_Y}$$
* $$\mathrm{T\_X}=$$`\foo` der vi definerer `\foo` som `\def\foo#1{\textbf{#1}}`
* $$\mathrm{T\_Y}=$$`\bar` der vi først definerer `\def\abc{Hello}`, `\def\xyz{, World!}` og deretter `\def\bar{\abc\xyz}`
Vi bruker følgende kodefragment for å demonstrere den tidligere analysen vår:
\expandafter\expandafter\expandafter\foo\bar
Ut fra diskusjonen vår er resultatet av `\expandafter1\expandafter2\expandafter3` $$\mathrm{T\_X}\mathrm{T\_Y}$$ produserer en sekvens av tokener av formen:
$$\mathrm{T\_X}\text{\\}$$
der den nøyaktige sekvensen avhenger av typen token $$\mathrm{T\_Y}$$. Hvis vi setter inn eksempelkommandoene våre ved å bruke $$\mathrm{T\_X}=$$`\foo` og $$\mathrm{T\_Y}=$$`\bar`, som er definert som `\def\bar{\abc\xyz}`, ser vi:
* den første tokenen i $$\mathrm{T\_Y}$$ er `\abc` og dens utvidelse er en sekvens av tegntokener: `Hello`
* de gjenværende tokene i $$\mathrm{T\_Y}$$ er den ene tokenen som representerer `\xyz`.
Hvis vi setter denne informasjonen inn i «analysen» vår, 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\*}$$
Merk at senkede indekser tokenet og tokenliste (tegn) brukes for å understreke (minne oss om) at TeX leser *heltallsverdier for tokener*, ikke *teksttegn*, derfor er det ikke nødvendig å vise mellomromstegn eller andre skilletegn etter `\foo`: slike skilletegn er for lengst blitt behandlet eller kastet; her befinner vi oss solid inne i TeXs indre verden av tokenlister og heltallsverdier for tokener.
Når TeX behandler tokenlistesekvensen som er produsert av våre `\expandafter` kommandoer, vil den sette `**H**ello, World!`—bare `H` settes i fet skrift. Vi kunne oppnå samme resultat ved å skrive den tilsvarende TeX-koden `\foo Hello\xyz`. Legg merke til at definisjonen av `\foo` brukte én enkelt parameter; følgelig, `\foo` absorberer den ene `H` tegntokenen for argumentet sitt, og lar de gjenværende tegntokene (`ello`) urørt.
**Merknader:**
* å skrive `\foo\bar` gir et svært annerledes resultat: tokenen for `\bar` ville bli brukt som argument for `\foo` noe som resulterer i at det settes **`Hello, World`**—alt settes i fet skrift.
* å skrive `\expandafter\foo\bar` fører til at `\bar` utvides, noe som produserer to tokener: $$\text{abc}*\text{token}\text{xyz}*\text{token}$$. Deretter, etter at $$\text{foo}*\text{token}$$ settes inn på nytt av `\expandafter` behandler TeX tokensekvensen $$\text{foo}*\text{token}\text{abc}*\text{token}\text{xyz}*\text{token}$$ som setter `**Hello**, World`—bare **`Hello`** i fet skrift. Her blir den ene tokenen $$\text{abc}*\text{token}$$ behandlet som argument for makrotokenen $$\text{foo}*\text{token}$$, og lar tokenen $$\text{xyz}\_\text{token}$$ urørt, og innholdet settes i den gjeldende skrifttypen.
## Merknad om \expandafter og makroer med argumenter
Når du bruker `\expandafter` for å tvinge fram utvidelse av makroer er det verdt å vite hvordan makroutvidelse fungerer—særlig for makroer som tar argumenter. Før TeX kan kjøre en makro—det vil si lese og behandle tokener som finnes i makroens definisjon—må TeX gjøre makroen «klar til å kjøres» ved å utføre den innledende makroutvidelsesprosessen. Hvis en makros definisjon inneholder bruk av parametere (`#1`, `#2`, ... `#9`), krever en del av makroutvidelsesprosessen at TeX skanner inndataen etter tokener som utgjør argumentet/argumentene brukeren har oppgitt: disse argumenttokenene absorberes (fjernes) fra inndataen. Under makroutvidelsen leser og absorberer TeX tokener fra inndataen for å lage små tokenlister, én liste per argument; disse tokenlistene vil deretter bli satt inn på riktig sted i makroens kropp—når TeX utfører den. Det siste steget i makroutvidelsen innebærer at TeX finner makrodefinisjonen som er lagret i minnet og sørger for at det stedet blir kilden som TeX leser sin neste mengde inndatatokener fra. Makroutførelse begynner når TeX starter å lese og behandle disse tokene, og mater inn tokenlistene som tidligere er opprettet for å lagre argumentene.
### Skiljetokener absorberes også
Hvis den opprinnelige makrodefinisjonen også brukte tokener som fungerte som skilletegn, måtte TeX også sammenligne den opprinnelige makrodefinisjonen med brukerens bruk (kall) av den makroen, for å finne og matche skiljetokener. Når de er matchet/funnet, ignoreres skiljetokenene etterpå fordi deres eneste formål er å fungere som «tegnsetting», og hjelpe TeX med å plukke ut og identifisere de faktiske tokene som skal danne hvert argument.
[Del 1](/latex/no/dybdeartikler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/no/dybdeartikler/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/no/dybdeartikler/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/no/dybdeartikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/no/dybdeartikler/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/no/dybdeartikler/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/no/dybdeartikler/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.