> 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/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md).

# Hvordan fungerer \expandafter: En introduksjon til TeX-tokens

[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)

## Bakgrunn for \\\expandafter: TeX-tokener og tokenlister

Som et første skritt mot å forstå hvordan `\expandafter` det virkelig fungerer, skal vi se på to komponenter i TeX som er grunnleggende for driften av `\expandafter`: TeX-tokener (heltall) og tokenlister (lister av heltall). Lesere som ønsker å utforske disse temaene i langt større detalj, kan være interessert i å lese følgende artikler publisert av Overleaf:

* [Hva er en TeX-token?](/latex/no/dybdeartikler/53-what-is-a-tex-token.md)
* [Hva er en TeX-tokenliste?](/latex/no/dybdeartikler/54-what-is-a-tex-token-list.md)-[Hvordan fungerer TeX-makroer egentlig?](/latex/no/flere-emner/01-a-six-part-series-how-do-tex-macros-actually-work.md)

### Hvor kom tokendataene fra?

Gjennom hele denne artikkelen bruker vi faktiske tokentilverdier beregnet av TeX—data som vanligvis ikke er tilgjengelige for brukere. For lesere som er nysgjerrige på å vite hvordan disse tokentilverdiene ble hentet, har Overleaf egendefinerte bygg av flere TeX-motorer som vi bruker til forskning. Disse motorene er modifisert til å skrive ut informasjon om TeXs interne behandlingsaktiviteter—noe som bidrar til å gi ekstra bakgrunnsmateriale for noen av artiklene vi produserer. Ved å vise/diskutere numeriske tokentilverdier er målet vårt å inkludere detaljer som forhåpentligvis hjelper leserne til bedre å forstå «TeX-tokener», slik at dette viktige konseptet føles litt mindre uigjennomtrengelig.

## TeX-tokener 101 (og begreper om ekspansjon)

Når TeX behandler inndatafilen din, leser det teksten og konverterer enkelte tegn og sekvenser av tegn (kommandoer) til såkalte *tokens*. En TeX-token er rett og slett en heltallsverdi beregnet av TeX, som brukes til å «kode» data TeX trenger å lagre om et element som er lest inn fra gjeldende inndatakilde. Tenk på tokener som små informasjonsenheter som «pakker sammen» data TeX trenger å registrere, klare til å sendes videre til neste behandlingssteg. Internt opererer TeX på disse heltallige tokene—det bruker ikke de faktiske bokstavene, symbolene, sifrene osv. som opprinnelig stod i inndatafilen din: alt konverteres til en token (et heltall), og TeX arbeider med disse.

## Hvordan beregner TeX tokentilverdier

Her ser vi på tokentilverdier som brukes i Knuths opprinnelige TeX, e-TeX og pdfTeX; for andre TeX-motorer, særlig XeTeX og LuaTeX, må tokentilverdiene deres være litt annerledes for å ta hensyn til bruken av Unicode, men beregningsmetodene ligner dem som beskrives nedenfor.

### Tegntokener (ikke-aktive tegn)

Beregningen av tokentilverdier for ikke-aktive tegn er enkel:

$$\text{character token} = 256\times \text{(category code)} + \text{character (ASCII) code}$$

**Eksempel**: Bokstaven A med [kategorikode](/latex/no/flere-emner/43-table-of-tex-category-codes.md) 11, tegnkode 65 representeres av TeX som tegntokenverdien $$256\times 11 + 65 = 2881$$.

Du kan møte beskrivelser i TeX-litteraturen som bemerker at når TeX først har lest inn et tegn, blir kategorikodeverdien «permanent knyttet» til det tegnet: beregningen av tokentilverdien ovenfor viser hvorfor det er sant. Senere i TeXs behandling kan det imidlertid «pakke ut» tegntokener for å avsløre paret (tegnkode, kategorikode) som tokenet ble konstruert fra—når TeX gjør denne «utpakkingen», vil det fortsatt ikke endre tegnets kategorikode; det bruker bare denne informasjonen i den påfølgende behandlingen.

### Kommandotokener

TeXs inndatabehandling og tokengenerering gjenkjenner to typer kommandoer:

* kommandoer konstruert av ett eller flere tegn som har kategorikode 11;
* enkeltegnskommandoer der det tegnets kategorikode ikke er 11: som for eksempel `\$` eller `\\#`.

I begge tilfeller utelater TeX det innledende `\` tegnet og bruker tegnkoden til hvert gjenværende tegn til å beregne et heltall som TeX kaller `curcs` (**gjeld**ende **c**kontroll **s**sekvens). TeX bruker deretter verdien av `curcs` til å beregne en tokentilverdi for kommandoen.

#### Kommandoer laget av tegn med kategorikode 11

Anta at kommandoen vår (uten det innledende `\` tegnet) er sammensatt av en sekvens av tegn: $$\mathrm{C\_1C\_2C\_3...C\_N}$$ der $$\mathrm{C}\_i$$ er tegnkoden til hvert tegn—for eksempel er tegnkoden til A 65. TeX bruker alle tegnkodene $$\mathrm{C}\_i$$ til å beregne heltallet `curcs` (ved bruk av en [hash-funksjon](https://en.wikipedia.org/wiki/Hash_function)). Når TeX har beregnet verdien av `curcs` legger det ganske enkelt til 4095 for å gi tokentilverdien:

$$\text{command token} = \text{curcs + 4095}$$

Merk at variabelen `curcs` spiller en svært viktig rolle i TeXs interne behandlingsaktiviteter.

#### Enkeltegnskommandoer

Tokener som representerer kommandoer som `\$`, `\\#` osv. er gjenstand for en litt annen beregning: heltallet `curcs` beregnes nå med den enklere formelen:

$$\text{curcs} = 257 + \text{character (ASCII) code}$$

For eksempel, med `\$`, $$\text{curcs}=257 + 36 = 293$$. TeX legger igjen til 4095 til denne verdien (ved bruk av $$\text{command token} = \text{curcs} + 4095$$) noe som gir `\$` en tokentilverdi på $$293 + 4095 = 4388$$.

Sammenlignet med kommandoer sammensatt av tegn med kategorikode 11, er den eneste forskjellen her måten TeX beregner verdien for `curcs`.

**Merk**: heltallet `curcs` beregnes ikke for tegntokener: det settes alltid til 0 når TeX oppretter, eller arbeider med, tegntokener.

#### Tokener for aktive tegn

TeX har begrepet såkalte *aktive tegn*: ethvert tegn som er tildelt kategorikode 13. Tokener for denne spesielle tegnklassen er underlagt en annen beregning enn vanlige tegn.

Mekanismen for aktive tegn gjør det mulig for TeX å lage det som i praksis er enkelttegnsmakroer som du kan bruke *uten* uten å måtte foranstille det aktive tegnet med et escape-tegn (vanligvis `\`): det isolerte tegnet vil utløse sin makrooppførsel. Det klassiske eksemplet er tilde-tegnet (\~) som TeX/LaTeX bruker for ikke-brytende mellomrom, og som kan defineres/aktiveres slik:

```
\\catcode`~=13 %tilordne kategorikode 13 til ~
\\def~{\\penalty100000\\ } % definer ~ til å fungere som en makro
```

Når TeX senere leser et `~` tegn, vil det oppdage at kategorikoden er 13 og behandle det som en «mini-makro». For å beregne et token som representerer et aktivt tegn, bruker TeX en annen variant for beregning av `curcs`:

$$\begin{align\*} \text{curcs} &= \text{character code} + 1\ \text{active character token} &= \text{curcs} + 4095\ \end{align\*}$$

For eksempel har \~-tegnet tegnkode 126, noe som betyr at tokenverdien for det aktive tegnet beregnes slik:

$$\begin{align\*} \text{curcs} &= 126 + 1\ \text{active character token} &= 127 + 4095\ &=4222\ \end{align\*}$$

Merk at, i likhet med kommandoer, er tokener som representerer aktive tegn > 4095.

### Konsekvenser/notater

* Ethvert token hvis verdi overstiger 4095, kan umiddelbart identifiseres som et kommandotoken—derfor kan TeX svært enkelt oppdage om et bestemt token representerer et tegn eller en kommando.
* For enhver tokentilverdi kan TeX, når det trenger det, «pakke ut» dette tokenet for å avsløre tegnet (og dets kategorikode), eller kommandoen, som opprinnelig var til stede i din `.tex` fil, lagret i en makrodefinisjon eller inneholdt i en annen tokenliste.
* Den «mellomliggende» størrelsen kalt `curcs`—som TeX bruker til å beregne kommandotokentilverdier—spiller en viktig rolle i TeXs lavnivåbehandling. `curcs` fungerer som en «indeksverdi» som TeX bruker til å lagre/slå opp den nåværende betydningen av en kommando. Gitt ethvert kommandotoken, $$\mathrm{T}$$, trekker TeX ganske enkelt fra 4095 for å få tilgang til verdien av `curcs`: $$\text{curcs} = \mathrm{T}-4095$$

For øvrig lagrer TeX faktisk den lesbare tegnstrengen som et kommandotoken genereres fra—dette er avgjørende for feilrapportering og andre kommandoer som `\string` hvis ekspansjon er den lesbare versjonen av en tokentilverdi. Men disse lesbare tegnstrengene som lagres inne i TeX brukes/skrives bare ut når det blir bedt om det: for all annen behandling brukes tokenets heltallsverdi.

## Å se på noen virkelige tokener

Bare for å gjøre begrepet tokener litt mindre uigjennomtrengelig, skal vi definere følgende enkle makro og ta en titt på tokene TeX produserer:

```
\\def\\hello{Greetings, from \\TeX. \\hskip 10pt}
```

For `\\hello` makroen bruker TeX tegnene `h`, `e`, `l`, `l`, `o` for å beregne en verdi på 3745 for `curcs`; TeX legger deretter til 4095 for å lage en tokentilverdi på $$3745 + 4095 = 7840$$ (for Knuths TeX, e-TeX eller pdfTeX).

Etter å ha opprettet et token for å representere `\\hello`, den `\def` kommandoen får TeX til å lese de påfølgende tokenene og bruke dem til å opprette en tokenliste som lagres som *definisjonen* i `\\hello` kommandoen. Den lagrede definisjonen (tokenlisten) kan deretter hentes hver gang du ber TeX om å bruke `\\hello` kommandoen.

Følgende tabell viser de faktiske tokentilverdiene som er opprettet for hvert element (tegn, makro eller primitiv) som inngår i `\\hello` makrodefinisjonen—denne listen av tokener (heltall) er det TeX lagrer i minnet sitt (som en datastruktur kjent som en [lenket liste](https://en.wikipedia.org/wiki/Linked_list)). Lesere som ønsker å forstå tokenlister mer detaljert, henvises til Overleaf-artikkelen [Hva er en TeX-tokenliste?](/latex/no/dybdeartikler/54-what-is-a-tex-token-list.md)

|                    |                          |
| ------------------ | ------------------------ |
| **TeX-tokenverdi** | **Representert element** |
| 2887               | G                        |
| 2930               | r                        |
| 2917               | e                        |
| 2917               | e                        |
| 2932               | t                        |
| 2921               | i                        |
| 2926               | n                        |
| 2919               | g                        |
| 2931               | s                        |
| 3116               | ,                        |
| 2592               |                          |
| 2918               | f                        |
| 2930               | r                        |
| 2927               | o                        |
| 2925               | m                        |
| 2592               |                          |
| 5235               | \TeX                     |
| 3118               | .                        |
| 2592               |                          |
| 7943               | \hskip                   |
| 3121               | 1                        |
| 3120               | 0                        |
| 2928               | p                        |
| 2932               | t                        |

I tokenlisten ovenfor har tegnene kategorikodene 10, 11 eller 12. For eksempel:

* tegn har kategorikode 10 og tegnkode 32, noe som gir en tokentilverdi på $$256\times 10 + 32 = 2592$$
* `,` og `.` har kategorikode 12 og tegnkodene 44 og 46 henholdsvis, noe som gir tokener:
* token for `,` $$= 256 \times 12 + 44 = 3116$$
* token for `.` $$= 256\times 12+ 46 = 3118$$

Når TeX senere møter tokentilverdien 7840 (som representerer `\\hello`) kan det, om nødvendig, «pakke ut» dette tokenet for å hente ut `curcs` gjennom den enkle beregningen $$\text{curcs} = \text{token value} - 4095$$ (se ovenfor). Ved å bruke verdien av `curcs` kan TeX slå opp i sine interne datatabeller for å fastslå at kommandotoken 7840 representerer en makrokommando. I tillegg kan TeX, igjen via `curcs`, også slå opp og hente den lagrede definisjonen av `\\hello`.

Når TeX trenger å behandle token 7840 fullt ut, dvs. å kjøre `\\hello` makroen, trenger det ikke lenger token 7840: det tokenet har *gjort jobben sin*—dvs. det fikk TeX til å kjøre makroen `\\hello`. TeX kan nå forkaste token 7840 og hente tokenene som representerer definisjonen (tokenlisten) lagret i minnet. I praksis er `\\hello` makrokommandoen (token 7840) blitt *fjernet* fra TeXs gjeldende inndatakilde og *erstattet* med tokener som finnes i definisjonen av `\\hello`. Det vi nettopp har beskrevet er én form for *tokenekspansjon*.

Den `\TeX` kommandoen (tokentilverdi 5235 oppført ovenfor) som brukes innenfor `\\hello` er selv en makro konstruert av flere tokener—så definisjonen er også lagret som en tokenliste:

|                    |                          |
| ------------------ | ------------------------ |
| **TeX-tokenverdi** | **Representert element** |
| 2900               | T                        |
| 19598              | \kern                    |
| 3117               | -                        |
| 3118               | .                        |
| 3121               | 1                        |
| 3126               | 6                        |
| 3126               | 6                        |
| 3127               | 7                        |
| 2917               | e                        |
| 2925               | m                        |
| 19597              | \lower                   |
| 3118               | .                        |
| 3125               | 5                        |
| 2917               | e                        |
| 2936               | x                        |
| 6175               | \hbox                    |
| 379                | {                        |
| 2885               | E                        |
| 637                | }                        |
| 19598              | \kern                    |
| 3117               | -                        |
| 3118               | .                        |
| 3121               | 1                        |
| 3122               | 2                        |
| 3125               | 5                        |
| 2917               | e                        |
| 2925               | m                        |
| 2904               | X                        |

Hvis vi skulle erstatte `\\hello` kommandoen med den komplette listen av tokener som den er bygget av, inkludert `\TeX` makroen, ville det bli en ganske lang liste—dvs. hvis vi også *ekspanderte* den `\TeX` makroen, ville vi se:

![En liste over tokener lagret i en TeX-makro](/files/327729b71dfc7a4406498e68e95b837313cc0b16)

I hovedsak ville den ene tokentilverdien 7840 (for `\\hello`) ved full ekspansjon produsere totalt 51 tokener (heltall) som representerer tegn og primitive kommandoer. I den følgende listen er tegnet eller kommandoen som representeres av hvert token, satt i parenteser «(...)»—disse lagres ikke direkte i TeXs tokenlister og vises for å hjelpe leseren:

```
2887 (G), 2930 (r), 2917 (e), 2917 (e), 2932 (t), 2921 (i), 2926 (n), 2919 (g), 2931 (s), 3116 (,), 2592 (<mellomrom>), 2918 (f), 2930 (r), 2927 (o), 2925 (m), 2592 (<mellomrom>),  2900 (T), 19598 (\\kern), 3117 (-), 3118 (.), 3121 (1), 3126 (6), 3126 (6), 3127 (7), 2917 (e), 2925 (m), 19597 (\\lower), 3118 (.), 3125 (5), 2917 (e), 2936 (x), 6175 (\\hbox), 379 ({), 2885 (E), 637 (}), 19598 (\\kern), 3117 (-), 3118 (.), 3121 (1), 3122 (2), 3125 (5), 2917 (e), 2925 (m), 2904 (X), 3118 (.), 2592 (<mellomrom>), 7943 (\\hskip), 3121 (1), 3120 (0), 2928 (p), 2932 (t)
```

For et menneske er dette bare en rekke heltall, men for TeX koder det en stor mengde informasjon.

## Les tokener nå og spar dem til senere

Når TeX leser inndataene dine, kan det finnes tider hvor det trenger (eller blir instruert til) å utsette full behandling av et bestemt sett med tokener. Hvis det blir bedt om det, vil TeX fortsette å opprette tokener fra inndataene, men lagre dem for senere bruk—og deretter hente dem frem og behandle dem som en del av sin typografiske aktivitet. Disse lagrede tokene lagres som såkalte *tokenlister* , som i praksis er TeXs eneste (interne) lagringsmekanisme for tokendata.

Vi har allerede sett eksempler på tokenlister—makroene listet ovenfor: definisjonen av disse makroene lagres i TeXs minne som lister av tokener. TeX vil bare behandle (utføre) slike tokenlister når du bestemmer deg for å kalle disse makroene. Husk også at hvert token (heltallsverdi) koder tilstrekkelig informasjon til at TeX lett kan finne ut om hvert token lagret i en makrodefinisjon representerer et tegn eller en kommando. `\\hello` og `\TeX` makroene listet ovenfor: definisjonen av disse makroene lagres i TeXs minne som lister av tokener. TeX vil bare behandle (utføre) slike tokenlister når du bestemmer deg for å kalle disse makroene. Husk også at hvert token (heltallsverdi) koder tilstrekkelig informasjon til at TeX lett kan finne ut om hvert token lagret i en makrodefinisjon representerer et tegn eller en kommando.

### Lagring av tokener med tokenregistre

Et annet eksempel på tokenlagring er den eksplisitte opprettelsen av lister av tokener som lagres i såkalte *tokenregistre*: dedikerte interne lagringsområder som TeX stiller til rådighet for brukere til å lagre tokenlister. TeXs primitive kommando `\toksdef` er én måte å bruke tokenregistre på; for eksempel, for å bruke tokenregister `100` og referere til det ved hjelp av kommandoen `\\mylist`:

```
        \\toksdef\\mylist=100
        \\mylist={noen \\TeX{} tokener her}
```

`\\mylist` er i praksis bare et navn du tildeler en liste med tokener lagret i registerplassering `100`. På samme måte som en makrodefinisjon, `\\mylist` inneholder følgende tokenliste:

|                    |                          |
| ------------------ | ------------------------ |
| **TeX-tokenverdi** | **Representert element** |
| 2931               | s                        |
| 2927               | o                        |
| 2925               | m                        |
| 2917               | e                        |
| 2592               |                          |
| 5235               | \TeX                     |
| 379                | {                        |
| 637                | }                        |
| 2592               |                          |
| 2932               | t                        |
| 2927               | o                        |
| 2923               | k                        |
| 2917               | e                        |
| 2926               | n                        |
| 2931               | s                        |
| 2592               |                          |
| 2920               | h                        |
| 2917               | e                        |
| 2930               | r                        |
| 2917               | e                        |

**Merk**: for å avslutte `\TeX` makroen og forhindre den i å sluke det følgende `<mellomrom>` tegnet brukte vi et par klammer `{}` rett etter `\TeX`—tokene for `{` (379) og `}` (637) lagres i tokenlisten. Et annet alternativ er å bruke et token for «kontrollmellomrom» `\\<space>` som ville vises i tokenlisten som vist nedenfor (med fet skrift):

|                    |                          |
| ------------------ | ------------------------ |
| **TeX-tokenverdi** | **Representert element** |
| 2931               | s                        |
| 2927               | o                        |
| 2925               | m                        |
| 2917               | e                        |
| 2592               |                          |
| 5235               | \TeX                     |
| **4384**           | **\\**                   |
| 2932               | t                        |
| 2927               | o                        |
| 2923               | k                        |
| 2917               | e                        |
| 2926               | n                        |
| 2931               | s                        |
| 2592               |                          |
| 2920               | h                        |
| 2917               | e                        |
| 2930               | r                        |
| 2917               | e                        |

Merk at `<mellomrom>` tegn er representert som en *tegntoken* med verdi $$256\times 10 + 32 = 2592$$ men `\\<space>` behandles som et enkelt *kommandotoken* (verdi 4384) som beregnes ved hjelp av formelene gitt ovenfor:

\\\begin{align\*} \\\text{curcs} & = 257 + \\\text{tegn- (ASCII-) kode}\\\\\\\ & = 257 + 32\\\\\\\ &=289\\\ \\\text{kommandotoken for} \\\left<\\\text{\\\\\\\space}\\\right> & = \\\text{curcs + 4095}\\\\\\\ & = 289+4095\\\\\\\ &=4384\\\ \\\end{align\*}

I hovedsak `\\mylist={noen \\TeX{} tokener her}` sier til TeX: vennligst skann inndatafilen min for å konvertere de følgende tegnene/kommandoene til tokener og spar dem til senere bruk. TeX vil etterkomme dette og lagre disse tokene i en minneplassering du kan få tilgang til ved å skrive `\\the\\mylist`, og instruerer TeX til å sette inn en kopi av tokene som finnes i tokenregister `\\mylist`. TeX-motorer inkluderer en rekke primitive kommandoer som eksplisitt genererer og lagrer tokenlister—som `\everyjob`, `\everypar`, `\mark`, og mange andre.

[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/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md?ask=<question>&goal=<endgoal>
```

`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.