> 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/flere-emner/22-how-tex-macros-actually-work-part-4.md).

# Hvordan TeX-makroer egentlig fungerer: Del 4

[Del 1](/latex/no/flere-emner/19-how-tex-macros-actually-work-part-1.md) [Del 2](/latex/no/flere-emner/20-how-tex-macros-actually-work-part-2.md) [Del 3](/latex/no/flere-emner/21-how-tex-macros-actually-work-part-3.md) [Del 4](/latex/no/flere-emner/22-how-tex-macros-actually-work-part-4.md) [Del 5](/latex/no/flere-emner/23-how-tex-macros-actually-work-part-5.md) [Del 6](/latex/no/flere-emner/24-how-tex-macros-actually-work-part-6.md)

## Introduksjon og oversikt

I del 1–3 gikk vi i dybden på noen detaljer på lavt nivå som bakgrunn som forberedelse til å forstå hvordan TeX-makroer fungerer. I denne artikkelen skal vi «komme opp for litt luft» og gå gjennom noen grunnleggende praktiske prinsipper for TeX-makroer som forberedelse til et nytt dypdykk i del 5 og 6. Gjennom hele denne artikkelen skal vi vise eksempelsmakroer definert ved hjelp av TeXs primitive kommando `\def`: vi kommer ikke til å bruke den, kanskje mer kjente, LaTeX-kommandoen `\newcommand`. Det er en veldig god grunn til dette: målet vårt er å forstå de grunnleggende prinsippene bak TeXs makrooppførsel, men for å gjøre det må vi bruke kjernekommandoer *innebygd i* TeX-programvaren. LaTeX-kommandoer, som `\newcommand`, er i seg selv makroer: kommandoer med spesifikk programmert oppførsel som til syvende og sist er bygget opp av lag med TeX-primitive kommandoer på lavere nivå. For å forstå den grunnleggende oppførselen til TeX bedre må vi bruke TeX-primitiver, ikke LaTeX-makroer.

### Hvor er vi på vei?

I hovedsak arbeider vi mot en forklaring av makroer som en spesialisert form for tokenliste: når du ber TeX definere en makro, oppretter den en sekvens av token (en tokenliste) og lagrer dem i minnet sitt knyttet til et navn du definerer. I del 5 og 6 skal vi se nærmere på tokenlister for makroer, men hvis du heller vil hoppe fra denne artikkelen for å lese noe bakgrunnsinformasjon, finner du det i [Hva er en TeX-tokenliste?](/latex/no/dybdeartikler/54-what-is-a-tex-token-list.md)

Tokenlister for makroer, og parametrene deres, inneholder noen ekstra finurligheter som vi skal gå gjennom i detalj — og bruke mange eksempler. For å forstå TeXs makrobehandlingsoppførsel(er) bedre er det egentlig én nøkkelfaktor å huske: TeX tenker bare på tegn på det tidligste stadiet av inndata-behandlingen: fra det punktet og utover er det token hele veien! Gjennom denne, og de resterende artiklene i denne serien, skal vi utforske rollen tokenene spiller i TeX-makroer.

## De fire delene av en makro

### Påminnelse: makroparametere og makroargumenter

Før vi begynner, er det verdt å minne oss selv på forskjellen mellom en makros *parametere* argumenter *argumentene*, fordi vi kommer til å bruke begge begrepene gjennom hele denne artikkelen. Anta at du definerer en makro \foo

```
\def\foo#1#2{Dette er #1, dette er #2}
```

Konstruksjonene (tokenene) `#1`, `#2` (opp til `#9`) kalles makroens *parametere*: tenk på dem som «plassholdere» for de faktiske dataene du vil bruke når du kaller makroen:

```
\foo{alpha}{beta}
```

Her er `alpha` og `beta` er *argumentene* brukt med dette kallet til \foo: en makros argumenter er de faktiske verdiene som mates inn i parameterplassholderne (`#1`, `#2`... `#9`) som ble brukt da du definerte makroen.

### Makrodefinisjon: har 4 elementer

Vi begynner med noe som kanskje ser ut som en litt formell definisjon av en makro, men den gir et nyttig rammeverk for videre diskusjoner.

Enhver makrodefinisjon består av 4 deler:

```
<TeX-makro-primitive><makronavn><parametertekst>{<erstatningstekst>}
```

der:

* `<TeX-makro-primitive>`: en av `\def`, `\edef`, `\gdef` eller `\xdef`;
* `<makronavn>`: navnet gitt til makrokommandoen din, for eksempel `\foo`;
* `<parametertekst>`: dette kan mangle, men hvis en er til stede, er det en serie av *tokens* som kommer før `<erstatningstekst>` parameterteksten `<parametertekst>` kan inneholde makroparametere (`#1`, `#2`... `#9`) og andre tokentyper. I hovedsak, og som vi skal se i detalj, `<parametertekst>` gir en slags *tokenmal* som TeX bruker for å finne ut hvilke token brukeren ønsker å bruke som makroens argumenter: når du kaller en makro, mater TeX *argument* tokenene inn i makroens `<erstatningstekst>` (som også er en tokenliste);
* `{<erstatningstekst>}`: dette er selve kroppen til makroen din: den er en serie av token som *argumentene* blir «injisert» når makroen behandles (ekspanderes). Argumentene mates inn i posisjonene angitt av makroparametrene brukt i den opprinnelige definisjonen.

**MERKNAD**: Gjennom diskusjonen antar vi at `<makronavn>` vil bli fulgt av et mellomromstegn med kategorikode 10 for å fungere som et skilletegn for å avslutte `<makronavn>`. Vi *har ikke* eksplisitt vist det mellomromstegnet i teksten/diskusjonen vår, men vi antar at det er der. Strengt tatt burde vi representere det noe slikt:

```
<TeX-makroprimitiv><makronavn><mellomrom><parametertekst>{<erstatningstekst>}
```

Vi kommer imidlertid til å utelate en eksplisitt inkludering av et `<mellomrom>` tegn og implisitt anta at det er til stede.

#### Merknader om {}

Vi har vist bruk av to klammeparenteser: `{` og `}` som omslutter (avgrenser) den faktiske kroppen til makroens `<erstatningstekst>`Men bruken av `{` og `}` er bare en vedtatt konvensjon fordi det TeX faktisk forventer er teksten til makroen din `<erstatningstekst>` å starte med et tegn med kategorikode 1 («Start en gruppe») og avslutte med et tegn med kategorikode 2 («Avslutt en gruppe»). Etter konvensjon er dette `{` og `}` klammeparentesene

```
\catcode`\(=1
\catcode`\)=2
```

Nå kan du definere og bruke makroer slik:

```
\def\foo #1(Hello, #1)
\foo(World!)
```

Og du kan fortsatt bruke `{` og `}` fordi vi ikke har endret kategorikodene deres — flere tegn kan ha, og har, samme kategorikode, så du kan fortsette å definere makroer på vanlig måte:

```
\def\foo #1{Hello, #1}
\foo{World!}
```

### og {}

Komponentene i en makrodefinisjon som er mest relevante for diskusjonen vår, er `<parametertekst>` og `{<erstatningstekst>}`. Når du definerer en makro, er `<parametertekst>` i praksis en streng tokenmal som definerer hvordan makroen skal brukes. Som nevnt, `<parametertekst>` kan være tom, f.eks. `\def\foo{Noe tekst}` der ingenting står mellom kommandonavnet vårt (`\foo`) og den åpne klammeparentesen `{` som her markerer starten på makroens `<erstatningstekst>`.

**Merk**: Noen lesere kjenner kanskje til TeXs «hashquote»-mekanisme (`#{`) men vi skal ikke ta opp det her.

### og makro-skilletegn

Denne artikkelen er ikke utformet som en grundig og fullstendig gjennomgang av å skrive makroer, men det er verdt å ta en kort oppfriskning, med noen eksempler, som viser at `<parametertekst>` kan bli kompleks fordi TeX tillater `<parametertekst>` å inneholde:

* **makroparametere**: (`#1`, `#2`,... `#9`) som fungerer som «plassholdere» for verdier brukeren vil oppgi når de kjører makroen — makroens *argumentene*;
* **skilletegntoken**: vilkårlige token, blandet inn blant/omkring parametertokenene, og brukt for å spesifisere grensen mellom makroparametere. Du kan tenke på disse skilletegnene som en slags «tegnsetting» som gjør `<parametertekst>` til en «tokenmal» du må følge når du bruker makroen. Skilletegntoken blir ikke satt med typografi.

Så hva betyr dette egentlig — la oss se på noen eksempler.  `<parametertekst>` står mellom navnet på makroen og venstre klammeparentes `{` i makrodefinisjonen.

#### Skilletegn: eksempel 1

Anta at vi definerer en enkel makro `\foo` slik:

```
\def\foo ABC{hello, there}
```

* `<parametertekst>` = `ABC`
* Det finnes ingen parametertoken (`#1`, `#2`,... `#9`)
* Skilletegnene er *de tre tegntokenene* `ABC` men i dette eksemplet er de noe overflødige og brukes bare som et eksempel.

De tre tegntokenene `ABC` behandles som skilletegn: ikke noe som skal settes med typografi, men «tegnsetting» som forventes å være til stede når makroen kalles — når du bruker makroen `\foo` må du oppgi de samme skilletegnene som var til stede da den ble definert.

Hvis du skriver `\foo ABC` i teksten din, vil dette sette `hello, there`med typografi — tegntokenene `ABC` blir ikke satt med typografi, men TeX kontrollerte svært nøye at de var til stede i kallet ditt til `\foo`. TeX leter etter disse skilletegnene («tegnsettingen») og fjerner (absorberer) dem, som du kan se i det følgende Overleaf-skjermbildet: `ABC` blir ikke satt med typografi:

![Overleaf som kjører en TeX-makro](/files/769121803888df5b11018ce2f846ecf3f4c4b12c)

Hvis du prøver å bruke `\foo` uten `ABC` skilletegnene, vil TeX klage `Bruk av \foo stemmer ikke overens med definisjonen.`:

![Viser en TeX-feil på Overleaf](/files/54662fe3d0087deeb502e112e1177746857d46df)

I eksemplet ovenfor, etter å ha oppdaget `\foo` forventer TeX å se de tre tegntokenene `ABC` men det gjør den ikke: den ser tegntokenet for `w` og oppdager umiddelbart at noe er galt.

#### Skilletegn: eksempel 2

Et interessant, og kanskje overraskende, faktum er at skilletegn kan være vilkårlige kommandotoken — inkludert kommandoer som *ikke engang er definert*. For eksempel kunne vi definere `\foo` slik:

```
\def\foo A\bob B\anne{Hello \TeX{}}
```

* `<parametertekst>` = `A\bob B\anne`
* Det finnes ingen parametertoken (`#1`, `#2`,... `#9`)
* Skilletegnene er tokenene `A\bob B\anne` men igjen er de i dette eksemplet overflødige og kun for diskusjonsformål. Merk at `\bob` og `\anne` er oppdiktede kommandoer som *ikke var definert*—og det trenger de heller ikke være.

Når du kaller en makro, kontrollerer (skanner) TeX `<parametertekst>` som den er til stede *i makrokallet ditt* og sammenligner den, token for token, med «tokenmal»-versjonen *lagret i minnet*—den som ble opprettet da makroen ble definert. TeX skanner *brukt i makrokallet ditt* og konverterer ganske enkelt eventuelle kommandoer den finner der til deres numeriske tokenverdi: den prøver ikke å utføre disse kommandoene, derfor spiller det ingen rolle at `\bob` og `\anne` aldri ble definert. TeX bruker ganske enkelt tokenmalen lagret i minnet som en veiledning som gjør det mulig å finne ut hvilke token i `<parametertekst>` i makrokallet ditt som er de faktiske argumentene som skal mates inn i `<erstatningstekst>`.

Som du kan se av det følgende Overleaf-skjermutsnittet, var ingen av tegntokenene (`Et` og `B`) innenfor `A\bob B\anne` ble satt med typografi og våre udefinerte kommandoer `\bob` og `\anne` forårsaket ingen problemer. Alle disse tokenene ble *absorbert* av TeX mens den matchet din bruk av `\foo` med definisjonen (tokenmalen) til `\foo` (en tokenliste) lagret i minnet.

![Overleaf som kjører en TeX-makro](/files/5ffbb3d8e0234b5b3a8d8ea3808fbb77fe82e115)

#### Skilletegn: eksempel 3

Du kan blande inn ulike skilletegn (tegntoken, kommandotoken) med makroparametere, som i dette eksemplet:

```
\def\foo A\bob#1B\anne#2\jane#3bye!{Hello from \TeX{} to \#1=#1, \#2=#2 and \#3=#3}
```

* `<parametertekst>` = `A\bob#1B\anne#2\jane#3bye!`
* Det er 3 makroparametertoken: `#1`, `#2`, `#3`
* Denne gangen er parameterne (`#1`, `#2`, `#3`) avgrenset av en kombinasjon av token:

  `A\bob#1B\anne#2\jane#3bye!`

Her har du i praksis gitt TeX en mal som den svært nøye vil prøve å matche, og forventer, når du kaller `\foo`: den vil gå gjennom makrokallet ditt, *token for token*, og forvente å matche (finne):

* de to tokenene `Et` og `\bob` før `#1`
* de to tokenene `B` og `\anne` før `#2`
* tokenet `\jane` før parameter `#3` og *fire tegntoken* `b`, `y`,`e` og `!` etter `#3`.

**Husk**: TeX tenker i token, så `bye!` er *fire tegntoken*.

Det er to måter vi kan bruke denne makroen på — vi kunne sette eventuelle argumenter med flere token i klammer for å lage en gruppe:

```
\foo A\bob{This}B\anne{That}\jane{Other}bye!
```

Men det *er ikke nødvendig* fordi makrodefinisjonen vår har skilletegn som gir en tokenmal. TeX kan bruke den malen til å plukke ut tokenene for hvert argument blant token som kun er skilletegn. Vi kan bruke makroen vår slik:

```
\foo A\bob ThisB\anne That\jane Otherbye!
```

og TeX kan plukke ut argumentene for å gi samme resultat som ved bruk av grupper `{...}`:

![Overleaf som kjører en TeX-makro ved bruk av skilletegn](/files/733e91b51a494c89e300696e9ba3cb66ae404bae)

Legg merke til hvordan TeX var i stand til nøyaktig å oppdage hvilke token som matchet parameterne `#1` og `#3`:

![Overleaf som kjører en TeX-makro ved bruk av skilletegn](/files/633e97997afcc268a6e5160d786b5a2213ad58b6)

#### Skilletegn: eksempel 4 (det handler om token, ikke tegn!)

Her er et kort eksempel som viser at når man arbeider med makroer, er det viktig å huske at vi virkelig befinner oss i tokenenes verden *tokens* og **inneholder** *tegn*…

Vi skal definere den følgende korte makroen der A og B er tegn som fungerer som skilletegn, og begge har kategorikode 11. Dette fungerer uten problemer:

```
\documentclass{article}
\begin{document}
\def\foo A#1B{Hello, #1}
\foo AGrahamB
\end{document}
```

og setter med typografi `Hello, Graham`.

Men hvis du endrer kategorikoden til A eller B til noe annet enn 11, vil makrokallet mislykkes. Anta at vi endrer kategorikoden til B til 12, ved å bruke ``\catcode`B=12`` og prøver å kalle makroen igjen, som før:

```
\documentclass{article}
\begin{document}
\def\foo A#1B{Hello, #1}
\foo AGrahamB % Dette fungerer
\catcode`\B=12\relax
\foo AGrahamB
\end{document}
```

Det mislykkes med en noe forvirrende feilmelding:

```
Løpsk argument?
GrahamB \end {document}
! Filen tok slutt mens jeg skannet bruk av \foo.
<innsatt tekst>
                \par
<*> main.tex

Jeg tror du har glemt en `}', som får meg
til å lese forbi der du ville at jeg skulle stoppe.
Jeg skal prøve å gjenopprette; men hvis feilen er alvorlig,
bør du heller skrive `E' eller `X' nå og rette filen din.

! Nødstopp.
<*> main.tex

*** (jobben avbrutt, ingen gyldig \end funnet)
```

![Overleaf som viser en feil i en TeX-makro](/files/98f09ef756a81afdb59f62404c28542aea82cbf2)

Dessverre er TeXs standardforslag om ``Jeg tror du har glemt en `}'`` er **feil**, er det ikke forårsaket av en manglende klammeparentes (`}`).

#### Hva har skjedd?

TeX prøver å matche `\foo` makro *kallet* med `\foo` makro *definisjonen* den har lagret i minnet. Når du kaller en makro som trenger ett eller flere argumenter, må TeX undersøke (skanne) bruken din av makroen for å finne ut *argumentene* som du oppgir til den makroen. Her forventer TeX at argumentet er klemt inn mellom en A (kategorikode 11) og en B (kategorikode 11). Husk: TeX tenker i *tokens*, **inneholder** *tegn*.

Tokenverdiene for A og B, $$\mathrm{T\_A}$$ og $$\mathrm{T\_B}$$ henholdsvis, er:

$$\mathrm{T\_A = 256 \times 11 + 65 = 2881}$$ $$\mathrm{T\_B = 256 \times 11 + 66 =2882}$$

Men mens TeX fortsetter søket, ser den B *men* nå har den kategorikode 12, og det gir en annen tokenverdi:

$$\mathrm{T'\_B= 256 \times 12 + 66 =3138}$$

I `\foo` i makrodefinisjonen var tokenverdien for B (brukt som skilletegn) 2882, men TeX ser nå en tokenverdi på 3138: den tror dette bare er enda et token som skal brukes i *argument* som er oppgitt til `\foo`. Så langt TeX er bekymret, er ikke det siste tokenet i argumentet funnet ennå, så den går videre for å hente et nytt token i søket etter en B med kategorikode 11. Det er da, og derfor, makroen mislykkes: i forsøket på å finne argumentet «går» TeX for langt og begynner å lese token som du ikke hadde tenkt skulle bli en del av argumentet for `\foo` makrokallet. Hva som skjer videre avhenger av tokenene TeX oppdager etter B — de vil utløse ulike `Løpsk argument?` feil.

I eksemplet vårt går TeX for langt og bruker strømmen av token `\end {document}` og treffer raskt slutten av filen, derav feilmeldingen:

```
! Filen tok slutt mens jeg skannet bruk av \foo
```

## Del 5

Som vi så ovenfor, kan `<parametertekst>` delen av makrodefinisjonen vår variere fra ekstremt enkel til en kompleks blanding av makroparametere blandet med tegntoken og kommandotoken som fungerer som skilletegn. TeX er i stand til å behandle de ulike kombinasjonene av token som finnes i `<parametertekst>` for å trekke ut argumentene som er oppgitt til en makro — og oppdage når vi prøver å bruke en makro feil. Hvordan den gjør det, er temaet for neste artikkel i serien.

[Del 1](/latex/no/flere-emner/19-how-tex-macros-actually-work-part-1.md) [Del 2](/latex/no/flere-emner/20-how-tex-macros-actually-work-part-2.md) [Del 3](/latex/no/flere-emner/21-how-tex-macros-actually-work-part-3.md) [Del 4](/latex/no/flere-emner/22-how-tex-macros-actually-work-part-4.md) [Del 5](/latex/no/flere-emner/23-how-tex-macros-actually-work-part-5.md) [Del 6](/latex/no/flere-emner/24-how-tex-macros-actually-work-part-6.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/flere-emner/22-how-tex-macros-actually-work-part-4.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.